Next Tuesday (May 14th, 2013) I will be presenting a small demo of how Reactive Extensions can help you out in a desktop application.

I’ll develop a small WPF app that will do internet searching via Bing.

Anyone in Bucharest is free to drop by and watch my demo or my colleague’s demo (Alexandru Gatej will be presenting “Aspects of plan caching and recompilation in Microsoft SQL Server”).

Location and time :

Beginning at 18:30 (Alexandru’s presentation will go first) at UBISOFT Romania ( <- click for map ), 2 Expozitiei Boulevard, district 1, Bucharest.

Hope to see many people!

After two and a half year of struggling with the crappy Android OS on Samsung Galaxy S I’ve finally decided that ‘enough is enough’.

I’ve wanted a small tablet so I can read (blogs and so on) easily so I was a bit into Samsung Galaxy Note II. Along with the fact that this too is an Android phone (OS which corrupts its own system files and lost my whole user data, lags horribly and so on) several fellow colleagues from RONUA (a local programming user group) warned me against as they already are owners.

One told me that approximately 50% of the phone calls he can’t hear the other party nor he can be heard and the other one told me he is experiencing approximately a complete OS freeze once per day. He is only able to restart the device by removing the battery and reinstering it.

I then looked for another-OS, large-display and low-SAR phone in the market. iOS ‘simply works’, I can’t deny but there was no large screen phone available, no low-SAR phone and nonetheless objective-C sucks incredibly bad.
Ironically I found another Samsung, the ATIV S.

Image source : Engadget

Windows development is my main job plus I’ve heard that the apps ecosystem in the Windows Phone marketplace is quite poor. Therefore I thought to myself : ‘maybe I could also write an app for it too!’. Having already tried development on Android and being quite outraged surprised by its quirks.

I bit the bullet and bought the ATIV S from eMAG (a local retailer).

The first thing that surprised me was the curiosity of the shipping consultant (the guy that brings the product’s box, unboxes it and tests it in front of you). He was quite curious and said he’s never seen a Windows phone before.

Nice display, nice case and so on. Tried to insert the SIM card at home from the old phone but, to my shame, I did not pay attention to the fact that I needed a microSIM not a ‘standard’ SIM. So I had to wait till the next day to get to Vodacrap (Vodafone) to get it replaced.

I also found out that the contacts that Android told me that were saved on the Google Account were not. In fact I could not even access them via web. I simply had to manually move once again contacts. Thanks again Google, thank you to Linux (Android, whatever, same shthing).

The phone boots fast (20-30 sec compared to 2min30..3min of Galaxy S) and whatever you do it will not lag AT ALL no matter what. Combine with the fast and fluid animations this does indeed make up a very nice user experience.
The real nice thing is, however, the battery. A 2300 mAH battery combined with the battery saver mode will allow me to talk, text, browse websites, check in on FourSquare, etc etc and recharge it every three … three and a half days.

So far I didn’t had to use a kind of app and not find something in the marketplace. There are even Google Maps. Sure, Instagram is a missing thing for some but not for me. And even for that there is something in development as far as I’ve heard.

In another case, having a pretty quiet week and on average one phonecall per day I managed to go well beyond 5 days between recharges. I haven’t seen another smartphone reach these levels. Well at least not without Mugen Power batteries.

‘Bling’ features include NFC (who has / will use this anyway?), Bluetooth 3.0 and a microSD card slot (had one on the Galaxy S but never had the need to use it..).

The only things that I would consider lacking but by no means a ‘deal-breaker’ would be :

• A larger than 5 inch screen
• Easy to find leather cases (I found only one but not in the same city, I had to have it shipped)
• 4G / LTE connectivity

The camera is just as good as a phone camera can be, IMHO and at least it does have a LED ‘flash’ unlike Galaxy S. Not as good as Lumia 920′s of course but good enough to take some easy photos in the sunshine..

Now I will give Windows Phone 8 development a chance and see how this goes..

Recently I had to extract the public key from a signed .NET assembly and I needed to run the sn.exe tool in order to obtain it. That required opening a command prompt and then setting the current directory to the one in which the assembly resided.

Typically I did :

1. Win+R (Run)
2. cmd
3. Enter
4. F: [ENTER] (or whatever the drive was)
5. CD and either type the directory (using the TAB autocomplete or not) or copy the folder path and pasting it into the command prompt [ENTER]

Then I thought how can I simplify this little tedious task, which I sometimes do many times a day. After looking for Microsoft PowerToys which is no longer available I found out a little gem hidden in Windows Explorer. This is what my contextual menu looks like normally :

But just pressing (and keeping pressed) SHIFT before the right-click will give you this :

Selecting this command will do the opening of the command prompt and setting the drive and path in one click.

Of course, the next thing is to add the path to SN.EXE in the Environment Variable PATH in order to be able to execute it “anywhere”.

I hope this helps at least some of us

There is a baked in logging class called, intuitively, Log. For some strange reason the authors chose to name its methods, most of them, with one letter. That is :

Log.d(..); // debug level
Log.e(..); // error level
...

Until you hit

...
Log.wtf(..);
...

This one’s funny and I appreciate their sense of humor as it goes up to renaming WTF to “What a Terrible Failure”. Like we’re so dumb that we can’t figure what they really had in mind

Another peculiarity is that in an activity (this akin to a Page / Form / whatever) you have some methods that you can/should override such as onCreate(). Everywhere is stated that the first thing you should write in the overriding method is a call to the super (that is base) class’s method. If it is really all that important and vital why didn’t the class designers go with a template method in first place?

That is a design pattern, that in this case, would go like so :

public class Activity {

    // ...

    private void onCreateInternal(Bundle savedInstanceState) {
        //vital stuff
        onCreate(savedInstanceState);
    }

    protected void onCreate(Bundle savedInstanceState) {
    }

    // ...

}

Take note of another difference between C# and Java : the methods and classes are virtual/unsealed by default. So the onCreate method in my example above is overrideable in any subclass. Also in Java terminology the base class is called the superclass.

Other differences of terminology include :

• A namespace is called a package
• By default an import (which is akin to a using directive) imports by default just the specified type and not the whole package (namespace). You need to use a wildcard to import the whole package
• The closest thing to an assembly is called a JAR (Java ARchive).
• Eclipse by default is set to autocompile. That is whenever you hit CTRL-S (Save) to a Java file the project is (re)compiled. This sounds terrible but it isn’t! You can’t even notice. Either there is an incremental compilation either the performance of the compiler is incredible.
• Unlike Visual Studio, Eclipse presents the import block collapsed by default. I wish I had this in VS… Just like a mobile app fan would say “there’s an app for that”, I bet for VS “there’s a plugin for that”
• In Java if you want to call the super (base) class’s constructor from the current class’s constructor you will write “super(…);” in the constructor’s body. When I first saw this I said to myself Fu-Kin-Su-Pa (er… “great”, that is). “Now I have the liberty to call the base/super constructor from wherever inside the constructor I want”. Well, no. It’s either the first line or it isn’t.

Well, I’ll rant more as I go learning Android development.

My goal is to get to know enough so I can do it in Xamarin via C# but first I must understand the underlying things in order to go a level of abstraction above.

In the next episode(s) : I am indebted with a follow-up from my presentation held at RONUA last year.

Recently I’ve been toying around with Android development (since I own an Android “smart” phone for over 2 years now) and mobile development is all the rage now. Moreover, I’ve been trying to do new things lately since even the pragmatic programmer guide advises us to learn a new language each year (kind of aggressive if you ask me).

Anyway I will try to show what a C# developer (almost 8 years now) discovers by doing Java development on Eclipse for Android.

For today :

leaving a member of a class without an access modifier defaults to internal instead of private :

// C#
void Test() // private method
{
}

// Java
void test() { // internal method
}

Overriding a method does not require any kind of keyword or special ceremony. You can use the @Override annotation but this is optional. You can get burned this way easily.

