.Net Developement : Programming

Serialization

Paul June — Fri, 17 Mar 2006 19:26:00 GMT

I know that this is an old age technology in .Net. But I was surprised that some C# programmers still don’t know about serialization. So I’m creating this blog for the ones who still hasn’t got any idea on serialization. But if you already know this, then just skip this blog entry.

Here’s a FAQ about serialization.

What is serialization?
Well, according to MSDN, “as the process of storing the state of an object instance to a storage medium”. So why do we need to store a class in an external storage? The reason for this is that, sometimes we need to communicate across between applications. And sometimes, it’s a lot easier if we can pass objects between two separate application domains.

Why use serialization?
Just like as said earlier, sometimes when you need to pass objects between two applications, you can’t pass it through memory coz two different applications resides in two different domains. So you must find a way to store it externally so that the other application could read the external file and recreate your class.

How do you serialize a class?
All you have to do is mark your class as serializable. To do this just place the serializable keyword enclosed in angle bars before the declaration of your class:

[Serializable]
public class MyObject {
   public int n1 = 0;
   public int n2 = 0;
   public String str = null;
}

This is the basic serializable class. When you serialize the class. All of its private and public properties would also be saved. Now, to serialize a class, you must have a serializer. To explain it better, Here’s an example:

MyObject obj = new MyObject();
obj.n1 = 1;
obj.n2 = 24;
obj.str = "Some String";
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin",
FileMode.Create,
FileAccess.Write, FileShare.None);
formatter.Serialize(stream, obj);
stream.Close();

This sample writes your class into a File names “MyFile.bin”.

After serializing, what should I do?
After serializing the class, you should deserialize it for you to restore the state of the saved class. Here’s a sample:
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin",
                          FileMode.Open,
                          FileAccess.Read,
                          FileShare.Read);
MyObject obj = (MyObject) formatter.Deserialize(fromStream);
stream.Close();

// Here's the proof
Console.WriteLine("n1: {0}", obj.n1);
Console.WriteLine("n2: {0}", obj.n2);
Console.WriteLine("str: {0}", obj.str);

In the previous example, we are using the BinaryFormatter as the serializer for our class. The BinaryFormatter class serializes our class into a file. But its pretty useful to serialize our class into an xml stream. This is the case of Webservices. To serialize a class into an xml stream, you’ll have to use the SoapFormatter instead of BinaryFormatter.

What if I don’t like to include some properties during serialization?
To exclude some properties, just mark them as NonSerialized. Here’s a sample:

[Serializable]
public class MyObject
{
   public int n1;
   [NonSerialized] public int n2;
   public String str;
}

This process is called Selective Serialization.

What about the ISerializable Interface?
The ISerializable interface is used when your doing Custom Serialization. Wondering what difference it is compared to Selective Serialization? Well, when your class is implementing the ISerializable interface, you will have the power to set values to your variables during serialization. This is pretty much useful when a value in your class would be invalid after deserialization, but you need to initialize its value. You must be also wondering if why not just place the initialization code in your constructor? The answer is simple, during deserialization your constructor would not be called. So how to implement ISerializable? Here’s a sample:

Serializable]
public class MyObject : ISerializable
{
   public int n1;
   public int n2;
   public String str;

   public MyObject()
   {
   }

     protected MyObject(SerializationInfo info, StreamingContext context)
   {
     n1 = info.GetInt32("i");
     n2 = info.GetInt32("j");
     str = info.GetString("k");
   }

   public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
   {
      info.AddValue("i", n1);
      info.AddValue("j", n2);
      info.AddValue("k", str);
   }
}

There are two things to consider when implementing the ISerializable interface. You should implement a special constructor which happens during deserialization. And also the GetObjectData method, this method is called during the serialization process.

When should I use Serialization?
A straightforward answer, always. You should mark your classes serializable as often as possible. Coz you might not know that the user of your class might design to inherit your class and serialize it. Hmmm. I kinda forgot to say that you cannot serialize an object if the base class is not serializable. Sorry for that.

So during your design phase, you should identify the classes that you think its users would serialize. To be safe, you can mark all of your class into serializables.

I hope this clarifies any issue about serialization. Cheers!

C# GetObject and CreateObject

Paul June — Wed, 15 Mar 2006 16:08:00 GMT

When interoperating with COM applicaitons, sometimes you need to get the running instance of the application object of the app. In VB you would be doing this by using the GetObject method.

Basically the GetObject method returns a reference to an object provided by a COM component.
For example you want to get a reference on the currently running excel program.

Dim excelObj As Object

excelObj = GetObject(, "Excel.Application")

If the above statement causes an error, then no instance of the excel application is running.
This routine is very basic for VB programmers.
But what about C#? How could you do this in C#?

