Rakesh Rajan's blog : .NET FAQ

XML Serialize IDictionary types (Hashtable, DictionaryBase etc.)

rakeshrajan — Sun, 15 Jan 2006 12:42:00 GMT

Problem

You want to serialize a type; however it:

implements IDictionary, or
derives from DictionaryBase, contains a member which implements IDictionary or derives from DictionaryBase,

which causes XmlSerializer to throw an exception:
"System.NotSupportedException: The type X is not supported because it implements IDictionary".

Solution

Override XmlSerialization by making the type implement the System.Xml.Serialization.IXmlSerializable class. Define how you want the object to be serialized in XML in the WriteXml method, and define how you could recreate the object from an xml string in the ReadXml method.

Code

Download the full code here.

The WriteXml and ReadXml methods used in the sample follow.

public void WriteXml(System.Xml.XmlWriter writer)
{
	// Used while Serialization

	// Serialize each BizEntity this collection holds
	foreach( string key in this.Dictionary.Keys )
	{
		Serializer.Serialize(writer, this.Dictionary[key]);
	}
}

public void ReadXml(System.Xml.XmlReader reader)
{
	// Used while Deserialization

	// Move past container
	reader.Read();

	// Deserialize and add the BizEntitiy objects
	while( reader.NodeType != XmlNodeType.EndElement )
	{
		BizEntity entity;

		entity = Serializer.Deserialize(reader) as BizEntity;
		reader.MoveToContent();
		this.Dictionary.Add(entity.Key, entity);
	}
}

Description

By default, XML Serialization does not serialize types that implement IDictionary; it throws an exception when you attempt to do so. This comes quite in the way when you need to switch serialization techniques, or have custom collections which derive from DictionaryBase or any other sort of scenario.

The workaround for this problem is to let XML Serializer know how to serialize your IDictionary types yourself, by implementing the System.Xml.Serialization.IXmlSerializable class. This interface declares three methods - ReadXml, WriteXml and GetSchema.

When XmlSerializer attempts to serialize a type and finds that it implements IXmlSerializable, the serializer would simply pass control to the ReadXml (during deserialization) or WriteXml (during serialization) methods. In other words, you yourself handle how serialization and deserialization should happen.

.NET Certifications FAQ

rakeshrajan — Fri, 23 Sep 2005 06:57:00 GMT

This is something that comes up frequently.

Check out the below link I wrote a long long time ago. Hope it has some helpful information. Please drop me a mail if you have questions.

http://t-mug.org/certification.aspx

How to make Visual Studio .NET create web projects in a user defined folder

rakeshrajan — Mon, 22 Aug 2005 14:57:00 GMT

Just published this here:
http://support.microsoft.com/kb/555436

How to share custom application configuration settings across projects in .NET

rakeshrajan — Tue, 16 Aug 2005 19:12:00 GMT

Just published this here:
http://support.microsoft.com/kb/555396

Interestingly, I had stumbled upon this while answering this post:
http://www.msdn.microsoft.com/newsgroups/default.aspx?dg=microsoft.public.dotnet.general&mid=ff9719e6-3829-4122-8b23-565087e9b1a4&sloc=en-us

Why Multiple Inheritance was not implemented in .NET

rakeshrajan — Wed, 29 Jun 2005 15:56:00 GMT

Just came across this blog entry on why Multiple Inheritance was not implemented in .NET.

http://blogs.msdn.com/csharpfaq/archive/2004/03/07/85562.aspx

How to find out the immediate calling method

rakeshrajan — Tue, 03 May 2005 03:55:00 GMT

Use the StackFrame and StackTrace classes.

For example:


	public static void SourceMethod()
	{
		TargetMethod();
	}

	public static void TargetMethod()
	{
		StackTrace st = new StackTrace();

		// This will output 'SourceMethod'
		Console.WriteLine(st.GetFrame(1).GetMethod().Name);
	}

Note:
Code optimizations might give you different results. Some methods may even be completely optimized out. But this code should work fine without any optimizations.