// C#
public override bool Equals(object other)
{
    return _id == other._id;
}

// Java; WRONG! DO NOT USE
public bool equals(Person other) {
    return this.id == other.id;
}

//Correct
public bool equals(Object other) {
    return this.id == other.id;
}

Overriding requires that you use the same method signature (that is, the same return type, the same parameter types and order). If you accidentally mistake the signature (Person instead of Object) you will overload instead of overriding with unknown effects.

In other “news”, Android development has a lot of similarities with WPF :

• You have activities (similar to pages in Silverlight/WPF).
• These are XML-defined.
• There are a few base-layout controls (viewobjects) like LinearLayout (StackPanel), GridLayout and so on.
• You must not access UI elements from other threads than the main / UI thread.
• The layout viewobjects have similar properties to the layout controls in WPF/Silverlight : width/height which can be specified absolutely or relatively and so on.

The lack of properties baked in the language is annoying regardless of the features of Eclipse (generate getters and setters). The auto-complete feature is far from Visual Studio and there is no “ReSharper” to easily import missing types. Yes there is F2 but still..

The lack of delegates makes multithreading a pain (you know where this pain is located) and so is the wiring of the handlers for clicking buttons and all.

Oh well, I’ll carry on and be back with new opinions as I go.

This will be a local user group talk that I’ll be having, in Bucharest on Tuesday 13th of November.

Storing large binary objects (usually image files) in the RDBMS has been a blessing but for some is unconceivable. We will explore different ways to do this, from worse to best and we will take advantage of a new feature introduced by SQL Server 2012.

The location is TeamNet Int’l HQ – Sema Parc, Splaiul Independenţei nr. 319, clădirea RiverView, etaj 8
Except an ID there is nothing else that you need to bring in order to participate to the event.
Further geographical details.

The most popular way to get there is by taking the subway as there is a station right near the building.

The official announcement can be found on RONUA’s site.

See you there!

——–

Later edit : It’s been great! Not too many people but keen to learn new stuff. Here’s two pictures from the talk. Notice a new generation of programmers forming

Let’s suppose you have three classes in a simple hierarchy :

public class A
{
}

public class B : A
{
}

public class C : A
{
}

Now suppose you receive an instance of one of these classes (you don’t know the exact type to which this instance belongs). How can you determine programatically if the instance is of a type inheriting from A or it is of type A exactly?

Normally I would do the following :

var instance = ObtainInstanceFromSomeWhere(); // this method will not return null
var instanceIsExactlyOfTypeA = typeof(A) == instance.GetType();
var instanceIsOfTypeAOrAnInheritingType = typeof(A).IsAssignableFrom(instance.GetType());

All these work and are nice and dandy. However ReSharper showed me a nicer alternative to the last statement :

var instanceIsOfTypeAOrAnInheritingType = typeof(A).IsInstanceOfType(instance);

Now, pro’lly, many of you knew about this method but I didn’t!
Hopefully it will help someone..

In WPF, when applying the MVVM (an arhitectural pattern) we often need to implement the INotifyPropertyChanged on certain classes (ViewModel classes), which means something like this :

public class PersonViewModel : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value) return;
            _name = value;
            NotifyPropertyChanged("Name");
        }
    }

    private void NotifyPropertyChanged(string propertyName)
    {
        var evt = PropertyChanged;
        if (evt != null) evt(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

In case you’re wondering why I copied the PropertyChanged value to the local variable called “evt” and then tested it for null is that you can have race conditions, in general, triggering events (i.e.: you test the attribute value, it is not null and before you trigger it some other thread sets it to null and bang, NullReferenceException when you trigger it). More details on this CodeProject.

The next step is to pull the NotifyPropertyChanged method and PropertyChanged event into a base class (let’s call it ViewModelBase) and you’ve eliminated redundancy between several ViewModel classes.

The not-so-nice part is having the call to NotifyPropertyChanged stringly-typed. That means that if later you rename (via Visual Studio or ReSharper) the Name property to “FullName” the call will still pass “Name” as the argument.

Some blog posts around the web show how you can use a Func to make it type-safe (refactor safe etc).

More or less they’re doing the same thing :

public abstract class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyChanged(Expression<Func<object>> propertyAccessor)
    {
        var evt = PropertyChanged;
        if (evt == null) return;
        var propertyName = propertyAccessor.GetName();
        evt(this, new PropertyChangedEventArgs(propertyName));
    }
}

public static class Utils
{
    public static string GetName(this LambdaExpression expression)
    {
        MemberExpression memberExpression;
        if (expression.Body is UnaryExpression)
        {
            var unaryExpression = (UnaryExpression)expression.Body;
            memberExpression = (MemberExpression)unaryExpression.Operand;
        }
        else if (expression.Body is MemberExpression)
        {
            memberExpression = (MemberExpression)expression.Body;
        }
        else
        {
            return null;
        }
        return memberExpression.Member.Name;
    }
}

This is definitely nicer, not-redundant and type-safe. It does have the drawback of having some runtime performance penalty associated with the reflection of the expression. You could cache the property name string in a private field but then you’d have to write more code in the ViewModel classes which would… suck. In practice this performance penalty is negligible so you can just ignore this.

Then came .NET 4.5 and among other improvements a new mechanism has been introduced : CallMemberName.

Historically some folks tried to get programatically the name of the caller method by inspecting the StackTrace (for example using System.Environment.StackTrace) but this is prone to errors since in Release mode the compiler could eliminate some methods by inlining them and you’ll be screwed. Plus the penalty would be higher than reflecting an expression.

The new mechanism in .NET 4.5 is type-safe, has no runtime performance penalty and it’s more elegant. Here’s how you can use it :

public abstract class ViewModelBase : INotifyPropertyChanged
{
    protected void NotifyPropertyChanged([CallerMemberName] string propertyName = null)
    {
        var deleg = PropertyChanged;
        if (deleg != null)
        {
            deleg(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

public class PersonViewModel : ViewModelBase
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value) return;
            _name = value;
            NotifyPropertyChanged();
        }
    }
}

I’ve recently built a very small GuidGen utility (which as the name implies generates GUIDs, copies it in the Windows Clipboard and stores a history of past generated GUIDs). You can browse some of the code and check out the project.

Much nicer, isn’t it?

Funny thing, this new mechanism can be used for non-UI tasks. For example if you have a project that uses and RDBMS and you use stored procedures. Let’s say you have one method in a repository class for each stored procedure, and even more, the method’s name matches the stored procedure’s name :

public VerificationResult VerifyUser(VerificationData verificationData)
{
    if (EmailValidator.IsEmailInvalid(verificationData.EmailAddress)) throw new FormatException("emailAddress");

    var result = CreateNewCommand("VerifyUser").GetEnumResult<VerificationFailReason>(
        CreateEmailAddressParameter(verificationData.EmailAddress),
        CreateUniqueIdentifierParam("@VerificationCode", verificationData.VerificationCode));

    return new VerificationResult(result);
}

Observe on line 5 how the call to CreateNewCommand passes a string which matches the current method’s name. This can also be simplified (and become refactor-safe) using the new CallMemberName mechanism.

So you can’t really say that CallMemberName is useful only for UI tasks

Sometimes you need to update data in a table and then update data in another table but based on a filter condition found from the first table. Specifically have you had to do this in the past?

-- ...

UPDATE Users
SET    Verified     = 1
FROM   Logins
WHERE  EmailAddress = @EmailAddress

DECLARE @UserId INT;

SELECT TOP 1
       @UserId = UserId
FROM   Logins
WHERE  EmailAddress = @EmailAddress

UPDATE  Users
SET     State = 2 -- Verified
WHERE   Id = @UserId

-- ...

This is not only inefficient (from an execution plan perspective) but also prone to race conditions and requires more code. The simpler and safer alternative is to use the OUTPUT clause of the UPDATE.

Here’s how :

DECLARE @UserIdTable TABLE ( Id INT );

UPDATE Users
SET    Verified     = 1
OUTPUT UserId
INTO   @UserIdTable
FROM   Logins
WHERE  EmailAddress = @EmailAddress

DECLARE @UserId INT = SELECT TOP 1 Id FROM @UserIdTable;

UPDATE  Users
SET     State = 2 -- Verified
WHERE   Id = @UserId

In the above code sample I take advantage of the new declare and initialize syntax introduced in SQL Server 2008. The OUTPUT clause has been introduced in SQL Server 2005 so nothing here is really news.

Another simplification that I hoped it was possible was to avoid the declaration of the local table variable and just push the OUTPUT into the local variable (@UserId) but it seems you can’t.

I found out about the OUTPUT clause recently from Remus Rusanu’s blog post about implementing queues with tables. These have, usually, high concurrency and any race condition that might occur will occur. OUTPUT is usually the best way to solve it.

I read today a nice article, from Kathleen Dollard, called To “as” or not to “as”. This is a pain-point for me on which I stumble often, so I decided to write this little rant.

I particularly liked a paragraph from the above-cited article :

One of the things that makes hard bugs hard is when there is a disconnect in time or space between the cause and the symptom. Time is time, space is lines of code, assembly placement, etc. Code can be written to minimize these disconnects. One of the ways to do that is to fail quickly. When application state becomes incorrect, yell about it immediately and rarely continue with the application in an invalid state. A null-reference exception at an unexpected time just makes code more difficult to debug.

I couldn’t express this as good as Kathleen did. Make no mistake I am quite biased in this comparison (direct-cast vs. as-cast). I kind of hate the abuse of the as operator.

Very often people turn to as instead of the direct (prefix) cast because:

• They fear the InvalidCastException (strange, they don’t seem to fear the NullReferenceException)
• They feel the syntax more fluent, closer to the human language.

I would consider the only valid case to use the as-cast is, just like Kathleen states, when a null value result is valid for the rest of the execution of the code. For the rest of the cases it’s just wrong.

This also promotes (doesn’t necessarily causes but promotes) bad practices like this :

public static void OnButtonClick(object sender, EventArgs e)
{
    var button = sender as Button;
    if (button == null)
    {
        return;
    }
    if (button.Tag == "somevalue")
    {
        // do something
    }
    // ...
}

In this example the event handler (which could be attached to more than one distinct button) simply forces under the rug a situation which would be abnormal (the sender not being a button) instead of releasing it so the developers could find it easier and debug it. A saner approach is :

public static void OnButtonClick(object sender, EventArgs e)
{
    var button = (Button)sender;
    if (button.Tag == "somevalue")
    {
        // do something
    }
    // ...
}

This brings me to another advantage of the prefix-cast : it produces shorter, clearer code.

In other cases the as abuse does more harm, hiding the source of a bug :

public void ProcessData(Entity entity)
{
    var person = entity as Person;
    UpdatePersonStatistics(person);
    // .. more code
}

public void UpdatePersonStatistics(Person person)
{
    NormalizeData(person);
    // .. more code
}

public void NormalizeData(Person person)
{
    person.Name = person.Name.Substring(0, 50);
    person.Address = person.Address.Substring(0, 100);
    // .. more code
}

Of course this is a contrived example full of bad practices but for now let’s focus on the as usage. Suppose the ProcessData method receives an instance of Category by mistake. Since Category inherits Entity the compiler will not complain.

The result is that there will be a NullReferenceException two methods further, in the NormalizeData method. If the cast was done with a prefix cast the error was a little bit easier to spot. This is confusing two-fold :

1. The name of the exception suggests that a null reference was somehow obtained but in fact a real instance of Category was passed, not a null
2. The error does not originate from the NormalizeData code but from the caller of the ProcessData

Summary

Use as only if a null result of the conversion makes sense for the flow of the execution. Otherwise use prefix cast.

A frequently-used design pattern is the Decorator. This is also known as a mixin (or they might not be the very same thing but certainly they are related).

Typically you might need to create a class that implements a certain interface and uses another class that implements that exact interface but you need to provide some additional feature(s). An example would be a class that adds transactional behavior to an existing data-access class (a naive example) :

public interface IDataAccess
{
    void AddCustomerInvoice(Invoice invoice, User user);
}

public class DataAccess : IDataAccess
{
    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        InsertInvoice(invoice, user);
        UpdateCustomerDebt(user, invoice.Total);
    }

    // ... the rest of the implementation
}

