You had me at "Hello World"

Attaching an Event Handler

2009-10-01T01:25:00Z

Whenever I need to attach an event handler, usually I use one of these methods, a delegate, anonymous method, or lambda expression.

For complex events (more than 3 lines of code), I create a separate method. If the method is short, I use anonymous method. But if the event is just one line, I use lambda expression.

private void button1_Click(object sender, EventArgs e)
{
    MessageBox.Show("Hello World!");
}

private void Form1_Load(object sender, EventArgs e)
{
    //This is good for complex events.
    button1.Click += button1_Click;
    //Anonymous method, suitable for short event.
    button2.Click += delegate(object obj, EventArgs arg)
    {
        MessageBox.Show("Hello World!");
    };
    //Lambda expression, great for one line event.
    button3.Click += ((x, y) => MessageBox.Show("Hello World!"));
}

How to Give Authenticated Users or Everyone Access to Your Share Programmatically

2009-07-13T19:41:40Z

Another follow-up from my previous article, Programmatically Configuring Permissions on a Share, David B asked a question, how to share a folder to Everyone, instead of to a specific users. This article will answer that question, based on the code on my previous article.

That is an interesting question, since ‘Everyone’ can be replaced with ‘Authenticated Users’, ‘Network Service’, etc.

First, if you need only to give Everyone read-only access permission, the easiest thing is to set the DACL property of Win32_SecurityDescriptor to null. This is not equal with an array of null. An array of null will lock everyone out from this share.

ManagementObject secDescriptor = new ManagementClass(new ManagementPath("Win32_SecurityDescriptor"), null);
secDescriptor["ControlFlags"] = 4; //SE_DACL_PRESENT 
secDescriptor["DACL"] = null;

If you need to be more explicit, or you need to assign other security principal different access, that method above will not work. As soon as you assign someone access to the share, ‘Everyone’ will lose its read access.

To assign the permission explicitly, the key is to form the correct Win32_Trustee to represent that special account (Network Service, Everyone, Authenticated Users, etc.). Take a look at System.Security.Principal.WellKnownSidType enum. It has a number of well known sid that you might be interested with.

What needs to be done is to assign the SID property of the Win32_Trustee object with the security identifier derived from the well known sid.

Let assume you have this method:

private byte[] GetWellKnwonSid(WellKnownSidType SidType)
{
    SecurityIdentifier Result = new SecurityIdentifier(SidType, null);
    byte[] sidArray = new byte[Result.BinaryLength];
    Result.GetBinaryForm(sidArray, 0);

    return sidArray;
}

Then when Win32_Trustee object is created, assign the SID property as follow:

ManagementObject Trustee = new ManagementClass(new ManagementPath("Win32_Trustee"), null);
Trustee["SID"] = GetWellKnwonSid(WellKnownSidType.WorldSid);

That code above will create Win32_Trustee for ‘Everyone’. Use this Win32_Trustee to form the Win32_Ace, and you now explicitly assign ‘Everyone’ access to your share.

How to Programmatically Modify the IIS Virtual Directory

2009-05-29T19:16:45Z

If you have more than a dozen web servers in a cluster with identical setting, and you need to update the virtual directory, it is much more convenient to write a simple program to update it. This example shows how to do it. In this case, this snippet will change the physical path of a virtual directory.

This snippet works on IIS 6 and IIS 7. PowerShell may not be installed in Server 2003, to make this snippet more generic, this snippet is written in C#, otherwise, PowerShell script may be a better option.

private const string MetabasePath = "IIS://Localhost/W3SVC/1/Root";

//Get the virtual directory of IIS.
private static DirectoryEntry GetVirtualDirectory(DirectoryEntry IISDirectory, string vDirName)
{
    string ClassName = IISDirectory.SchemaClassName.ToString();

    if (!((ClassName.EndsWith("Server")) || (ClassName.EndsWith("VirtualDir"))))
    {
        throw new Exception(String.Format("Virtual Directory can be updated under site or virual directory node. Metabase:{0}, SchemaClassName={1}", MetabasePath, ClassName));
    }

    //Iterate through the children, as Find() method is having an issue with IIS 6, if more than one thread is accessing IIS, an AccessViolationException is thrown.
    //The fix is applying the a hot fix http://support.microsoft.com/kb/946517. Either use Find(), or use this method below.
    //Since IIS may not have the hot fix installed, this sample iterates the children.
    foreach (DirectoryEntry VirtualDir in IISDirectory.Children)
        if (String.Compare(VirtualDir.Name, vDirName, StringComparison.OrdinalIgnoreCase) == 0)
            return VirtualDir;

    return null;
}