There is no direct equivalent of the GetObject method in C#. I have this problem lately, and I have produced a simple routine that "could be" the equivalent of GetObject method (I've used this to get a reference on a running Autodesk AutoCAD application:

acadObj = (AcadApplication) Marshal.GetActiveObject("AutoCAD.Application.16");

Note: you'll have to add the namespace System.Runtime.InteropServices to be able to use the Marshal object.
In VB you can also create a reference to a COM applicaiton by using the CreateObject method if the GetObject method fails:

excelObj = CreateObject("Excel.Application")

In C# its quite very simple. You just need to allocate the application object of the COM component:

AcadApplication acadObj = new AcadApplication();

This sample routine would then launch a new AutoCAD application.

Generics 101

Paul June — Sun, 05 Mar 2006 19:08:00 GMT

Another new feature of C# 2.0 is the ability to create classes that can handle different types while eradicating type boxing on the underlying type. This new feature is called Generic Classes.

This type of class enable its user to create a somewhat “general class” that could accommodate any types. By using this class there is no need for type casting thus reducing the possibility of runtime errors.

Generic classes are most widely used on user-defined collections. In the previous version (framework 1.1) you are forced to implement collections using object as its underlying type so that it could store any types. This implementation would result into runtime type checking and type casting. To avoid this you can implement a class for each type that you are planning to support, thus creating an overhead of multiple implementations of a class.

Here’s a scenario. You are creating a user defined collection which has the capability to convert its stored values into a csv file. The first step is to inherit from a collectionbase class. Second is to implement your add/remove/get methods. Here then comes the problem, what type would my get function return? Or what type would my add function receive?

Generic class is the solution for the problem above.

Here’s the proper syntax for declaring a Generic Class:

public class GenericClass<T> {
   T _value;
   public GenericClass(){}
   public void setValue(T data) {
      _value = data;
   }
   public T getValue() {
      return _value;
   }
}

Let’s examine this class. The first odd thing that you would notice is the angle bars located right after the class name. These angle bars encapsulates the type that this class uses. After specifying the type, you can then use it like a normal type. By default the <T> would act as an object type within your class.

To use the above class in your program, you can initialize it this way:

GenericClass<int> generic = new GenericClass<int>();

Try to check if your setValue and getValue functions return an int which was the specified type within the angle bars.

As you can see, both of the methods of the class now returns int.

In C# 2.0 there are already Collection based Generics that’s readily available. Most likely, you’ll going to use these classes rather than create one yourself.
      • List is the generic class corresponding to ArrayList.
      • Dictionary is the generic class corresponding to Hashtable.
      • Collection is the generic class corresponding to CollectionBase.

Nullable Types

Paul June — Tue, 28 Feb 2006 19:08:00 GMT

Well, this is the official opening of my blog.
I’ll be blogging on the new features of Visual C# 2005 on my first few posts. The newest feats that I love on C# is on its new Nullable Types.

Nullable types gives you the ability to create types that can hold null values. You might be wondering on how would this be useful. Well nullable types can be very useful when dealing with database values. Such as you don’t need to convert null values in your database to a blank string or 0 if numeric when passing it directly to a variable.

By default, types cannot contain null values. Here’s an example that demonstrates this:

int x = null;

The code above generates an error (Cannot convert null to 'int' because it is a value type).

A nullable type can represent the normal range of values for its underlying value type, plus an additional null value. For example, a Nullable<Int32>, can be assigned any value from -2147483648 to 2147483647, or it can be assigned the null value. A Nullable<bool> can be assigned the values true or false, or null.

To create Nullable Types you must declare your variable this way:

System.Nullable<int> x;
// Then you can assign it to a null value
x = null;

But there is a short way of doing this just add a “?” operator after your type declaration:

int? x = null;

Both two types of the declaration are interchangeable.

By declaring your type as nullable, you have additional properties on your object. These are HasValue and Value read-only properties. Both of these properties is being used to check the nullability of your data. The HasValue property returns true if the variable contains a value, or false if it is null. The Value property returns a value if one is assigned, otherwise a System.InvalidOperationException is thrown. Here’s an example:

int? x = null;
if (x.HasValue) {
int j = x.Value;
}

Another useful additional function is the GetValueOrDefault. This function returns the current value or the default value of the type if its current value is null.

int? x = null;
int j = x.GetValueOrDefault();

The statement would give the variable j a 0 value instead of a null.

This might be the coolest feature of the nullable types. If your variable is of nullable, then you can use the new “??” operator. This is the shortcut of “?:” operator (iif in VB) on detecting null values.

// This is the old declaration
int? x = null;
int j = x == null ? 0 : x;

// This is the new declaration
int? x = null;
int j = x ?? 0;

Both statements are interchangeable. It’s just in your choice on which looks easier.

This wraps up my first blog. Hope to see you on my next!