public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
         using(var tx = new TransactionScope())
         {
             _dataAccess.AddCustomerInvoice(invoice, user);
             tx.Complete();
         }
    }

    // ... the rest of the implementation
}

Another type of example would be the Adapter design pattern. An example would be providing access to a (static) class (that may be out of your control) in a mock-able manner. That is, implement another class, non-static, which implements a defined interface and eases unit-testing :

public class StorageManager
{
    public void StoreData(string key, byte[] data)
    {
         if (string.IsNullOrWhiteSpace(key))
         {
              throw new ArgumentNullException("key");
         }
         if (data == null)
         {
             throw new ArgumentNullException("data");
         }
         System.IO.File.WriteAllBytes(key + ".bin", data);
    }
}

This class, as you can see, uses the static File class in the BCL of .NET Framework. If I need to unit-test the StoreData method in a way to assert that the data is actually written to the file (and maybe test the file is named as the key and the binary data and only the binary data is placed in that file etc.) then I can’t do it. Well you might get away with TypeMock Isolator (expensive piece of… software) or Moles/Pex but it’s just not right™.

So we define an interface :

public interface IFileAccess
{
    void WriteAllBytes(string filePath, byte[] binaryContent);
}

and then we write an implementation for this class

public class FileAccessAdapter : IFileAccess
{
    public void WriteAllBytes(string filePath, byte[] binaryContent)
    {
        System.IO.File.WriteAllBytes(filePath, binaryContent);
    }
}

Finally we update the StorageManager class :

public class StorageManager
{
    private readonly IFileAccess _fileAccess;

    public StorageManager(IFileAccess fileAccess)
    {
         if (fileAccess == null)
         {
             throw new ArgumentNullException("fileAccess");
         }
         _fileAccess = fileAccess;
    }

    public void StoreData(string key, byte[] data)
    {
         if (string.IsNullOrWhiteSpace(key))
         {
              throw new ArgumentNullException("key");
         }
         if (data == null)
         {
             throw new ArgumentNullException("data");
         }
         _fileAccess.WriteAllBytes(key + ".bin", data);
    }
}

Now we can unit test the StorageManager class by providing a mock of the IFileAccess interface.

Having finished the introduction let’s get to business. The nice thing is that using these patterns you have a more loosely-coupled code and you can unit test it. The not-so-nice thing is that you need to write a lot of repetitive code that’s really boring. I mean usually the interfaces won’t have 1-2 methods like my examples above but sometimes tens or even a hundred (yes, unfortunately some people haven’t heard of ISP – Interface Segregation Principle).

Today, as I was creating such an adapter for a static class to which I don’t have much control, I thought : maybe ReSharper can help me… I looked in the implement interface dialog box but no help. Then I turned to Google and as usual in the past few years one of the best piece of information came from Stackoverflow : How to (visual studio 2008 / Resharper) refactor / automate mixin pattern.

Trying to implement the adapter pattern I failed since ReSharper does not support this scenario directly but being intrigued I tried to create a decorator (the first scenario presented above). However, let’s resume the first example. At first I wrote the class definition and the constructor for the TransactionalDataAccess class :

public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }
}

Then I pressed ALT-INSERT inside the block of code of the class :

I selected Delegating members and then in the following dialog box :

I selected all the interface’s members (in this simple example there was only one but in production I selected around 50 members). Finally the code generated was like this :

public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        _dataAccess.AddCustomerInvoice(invoice, user);
    }
}

I just added the transaction wrapper :

public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        using (var tx = new TransactionScope())
        {
            _dataAccess.AddCustomerInvoice(invoice, user);
            tx.Complete();
        }
    }
}