//Update the physical path of the site.
private static void UpdatePhysicalPath(string virtualDirectoryName, string newPath)
{
    using (DirectoryEntry Site = new DirectoryEntry(MetabasePath))
    {
        DirectoryEntry StatsNet = GetVirtualDirectory(Site, virtualDirectoryName);

        if (StatsNet == null)
            throw new Exception(String.Format("Site not found. Metabase={0}, virtualDirectory={1}", MetabasePath, virtualDirectoryName));

        StatsNet.Properties["Path"][0] = newPath;
        StatsNet.CommitChanges();
    }
}

static void Main(string[] args)
{
    UpdatePhysicalPath("MySite", @"d:\http\MyNewSite");
}

That snippet above shows how to change the path, there are a lot of properties that can be changed, at least this shows the basic idea.

Concatenating A List of Elements into A String, From [A] [B] [C] into "A, B, C"

2009-05-12T07:19:58Z

This is a quite common problem, there is a list of strings, and you need to concatenate them with a delimiter, let says a comma. There are several different approaches to this problem.

Before .Net era, I use for loop, and check if the loop counter is not pointing to the last element in the list. If it is not pointing to the last element, add the delimiter. This approach has one problem, if the number of elements are not known. The other way is by concatenating the list and the delimiter, and then truncate the last delimiter after assembling the whole list.

After .Net becoming more popular, the framework utilizes iterator pattern. Using foreach is much more convenient way to iterate and also to concatenate a list. The solution I had before is much more problematic, as I do not know if I am reading at the last element.

Currently, I have two favorite methods to concatenate a list of elements into a single string with delimiter in between.

The first one is using LINQ.

public string Concatenate(IEnumerable<string> list, string delimiter)
{
    return list.Aggregate((First, Second) => First + delimiter + Second);
}

That method above, probably does not have the greatest performance, as it will create too many strings, especially if the list has a lot of elements. The second one is using extension method, this code has better performance.

public static class ConcatExtension
{
    public static string Concatenate<T>(this IEnumerable<T> list, string delimiter) 
    {
        StringBuilder Builder = new StringBuilder();
        
        using (IEnumerator<T> Reader = list.GetEnumerator())
        {
            if (Reader.MoveNext()) Builder.Append(Reader.Current.ToString());
            while (Reader.MoveNext()) Builder.Append(delimiter).Append(Reader.Current.ToString());
        }

        return Builder.ToString();
    }
}

Now let see, the second approach uses StringBuilder, thus reducing the memory pressure. The idea is not to add delimiter after processing the element, but to add the delimiter before every element, except the first one.

If I have these array of values:

List<string> ListOfValues = new List<string>()  { "Orange", "Apple", "Watermelon", "Grape", "Peach", "Banana" };

Then these two calls will give you identical return.

string s1 = Concatenate(ListOfValues, ", ");
string s2 = ListOfValues.Concatenate(", ");

The results will be:

Orange, Apple, Watermelon, Grape, Peach, Banana.

So far, these are the simplest solution to concatenate the elements inside a collection into a delimited string.

Generating P/Invoke Signature

2009-04-15T20:12:56Z

I have been using PInvoke.Net for long time. I discovered a tool, P/Invoke Interop Assistant. It is very cool. Not only it can gives you the managed wrapper around the native Windows API, it also gives you the ability to generate the unmanaged signature for your managed assemblies. The best thing, the source code is available.

Get P/Invoke Interop Assistant here.

Workaround to deserialize ‘True’, ‘False’ using XmlSerializer

2009-04-03T18:11:00Z

This is the scenario, system A is taking an xml from system B. System A will deserialize the xml into an object. Unfortunately, a dev in system B decides that System.Xml namespace is evil and construct the xml using StringBuilder. In one of the element, the dev call ToString() method of a boolean variable. The result? the xml contains ‘True’ or ‘False’. System A takes the input and it throws exceptions with error message “The string 'False' is not a valid Boolean value”, or “The string 'True' is not a valid Boolean value'”.

W3C defines boolean data type as ‘true’, ‘false’, ‘0’, and ‘1’. So this behavior is expected.

There is a way to workaround this, only under this scenario, you want to keep the type safety of your object, and you have the code. The steps are:

Decorate the boolean property with XmlIgnore.
Inherit your class and add a string property, decorate it with XmlElement. Set the element name to match the xml node name.
Add code on the new property on the descendant class, to make the property in the descendant class work as an adapter for the actual boolean property.

