Ideas on Hand

MVP of the year

2013-04-03T12:36:00.002+05:30

On Thursday, January 24, 2013, I was a surprised to see my inbox that I am awarded as MVP of the year 2012. I am one among the 32 people awarded as MVP of the year and only person from India. It feels great to receive such a great award. Here is a official site that tells the story,

Developer MVPs of the Year

Thank you Microsoft for such a great honor. I also thank my MVP lead Tanmay Kapoor and Biplab Paul for their support.

Creating RCW Interops from ActiveX (OCX) Controls

2012-09-30T14:46:00.004+05:30

Many times we need to use ActiveX controls (ocx) developed in VB6 or C++ in our .NET applications. As you might aware of that, we can't directly use ActiveX components in .NET application. So, we need to create wrapper assemblies around the ActiveX components which we call Runtime Callable Wrappers as I have already talked about that in my previous posts. I am not going to discuss details of RCW, but I will show how to generate the RCWs.

You can generate RCW in two ways

1. Using Visual Studio

2. Using Tools TlbImp.exe and AxImp.exe.

Using Visual Studio to generate RCW:

This is the simplest way of generating RCWs. Then in your project, open the toolbar, right click on it and select 'Choose controls'. Browse the .ocx file and click OK.

Now open the 'obj' folder present inside the project folder and you will see two interop dlls are generated namely AxInterop.<FileName>.dll and <FileName>.dll. For example, if the control name is MyControl.OCX then generated assemblies will be AxMyControls.dll and MyControls.dll. The prior one contains the visible components of the user control that can be placed on the form. And later one contains the types.

Using Tools to generate RCW:

Above method of generating RCW fulfils most of the times. However, if you want to have some control over how the interops are generated like default namespace, strong naming etc., you can't do much with Visual Studio. However, for that you can use framework tools to generate RCW yourself.

AxImp.exe and TlbImp.exe are two such tools that ship with NET Framework SDK. In fact AxImp.exe alone is sufficient to generate required interops. We will how that works now. Suppose you have an ActiveX control called MyControl.OCX. Open the visual studio command prompt, change the directory to the folder where MyControl.ocx resides and run the below command.

AXIMP MyControl.OCX

This will generate two interops AxMyControl.dll and MyControl.dll. The default namespace in the prior one will be AxMyControl and default namespace in MyControl.dll will be MyControl. If you want to change the out putfile name to AxInterop.MyControl.dll, you can run the below command,

AXIMP MyControl.OCX /OUT:AxInterop.MyControl.dll

This will generate AxInterop.MyControl.dll and MyControl.dll. You can see that when using AXIMP tool, you do not have any control over other interop dll i.e. MyControl.dll. You also do not have control over default namespace name. So, if I want to give your own names say AxInterop.MyControl.dll and Interop.MyControl.dll with custom namespaces say LegacyControls, then I will do it as below:

First generate the interop assembly containign type definitions using TLBIMP tool as below,

TLBIMP MyControl.OCX /OUT:Interop.MyControl.dll /namespace:LegacyControls

If you want the generated assembly to be strong named, you can supply the strong name key file to above command (as below)

TLBIMP MyControl.OCX ... /KEYFILE:MyCompanyKey.snk

Now generate the ActiveX interop using AXIMP tool using the above generated RCW,

AXIMP MyControl.OCX /OUT:AxInterop.MyControl.dll /RCW:Interop.MyControl.dll

and of course you can sign this assembly just like as explained before.

Now you have generated the two interops AxInterop.MyControl.dll and Interop.MyControl.dll with having namespace AxLegacyControls and LegacyControls respectively.

Note: You must register the OCX before you can use the generated interops.

Interface Vs. Abstract Class, Why and When

2012-06-15T13:33:00.003+05:30

Recently many people asked me this question - what is the difference between an abstract class and an interface? - This is a typical interview question and you can easily find answers like below in any .NET book.

abstract classes can contain pure abstract methods as well as concrete methods. But all methods in an interface are implicitly abstract
Methods in an abstract class can be protected, private, static etc. But, all items in an interface are implicitly public
A class can inherit multiple interfaces, but it can inherit only one abstract class.
etc. :)

But, in my view, one shouldn't compare interfaces and abstract classes because each of them have their own strength and weaknesses. I have also seen many people who go dumbfounded if someone asks them - Why do you use an interface? Or Why do you use an abstract class? I suggest you to go through this MSDN page which gives you an idea of when to use what. In this blog, I will try to explore my knowledge on these two concepts.

Abstract Class

An abstract class is just another class with abstract keyword. But, the keyword 'abstract' adds some additional features to the class like - the class can contain just method declarations, an instance of the class cannot be created. So, below one is an abstract class.

public abstract class Animal

{

public void Walk()

{

Console.WriteLine("Walking");

}

public void Sleep()

{

Console.WriteLine("Sleeping");

}

public abstract void Eat();

}

This class defines the basic characteristics of an animal like every animal sleeps, Moves, eats etc. But look at the Eat function. I have made it abstract in the sense - every animal can eat but what it eats depends upon the kind of animal.

class Cow : Animal