… and I was done with it. For the adapter class all you need is to extract the interface from the static class (you can view the metadata using Visual Studio and copy/paste it). Then create the adapter class, create a constructor with (at least) one parameter of the interface type, generate the delegating members just like above, modify or delete the constructor and the private field and replace (CTRL-H) all the occurences of the private field with a call to the static class being adapted.

… that’s all folks!

I downloaded and installed Windows 8 Release Preview on two of my computers since one (the laptop) was up for selling to a friend and the (up to then) unused desktop was OS-less.

The installation is well streamlined, just like Office 2010 (or maybe even 2007?) in that it provides a large and attractive “Install now” button so you have very little to think. If you need to customize the installation there is a small link beneath that allows you to do just that. I didn’t opt for that.

It took, I think, 20 minutes to install completely which is pretty decent in my opinion. At this moment I need to state the hardware involved :

• Intel Core 2 Quad 2.4 GHz CPU
• GIGABYTE GA-EP-45-UD3LR Mainboard
• HDD 1.0 TB Western Digital (5400 rpm – yeah, it will fly out the window soon)
• 8 GB RAM DDR2

As you can guess the major visual difference is the start menu which looks pretty freaky as in the picture above. You will need some time to get accustomed to it. The tiles at the left are metro apps (which work pretty different, running in full screen and having the same visual style). At the right there are non-metro apps (should we call them “legacy apps”?). The desktop itself is a metro app.

The taskbar does not have the start button anymore since the start menu is a full screen thing. So you’ll probably start up, by mistake, IE 10 a few times since by default it is the leftmost thing on the taskbar. IE 10 seems to be pretty much the same thing as IE 9 but snappier.

I also struggled a bit to change the audio volume but I found that “touching” (with the mouse cursor) the top right corner brings up a band/pane which contains several settings such as audio volume, power commands and others (search, share, start, devices and settings).

A similar “charm” (it seems this is the name) exists on the left, for switching apps. You can get used to these, it ain’t too hard.

A really nice improvement is the copy/cut files dialog :

It’s nice because it has a graph and shows actual average as a horizontal line which varies depending on the actual speed of the process. It also has a nice new addition : the pause button which can be pretty handy if you need to relax a drive’s load.

The Win-TAB 3D animation for switching apps seems gone (or at least you won’t be able to trigger it with Win-TAB) which kinda sucks.

The dialog boxes are somewhat improved in the way they are simpler to understand and to decide what to do further. The file searching seems faster and app searching too.

All in all it seems like a real upgrade.

I am by no means against any of the instructions which exist in C#, including goto (wow, I said that). Each of them can have its place and its normal use in an application. However things can be abused and code gets nasty.

For example let’s consider we are displaying a hierarchy of people in an organization in a tree-like visual component. We will create a class that models a person :

public class Person
{
    public string Name { get; set; }
    public IEnumerable Subordinates { get; set; }
}

All is nice but some requests come in, such as : each type of person should have a distinctive icon at its left, the managers should have salutation type displayed etc.

Then you think “I know, I’ll create a PersonType enum”. That’s when things will begin to get nasty.

public enum PersonType
{
    Undefined,
    Simple,
    Manager
}

public class Person
{
    public IEnumerable Subordinates { get; set; }

    // new members :
    public PersonType Type { get; set; }
    public string Salutation { get; set; }
    private string _name;

    // modified members :
    public string Name
    {
        get
        {
             switch(Type)
             {
                 case PersonType.Simple: return _name;
                 case PersonType.Manager : return Salutation + " " + _name;
                 default : throw new InvalidOperationException();
             }
        }
        set { _name = value; }
    }

    public Image Icon
    {
        get
        {
            switch(Type)
            {
                 case PersonType.Simple: return Icons.SimplePersonIcon;
                 case PersonType.Manager : return Icons.ManagerIcon;
                 default : throw new InvalidOperationException();
            }
        }
    }
}

If you find yourself writing switches in one or more properties or methods of the class, switching on the same thing (PersonType here) then stop it. You are writing hard-to-maintain and error-prone code. Plus its inelegant. This practically is a cry for polymorphism.

The right thing to do™ is to have three classes : an abstract Person class, a SimplePerson class (inheriting the Person class) and a ManagerPerson class (also inheriting the Person class) :

public abstract class Person
{
    public virtual string Name { get; set; }
    public IEnumerable Subordinates { get; set; }
    public abstract Image Icon { get; }
    public string Salutation { get; set; }
}

public class SimplePerson : Person
{
    public override Image Icon { get { Icons.SimplePersonIcon; } }
}

public class ManagerPerson : Person
{
    private string _name;

    public override Image Icon { get { Icons.ManagerIcon; } }
    public override string Name
    {
        get
        {
            return Salutation + " " + _name;
        }
        set
        {
            _name = value;
        }
    }
}

Notice that the code is shorter, simpler to follow and understand. Furthermore although we did introduce two more classes, we also removed the PersonType enum so at a total we introduced only one more class.

TL;DR :

• Paging got simpler and more efficient
• Sequences have been introduced; better performance for auto-generated IDs and easier to have IDs unique across tables
• FileTables have been introduced : building upon the FileStream feature now we can have non-transactional access to files stored in the DB as a windows share along with transactional access via T-SQL

Lengthier version :

SQL Server 2012, in my opinion does not come with earth-shaking changes but comes with performance improvements, feature improvements and a some new features.

First of all, Management Studio has the same engine as Visual Studio which means you get a nice WPF experience, better font rendering and CTRL-scroll quick zoom-in/zoom-out.

Let’s say you want to retrieve data from the database in a paged way (that means chunks of data of a requested size or smaller). Typically you would write this in SQL Server 2008 R2 or older :

DECLARE	@Offset		AS INT = 6
DECLARE @PageSize	AS INT = 5

SELECT	Id,
		Name
FROM
(
	SELECT	Id,
			Name,
			ROW_NUMBER()	OVER (ORDER BY Id)	AS	RowNumber
	FROM	Users
) UsersSelection

WHERE	UsersSelection.RowNumber >  @Offset
	AND	UsersSelection.RowNumber <= @Offset + @PageSize

In SQL Server 2012 the T-SQL syntax has been updated introducing keywords that facilitate a simpler and more efficient paging, keywords such as OFFSET, FETCH, NEXT ROWS and ONLY. A script that would retrieve the same data would be :

DECLARE	@Offset		AS INT = 6
DECLARE @PageSize	AS INT = 5

SELECT		Id,
			Name
FROM		Users
ORDER BY	Id
OFFSET		@Offset		ROWS
FETCH NEXT	@PageSize	ROWS ONLY

Observe the simpler, clearer syntax. Also, considering that the subselect has been eliminated (the subselect was required because the ROW_NUMBER column could not be addressed in the same select – for the WHERE clause), also the query cost was improved :

2008 :

2012 :

More details about the paging (some call it pagination) semantics can be found on MSDN.

Next, let’s introduce sequences. MSDN states that :

A sequence is a user-defined schema bound object that generates a sequence of numeric values according to the specification with which the sequence was created. The sequence of numeric values is generated in an ascending or descending order at a defined interval and can be configured to restart (cycle) when exhausted. Sequences, unlike identity columns, are not associated with specific tables. Applications refer to a sequence object to retrieve its next value. The relationship between sequences and tables is controlled by the application. User applications can reference a sequence object and coordinate the values across multiple rows and tables.

…
…
…

Use sequences instead of identity columns in the following scenarios:

• The application requires a number before the insert into the table is made.
• The application requires sharing a single series of numbers between multiple tables or multiple columns within a table.
• The application must restart the number series when a specified number is reached. For example, after assigning values 1 through 10, the application starts assigning values 1 through 10 again.
• The application requires sequence values to be sorted by another field. The NEXT VALUE FOR function can apply the OVER clause to the function call. The OVER clause guarantees that the values returned are generated in the order of the OVER clause’s ORDER BY clause.
• An application requires multiple numbers to be assigned at the same time. For example, an application needs to reserve five sequential numbers. Requesting identity values could result in gaps in the series if other processes were simultaneously issued numbers. Calling sp_sequence_get_range can retrieve several numbers in the sequence at once.
• You need to change the specification of the sequence, such as the increment value.