[XmlRoot(ElementName = "data", Namespace = "http://contoso.com/")]
[XmlInclude(typeof(MyClassXmlAdapter))]
public class MyClass
{
    [XmlIgnore]
    public bool BooleanField { get; set; }
}

[XmlRoot(ElementName = "data", Namespace = "http://contoso.com/")]
public sealed class MyClassXmlAdapter : MyClass
{
    [XmlElement(ElementName = "Test")]
    public string BooleanAsString
    {
        get
        {
            return XmlConvert.ToString(BooleanField);
        }

        set
        {
            bool ParsedValue;

            if (!Boolean.TryParse(value, out ParsedValue))
                ParsedValue = XmlConvert.ToBoolean(value);

            BooleanField = ParsedValue;
        }
    }
}

In your serialization code, create the XmlSerializer using MyClassXmlAdapter as type, and the serializer will serialize and deserialize to MyClass with no problem. All of your code that works with MyClass won’t have to be changed.

If you don’t have access to the code, or the class is sealed, it is much more difficult. The only way to do it is by using a helper class. In this sample below, MyClass is sealed and you have only the assembly. Then the solution is to create another class that have almost identical fields with MyClass, with the exception the boolean field.

[XmlRoot(ElementName = "data", Namespace = "http://contoso.com/")]
public sealed class MyClass
{
    [XmlElement]
    public bool BooleanField { get; set; }
}

[XmlRoot(ElementName = "data", Namespace = "http://contoso.com/")]
public sealed class MyClassXmlAdapter
{
    private bool _BooleanField;

    [XmlElement(ElementName = "Test")]
    public string BooleanAsString
    {
        get
        {
            return XmlConvert.ToString(_BooleanField);
        }

        set
        {
            bool ParsedValue;

            if (!Boolean.TryParse(value, out ParsedValue))
                ParsedValue = XmlConvert.ToBoolean(value);

            _BooleanField = ParsedValue;
        }
    }

    public void CopyTo(MyClass target)
    {
        target.BooleanField = this.BooleanField;
    }
}

After deserializing the xml with ‘True’ or ‘False’, call CopyTo().

These solutions are not ideal, but at least, these are better options rather than cleaning up the Xml.

C# 3.0 Automatic Property

2009-02-13T02:30:06Z

C# introduces a number of syntactic sugar, including Automatic Property link. A question was asked, why is this useful, what is the advantage of this approach compared to exposing the field as public field?

The advantage of the automatic property is that while you have a much cleaner code, you still have encapsulation, you can restrict the setter, so only internal classes, or descendant classes can update the property.

public class AutomaticPropertyClass
{
    public string PublicProperty { get; set; }
    public int    ReadOnlyProperty { get; private set; }
    public double InternalProperty { get; internal set; }
    public char   ProtectedProperty { get; protected set; }
}

That code is much simpler than having to declare private field and then the property, and the developer still can define the accessibility. Yes, this is quite old, but since I was asked that question, might as well blog about it. :)

How to Add Command Line Support with Your .MSI

2009-02-06T21:23:59Z

One of the requirements in building setups was to allow the Operations team to execute the .msi file from the command line. GUI is not for expert! :)

If you are familiar with Visual Studio setup, each of the UI element has a property, and you pass this property to your custom action, or use it as condition in your setup (whether to install the documentation, help, or whether to install to the gac or not, etc.).

msiexec.exe allows you to pass some parameters to override those properties. Unfortunately the .msi file that Visual Studio generates always set the default values, default value being the values that the developers set during design time.

After inspecting the .msi, there are some custom actions that will set the property value to the default. This custom actions are always executed, whether the users sets the property via command line parameter or not. That means, if the user pass some parameters to override the property, the setup will execute the custom action, reassign the property value to the original default value.

So what needs to be done is to prevent the custom action from executing when the property is overridden by the user. This can be done quite easily with text box dialogs, checkbox dialogs are a little bit more difficult, I will cover it in other post.

The property has blank value/null in the beginning, if the user overrides the property via command line parameter, this value will not be null. By giving custom actions a condition, to execute only if the property is blank, the value that the user gave via command line will not be overridden.

You need to set the conditions in two different tables in your .msi file, InstallExecuteSequence and InstallUISequence. One to support GUI mode (interactive) and the other to support quiet/passive mode.

This is the example on how to do it, repeat the steps for every property that you want to be able to override:

Identify the property that you want to override. From within Visual Studio, writes down the property that you want to be able to override. For example, you set a property SERVERNAME, related to Edit1Property on Textboxes (A), and the default value is 'DefaultServerName'.
Check the InstallUISequence and InstallExecuteSequence tables in the .msi using Orcas, you should see something like this:

