C# 4 and .NET 4

76 ❘ ChaPTer 3 Objects And types
{
// initialization code
}
// rest of class definition
}
One reason for writing a static constructor is if your class has some static fields or properties that need to be
initialized from an external source before the class is first used.
The .NET runtime makes no guarantees about when a static constructor will be executed, so you should
not place any code in it that relies on it being executed at a particular time (for example, when an assembly
is loaded). Nor is it possible to predict in what order static constructors of different classes will execute.
However, what is guaranteed is that the static constructor will run at most once, and that it will be
invoked before your code makes any reference to the class. In C#, the static constructor is usually executed
immediately before the first call to any member of the class.
Notice that the static constructor does not have any access modifiers. It’s never called by any other C# code,
but always by the .NET runtime when the class is loaded, so any access modifier such as public or private
would be meaningless. For this same reason, the static constructor can never take any parameters, and there
can be only one static constructor for a class. It should also be obvious that a static constructor can access
only static members, not instance members, of the class.
Note that it is possible to have a static constructor and a zero-parameter instance constructor defined in
the same class. Although the parameter lists are identical, there is no conflict. That’s because the static
constructor is executed when the class is loaded, but the instance constructor is executed whenever an
instance is created — so there won’t be any confusion about which constructor gets executed when.
Note that if you have more than one class that has a static constructor, the static constructor that will be
executed first is undefined. This means that you should not put any code in a static constructor that depends
on other static constructors having been or not having been executed. However, if any static fields have been
given default values, these will be allocated before the static constructor is called.
The next example illustrates the use of a static constructor and is based on the idea of a program that has
user preferences (which are presumably stored in some configuration file). To keep things simple, we’ll
assume just one user preference — a quantity called BackColor, which might represent the background
color to be used in an application. And because we don’t want to get into the details of writing code to read
data from an external source here, we’ll make the assumption that the preference is to have a background
color of red on weekdays and green on weekends. All the program will do is display the preference in a
console window — but this is enough to see a static constructor at work.
namespace Wrox.ProCSharp.StaticConstructorSample
{
public class UserPreferences
{
public static readonly Color BackColor;
static UserPreferences()
{
DateTime now = DateTime.Now;
if (now.DayOfWeek == DayOfWeek.Saturday
|| now.DayOfWeek == DayOfWeek.Sunday)
BackColor = Color.Green;
else
BackColor = Color.Red;
}
}
}
private UserPreferences()
{
}
www.it-ebooks.info