{

public override void Eat()

{

Console.WriteLine("Eating grass");

}

class Tiger : Animal

{

public override void Eat()

{

Console.WriteLine("Eating meat");

}

I hope above example doesn't need any explanation. You can see that abstract class defines an IS-A relationship. Which means Cow is an Animal, so Cow has all the basic characters of an Animal. e.g. Move and Sleep functions need not be re-defined in Cow class.

Also note that, If I add any new behaviour to base class, child classes need not be changed at all and they simply inherit the new behaviour. For example, if I define a new behaviour 'Drink' in animal class, both the child classes simply adapt the new behaviour immediately.

public abstract class Animal

{

...

public void Drink()

{

Console.WriteLine("Drinking water");

}

public abstract void Eat();

}

So, visioning is not a problem when you use abstract class. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface. Hence, If you want to create multiple versions of your component, create an abstract class.

One more thing to be noted that all these 2 classes Tiger, Cow are closely related i.e. both are Animals and share common behaviour of an animal. So, when the classes are closely related and share common functionality - Use Abstract classes.

Interfaces

In contrast to abstract class, an Interface defines a CAN-DO relationship rather than IS-A relationship. For example, the definition of String class looks like below,

class String : IComparable, ICloneable, IConvertible

This definition tells you that - you can compare string objects, you can clone string objects, you can convert string objects into other type.

Next thing is, when the classes are not closes related and you still want to have a common functionality among them - Use Interfaces. Let's consider an example,

public interface IEquatable<T>

{

bool Equals(T other);

}

public class Person: IEquatable<Person>

{

private string Name;

private DateTime DateOfBirth;

public bool Equals(Person other)

{

return other.Equals(other.Name) && other.DateOfBirth == this.DateOfBirth;

}

public class Home : IEquatable<Home>

{

private int HouseNumber;

private int AreaCode;

public bool Equals(Home other)

{

return other.AreaCode == this.AreaCode && other.HouseNumber == this.HouseNumber;

}

Here 2 non-related classes Home and Person want to have Equality function. See that functionality 'Equals' is common between the 2 classes but the implementation is completely different. Hence, both Home & Person implement IEquatable interface but implement Equals method independently.

Now you can ask, if the implementations are different, what is the need of using interface? Of course, just remove the IEquatable interface and the program still works. So, why interface? Let me try to make it clear step by step.

Firstly, An interface acts as a CONTRACT. This means, any class that implements an interface agrees to implement all the methods in that interface. Also note that, (ideally) once implemented, interface (contract) definition cannot change i.e. you cannot add new methods and modify existing ones in an interface. This is very important aspect of interfaces. This assures the consumer of your class that, the class will implement all the methods defined in the interface contract though the implementation can change. For example, I know that Person class implements IEquatable interface. Hence I am guaranteed that Person class always contains Equals method. Hence, I am ensured that my below code always works.

IEquatable<Person> person1 = new Person();

IEquatable<Person> person2 = new Person();

bool areTheyEqual = person1.Equals(person2);

Having this, a new version of Person class is released and Equals method now includes a check for address of person also.

public class Person: IEquatable<Person>

{

privatestring Name;

private DateTime DateOfBirth;
private Address Address;

publicbool Equals(Person other)

{

      return other.Equals(other.Name) &&
             other.DateOfBirth == this.DateOfBirth &&
             other.Address == this.Address;

}

See that, though the implementation has changed, my consumer code still works. So, having an interface implemented makes your class Backward compatible.

Secondly, interfaces are quite useful when you want call a method on dynamic object. For example, below helper function prints all the items in a collection - A List, Array, String etc.

public void DisplayAllItems<T>(IEnumerable<T> collection)

{

foreach (var item in collection)

{

Console.WriteLine(item);

}

In the above function, you can pass a List, array or any object that implements IEnumerable interface. Otherwise, we would need to implement the display logic for each collection type separately.

These are 2 examples of why to use interfaces. There are other lot of reasons for using interfaces like laying out complex architectures, implementing design patterns etc. But, I hope this blog gives you an idea of why to use interfaces.

That concludes the discussion of differentiating between interface & abstract class, which one to prefer & when. I hope you enjoyed reading my blog. Please put your feedback which help me in improving myself and also to help others.

Query KB updates installed in Window 7

2012-04-04T12:39:00.000+05:30

Prior to Windows Vista, WMI's Win32_QuickFixEngineering class was used for querying the KB updates installed in the system. But, Starting with Windows Vista, win32_QuickFixEngineering returns only the updates supplied by Component Based Servicing (CBS). It will not return updates installed by MSI or Windows Updates. Read this page for more info. So, to query the updates installed via MSI or Windows Updates, you can use Windows Update Agent Object Model. Here I am going to show you, how to query the installed KB updates in C#.

We begin by adding reference to Wuapi.dll. You can do that by selecting "WUAPI 2.0 Type Library" from COM tab in Add Reference dialog in Visual Studio.

Once you add reference to Wuapi.dll, you can create an object of WUApiLib.UpdateSession class. This class cab be used by the caller to perform operations that involve updates, such as download, install or search for updates. Once you have UpdateSession object ready, you can call QueryHistory on it to get history of installed updates. Let me show you the code directly.

WUApiLib.UpdateSession session = new UpdateSession();

IUpdateSearcher us = session.CreateUpdateSearcher();

var updatesCollection = session.QueryHistory(String.Empty, 0, us.GetTotalHistoryCount());

for (int i = 0; i < updatesCollection.Count; i++)

{

Console.WriteLine(coll[i].Title);

}

Note that, the list of updates resulted from above code may not match with the list of updates in Add/Remove Programs window in control panel. The missing updates might be installed via Component Based Servicing or they are non-microsoft updates.

References:

Searching, Downloading, and Installing Updates (link)
Using the Windows Update Agent API (link)

Memory Leaks in .NET Application - Don't let them slip through your eyes.

2012-02-24T13:55:00.001+05:30

Before talking about the main topic, I would like to briefly go through the CLR garbage collection mechanism. When a .NET application is executed, CLR allocates a block of memory which is called managed heap. This managed heap is logically divided among 3 generations - Gen0, Gen1 and Gen2. Usually Gen0 contains the newly created and short lived objects. So, here is a quick view on what happens during garbage collection -

Whenever generation 0 gets full, garbage collection occurs. During garbage collection, the garbage collector examines each object in Gen0 to know whether the object is a root. A root object is one which has a valid reference (or simply the object is still in use). After the root examination, garbage collector collects all non-root objects and frees the memory occupied by them and the root objects which survived the garbage collection are moved to Gen1. At the end of garbage collection, Gen0 will be 100% empty.
Now, suppose the application needs more memory than which is available in Gen0. So, Garbage collection must occur which collects objects in both Gen0 and Gen1. Again, the garbage collection starts from identifying root objects in Gen1. All the non-root objects are collected and their memory is reclaimed. The survived objects (roots) will be moved to Gen2. Then Garbage collector collects Gen0 objects as explained in Step1.
Sometimes Later the application might require more memory than which is available in Gen0 & Gen1 together. So, the garbage collection must occur on all three generations. So, Garbage Collector starts examining the objects in Gen2. All non-root objects are collected and their memory is freed-up. The survived objects are going to remain in Gen2 only. Then Garbage collector collects Gen1 and Gen0 objects as explained in Step1 & 2.

What is a Memory Leak?

What we can see from the above explanation is that until an object has a root it is going to remain in memory and is always promoted to higher generation. Having this said, let's see what is memory leak.

Consider you have a class which holds a reference to an unmanaged handle as shown below.

class UnmanagedClass

{

IntPtr handle;

Int32[] someBigArray = new Int32[200000]; //a dummy array to hold sufficiently large memory.

public UnmanagedClass()

{

handle = GetUnmanagedHandle(); // consider this method returns an unmanaged handle

}

Then I will create an instance of above class as below,

private void MemoryLeakTest()

{

for(int i = 0; i < 1000000; i++)

{

String str = new String();

UnmanagedClass uc = new UnmanagedClass(); //doesn't

}

In the above function, after every loop, both sr & uc become eligible for garbage collection. Suppose, after 5 loops, generation 0 becomes full and GC must run. See that after 5 loops there are 5 string objects and 5 UnmanagedClass objects are created on heap. Garbage collection starts and sees that all five string objects have no roots. So, it frees the memory occupied by the string objects. Then it starts examiniting the Unmanaged class objects. But, each uc object has an unmanaged root. Since GC cares for only managed object but not unmanaged objects, it will not examine the unmanaged handle. Hence, it treats all 5 UnmanagedClass instances to be roots and moves them to Generation1. At this point the generations look like below.

Ultimately Generation0 becomes empty and the loop starts executing again. Now, again after 5 loops Gen0 becomes full and GC occurs. As explained previously, all 5 Unmanaged objects are treated to be roots and they are moved to Generation1. But, there may not be sufficient space in Gen1 to accumulate all objects that survived in Gen0 collection. So, GC has to run on Gen1 as well. Hence, GC starts examining UnmanagedClass objects in Gen1. Again GC sees that they contain a valid handle hence they are moved to Gen2. At this point Gen1 and Gen2 have 5 UnmanagedClass objects each and Gen0 is empty.

In the same way, after another 5 loops, the 5 UnmanagedClass objects in Gen1 will survive GC and moved to Gen2 and Gen0 objects will be moved to Gen1 and the picture looks like below,

You can see that now the generation2 is getting full and it has to be garbage collected. But, again, all the objects in contain an unmanaged handle and they will not be collected at all. Hence, at the next GC, there will be no memory to left in Gen2 to move any objects into it. At this point, you can say that the application is leaking memory.

So, if the application continues to run, at some point of time, there will be no memory left to allocate any objects and CLR will throw OutOfMemoryException and process terminates.

How to avoid Memory Leaks?

If your class has an unmanaged handle, implement Finalize and Dispose pattern to release the unmanaged handle. This article gives you an overview of Dispose pattern and this page shows you how dispose an unmanaged handle.
If you are a consumer of a class that implements IDisposable, as a developer, you are responsible for calling Dispose on it. Ensure, all Disposable objects are disposed or at least those objects that do not have finalizers.
Avoid static collections. You might know that a type loaded in memory is never loaded until the application is shutdown. Since, static members are type members, they are going to stay in the memory always. So, use static members carefully.

I hope you enjoyed reading this article. Happy Programming.

GC.AddMemoryPressure - Working with native resources.

2012-02-12T21:53:00.000+05:30

In this writing, I am going to explain how to deal with a situation where an object occupies a large amount of unmanaged memory while consuming very little managed memory. For example, suppose you are using a Bitmap object in your application. The Bitmap application can consume a lot of native memory. But your application just uses the handle to Bitmap which just uses just 4 bytes in 32 bit machines and 8 bytes in 64 bit machines. This means, your application could create several Bitmaps before the garbage collection kicks in. But at the same time, the native memory consumption by the process can increase enormously.

Let me show you an example. In figure A below, I have allocated 2 bitmaps, each of which occupies some big amount of native memory. But you can see that managed heap just containes wrapper to the Bitmaps which occupy very less memory. I will go ahead and create 2 more bitmaps (figure-B). You can see that native memory usage is gradually increasing while there is still enough memory on managed heap. Since, there is enough memory available on the heap, garbage collection doesn't kickin. So, if some more bitmaps are created and garbage collection doesn't occur, then you might run out of native memory which can result in catastrophic failures.

To deal with such problems, System.GC class provides two static methods - AddMemoryPressure and RemoveMemoryPressure, whose signature is like below.

public static void AddMemoryPressure(long bytesAllocated);

public static void RemoveMemoryPressure(long bytesAllocated);

To know the advantage of these two methods, have a look at the below BitmapObject class. This class is a wrapper around Bitmap. For simplicity, the constructor accepts an image file and constructs a Bitmap.

class BitmapObject

{

private System.Drawing.Bitmap _bitmap;

private Int64 _memoryPressure;

public BitmapObject(String file, Int64 size)

{

_bitmap = new System.Drawing.Bitmap(file);

if (_bitmap != null)

{

_memoryPressure = size;

GC.AddMemoryPressure(_memoryPressure);

}

public System.Drawing.Bitmap GetBitmap()

{

return _bitmap;

}

~BitmapObject()

{

if (_bitmap != null)

{

_bitmap.Dispose();

GC.RemoveMemoryPressure(_memoryPressure);

}

Whenever you want to create an instance of System.Bitmap, you can consider creating an instance of above class instead. For instance, I want to create a Bitmap which can have approximately 5MB size. So, I will create an instance of BitmapOject by passing fileName and size as below,

BitmapObject oBitmap = new BitmapObject("c:\\SomePicture.bmp", 5 * 1024 * 1024);

When the constructor executes, it first creates a Bitmap and stores it reference in _bitmap. Then the constructor calls GC.AddMemoryPressure method passing the size (5MB) to it. This gives CLR a hint of how much native memory is actually occupied by the object. So, though only 4 bytes (or 8 bytes in 64 bit machines) in managed heap, clr assumes that the object actually consumes 5MB. So, suppose Managed heap is of 50MB, then creating 10 instances of BitmapObject makes CLR think managed heap is full and hence it enforces garbage collection. When the garbage collection occurs, the finalizer method executes disposes the bitmap and removes the memory pressure.

Contravariance: Is it really what it is?

2012-02-10T23:34:00.001+05:30

By definition, contravariance referes to a situtaion where you assign base class instance to a child class reference. Let's directly see an example,

class BaseClass

{

}

class ChildClass: BaseClass

{

}

class TestContraVariance

{

delegate void SomeContraVariantDelegate(ChildClass argument);

public void CreateContravariantDelegate()

{

SomeContraVariantDelegate cvd = new SomeContraVariantDelegate(EventHandlerMethod);

}

private void EventHandlerMethod(BaseClass arg)

{

}

Here, you can see the contravariance - Delegate SomeContraVariantDelegate expects a method that accepts ChildClass instance. But, the function EventHandlerMethod accepts an argument of type BaseClass. So, it appears that a base class object is assigned to a child class object which is not possible in normal scenarios. But, is it really what it seems to be? I don't think so. Let me explain,

In the above example, if you see carefully, the delegate calls the method but not method calls delegate. So, when delegate calls EventHandlerMethod it sends a ChildClass instance as parameter. This is perfectly valid because the method accepts BaseClass instance and the delegate passes ChildClass instance. So, actually ChildClass instance is assigned to BaseClass object but not the other way.

So, there exists nothing like assigning assigning BaseClass instance to ChildClass object and hence no contravariance like thing exists too.

CLR Optimizations - String Interning

2011-12-29T17:13:00.003+05:30

In my previous post, I explained how the immutable nature of strings can hurt the performance of your application. In this post, I am going to explain how CLR optimizes string handling through a technique called String Interning.

To begin with, let's take a look at below simple program.

static void Main()

{

String s1 = "tiger";

String s2 = "tiger";

//compare the values of s1 and s2

bool valuesEqual = String.Equals(s1, s2);

//compare the references of s1 and s2

bool referenceEqual = Object.ReferenceEquals(s1, s2);

}

When you execute this program, valuesEqual will be true which is expected to be true since both s1 and s2 contain the same value "tiger". What about the value of referenceEquals variable? there is a twist here. You expect referenceEquals to be false because both s1 and s2 are completely different objects and hence their references should be different. But wait, the value of referenceEquals will also be true!

To proceed further, just change the value of s2 to something else say "lion" and run your program. Now, valueEquals is false which is expected. Also referenceEqual is false too. Now, if you are wondoring why referenceEquals was true in first case. The answer is - it was because the result of String Interning, an optimization technique adapted by clr for string manipulation. So, let's understand what is String interning.

When you run your application (say the above program iteself), CLR creates an internal hash table. Initially the hash table will empty. Then, string s1 is created on heap with value "tiger". Now, an entry is made in the hash table where key will be "tiger" and value will be reference to string object created on the heap.

You see that s1 is created on the heap and the address (reference) of the object is stored in hash table for "tiger". Then, the CLR sees the second instruction String s2 = "tiger"; Now, instead of creating a new string object on heap, it first searches the hash table for the key "tiger" and it will defnitely find an entry. This means that a string "tiger" already exists on the heap whose reference is 0x100. Hence, CLR simly stores the reference from hash table into s2. This way, creating of a new object is avoided and thereby saving memory.

Later if s2 is assigned a different value say "lion", then CLR will first search for the key "lion" in hash table. But it will not find any entry in hash table. Hence, a new String object will be created on heap for "lion". Also, a new entry will be made in the hash table with key being "lion" and value being reference to new object on heap.

Pretty interesting right? By adapting string interning mechanism, CLR efficiently controls the creation of strings. If you think that this feature is quite useful and want to take advantage of it, you can refer MSDN for String class's static methods Intern and IsInterned.

Apart from above said advantanges, this mechanism has also some disadvantages. The additional overhead in creating & maintaining hash table, repeated hash table lookups can hurt the performance of your application. If you think, string interning hurts your application performance, you can turn this feature off by supplying assembly level attribute "CompilationRelaxationAttribute" with value "CompilationRelaxation.NoStringInterning". But there is a catch here. Even if you supply this attribute, CLR may ignore this attribute and use String Interning. So, just be aware of this.

WBEMTEST - A simple tool to access WMI classes

2011-12-28T23:13:00.002+05:30

Windows Management Instrumentation (WMI) is the repository of windows information. Basically WMI contains a whole bunch of classes where each class holds complete information about some part of windows. For example there is a class called Win32_Printer which represents a printer installed in the system. Similarly there is a Win32_Product which represents a product installed in the system. You can complete information of all WMI classes here.

Whenver you decide to use WMI for accessing any piece of information, the first thing is to know which class contains the information and what are all the properties and methods present in that class. Initially, I always used to visit msdn to search for the right class and its components. This usually is quite time consuming. That time I cam across a handy tool that comes along with windows operating system itself - wbemtest.exe. This tool is quite handy - you can quickly access a class to know what and all properties it contains. Also, you can access existing istances of these classes. For example, there exist as many istannces of Win32_Processor class as the number of processors present in the system. If you are interested in knowing any information about a perticular processor, you can open corresponding instance. Here is how you can use wbemtest.exe to access existing instances of Win32_Processor class.

1. Run "wbemtest.exe" either from command prompt or directly from \System32\wbem folder. This will open the window shown in below figure.

2. Then click "Connect" button. This will open a window (Figure B) where you have to give the namespace which contains your desired class. A namespace is just like your C# namespace, which contains many classes. You can also think of namespace as a category like CimV2, SecurityCenter etc. Find more info on these namespaces here.

3. I am intersted in Win32_Processor class which is in cimv2 namespace. So, I will enter cimv2 and click connect. This will load cimv2 and all the buttons in first figure will be enabled. Click "Enum Instances" button which will ask you to enter the class name. It looks like below.

4. Click Ok. This will open another window listing all the instances of Win32_Processor. In my computer, there is only one processor in my system, so i get only one entry.

5. Double click on the entry. This will open the details of the processor which looks like below image. You can see that the window lists all Win32_Processor class properties with values loaded into them. So, you can get all information like, processor architecture, name, address width, data width etc.

Isn't this a nice tool? One drawback of this tool is that you need to know which class you want to access which means you cannot loop through all WMI classes. But, this tool is very handy as it is at your fingertip. I hope you too will find this useful.

Obtaining Culture Information through FormatProviders

2011-12-22T22:38:00.001+05:30

Often we come across the situations where we need to read the culture specific information like date/time format, decimal seperator, currency symbol, number styles etc. Mostly we need this information for formatting the output according to user culture. In this post, I will show you how you can obtain such culture specific information.

That said, without spending much time in theory, let's see where we find this information. As you might know, System.Globalization.CultureInfo class is the one you must target for this purpose. This class, CultureInfo, provides a public function called GetFormat (a method declared in IFormatProvider interface) whose signture looks like below,

 public virtual object GetFormat(Type formatType);

As of now, formatType paramter can be either NumberFormatInfo or DataTimeFormatInfo both of which are defined in System.Globalization namespace. The NumberFormatInfo class provides you information about number system such as Positive Sign, Negetive Sign, Decimal seperator, Currency Symbo, Native Digits etc. On the other hand DateTimeFormatInfo provides information about Date and Time formats like, DateSeperator, FirstDayOfWeek, LongDate format, ShortDate format, Time Seperator etc.

For example, here is how I get the currency symbol for the culture fr-FR.

 Type formatType = typeof(NumberFormatInfo);  
 CultureInfo frCulture = CultureInfo.GetCultureInfo("fr-FR");  
 NumberFormatInfo info = frCulture.GetFormat(formatType) as NumberFormatInfo;  
 String currencySymbol = info.CurrencySymbol;

I think the above example gives you the whole idea on how to get culture specific information. Below is the code that will give you all DateTime format info that is possible to get from current culture. You can use this code for NumberFormatInfo as well (just replace DateTimeFormatInfo with NumberFormatInfo).

 public String GetDateTimeFormatInfo(String cultureName)  
 {  
   CultureInfo cultInfo = CultureInfo.GetCultureInfo(cultureName);  
   var formatInfo = (DateTimeFormatInfo)cultInfo.GetFormat(typeof(DateTimeFormatInfo));  
   PropertyInfo[] properties = formatInfo.GetType().GetProperties();  
   String info = String.Empty;  
   foreach (var prop in properties)  
   {  
      if (prop.GetValue(formatInfo, null) is Array)  
      {  
         Array a = prop.GetValue(formatInfo, null) as Array;  
         String values = String.Empty;  
         foreach (var item in a)  
         {  
            values += item + ",";  
         }  
         info += prop.Name+":"+values.Substring(0,values.Length-1);  
         info += Environment.NewLine;  
      }  
      else  
      {  
         info += prop.Name + " : " + prop.GetValue(formatInfo, null);  
         info += Environment.NewLine;  
      }  
   }  
   return info;  
 }

Note: You can also obtain all this information from registry. If you are keen, you can have examine the below registry key.

 HKEY_CURRENT_USER\Control Panel\International

Handling System Shutdown / Logoff events in C#.NET

2011-12-05T23:53:00.001+05:30

On .NET forums, I often come across people interested in knowing about notifications of something changed in the system. For example whether windows is shutting down, whether user is logging off, power mode changed, or system font changed etc. For instance, you may want to perform some operation when your application is terminating. In that case, what are all the possible ways of terminating the application?

Closing the application by clicking close 'x' button
Due to exception
User kills the process
When the user logs off or system shuts down

The first 2 are common scenarios which the user can take care of easily. But what about the 3rd and 4th cases? The 3rd case is, I don't think we can control. However, 4th one is interesting. When the system shutdown is started either by user or by any automated process, the shutdown process will terminate all running processes. Before that it sends a signal to all running processes that the system is going to shutdown. Upon receiving this signal, a process can do any windup operation so as to prevent any data loss. This is very important because you might be in middle of some important operation and sudden application termination may cause valuable data loss.

So, how do a .NET application receives this signal? Whenver it comes to the matter of system related things, many people think of native OS DLLs or PInvoke (some unmanaged way). But wait, we have some managed objects that do the work. There is a class called SystemEvents in Microsoft.Win32 dll which offers many system based events. You can google or refer MSDN for more info SystemEvents class. Here, I will just take an example of how System shutdown or user logoff events are handled.

Below is a simple console application that displays a message box whenever a system shutdown occurs or user logs off (In any case, it causes CLR to unload and hence a notification is sent about the event).

class Program

{

static void Main(string[] args)

{

SystemEvents.SessionEnding += SystemEvents_SessionEnding;

Console.ReadLine(); //This is needed to keep the application running.

}

static void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)

{

switch (e.Reason)

{

case SessionEndReasons.Logoff:

MessageBox.Show("User logging off");

break;

case SessionEndReasons.SystemShutdown:

MessageBox.Show("System is shutting down");

break;

}

Beware of excessive string objects

2011-12-05T12:50:00.001+05:30

Of all the primitive types in C#, string is a special primitive type in the following regard,

It is a reference type (class), unlike - other primitive types being ValueType.
It is immutable - i.e. once a string is created, it's contents cannot be altered.

Since string is a reference type, a string object must be created on a managed heap which should be garbage collected when the object becomes orphan. This is fine in the sense that at one or other place we can't avoid creating managed objects and all managed objects have to be garbage collected. But, if you look at the second point above which states strings are immutable. Having said this, what if you want to manipulate the string contents (like appending substring, converting to lower case etc.) ? Ofcourse you can do that. But, the original string is never altered, instead, a new string object is created with new value. What does that mean? Take a look at below code.

string s1 = "Hello World";

string temp = s1; // store the reference of s1 into temp

s1 = "New World"; // modify s1.

First I created a string s1 with value "Hello Word". Then I stored the reference of s1 in temp i.e. both temp & s1 are pointing to the same object. You can verify that by calling Object.ReferenceEquals (s1, temp) which will return true if the reference is same. Then I modify s1 to "New World". At this time, I am actually creating a new String rather than modifying the value in s1. You can verify that by comparing contents of temp and s1. So what is the impact of this? Well, to know the impact, see the below code.

string s = string.Empty;

Stopwatch watch = new Stopwatch();

Int32 count = 0;

watch.Start();

while (true)

{

s = s + (count++).ToString();

if (watch.ElapsedMilliseconds >= 1000)

{

break;

}

//Thread.Sleep (1);

}

When I ran this code on my i3 machine running Windows7, the loop ran approximately 3 million times. Also, Garbage collection (Gen0) ran for 100 times !!! This is really huge impact on the performance. This is because, after every loop, a new string is created and the old reference becomes the candidate for garbage collection. Also, if you look at the average size of string created at every loop - it is 3Mb. If the garbage collection had not occured, just calculate the total memory occupied by all strings in one second. Thanks to GC for avoiding a disaster. When I uncommented the Sleep statement, the GC collection count reduced to 0.1 per second as the number of strings created per second reduced from 3 million to just 300 !

Above demo clearly states that too many strings in memory is not good. So, what are all the possible ways?

Prefer StringBuilder over String in cases involving heavy string manipulations
Avoid string manipulations inside a loop at all possible places.
Avoid too many class level/ global string fileds.

Be Careful of Constant fields in .NET

2011-11-22T14:03:00.001+05:30

We all know that Constant fields are those whose value never changes in the lifetime of an application. Constant are really useful constructs that offer many benifits to the user like,

Constants make developer sure that their value never changes (even by mistake).
Constants are compile time values, which means their values are directly embedded inside the metadata. Hence, constants don't require memory allocation at runtime.

All that said, there is a risk in using the constants if appropriate care is not taken. See the second point above - "constant values are embedded directly inside the metadata". This statement has an impact when you have constant fields in a DLL which are used in one or more applications. Let me start demostrating you through a sample code. Consider that the below class exists in a library called MyLibrary.DLL.

public class GlobalConstants

{

public const Int32 MAX_VALUE = 2;

public const String MALESTRING = "Male";

public const String FEMALESTRING = "Female";

}

Now, I have to use GlobalConstants in my application. For that I will create a Console Application called SampleClient.exe. Inside the Main function I use the above constants as

class Program

{

static void Main(string[] args)

{

int maxValue = GlobalConstants.MAX_VALUE;

String Female = GlobalConstants.FEMALESTRING;

Console.WriteLine(maxValue);

Console.WriteLine(Female);

}

Build SampleClient.exe and run it directly from bin folder. Your application will print 2 and Female as expected and everything is fine. Now I got a requirment that MAX_VALUE should be changed to 100, MALE should be "Man" and FEMALE should change to "Woman". Ok, thats fine. I will update GlobalConstants in MyLibrary.DLL class as below.

public class GlobalConstants

{

public const Int32 MAX_VALUE = 100;

public const String MALESTRING = "Man";

public const String FEMALESTRING = "Woman";

}

I will re-build MyLibrary.DLL and send the dll for use in SampleClient.exe. So, place the new dll in bin folder of SampleClient and run it. SampleClient is now refering to new MyLibrary.DLL. But what output do you see? you expect that it will print 100 and Woman but it still prints 2 and Female. So, what is the problem? For that you need to see the IL code of Main method in SampleClient.

Observe that the values 2 and FEMALE are hardcoded in the IL. Though you have changed MAX_VALUE to 100 & FEMALE to "Woman", the values are not reflected. To correct this problem, you must re-build SampleClient application too to make use of new constant value in the dll. Rebuilding SampleClient will embed the new MAX_VALUE and FEMALE values into metadata of Main method.

With this problem, consider your DLL is consumed by Hundreds of applications. So, changing a constant value in your library will result in rebuilding of all it's consumers. So, be careful with constants, use them only when you are sure that their value never-ever change or if they change, you afford re-building it's consumers. Or, if you think constant values may change, then prefer using 'readonly' fields over constants. I will discuss about 'readonly' fields in my next writing.

Creating Multi Column ComboBox in .NET

2011-11-15T17:33:00.001+05:30

Recently I was working on an assignment wherein I had to create a Custom ComboBox to display multiple columns when it is dropped down. Something similar to below image.

The actual assignmet was little more complex than the one I have shown in the above image. Anyways, if you look at the image, you will also find the combo box pretty useful as it can display data in column manner like FirstName-LastName, Name-Place etc. So, if you like it, you can design it yourself. All you have to do is, create class that inherits ComboBox, set the DrawMode property to OwnerDrawFixed, override OnDrawItem method to draw the columns manually.

Sounds simple, isn't it? Now, how do we supply items to this ComboBox? If we have to display an item in multicolumn fashion, ideally the item must be composite one i.e. a Dictionary<T, T> or a class with 2 instance members. Since ComboBox's Items property is a collection of objects, we can place anything into it. This has got both advantage as well as disadvantages. Advantage is we can place object of our custom class into ComboBox while the disadvantage is user can enter any kind of item which cannot be represented in the way we need to display it.

Ok, all that said, I will create a class whose instances we are going to place in the combo box. I will call this class as XComboItem (X stands for Extended).

public class XComboItem

{

public String DisplayName { get; set; }

public Object Value { get; set; }

public String Description { get; set; }

}

So, this is the class, whose objects we are going to place in out custom combo Box. I will name the combo as XComboBox.

public partial class XComboBox : ComboBox

{

private Int32 ColumnGap = 20;

private Int32 firstColumnWidth;

private Int32 secondColumnWidth;

public XComboBox(): base()

{

DrawMode = DrawMode.OwnerDrawFixed;

firstColumnWidth = DropDownWidth / 2;

secondColumnWidth = DropDownWidth / 2;

}

In this, firstColumnWidth and secondColumnWidth are the widths of both columns that I am going to display in combo dropdown list (in pixels). Column gap is gap between two columns.Initially I will set the column widths to half the width of DropDownWidth. The only major thing is to override OnDrawItem() function. By overriding this function, you can draw the items in DropDownList of the combobox in the way you want. You can display each item with different font, differen style or even add image to each item. In our case, we need to display DisplayItem & Description of XComboItem in two seperate columns. The logic is getting the drawing object of current item, then use DrawString method appropriately. So, here goes our OnDrawItem.

protected override void OnDrawItem(DrawItemEventArgs e)

{

if (e.Index < 0)

{

return;

}

XComboItem item = (XComboItem)Items[e.Index];

ColumnGap = firstColumnWidth == 0 ? 0 : ColumnGap;

e.DrawBackground();

e.DrawFocusRectangle();

String first = item.DisplayName;

String second = item.Description;

while (TextRenderer.MeasureText(first, e.Font).Width > firstColumnWidth)

{

first = first.Substring(0, first.Length - 1);

}

Brush solidBrush = new SolidBrush(e.ForeColor);

e.Graphics.DrawString(first, e.Font, solidBrush, e.Bounds.Left, e.Bounds.Top);

e.Graphics.DrawString(second, e.Font, solidBrush, e.Bounds.Left + firstColumnWidth +

ColumnGap, e.Bounds.Top);

}

You can add any properties or methods to make the control more user friendly. So, That's it, our control is ready. To use, create the object of XComboItem and add the object to Items collection of XComboBox. Then run your application to see the effect.

Built-in General Purpose Delegates in .NET

2011-09-04T22:57:00.000+05:30

In day-to-day coding, we often need to create delegates. Every time we need a delegate, we usually create a new delegate and use it. But, if you know .NET already provides some ready made delegates which we can use for varying purposes. So, in this post I will be discussing some of the common built-in delegates that we can use for general purpose.

System.Action: The Action delegate can accept any method which takes zero arguments and returns void. The declaration goes like

public delegate void Action();
System.Action<…> : This is a generic version of System.Action delegate. This delegate can accept any method that takes 1 to 16 parameters and returns void. You can use this delegate as below,

public void SomeMethod(int a, string b, double c){}
System.Action<int, string , double> action = new System.Action<int, string , double>( SomeMethod );
System.Comparison<T>: Actually this delegate is used for specific purpose, I am discussing this here because it is often used in Sorting techniques. This takes a method as parameter which takes two arguments of type T and return an Integer. For example, I want to sort list of employees based on their first names then I can do it as,

private int CompareEmpoyees(Employee a, Employee b)
{
return a.FirstName.CompareTo(b.FirstName);
}
ListempList = GetEmployeeList();
Comparison comparer = new Comparison(CompareEmpoyees);
empList.Sort(comparer);

System.Func<…, out TOut> : This is a generic delegate that accepts any method that takes 0 to 16 arguments of any type and return an argument of type TOut. For example,

public Employee SomeMethod(int a, string b, double c)
{
}
System.Action<int, string , double> action = new System.Action<int, string , double, Employee>( SomeMethod );

System.MethodInvoker: This delegate is similar to System.Action delegate which accepts a method that takes zero arguments and returns void. But, as the name suggests, this delegate is used at places where you need to talk to UI elements from a background thread. Something like below,

MethodInvoker mi = new MethodInvoker ( () => { textBox1.Text = "Hello World"; });
this.Invoke(mi);

That is it for now. I will be editing this page if I find any other delegates that fit here. Meanwhile, If you want me to add anything here, please let me know.

Closing all open forms in .NET

2011-07-02T13:53:00.000+05:30

In your application you may have many hidden forms which you must close before exiting the application. It's because, hidden forms always stay in the memory until you close them. But, .net framework always takes care of disposing off all those objects when the application is terminated. But, the real problem comes when those hidden forms contain COM/ActiveX components. You all know, you must manually clean all unmanaged components. Now, if you forget to close such forms, it may lead to memory leaks.

It's very simple to close all such open forms. Application.OpenForms is the collection that contains all open forms. So, just loop through this collection and close one by one. Below is the code, where I am closing all open forms in main form's FormClosing event handler.

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

{

foreach (Form openForm in Application.OpenForms)

{

openForm.Close();

}

On first look, this code looks to be fine. But, there are two potential problems with this code.
First,Application.OpenForms contains your main form because it is also open currently. So, when the loop executes, it will call Close() on MainForm, which in-turn will fire FormClosing event of MainForm. This will results in calling MainForm_FormClosing method recursively and infinitely which leads to deadlock. So, a StackOverFlowException will occur. To avoid this, you can add a check as below.

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

{

foreach (Form openForm in Application.OpenForms)

{

if (openForm != this)

{

openForm.Close();

}

simple, isn't it? Is it good to go now? No. Still there is a problem. To understand the problem, let us consider, we have 3 open forms. So, Application.OpenForms collection contains 3 items (say in following order)

   1. MainForm
   2. SubForm1
   3. SubForm2

Ok. The loop executes first time and skips the Close() since the condition fails. During second loop, it closes the SubForm1 and imporatantly SubForm1 is removed from Application.OpenForms collection. This means the collection is altered. Now, during 3rd loop, it tries to access the collection, an 'InvalidOperationException' is thrown saying "Collection was modified; enumeration operation may not execute". Hence, what you can do is instead of directly accessing Application.OpenForms, store all open forms in an array or a list. Then loop through the array/List and close the forms. So, below is the final code.

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

{

List<Form> lstOpenForms = Application.OpenForms.OfType<Form>().ToList();

foreach (Form openForm in lstOpenForms)

{

if (openForm != this)

{

openForm.Close();

}

I hope this information was useful.