You know this is the action that you want from the Action name, it is CustomTextA, corresponds to the Textboxes (A), and it is the Edit1 control. If you check the CustomAction table, you will see something like this:
To prevent the custom action from executing, add this condition on both InstallUISequence and InstallExecuteSequence tables, SERVERNAME = "".

This tells, if the SERVERNAME is blank (the user did not override), execute the custom action to assign the default value. Please pay attention that the condition is for an empty string (two double quotes).
Save the .msi and close Orcas.
Execute the .msi using this command:
msiexec /i [The msi name].msi SERVERNAME="HELLOWORLDSERVER"

After executing those steps, the UI will show HELLOWORLDSERVER in the text box.

To set this condition automatically as part of your build process, we need to use a script to modify the setup. This can be done by setting the post build event for your project.

Create a .js script. Call it CommandLineSupport.js, repeat the update statement for every property that you want to be able to override.
//This script adds command-line support for MSI build with Visual Studio 2008.
var msiOpenDatabaseModeTransact = 1;

if (WScript.Arguments.Length != 1)
{
    WScript.StdErr.WriteLine(WScript.ScriptName + " file");
    WScript.Quit(1);
}

WScript.Echo(WScript.Arguments(0));
var filespec = WScript.Arguments(0);
var installer = WScript.CreateObject("WindowsInstaller.Installer");
var database = installer.OpenDatabase(filespec, msiOpenDatabaseModeTransact);

var sql
var view

try
{
    //Update InstallUISequence to support command-line parameters in interactive mode.
    sql = "UPDATE InstallUISequence SET Condition = 'SERVERNAME=\"\"' WHERE Action = 'CustomTextA_SetProperty_EDIT1'";
    view = database.OpenView(sql);
    view.Execute();
    view.Close();

    //Update InstallExecuteSequence to support command line in passive or quiet mode.
    sql = "UPDATE InstallExecuteSequence SET Condition = 'SERVERNAME=\"\"' WHERE Action = 'CustomTextA_SetProperty_EDIT1'";
    view = database.OpenView(sql);
    view.Execute();
    view.Close();

    database.Commit();
}
catch(e)
{
    WScript.StdErr.WriteLine(e);
    WScript.Quit(1);
}

Save the CommandLineSupport.js in the same folder with your setup project file, and set PostBuildEvent for the setup project.

Make sure .msi name matches your .msi file name.
Build the project.

Standard disclaimer applies, no warranty, use it at your own risk, always test the changes. Wow, this post is longer than what I thought it would be....

Fixing the Issue that Does Not Exist

2009-02-05T14:06:44Z

I spent some time planning on improvements that I wanted to do on one of our project. I reviewed the code that I notice a place where I think I could improve the performance by avoiding locking.

So I wrote the code, and tested it, works great, the new non-locking algorithm works fine. Then when I replaced the old code with my new code and ran my test, to my surprise, it did not behave the way I want it to be. Still works, but the performance and the throughput was not any better. In some cases, it actually yield worse performance compared with the old code.

Curious, I captured the performance counters by running my test app side by side, the one with old code, and the other one with new code.

Look and behold, under extreme cases, the old code has zero Total # of Contentions. The new code, of course has zero Total # of Contentions, and at the same time, consumes more memory due to the lock free algorithm implementation that I chose.

Basically, the lock free code tries to solve a problem that did not exist in the old code. Yes, it uses lock, but the old code runs really fast, and it is very tight, so there was no contention.

Moral of the story, reviewing the code may reveal some issue, put it to test, and verify that the issue is really an issue, before planning any work on it. One good thing, I did not spend too much time on it. :)

IE 8 RC 1 is Now Available for Download

2009-01-28T03:06:38Z

I downloaded and installed IE 8 RC 1 on my machine. It works really well, the performance improvement is significant.

I would encourage you to give it a try, http://www.microsoft.com/windows/internet-explorer/beta/worldwide-sites.aspx.

Disclaimer, this is an Release Candidate, not RTM. There could be some issues, but overall, this is really good.

It Is 2009, Happy New Year!!!

2009-01-01T11:36:00Z

Happy New Year, everyone. Wish you all the best this year.

When Building Multi-Threaded Applications using ThreadPool, Make the Number of Worker Threads Configurable

2008-12-16T14:14:14Z

Just a simple thought, when creating a multi-threaded applications, make the number of threads configurable. ThreadPool has this behavior that it will immediately set the minimum worker threads equal to the number of logical processors in your machine, and set the maximum to 250 per logical processor, well documented in msdn (.Net Framework 2.0 SP1).