Now, let’s take a concrete example of a scenario. Let’s say there is some kind of inventory in your company that needs to track certain company assets. Each asset must have its identifier which should be unique across the entire inventory. Let’s suppose we need to track chairs, monitors and other office items and their main characteristics.

One way to do this would be to create a wide table such as :

CREATE TABLE Inventory (
    Id INT IDENTITY(1,1) NOT NULL,
    ItemTypeId TINYINT NOT NULL,
    InchSize TINYINT NULL, -- applies only to monitors
    HasArmRest BIT NULL, -- applies only to chairs
    AdjustableHeight BIT NULL, --might apply to monitors and chairs

 -- ... and so on

That would be a wrong way to do this because of several reasons :

• It would be hard to read, maintain, query
• It would violate several database design rules
• Most of the columns would be nullable increasing the storage space and query speed

Therefore we will design several tables, one for each of the inventory item, also getting rid of the ItemTypeId column.

However generating the ID would no longer be so simple. If we put an ID column as an IDENTITY on each table then we won’t have unique IDs across the inventory. So the 2008-R2-and-older approach would be to create another table, with a single IDENTITY column, table whose whole purpose would be to generate unique IDs. The script to insert an item in this scenario would be :

DECLARE @Id INT
BEGIN TRY
	BEGIN TRANSACTION
		INSERT INTO InventoryIds DEFAULT VALUES
		SET @Id = SCOPE_IDENTITY()
		INSERT INTO Monitors
		(
			[Id],
			[Width]
		)
		VALUES
		(
			@Id,
			17
		)
	COMMIT TRANSACTION
END TRY
BEGIN CATCH
	ROLLBACK TRANSACTION;
	DECLARE @ErrorMessage NVARCHAR(4000);
    DECLARE @ErrorSeverity INT;
    DECLARE @ErrorState INT;
    SELECT	@ErrorMessage = ERROR_MESSAGE(),
			@ErrorSeverity = ERROR_SEVERITY(),
			@ErrorState = ERROR_STATE();
    RAISERROR (@ErrorMessage,
               @ErrorSeverity,
               @ErrorState);
END CATCH

Notice the use of SCOPE_IDENTITY() instead of @@IDENTITY (a short and nice comparison can be found in this StackOverflow response) and INSERT INTO [TableName] DEFAULT VALUES, which at least for me, was a new thing.

Seems overly complicated and to an extent it is. But at least it does a few things well :

• It is transactional so if for some reasons a part of fails, all fails and no orphan IDs will be left behind in the
• It employs a simpler error-handling through the use of TRY/CATCH. By the way 2012 introduces the THROW keyword which can be used as is (no parameters) to rethrow the error to the caller.
• On error it rolls back the transaction AND it reports the error to the caller as close as it was.

Let’s see how we can simplify this in SQL Server 2012 using sequences :

First, we don’t need the InventoryIds any more. Then we’ll create a sequence :

Notice the new “Sequences” node under “Programability”. Next we’ll set up the sequence attributes :

The cycle option is useless in this and the rest of the majority of scenarios. The cache option can be useful in high-loads scenarios since the database engine doesn’t need to read the disk for each ID generated, as it was the case with IDENTITY. The performance improvement is not huge but it’s welcome nevertheless.

Next we’ll write the SQL script to insert the same data :

INSERT INTO Monitors
(
	Id,
	Width
)
VALUES
(
	NEXT VALUE FOR seqInventory,
	19
)

Notice the simpler syntax, a lot shorter and more elegant. Also the monitor is larger

During the presentation at RONUA I was asked two questions that I didn’t have a (definitive) answer back then :

1. Can’t we use UNIQUEIDENTIFIERs and be done with these sequences or sequence-simulation via that table?

   Yes, we can but this has some disadvantages : longer key means more I/O and more storage which hampers JOIN performance and a GUID will be harder to manipulate for a human being – let’s say the poor guy that has to stamp all the inventory goods with the IDs

2. What data types are supported by sequences?

   TINYINT, INT, SMALLINT, BIGINT, DECIMAL and NUMERIC

Finally we approach filetables. This addresses storing (large) binary content in the database. Since this was possible the database people have been torn in two camps : the ones that see this as the best solution and the ones that hate this to death. Personally I’m in the first camp

Typically a CMS / or some other type of website will allow (some) users to upload pictures. This is a common scenario that is encountered but, of course, it’s not the only one.

The other solution would be to store the files on the disk (in the file system, that is) and have a table in the database which contains all the related data (filename, extension, length, date-modified, date-uploaded, actual-filename, actual-path and so on).

The advantages of storing the files in the database would be, in my opinion :

• One data store for all the application’s data; better organization
• A single backup not two or more
• Online backup; the app can add/delete/modify files while the backup is running
• Incremental backups; yes, rsync could do incremental backups for the filesystem but it’s harder

Now considering you would opt for this solution – storing the files in the DB – SQL Server 2012 offers you the filetable feature. This is a solution built upon the FILESTREAM feature which means storing the binary data outside of the MDF (Main Data File) of the database in order to avoid degrading the performance of the typical structured data.

The FileTable feature also allows you to access the files stored in the database via a virtual windows share so any app can access the files from there.

Let’s walk this through and we’ll comment on the feature as we go.

First let’s enable the FILESTREAM support at the server level. Open SQL Server Configuration Manager (requires Administrator privileges) select the SQL Server instance and right-click to properties :

We’ll check all the check-boxes. After this a server restart might be required. Next we’ll create a new database (an existing database can be enabled too, but for clarity we’ll start with a new database).
In the ‘New Database’ dialog we’ll go through the three tabs from bottom to top. Let’s start with Filegroups and create a new FILESTREAM group :

Next, at the options tab, choose a directory name and select the desired access level to the windows share (‘non-transacted access’). For this demo I chose ‘Full’ :

Finally we’ll add a new file in the General tab, then choose a name for the file, select FILESTREAM Data as its type, select the FILESTREAM group and choose a path. The path must exist and it will not be created by SQL Server. You need to create it before finalizing the database creation.

Now click ok and the database is finally created. It’s a bit of ‘pain in the side’ but it only hurts the first time (like other things in life..). Let’s create a filetable in this new database :

Notice the new ‘FileTable’ node under ‘Tables’. While doing this we’ll not be greeted with a dialog box (as I consider we should be) but with a new script like so :

-- =========================================
-- Create FileTable template
-- =========================================
USE <database, sysname, AdventureWorks>
GO

IF OBJECT_ID('<schema_name, sysname, dbo>.<table_name, sysname, sample_filetable>', 'U') IS NOT NULL
  DROP TABLE <schema_name, sysname, dbo>.<table_name, sysname, sample_filetable>
GO

CREATE TABLE <schema_name, sysname, dbo>.<table_name, sysname, sample_filetable> AS FILETABLE
  WITH
  (
    FILETABLE_DIRECTORY = '<file_table_directory_name, sysname, sample_filetable>',
    FILETABLE_COLLATE_FILENAME = <file_table_filename_collation, sysname, database_default>
  )
GO

From all this mess we’ll strip out the unnecessary and we’ll be left with this :

CREATE TABLE MyImages AS FILETABLE
  WITH
  (
    FILETABLE_DIRECTORY = 'MyImages'
  )

This little statement will create a table like so :

Right click on the file table (in Object Explorer) and select the Explore FileTable Directory. This will bring up an empty shared folder. Create a new text file and open it, write some text, save it and close the Notepad.

Now run

SELECT	*,
		CAST(file_stream as VARCHAR(MAX))	AS [TextContent]
FROM	MyImages

You’ll notice how the files moved, renamed, deleted, content-changed and any kind of change done in the windows share is reflected back in the FileTable and vice-versa!

This is a very powerful feature, and in my opinion, quite welcome.

Tuesday, July 10th, I’ll hold a small presentation on the new features of SQL Server 2012 for the database developer, consisting mainly of the sequences, new paging semantics and filetables.

I’ll post the code and slides soon after the presentation. I decided to drop (oh the irony) the slides.

Anyone close to Bucharest is more than welcome to come! Details can be found here.

The opening of the evening will be made by Alex Peta, presenting a cool notification system built upon JS and ASP.NET MVC 3.

Every now and then I have to decide if a character satisfies a predicate (char.IsPunctuation, char.IsSymbol and so on) found on the System.Char class. The MSDN pages are of limited help plus I need to browse each predicate. Therefore I wrote a small piece of code that, aside from the fact that it’s quite simple and has nothing spectacular, tests a set of characters through all these predicates.

Basically this is a reference for me, in order to avoid rewriting this over and over again, but since it could be helpful to others too I decided to publish it here.

using System;
using System.Linq;

namespace CharTest
{
    internal class Program
    {
        static void Main()
        {
            var charPredicates = new Predicate<char>[]
            {
                char.IsControl,
                char.IsDigit,
                char.IsHighSurrogate,
                char.IsLetter,
                char.IsLetterOrDigit,
                char.IsLowSurrogate,
                char.IsLower,
                char.IsNumber,
                char.IsPunctuation,
                char.IsSeparator,
                char.IsSurrogate,
                char.IsSymbol,
                char.IsUpper,
                char.IsWhiteSpace
            };

            Console.WriteLine("Enter an empty line to exit");
            Console.WriteLine();
            Console.WriteLine();

            string line;
            do
            {
                line = Console.ReadLine();
                var chars = line.Distinct().ToArray();
                for (var i = 0; i < chars.Count(); i++)
                {
                    var ch = chars[i];
                    Console.WriteLine();
                    Console.WriteLine("Distinct character " + (i + 1) + " : '" + ch + "'");
                    Console.WriteLine("-----------------------------------------");
                    foreach (var predicate in charPredicates)
                    {

                        Console.Write(predicate.Method.Name);
                        Console.SetCursorPosition(20, Console.CursorTop);
                        Console.WriteLine(predicate(ch));
                    }
                }
            }
            while (line != "");
        }
    }
}

As I wander free upon the large fields of code in this world I sometimes come upon interesting things. The wonder, the joy, the mysteries that I encounter I must share with all of you, otherwise it would be selfish of me.

I will, therefore, start a series (it surely will be a series) of such posts called “The monthly WTF”.

Today I present you :

        private static void CanWhatever(object sender, CanExecuteRoutedEventArgs e)
        {
            if (SomeString.IsNotNullOrEmpty())
            {
                if (Repo.AllowSingleSignOn)
                {
                    e.CanExecute = false;
                }
            }
            e.CanExecute = true;
        }

Notice anything special?

WPF formats non-string objects to a string using a fixed/hardcoded culture (en-US) regardless of the current culture (as in Thread.CurrentThread.CurrentCulture / CultureInfo.CurrentCulture).

Suppose you have a simple DataContext (ViewModel) like so :

public class Data
{
    public DateTime Now
    {
        get
        {
             return DateTime.Now;
        }
    }

    public string NowText
    {
        get
        {
              return DateTime.Now.ToString();
        }
    }
}

Binding an instance of `Data` to a view, with two TextBlocks each of which using ‘Now’ and ‘NowText’ respectively will yield different results if your CurrentCulture is NOT en-US.

Working on an internationalizable WPF app I’ve found out this sad truth. I don’t fully understand why this happens but I’ve found a way to “fix it”.

Somewhere before any piece of UI is shown on the screen (for example in App.xaml.cs in ApplicationStartup) just place this little piece of code :

FrameworkElement.LanguageProperty.OverrideMetadata(
  typeof(FrameworkElement),
  new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)));