Static readonly versus constants

rakeshrajan — Sun, 01 May 2005 16:03:00 GMT

Though both would appear similar – they are both read only and generate almost similar IL code – they have a number of differences. Here they are:

Constants are evaluated at compile time, whereas static (or static readonly) variables at runtime.

So, when the compiler generates the IL, the value of the constant is burned into the IL wherever it is referenced. Consequently, when you change the value of a constant, all the client applications referring the constant will have to be recompiled.

However, if you change the value of a static field, you only need to recompile that library and none of the clients. This is because the IL generated would only be referencing the static field, and will not have the value burned into it.

Though constants and readonly variables are both read only, readonly is a runtime constant, and can hold references types (like DataSet etc.). Constants on the other hand cannot hold reference types except for string and null.

Yet another difference is that constants need to be initialized at the declaration itself, whereas readonly fields may be initialized either at the declaration or in a constructor (or in static constructors/type initializers).

Override versus Hide (static binding versus dynamic binding)

rakeshrajan — Sun, 01 May 2005 05:56:00 GMT

Background This is a topic repeatedly asked about both online and offline. This entry explains the following OOPs concepts to help clear them:

Method overriding and method hiding (implemented using the override and new keywords in C# and Overrides and Shadows keywords in VB.NET).
Static Binding and Dynamic Binding in this context.
Other related concepts

Static Binding

When a reference type variable is initialized, the reference may hold either:

an object of the same type as that of the reference type
an object of a type related to the reference type

2 public class Base

3 {

4 public void Print()

5 {

6 Console.WriteLine("Base");

7 }

8 }

10 public class Derv : Base

11 {

12 public void Print()

13 {

14 Console.WriteLine("Derv");

15 }

16 }

The code below is perfectly legal in this context:

2 Base obj;

4 obj = new Base();

6 // This is possible since Derv is related to Base

7 obj = new Derv();

In such a scenario, when a method is invoked against a reference variable, the actual method going to be called depends upon the type of the reference. For example:

2 Base obj;

3 Derv der;

5 obj = new Base();

6 obj.Print(); // Output: 'Base'

8 obj = new Derv();

9 obj.Print(); // Output: 'Base'

11 der = new Derv();

12 der.Print(); // Output: 'Derv'

At line number 9, the compiler determines which method to call (the Base.Print method or Derv.Print method) by checking the type of the reference variable obj. Since the reference variable obj (not the actual object stored at the reference) happens to be of type Base, the compiler calls Base.Print. In a similar manner, at line number 12, the compiler invokes Derv.Print as the reference variable der is of type Derv.

This is known as Static Binding because the compiler does all this at compile time while building the final IL code, which is thus static (unchangeable at run-time).

Method Hiding

The type Derv derives from Base and thus inherits the Base.Print method. But note that Derv itself defines a Print method. When a derived class defines a method with the same name as that of a method in the base class, the base class’s method would never be invoked if the type of reference variable is that of the derived class. In the previous code snippet at line number 12, though Derv inherits the Base.Print method, it was Derv.Print that was invoked. Here, Derv.Print is said to be hiding Base.Print.

In order to make sure that this is indeed what the developer requires, the compiler would issue a warning saying that Derv.Print is hiding Base.Print. The compiler simply wants to bring to the attention of the programmer that there exists a method with the same name in the base class, and that the derived class’s method is hiding it. To get rid of the warning, we need to use the new keyword:

2 public class Derv : Base

3 {

4 public new void Print()

5 {

6 Console.WriteLine("Derv");

7 }

8 }

This reassures the compiler that the programmer knows about this issue, and that this implementation is purposeful.

Method Overriding and Dynamic Binding

By using the virtual and override keywords, you could control which method is invoked in an inheritance scenario.

2 public class Base

3 {

4 public virtual void Print()

5 {

6 Console.WriteLine("Base");

7 }

8 }

10 public class Derv : Base

11 {

12 public override void Print()

13 {

14 Console.WriteLine("Derv");

15 }

16 }

This definition would yield the following result.

2 Base obj;

4 obj = new Base();

5 obj.Print(); // Output: 'Base'

7 obj = new Derv();

8 obj.Print(); // Output: 'Derv'

Note that at line number 8, even though the reference variable obj was of type Base, the method that was invoked was Derv.Print rather than Base.Print. This is because of the following reasons:

Base.Print declares itself as virtual, which means derived classes may override this method
Derv.Print explicitly states that this method overrides the Base.Print method, by using the override keyword

Thus, when the Print method is invoked, the derived type’s method gets invoked.

In addition to Derv, there could be more types which derive from Base, or even from Derv or any of its subclasses. Consequently, at any point of time, the reference variable obj could be holding any object instance whose type is in some way related to the type Base. It is thus not possible to find out what is the actual type of the instance held in obj until runtime. Hence, binding happens at runtime when the actual object instance exists, and the method is then invoked dynamically. This is known as Dynamic Binding.

Remarks

If Derv.Print was not declared with the override keyword, Derv.Print would be ignored and Base.Print would be invoked. This design ensures that the programmer explicitly requests for overriding. Conversely, if Base.Print was not declared as virtual, Derv.Print will not be able to override that method; in other words, the base class developer should explicitly permit derived class developers to override its methods. This design prevents any accidental invocation of the derived class’s method when a new version of the base class with a method of the same name ships.

How to create a random (or unique) string (or number)

rakeshrajan — Thu, 14 Apr 2005 16:34:00 GMT

Problem

You want to create a unique number for:

using an a primary key in a table
for security purposes like creating a salt to attach to a hash value

Possible solutions

Create a new GUID (Globally Unique Identifier) by using the GUID.NewGuid method
Use the RNG Crypto service provider to create a random byte array and convert it into a string
Use DateTime.Now if that would suffice

Example for using RNG Crypto Service Provider:


	byte[] saltInBytes = new byte[8];
	RNGCryptoServiceProvider saltGenerator = new RNGCryptoServiceProvider();
	saltGenerator.GetBytes(saltInBytes);
	string saltAsString = Convert.ToBase64String(saltInBytes);

References

http://macronimous.com/resources/Secure_Password_Programming.asp

Find out the number of times a character is repeated in a string without using iteration

rakeshrajan — Thu, 14 Apr 2005 16:24:00 GMT

Problem

You want to find out the number of times a specific character is repeated in a string, but you don't want to use iterative blocks like while, for etc..

Solution

Use the Split method, and subtract 1 from the length of the string returned.

Example


	string input = "123#345#456#";
	int count = input.Split("#").Length - 1; // Returns 3

How to create a Plug-in architecture

rakeshrajan — Thu, 14 Apr 2005 16:23:00 GMT

Problem

You want to create an application which could dynamically load ‘plug-ins’ at runtime. You want to do this because:

you want other people to create plug-ins for your application without exposing your source code
you have a module which keeps changing but don't want to recompile your application every time it changes

Solution overview

Create an interface which all plug-ins must implement, and have it shared as an assembly referenced by both your application and the plug-ins.
Create a plug-in by implementing the interface, and build it as an assembly
Let the application know about the plug-in assembly, by using either the app.config file or any similar mechanism.
At run time, use Reflection (Activator.CreateInstance method) to create an object of the plug-in and store in a variable of the interface type.

Suggested references

Guidelines on naming conventions, standards etc.

rakeshrajan — Thu, 14 Apr 2005 16:21:00 GMT

MSDN has a paper which lays down guidelines on naming conventions, class member usages, exposing functionality etc. This is a must-see resource for all who want to use a standard convention while coding, to create class libraries and whoever else who just want to write some good piece of code.

Online link

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconnetframeworkdesignguidelines.asp

MSDN Collection link

ms-help://MS.VSCC.2003/MS.MSDNQTR.2003FEB.1033/cpgenref/html/cpconnetframeworkdesignguidelines.htm