ThreadPool will create a new thread every half second, also documented in msdn. This behavior could lead to thread explosions, where there are too much threads fighting for limited resources (memory, lock, disk IO, processor, etc.). Your app may run slower if the thread creation is not managed wisely.

It is also a good idea to be able to throttle the application to use fewer threads. It is a good idea to be able to limit the number of threads in the system through configuration. Set the max number of threads by calling SetMaxThreads, and if the config value is less than the number of logical processors, do not forget to call SetMinThreads. Be aware that this can also lead to other issue, like thread starvation.

This is just an idea, if you have been writing multi-threaded applications using ThreadPool, probably you have thought about this already. Keep in mind, your application needs as few thread as possible, but not fewer.

String.Split has High Cost on Performance

2008-12-16T01:59:24Z

One application had a memory issue, it just consume too much resources. The application performed well, but it is very obvious when we saw the performance counters, something can be done to make it better. Reviewing the code did not reveal something significant, the code already allocated objects that are necessary. The code parses a text file and generate an object based on the content of that text file.

After running CLR Profiler, I noticed that a lot of memory are consumed by int[], but there is no code that generates that kind of object. Digging a little bit deeper, I discovered that one method calls String.Split(). This method is one of the main method, it is being called about 80% of the time.

String.Split() creates an array of strings, and in the process, it creates a helper array of int. The size of the helper array can be really huge. After the code had been modified to avoid calling String.Split(), the memory consumption was significantly reduced.

If you need performance in a tight loop, avoid String.Split().

If you are using Visual Studio 2008, I strongly recommend for you to step through the .Net framework source code using debugger. Check Shawn Burke's post to do that.

How to Create Custom Event Log for Windows Service

2008-12-11T20:52:42Z

When you created a Windows Service, you usually add a Service Installer to allow this service to be installed using InstallUtil or installing it programmatically like this post shows you.

The service installer will create the Event Log for the service, and by default it is "Application", and the source is the name of your service.

The Event Source is most likely to be fine, but the event log may need to be set to something else. Unfortunately, the option is not visible from the installer.

The Installer object for your windows service, actually hosted several other Installer objects, one of the child Installer is responsible to create the Event Log. You need to find this object and then changed the Log property and it will create the appropriate event log. It is easy to find this object as this object is an instance of EventLogInstaller.

The code:

public partial class MyServiceInstaller : Installer
{
    private const stringLogName = "My Service Log";

    public MyServiceInstaller()
    {
        InitializeComponent();

        EventLogInstaller EventLogInstall = null;

        foreach (Installer I in this.serviceInstaller.Installers)
        {
            EventLogInstall = I as EventLogInstaller;

            if(EventLogInstall != null)
            {
                EventLogInstall.Log = LogName;
                EventLogInstall.UninstallAction = UninstallAction.NoAction;
                break;
            }
        }
    }
}

That code above shows how to create a custom Event Log for your service, the code also shows that the custom event log will never be uninstalled, depending on the requirements it can be easily changed.

If the event source needs to be changed as well, simply change the Source property and you are set.

One thing to pay attention, if you create a custom event log, you install the service programmatically, and your service is running with a restricted account, then you have to modify the code to install the service by adding a code to write one entry to the event log that you just created.

After the service installer is executed, the log is 'registered', but not created yet. To create it, one event must be written. If the service runs using a restricted user account, that account may not have enough security permission to write the first log, as the log need to be created.

When installing the service, the user must run the installer as Administrator, so the installer has all security privilege that it needs. So remember to write one event entry after programmatically installing the service.

How to Get IIS Web Sites Information Programmatically

2008-10-31T08:03:41Z

I needed to get the location of IIS log files on my servers, after doing a quick investigation, I am quite amazed on how much information are exposed via managed code.

This snippet will return the name of the sites and the location of the log files.

foreach (DirectoryEntry Site in new DirectoryEntry("IIS://" + System.Environment.MachineName + "/w3svc").Children)
    if (String.Compare(Site.SchemaClassName, "IIsWebServer", StringComparison.OrdinalIgnoreCase) == 0)
        Console.WriteLine(Site.Properties["ServerComment"].Value.ToString() + " == " + Site.Properties["LogFileDirectory"].Value.ToString());

To get more information about what fields and method you can access, please refer to this MSDN doc: http://msdn.microsoft.com/en-us/library/ms524487.aspx.

Just remember, in Vista/Windows Server 2008, you will need to run that code with elevated privilege.