It sets for any FrameworkElement (TextBlock and Label are included) the formatting culture to the current culture. Of course you might need to change it again if the current culture changes (for example an on-the-fly UI language changes).

How many of haven’t received unwanted LinkedIn invites from people that claim to know you, been colleagues and you haven’t even heard of?

Like… so :

or like so :

Don’t be fooled, they’re just trying to get their recruitment bonus. The right choice? The “REPORT SPAM” button up above. Press it. They deserve it. The correct way would have been a private message but it’s more useful for the recruiters to add a new contact since they may need to contact him/her again.

What do you think this piece of code will output?

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(GetValue() == (object)true);
            Console.WriteLine(object.Equals(GetValue(), true));
        }

        static object GetValue()
        {
            return true;
        }
    }

I won’t be like others and ask you not to run the code. Run the code if you feel like it. I’ll wait here.

…

Back already? Surprised?
I surely have been.. I’ve found a piece of code similar to this as I was cleaning up code in our repository. You have a method that is required to return object (as in System.Object) and you want to check if, unboxed, it holds the value of true (or not).

Why exactly does

    GetValue() == (object)true

return false considering that GetValue() returns always a true value? Well… because you are comparing two instances of a System.Object and the ‘==’ operator is coded in a way that uses the ReferenceEquals (and not Equals) method on System.Object.

The author could have unboxed it to a local variable and do the check after but the speed of coding is so much important for some of us.. Thank you ReSharper for pointing this to us and fixing a potentially subtle bug.

I had a rough experience a few days ago while trying to book a flight for my upcoming holiday. I … no, we, chose TAROM (site link here).

What happened, in short, I started to book the flight, filled-in all the flight details, got to the point where I need to provide the billing details (card number etc.), pressed next and then… “session expired, please start over again”. For a moment I checked my bank account. Sure enough they took the money and offered me just an error. No email, no nothing.

After 1 hour and something, I finally got to customer service representative who manually issued the tickets which couldn’t have been issued by the site. (Meanwhile I found out how hard is to cancel a payment from your bank to a rogue vendor).

In the end things got fixed but a bitter taste persists towards this TAROM operator. Anyway I tried to understand what went wrong in the process, IT-wise and this is what happened, I think :

1. The site gathered all the flight details from the sucker customer (me)
2. The site then asked for the billing info
3. Tried to bill me and succeeded
4. Tried to book the flight and failed (the session expired in the meanwhile)

From this short analysis a few WTFs have emerged :

• Why did they chose to have an absolute-date expiration policy for the session? (i.e. the session expires precisely 10 minutes after you start the booking process, no matter how many or how frequent you do further requests
• Why didn’t they leave the billing step as the final step?

Having had to put up with Romanian services for the last three decades I’ve learnt that the most probable reason for these WTFs is this :

Leaving the funny thing aside I suppose the ‘architects’ that built TAROM’s site (hope the plane doesn’t crash like the site) thought that it’s better to have the money in the bag and then see if all else went ok… or maybe they thought of a situation where many people would try to book few tickets? Or who knows…

What do you think dear reader?

Have you been testing code speed like this?

var start = DateTime.Now;
int i;
for(i = 0; i < 1000; i++)
{
    DoSomething();
}
var stop = DateTime.Now;
var total = stop - start;
var timePerIteration = total.Ticks / i;

Or maybe you’ve found the Stopwatch class and been happy with its superior time precision?

Better, I’d say, but I’ve quite had it. Plus I needed to benchmark a local website and needed to test parallel requests (something similar to ab – ApacheBench)

What does a programmer in such a case? Writes his own tools! That’s how BenchmarkNET appeared. Using BenchmarkNET you can write the same thing as above only much shorter and with a better timing precision :

var result = Benchmark.Sequentially(() => DoSomething(), 1000);

Neat? That’s not all. The result can easily printed out to a console or inspected with a debugger :

Benchmarking an HTTP operation over 10 parallel threads, 100 times for each thread?

var dl2 = Benchmark.Parallel(new BenchmarkParams<WebClient>(c => c.DownloadString("http://localhost/"), 100), 10, () => new WebClient());

The project has been published as open source (LGPL license) on CodePlex. You can discuss it, file bugs, or even contribute to it.

Have fun and if you test it out, please leave some feedback!

Later edit : It seems some people already dig it

TL;DR version :

Upon a curiosity of mine I found out that WCF with basicHttpBinding can be easily beaten (performance-wise) by plain-old ASP.NET even if stripped down of transactions, reliability, security etc. (1500 req/sec vs  800 req/sec)

Also SQL Server Express can handle 1300 inserts per second easily and up to 4300 queries per second just as well. This on a 6+ million rows table and stored on the hard disk not in RAM.

Long version :

A few days ago I was thinking how I implemented a certain web service a few years ago, a few employers ago. Although it was quite fast and efficient it wasn’t scalable. I, then, thought how I should have implemented it.

The web service had to receive an incoming (public) HTTP request, check for a visitor cookie. If there was a visitor-identifying cookie it would check against a data store (in-memory dictionary at that time) to see if that visitor answered.

It was about inviting visitors of certain sites to an on-line survey. A new visitor would be presented with a pop-up box having a “yes”, a “no” and “X” (close) button.

The business rules stated that if the visitor answered yes, the answer would be stored, the pop-up would close and then a new tab/window would appear with the survey. If the visitor answered no, then the same things would happen except opening the survey. If the visitor closed the pop-up, the next time the pop-up would appear again. If the visitor closed three times the pop-up then (s)he wouldn’t be bothered anymore with the invitation.

Quite simple I’d say. The tough thing was we only had one machine available (a quad-core Xeon 3.5 GHz 4GB RAM) and the expected traffic was 300-400 req/sec during normal load and maybe a peak load of 800-1000 req/sec. In that situation I decided to use a simple in-memory dictionary as data-store that I’d backup to disk a few times per hour. Things went smooth (at least till I left the company but also after I left, as an ex-colleague of mine told me).

You can easily see that this architecture, although efficient, is not scalable. At least not if you scale out I personally find efficiency and the ability to scale out completely independent.

So how would I reimplement this (if I would) in a scalable manner? Balancing and scaling the front-facing web servers would be straight-forward : a simple hardware NLB (network

load balancer) in front of n web servers and that’s that. In the back there would be m storage servers that would just store the visitors’ responses and server query responses

to the web servers. Having naturally partitionable data such as this (especially because it is not inter-related) makes the “sharding” easy.

My questions that arise are :

1. What type of communication should I employ between the web servers and the storage servers?
2. What type of storage should I use on the storage servers?

For communication I tested and benchmarked WCF (with basicHttpBinding) hosted in IIS and a simple ASP.NET Generic handler (.ashx thingie) in an empty web application. As for the storage I only tested SQL Server 2008 R2 Express with a database stored on the hard disk (I fancied using MySql with an in-memory storage engine or SQL Server with a database stored on a ram disk, and a periodic backup on a hard disk). However the test results on a standard DB on SQL Server satisfied me and I didn’t need to go any further.

A few words on the machine I used for testing : my el-cheapo laptop : a two-year old, AMD dual core with 3GB of RAM with Windows 7 Ultimate 64 bit. (complete specs here)

I started testing communication options. I set up a WCF service hosted in IIS Express, with minimal features, intended to max out performance (no security, singleton service instance, multiple concurrent calls, 1000 max concurrent connections and so on). I then made a small console app that would set up 10 threads that each of them would sequentially make 1,000 calls to the service and measure the whole time.

10 x 1,000 calls completed in 60 seconds [170 req/sec]. Like lame, dude..

Then I thrown up a small, empty web application with just one generic handler which could be queried a bit like so : http://localhost:1234/GetData.ashx?id=39283&opId=1 and it would only send out a single byte that would be the user state.

10 x 1,000 calls completed in 15 seconds [670 req/sec].

Wow, quite a different set of results… I then went out to turn to the community to find out how to improve the WCF service and I asked this on stackoverflow. Not much help there (at least at the time of this writing). I then set both web apps on IIS (full not express) 7.5 and turned compilation to release in all projects (wcf web app, asp.net web app and the test harness project). Things changed “a bit” :

ASP.NET Generic handler : 6.7 sec [1492 req/sec]
WCF service : 13.7 sec [730 req/sec]

Good enough I said to myself, since, in the end, you could easily scale them out. Then I went to see how the DB would stand up to this beating. At first I was quite pesimist about an RDBMS with the backing store on the HDD (no RAID 0, no nothing) – a 7200 rpm laptop hard-drive.

Starting from an empty table (Id – bigint – 64 bit, Response – tinyint – 8 bit) I started to insert sequentially (over the same connection, unclosed) 6 million rows. At first the table had a clustered index on the Id column slowing down the inserts. From 0 to the first 100,000th record it inserted at an approximate rate of 1500 rows/sec and then went down and down asymptotically until I got bored and stopped it (at around 3.5 million rows).

Then I truncated the table, removed the clustered index and I was able to insert consistently (again, sequentially on a single connection) at 1250 rows/sec. For kicks I truncated the table again (use TRUNCATE rather than DELETE TABLE because it’s way faster and cleaner) and used BULK INSERT just as in Dave’s article and got something like 58,000 rows/second!!!

Being satisfied with the findings I got to test the query performance. I used a 6 million rows content for the table and tested with a clustered index and got around 4.291 queries per second!!! while without an index the table scan ruined the performance to 1 (one) query per second. Adding back the index to the indexless table took 21 seconds. Decent, I’d say.

In the end I had one more “What if” question on the top of my head : What if instead of a bigint (Int64, long , however you call it) I would have a normal int (32 bits)? For 6 million generated visitorIds how many collisions I’d get? And by collision I mean something simillar to hash collisions. I got 11,000 for 6,000,000 (0.1%). Acceptable for the business case. Generating long (64 bit) Ids would not generate any collision.

Conclusion : You can safely use WCF with SQL Server and still get decent performance. If you really need and want to tweak the performance you can use other solutions (generic handlers, in-memory dictionaries or memory-backed DBMS’es or even NoSQL solutions) but they will be harder to design, implement, deploy and maintain. So start simple and then find your way.

http://en.wikipedia.org/wiki/Hash_collision

I held a presentation about WCF Streaming last Saturday, November 26th, at Microsoft HQ Bucharest. I illustrated WCF Streaming in a small client/server application which was supposed to (and in the end implemented it all) :

• Show all files available on the server in the client application
• Allow the end user to upload a file (up to 2GB) to the server
• Allow the user to download a file from the server
• Display a progress bar that would update in real-time showing the progress of the current transfer (upload or download)
• Allow the user to press the “Stop” button to stop the current transfer (upload or download)

The code to achieve this in a simple (non-robust, not production quality etc.) manner is quite small : around 50 lines of code for the server and around 200 lines for the client. The WCF runtime takes care of the rest.

Points of interest (things for which I suffered and hopefully you won’t) :

• Cassini (ASP.NET Web development) server does not support streaming, reports a cryptic (400 Bad request) error and it’s not documented at Microsoft!
• It’s not enough at the server level to set the maxReceivedMessageSize at the binding element, you must also set it in the maxRequestLength attribute on the system.web/httpRuntime element if you host the service in a site.
• Don’t try to define an operation with mixed types, that is, complex types that are decorated with MessageContract and any other types (including System.String). If one is MessageContract then all have to be. Found out the hard way, at runtime (not compile time)
• In order to get the folder path for a WCF application you must use HostingEnvironment.GetApplicationPhysicalPath.
• In .NET 4 there is a CopyTo method on the Stream class which simplifies copying data from a stream to another.
• Opt in for asynchronous method generation for the client-side WCF proxies

You can find below the PowerPoint slides and the code archive attached to this post.

WCF Streaming – slides

WCF Streaming – the code

Saturday, November 26th, there will be a session of presentations at Microsoft’s Bucharest Headquarters.

Free entrance, drinks and lunch on the house.

The event agenda :

• 09:30 – 10:00 Arrival
• 10:00 – 11:00 MVC / EF (Andrei Ignat)
• 11:00 – 12:00 WCF Streaming (Andrei Rinea)
• 12:00 – 13:00 SQL Server Denali (Cristian Lefter)
• 13:00 – 13:30 LUNCH
• 13:30 – 14:00 A lap around Windows 8 (Mihai Nadăș)
• 14:00 – 15:15 Hyper-V 3.0 și SCVMM 2012 (Valentin Cristea & Răzvan Rusu)
• 15:15 – 16:30 Office 365 și Lync Online & On-Premise (Alexandru Dionisie & Paul Roman)

I will be presenting WCF Streaming at 11:00. But I assure you the other presentations will be just as interesting as this!

Come and join us and you won’t regret it! But first register at the event site first! Only 22 seats available at the time of the writing.

Hope to see you there!.

Developing that small WCF presentation that I was talking about earlier, I got stumped on trying to get the local path. The server needs to access the App_Data folder to handle uploads and downloads but it needs the base path for that.

No, you don’t get HttpContext (HttpContext.Current is null) although the service is bound over basicHttpBinding.

Luckily I’ve found via StackOverflow that there is HostingEnvironment.ApplicationPhysicalPath which will help you.

Therefore a simple

public class Service : IService
{
    private readonly string _dataFolder;

    public Service()
    {
       _dataFolder = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "App_Data");
    }
}

.. will suffice.

I am preparing a small talk & demo on WCF streaming and I’ve tried a lot of things to get it started and working (the practical demo).

I was trying to showcase uploading and downloading large files, in an async manner with progress report and so on.

Turns out I get an exception, with HTTP code 400 Bad request no matter what I’ve tried :

• transferMode : StreamedRequest, StreamedResponse or Streamed (Buffered works but it’s not streaming so…)
• Tried using MessageContracts or plain Stream’s
• .NET Framework 3.5 or 4.0
• .. and many other things.

What was the issue? Well the damn development server (code named Cassini) !!! It seems another guy had the same issue, reported on StackOverflow and I was lucky to find it in the large WCF pile.

Running the same server project on the new IIS Express or plain old IIS makes it work.

Hope this will help someone too.. At all costs avoid Cassini (“ASP.NET Development Server”). This is not the first issue that this damn server introduces and surely not the last. I hope Visual Studi vNext will NOT include it anymore and will ship with IIS Express only.

Today as I was inspecting why some condition was evaluated to true instead of false I found out a strange thing. The code is something like :

var someList = new List<Person>();
if (someList.All(v => v.Age > 18))
{
    Console.WriteLine("All are 18 or older.");
}
else
{
    Console.WriteLine("At least one is less than 18.");
}

I was expecting that in case of an empty collection the All method would return false. But it doesn’t. The “All are 18 or older.” string would be printed.

In my case one more simple condition solved this issue :

    if (someList.Any() && someList.All(v => v.Age > 18))

After this I read the manual (RTFM) and according to MSDN (in a community comment however) :

It’s important to note that Enumerable.All() returns true for empty sequences

So it’s a “doh” moment for me.

Watch out for this in your code.

As I was writing a small TCP server for serving a Silverlight local TCP policy, I came across a certain need. Inspired by Dan Wahlin’s server implementation, I chose to write a simplified version for myself. I needed to keep some XML in the App.config without constraining it with a schema.

The normal solution in this case is a custom section, sibling to appSettings if you wish. So my App.Config looked at first like this:

<configuration>
  <appSettings>
    <add key="ipAddress" value="127.0.0.1"/>
  </appSettings>
  <access-policy>
    <cross-domain-access>
      <policy>
        <allow-from>
          <domain uri="*" />
        </allow-from>
        <grant-to>
          <socket-resource port="4502" protocol="tcp" />
        </grant-to>
      </policy>
    </cross-domain-access>
  </access-policy>
</configuration>

Upon running the program, even addressing the “ipAddress” key in the appSettings section throws an exception like:

System.Configuration.ConfigurationErrorsException was unhandled
  Message="Configuration system failed to initialize"
  Source="System.Configuration"
  BareMessage="Configuration system failed to initialize"
  Line=0
  StackTrace:
       at System.Configuration.ConfigurationManager.PrepareConfigSystem()
       at System.Configuration.ConfigurationManager.GetSection(String sectionName)
       at System.Configuration.ConfigurationManager.get_AppSettings()
       at ConsoleApplication1.Program.Main(String[] args) in C:\Users\Andrei\Documents\Visual Studio 2008\Projects\ConsoleApplication1\ConsoleApplication1\Program.cs:line 21
       at System.AppDomain._nExecuteAssembly(Assembly assembly, String[] args)
       at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       at System.Threading.ThreadHelper.ThreadStart()
  InnerException: System.Configuration.ConfigurationErrorsException
       Message="Unrecognized configuration section access-policy.
               (C:\\Users\\Andrei\\Documents\\Visual Studio 2008\\Projects\\ConsoleApplication1\\ConsoleApplication1\\bin\\Debug\\ConsoleApplication1.vshost.exe.config line 8)"
       Source="System.Configuration"
       BareMessage="Unrecognized configuration section access-policy."
       Filename="C:\\Users\\Andrei\\Documents\\Visual Studio 2008\\Projects\\ConsoleApplication1\\ConsoleApplication1\\bin\\Debug\\ConsoleApplication1.vshost.exe.config"
       Line=8
       StackTrace:
            at System.Configuration.ConfigurationSchemaErrors.ThrowIfErrors(Boolean ignoreLocal)
            at System.Configuration.BaseConfigurationRecord.ThrowIfParseErrors(ConfigurationSchemaErrors schemaErrors)
            at System.Configuration.BaseConfigurationRecord.ThrowIfInitErrors()
            at System.Configuration.ClientConfigurationSystem.EnsureInit(String configKey)
       InnerException:

So something is wrong. We need to tell the runtime that the “access-policy” section is allowed.

<configuration>
   <configSections>
    <section name="access-policy" type="CustomSections.InlineXmlSection, CustomSections"/>
   </configSections>
  ...

At first, I didn’t place the type attribute in the “section” element, but it turned out it had to be specified and not be empty. Moreover, it must contain the fully-qualified class name and the assembly which contains it. The class must inherit from System.Configuration.ConfigurationSection.
Also ensure that the assembly name is specified after the coma, in the type attribute and the configSections section is the first child element of the configuration (root) element.

So, I created an assembly called CustomSections, and added references to the System.Configuration assembly and the System.Xml assembly.

All you need to do is override the DeserializeSection method and load the XML document in there:

using System.Configuration;
using System.Xml;

namespace CustomSections
{
  public class InlineXmlSection : ConfigurationSection
  {
    public XmlDocument Content { get; private set; }

    protected override void DeserializeSection(XmlReader reader)
    {
      (this.Content = new XmlDocument()).Load(reader);
    }
  }
}

The code is pretty self-explanatory: we instantiate a new XmlDocument and load it from the XmlReader provided to us by the configuration infrastructure. If anything goes bad, the exception handling will be the responsibility of the caller. In this case, the first call to ConfigurationManager.

Now, let’s put the code to use:

private static void Main(string[] args)
{
  expectedRequestBytes = Encoding.UTF8.GetBytes("<policy-file-request/>");
  listener = new TcpListener(IPAddress.Parse(ConfigurationManager.AppSettings["ipAddress"]), 943);
  var policySection = (InlineXmlSection)ConfigurationManager.GetSection("access-policy");
  policyBytes = Encoding.UTF8.GetBytes(policySection.Content.OuterXml);
  ...
}

The underlined code is the relevant portion (the rest is provided for context). We get the section via ConfigurationManager.GetSection, and we have to cast the result to the desired section type. Then we use the section as we see fit.