XmlSerialization with IDictionary and CollectionBase Objects

Code Download HERE:

 

I recently was trying to create a class (a subclassed EventArgs class in my case) where I needed the class to contain a property which housed a few named valued pairs.
Additionally, I wanted to be able to XmlSerialize the class also, so I could store it for later retrieval.  The reasons for that are not really that important.

Of course, when one thinks of named value pairs, something like a Hashtable comes to mind.
So there I went off coding, making a class, which contained one public property, which was a hashtable.

Something like this:

 [Serializable]
 public class ReportRequestEventArgs : System.EventArgs
 {

  private string m_name;
  private Hashtable m_myHash = new Hashtable();

  public string Name   { get { return this.m_name; }  set { this.m_name = value; } }
  public Hashtable NameValuePairsViaAHashTable { get { return this.m_myHash; }  set { this.m_name = m_myHash; } }
}

 

Then you become quickly aware that you cannot XmlSerialize an object which is or contains anything of the IDictionary variety.
And you’ll find a post like this one:
http://www.mattberther.com/2004/06/000487.html

So I said "No problem, the value part of Hashtable can be complex objects, and all I need is a some string (keys) and some string (values).
So I’ll create a "Item" object, and then a "ItemCollection" object which implements CollectionBase.  Then I’ll serialize that the collection object.  Surely that can’t be an issue.

Well, I should have done more reading at Matt Berther’s site. Cuz here you go:
http://www.mattberther.com/2003/04/000052.html

 

So let me be the first one to say that I really haven’t "discovered" anything new, I’m just relaying my struggle with it, and some information that I found.  By reading other sites, you can probably discern the same things I have in this particuliar area.  I have tried to layout some examples so that you can get a better feel for what is happening.  And if you’re trying to just figure out some XmlSerialization in general, the examples are a good starting point.

I did "bring together" 2 different inputs, in regards to the CollectionBase serialization, and Nitin Pande‘s article on encoding.  When I was saving the xml to a database (text object in sql server 2000), I was finding that the encoding was switching up on me, unless I explicitly set it.

Any, on to my "Non-Discoveries" (aka, summing up what I figured out from others).

 

The issue is that everything works, except you can’t put an Xml tag on the collection declaration.
Here is a snipplet:

 [Serializable]
 //[System.Xml.Serialization.XmlRoot("MyCollectionXmlRoot")]
 public class MyCustomCollection : System.Collections.CollectionBase 
 {

 }

Which is what Matt is talking about at his (second) post listed above.
Thus he figured out that at least he could put the MyCollection in a Wrapper object.

I’m with him when he says "All in all, I dont see why the serialization of collections is so different for collections as opposed to other classes."  I don’t get on the "that is a bug/oversite" wagon too often, but this one might be it.
The exact error is "There was an error reflecting type" and then lists the MyCollection object afterwards (that’s for googlers trying to find the exact phrase match).

I actually thought I had figured something out, but turns out I just had a DataContainer myself, it just wasn’t as apparent at first.

Anyway.  Thanks Matt for the DataContainer idea.

For the rest of you, I’ve composed a little example C# solution to try and figure some of this stuff out. (Again, I haven’t "discovered" anything new).
I have purposely tried to name things differently, and not to standard, so you can see what is going on.
I find that sometimes the code becomes very ambigious when the same names are used over and over again.
You should be able to figure out how to XmlSerialize an:
Object
ObjectCollection
An ObjectTwo which houses an ObjectCollection
and finally a
ObjectTwoCollection which hold multiple ObjectTwo’s, (and the ObjectTwo’s contain the original ObjectCollection).
Let the example do the talking, and you’ll see what I mean.

Back to my original issue, which was I needed a subclassed EventArgs, which contained a (sub)Collection of key/value pairs (the key and value were just strings in this case).
(If you’re looking to do something like this, just replace StateObject.StateAbbrevation and StateObject.StateFullname with "KeyValuePair.Key and KeyValuePair.Value" , and that’s about what I have in my code)

I was able to do this, and in essence my (subclassed)EventArgs class became what Matt is calling the DataContainer.

My conclusion is that you CAN XmlSerialize a custom (CollectionBase) object, you just can’t give it the Xml name you want, UNLESS you do the Matt DataContainer work around.

The sample code will hopefully help you get a better understanding of what is going on.

My need was solved, and now I have a XmlSerialized version of my EventArgs class.
And I learned more about how XmlSerialization works and doesn’t work.
I might email the CRL team at Microsoft and ask them "What gives?"

///////////////////////////////////////

Some other posts of interest:

http://forums.asp.net/936361/ShowPost.aspx
http://geekswithblogs.net/kinger/archive/2005/07/04/45407.aspx
http://weblogs.asp.net/wim/archive/2004/08/12/213700.aspx
http://www.codeguru.com/forum/showthread.php?threadid=356926
http://www.ondotnet.com/pub/a/dotnet/2003/03/10/collections.html

 

 

/////////////// Start Code // (Use the attached image CodeLayOut.gif to help recreate it in your project)

 

// Start PersonObject.cs

using System;
using System.Xml.Serialization;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.BusinessObjects
{
 /// <summary>
 /// Summary description for PersonObject.
 /// </summary>
 ///

 [Serializable]
 [System.Xml.Serialization.XmlRootAttribute("PersonRootXmlNode")]
 public class PersonObject
 {

  private string m_firstName;
  private string m_lastName;
  private Collections.StateCollection m_stateIHaveLivedIn = new GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections.StateCollection ();

  [XmlElementAttribute("XmlFirstName")] //Keep in mind you can put anything inside the quotes to name the element.
  public string FirstName
  {
   get{ return this.m_firstName; }
   set { this.m_firstName = value;}
  }
  
  [XmlElementAttribute("XmlLastName")]
  public string LastName
  {
   get{ return this.m_lastName; }
   set { this.m_lastName = value;}
  }

  [XmlArray("StatesIHaveLivedIn"), XmlArrayItem("HeresOne")]
  public Collections.StateCollection StatesIHaveLivedIn
  {
   get{ return this.m_stateIHaveLivedIn;}
   set {this.m_stateIHaveLivedIn = value;}
  }

  public PersonObject()
  {
   //the XmlSerializer requires a default Constructor   
  }
  
  public PersonObject(string fn , string ln)
  {
   this.m_firstName = fn;
   this.m_lastName = ln;
  }
 }
}

// End PersonObject.cs

 

// Start StateObject.cs

using System;
using System.Xml.Serialization;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.BusinessObjects
{
 /// <summary>
 /// Summary description for StateObject.
 /// </summary>
 ///

 [Serializable]
 [System.Xml.Serialization.XmlRootAttribute("StateRootXmlNode")]
 public class StateObject
 {
  private string m_stateAbbreviation;
  private string m_stateFullName;
  private string m_secretInformation="Let’s throw a non serialized string in for kicks";

  [XmlElementAttribute("XmlStateAbbrev")] //Keep in mind you can put anything inside the quotes to name the element.
  public string StateAbbreviation
  {
   get{return this.m_stateAbbreviation; }
   set{this.m_stateAbbreviation = value;}
  }

  [XmlElementAttribute("XmlFullName_CallMeWhatever")]
  public string StateFullName
  {
   get{return this.m_stateFullName; }
   set{this.m_stateFullName = value;}
  } 

  [System.Xml.Serialization.XmlIgnoreAttribute()] //I just threw this in to complete the example a little more, with an ignore attribute
  public string PropertyWhichWontBeSerialized
  {
   get{return this.m_secretInformation; }
   set{this.m_secretInformation = value;}
  } 
  
  public StateObject()
  {
   //the XmlSerializer requires a default Constructor   
  }

  public StateObject(string abbr , string fullName)
  {
   this.m_stateAbbreviation = abbr;
   this.m_stateFullName = fullName;
  }
 }
}

// End StateObject.cs

 

// Start PersonCollection.cs

using System;
using System.Xml.Serialization;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections
{
 /// <summary>
 /// Summary description for PersonCollection.
 /// </summary>
 ///

 [Serializable]
 // ***** The next line is the issue.  When you uncomment, you get the Reflection error. // see comment in the CollectionOfStatesObjectsExample procedure
 //[System.Xml.Serialization.XmlRootAttribute("PersonCollectionRootXmlNode")]

 public class PersonCollection : System.Collections.CollectionBase 

 {
 
  public void Add (BusinessObjects.PersonObject per )
  {
   base.InnerList.Add(per);
  }

  public BusinessObjects.PersonObject this[int index]
  {
   get
   {
    return (BusinessObjects.PersonObject)base.InnerList[index];
   }
  }
 
 }
}

 

// End PersonCollection.cs

 

// Start PersonCollectionWithArraySubCollection.cs

using System;
using System.Xml.Serialization;
using System.Collections ;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections
{
 /// <summary>
 /// Summary description for PersonCollectionWithArraySubCollection.
 /// This really isn’t a collection, so roll with the punches on this one.
 /// </summary>
 ///

 //Now this works, but relies on an Array (not to be confused with an ArrayList) of PersonObjects.
 [Serializable]
 [System.Xml.Serialization.XmlRootAttribute("PersonCollWithArrayRootXmlNode")]
 public class PersonCollectionWithArraySubCollection
 {

  private BusinessObjects.PersonObject[] m_personArray;
  private string m_messageToUser = "This class is not a true collection, its a wrapper to hold multiple people";

 

  [XmlElementAttribute("XmlSpecialMessage")]
  public string MessageAboutThisClassToTheDeveloper
  {
   get{return this.m_messageToUser; }
   set{this.m_messageToUser = value;}
  } 

  [XmlArray("ArrayofPersons")] [XmlArrayItem("PersonInArray")] //Keep in mind you can put anything inside the quotes to name the element(s).

  public BusinessObjects.PersonObject[] PersonArray
  {
   get { return this.m_personArray; }
   set { this.m_personArray = value; }
  }

 }
}

 

// End PersonCollectionWithArraySubCollection.cs

 

// Start StateCollection.cs

using System;
using System.Xml.Serialization;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections
{
 /// <summary>
 /// Summary description for StateCollection.
 /// </summary>
 ///

 [Serializable]

 // ***** The next line is the issue.  When you uncomment, you get the Reflection error. //see the comment in the CollectionOfStatesObjectsExample procedure
 //[System.Xml.Serialization.XmlRootAttribute("StateCollectionRootXmlNode")]

 
 public class StateCollection : System.Collections.CollectionBase 
 {
 
  public void Add (BusinessObjects.StateObject sta )
  {
   base.InnerList.Add(sta);
  }

  public BusinessObjects.StateObject this[int index]
  {
   get
   {
    return (BusinessObjects.StateObject)base.InnerList[index];
   }
  }
 
 }
}

// End StateCollection.cs

 

 

// Start StateCollectionWrapperForXmlSerialization.cs

using System;
using System.Xml.Serialization;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.CollectionWrappers
{
 /// <summary>
 /// Summary description for StateCollectionWrapperForXmlSerialization.
 /// this really isn’t a collection, so roll with the punches
 /// </summary>
 ///
 [Serializable]
 //[System.Xml.Serialization.XmlRootAttribute("StateCollectionWrapper")]  // this might work too (XmlRootAttribute instead of XmlRoot), if you uncomment this line AND comment out the line immediately below
 [System.Xml.Serialization.XmlRoot ("WrapperRoot")]
 public class StateCollectionWrapperForXmlSerialization
 {
  
  private Collections.StateCollection m_states = new Collections.StateCollection ();

  [XmlArray("WrapperXmlArray"), XmlArrayItem("StateItem")]
  public Collections.StateCollection StateCollectionForTheWrapper
  {
   get{ return this.m_states;}
   set {this.m_states = value;}
  }

  
  public StateCollectionWrapperForXmlSerialization()
  {
   
  }
 
 
 }
}

// End StateCollectionWrapperForXmlSerialization.cs

 

 

// Start SerializationHelper.cs

using System;

using System.IO;

using System.Xml;

using System.Xml.Serialization;

using System.Collections;

using System.Reflection;

using System.Data ;

using System.Text;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

 

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.SerializationLib

{

/// <summary>

/// Summary description for Main.

/// </summary>

public class SerializationHelper

{

private SerializationHelper()

{

}

 

 

// Hints from http://www.eggheadcafe.com/articles/system.xml.xmlserialization.asp

//When I was using the "OLD" methods, I found the encoding would change as I saved it to and from a database.

 

private static String UnicodeByteArrayToString(Byte[] characters)

{

UnicodeEncoding encoding = new UnicodeEncoding ();

String constructedString = encoding.GetString(characters);

return (constructedString);

}

private static Byte[] StringToUnicodeByteArray(String pXmlString)

{

UnicodeEncoding encoding = new UnicodeEncoding ();

Byte[] byteArray = encoding.GetBytes(pXmlString);

return byteArray;

}

 

 

 

public static string SerializeAnyObject(object o , System.Type t)

{

String XmlizedString = null;

MemoryStream memoryStream = new MemoryStream();

XmlSerializer xs = new XmlSerializer(t);

XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.Unicode);

xs.Serialize(xmlTextWriter, o);

memoryStream = (MemoryStream)xmlTextWriter.BaseStream;

XmlizedString = UnicodeByteArrayToString(memoryStream.ToArray());

return XmlizedString;

}

public static object DeSerializeAnObject(string xml , System.Type t)

{

XmlSerializer xs = new XmlSerializer(t);

MemoryStream memoryStream = new MemoryStream(StringToUnicodeByteArray(xml));

XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.Unicode );

return xs.Deserialize(memoryStream);

}

 

 

public static string SerializeAnyObjectOLD(object o , System.Type t)

{

// serialize to xml

StringWriter sw = new StringWriter();

XmlSerializer ser = new XmlSerializer(t);

ser.Serialize(sw, o);

// return the xml as a string

return sw.ToString();

 

//PS

//You can actually remove the "t" argument, and

//replace the "(t)" to "o.GetType()"

//I wrote it like this , so I explicitly set the type when I call the method

//I’ll probably change it later, or overload it?

}

public static object DeSerializeAnObjectOLD(string xml , System.Type t)

{

//I didnt’ really test this for the example.

//If you want this to be generic, you’ll have to cast it (on the outside of this method)

StringReader reader = new StringReader(xml);

XmlSerializer ser = new XmlSerializer(t);

//usually, the code looks like this, its left here for showing what usually happens

// MyCustomObject returnCustomObject = ( MyCustomObject )ser.Deserialize(reader); //notice the cast

object returnObject = ser.Deserialize(reader);

reader.Close();

return returnObject;

}

 

 

 

}

}

 

// End SerializationHelper.cs

 

// Start EntryPoint.cs

using System;

namespace GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS
{
 /// <summary>
 /// Summary description for EntryPoint.
 /// </summary>
 class EntryPoint
 {
  /// <summary>
  /// The main entry point for the application.
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   try
   {

    SingleStateObjectExample();
    CollectionOfStatesObjectsExample();
    SinglePersonExample();
    CollectionOfPersonObjectsExample();
    StateWrapperCollection();
    PersonArrayAttempt();

    //and for kicks, lets deserialize something
    DerserializeSomethingForKicks();

   }

   catch(Exception ex)
   {
    Console.WriteLine (ex.Message );
   }

   Console.WriteLine ("Press Enter to Exit");
   Console.ReadLine();
  }

 
  public static void SingleStateObjectExample()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

   Console.WriteLine ("Start Single State " );
   BusinessObjects.StateObject sta1 = new BusinessObjects.StateObject("NC", "North Carolina");

   Console.WriteLine( SerializationLib.SerializationHelper.SerializeAnyObject( sta1 , sta1.GetType()));

   Console.WriteLine ("End Single State " );

   /////////////////////////////////////////
  }
 

  public static void CollectionOfStatesObjectsExample()
  {

   //Notice the output here
   //specifically "ArrayOfStateObject"
   //this is the name .NET gives it
   //this is the issue, when you try to say "I want to call it something else"
   //you get the reflection error.
   //Notice that "ArrayOfPersonObject" when the CollectionOfPersonObjectsExample method runs

   Console.WriteLine ("");
   Console.WriteLine ("");

   Console.WriteLine ("Start State Collection " );

   BusinessObjects.StateObject staNC = new BusinessObjects.StateObject("NC", "North Carolina");
   BusinessObjects.StateObject staVA = new BusinessObjects.StateObject("VA", "Virginia");
   BusinessObjects.StateObject staKY = new BusinessObjects.StateObject("KY", "Kentucky");

   Collections.StateCollection stateCollec1 = new Collections.StateCollection();
   stateCollec1.Add(staNC);
   stateCollec1.Add(staVA);
   stateCollec1.Add(staKY);

   Console.WriteLine (SerializationLib.SerializationHelper.SerializeAnyObject (  stateCollec1 , stateCollec1.GetType() ));
   Console.WriteLine ("End State  Collection " );

 

   //////////////////////////////////
   ///
  }

  public static void SinglePersonExample()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

 

   BusinessObjects.StateObject staNC = new BusinessObjects.StateObject("NC", "North Carolina");
   BusinessObjects.StateObject staVA = new BusinessObjects.StateObject("VA", "Virginia");
   BusinessObjects.StateObject staKY = new BusinessObjects.StateObject("KY", "Kentucky");

   Collections.StateCollection stateCollec1 = new Collections.StateCollection();
   stateCollec1.Add(staNC);
   stateCollec1.Add(staVA);
   stateCollec1.Add(staKY);

 

   Console.WriteLine ("Start Single Person " );
   BusinessObjects.PersonObject per1 = new BusinessObjects.PersonObject("Granada", "Coder");
   per1.StatesIHaveLivedIn = stateCollec1;

   Console.WriteLine (SerializationLib.SerializationHelper.SerializeAnyObject  ( per1 , per1.GetType() ));
   Console.WriteLine ("End Single Person " );

  }

  public static void CollectionOfPersonObjectsExample()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

 

   Console.WriteLine ("Start Person Collection " );

   BusinessObjects.StateObject staNC = new BusinessObjects.StateObject("NC", "North Carolina");
   BusinessObjects.StateObject staVA = new BusinessObjects.StateObject("VA", "Virginia");
   BusinessObjects.StateObject staKY = new BusinessObjects.StateObject("KY", "Kentucky");

   Collections.StateCollection stateCollec1 = new Collections.StateCollection();
   stateCollec1.Add(staNC);
   stateCollec1.Add(staVA);
   stateCollec1.Add(staKY);

 

   BusinessObjects.StateObject staAL = new BusinessObjects.StateObject("AL", "Punt Bama Punt");
   BusinessObjects.StateObject staWV = new BusinessObjects.StateObject("WV", "West Virginia");
   BusinessObjects.StateObject staTN = new BusinessObjects.StateObject("TN", "Tennessee");

   Collections.StateCollection stateCollec2 = new Collections.StateCollection();
   stateCollec2.Add(staAL);
   stateCollec2.Add(staWV);
   stateCollec2.Add(staTN);

   BusinessObjects.PersonObject perOne = new BusinessObjects.PersonObject("Granada", "Coder");
   perOne.StatesIHaveLivedIn = stateCollec1;

   BusinessObjects.PersonObject perTwo = new BusinessObjects.PersonObject("Jimmy", "CrackCorn");
   perTwo.StatesIHaveLivedIn = stateCollec2;

   Collections.PersonCollection perCollec = new Collections.PersonCollection();
   perCollec.Add (perOne);
   perCollec.Add (perTwo);

 

   Console.WriteLine (SerializationLib.SerializationHelper.SerializeAnyObject   (  perCollec , perCollec.GetType() ));
   Console.WriteLine ("End Person  Collection " );
   //////////////////////////////

  }

  public static void StateWrapperCollection()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

   Console.WriteLine ("Start State Wrapper Collection " );

   BusinessObjects.StateObject staNC = new BusinessObjects.StateObject("NC", "North Carolina");
   BusinessObjects.StateObject staVA = new BusinessObjects.StateObject("VA", "Virginia");
   BusinessObjects.StateObject staKY = new BusinessObjects.StateObject("KY", "Kentucky");

   Collections.StateCollection stateCollec1 = new Collections.StateCollection();
   stateCollec1.Add(staNC);
   stateCollec1.Add(staVA);
   stateCollec1.Add(staKY);

 

   CollectionWrappers.StateCollectionWrapperForXmlSerialization wrap1 = new GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.CollectionWrappers.StateCollectionWrapperForXmlSerialization ();
   wrap1.StateCollectionForTheWrapper = stateCollec1;

   Console.WriteLine( SerializationLib.SerializationHelper.SerializeAnyObject( wrap1 , wrap1.GetType()));

   Console.WriteLine ("End State Wrapper Collection " );
   /////////////////////////////

 

  }

  
  public static void PersonArrayAttempt()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

   Console.WriteLine ("Start Person Collection Array Attempt  " );

   BusinessObjects.StateObject staSC = new BusinessObjects.StateObject("SC", "South Carolina");
   BusinessObjects.StateObject staGA = new BusinessObjects.StateObject("GA", "Georgia");
   BusinessObjects.StateObject staFL = new BusinessObjects.StateObject("FL", "Florida");
   
   Collections.StateCollection southStatesCollec = new GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections.StateCollection ();
   southStatesCollec.Add(staSC);
   southStatesCollec.Add(staGA);
   southStatesCollec.Add(staFL);

   BusinessObjects.StateObject staNY = new BusinessObjects.StateObject("NY", "New York");
   BusinessObjects.StateObject staVT = new BusinessObjects.StateObject("VT", "Vermont");
   BusinessObjects.StateObject staNH = new BusinessObjects.StateObject("NH", "New Hampshire");

   Collections.StateCollection northStatesCollec = new Collections.StateCollection ();
   northStatesCollec.Add(staNY);
   northStatesCollec.Add(staVT);
   northStatesCollec.Add(staNH);

 

   BusinessObjects.PersonObject perFromSouth = new BusinessObjects.PersonObject("Deputy", "Dawg");
   BusinessObjects.PersonObject perFromNorth = new BusinessObjects.PersonObject("Roger", "Williams");

   perFromSouth.StatesIHaveLivedIn = southStatesCollec;
   perFromNorth.StatesIHaveLivedIn = northStatesCollec;

   Collections.PersonCollectionWithArraySubCollection personCollecWithArray = new GranadaCoder.Applications.CollectionBaseXmlSerializeExampleCS.Collections.PersonCollectionWithArraySubCollection ();
   personCollecWithArray.PersonArray =new BusinessObjects.PersonObject[] {perFromSouth , perFromNorth};

   Console.WriteLine (SerializationLib.SerializationHelper.SerializeAnyObject  ( personCollecWithArray , personCollecWithArray.GetType() ));
   Console.WriteLine ("End Person Collection Array Attempt  " );

  }

  public static void DerserializeSomethingForKicks()
  {

   Console.WriteLine ("");
   Console.WriteLine ("");

   Console.WriteLine ("Start Deserialize Sample" );
   BusinessObjects.StateObject sta1 = new BusinessObjects.StateObject("NC", "North Carolina");

   string xmlText = SerializationLib.SerializationHelper.SerializeAnyObject( sta1 , sta1.GetType());

   BusinessObjects.StateObject stateFromXml = (BusinessObjects.StateObject)SerializationLib.SerializationHelper.DeSerializeAnObject(xmlText, sta1.GetType());

   Console.WriteLine ( stateFromXml.StateAbbreviation + " " + stateFromXml.StateFullName  );

   Console.WriteLine ("End Deserialize Sample " );

  }

 
 }
}

// End EntryPoint.cs

 

Advertisements
This entry was posted in Software Development. Bookmark the permalink.

3 Responses to XmlSerialization with IDictionary and CollectionBase Objects

  1. Hai says:

    Dude, what are you talking about? Do you mean teaching or did you mean leaching? I am sure it\’s leaching since you\’ve been stealing my stuff!!

  2. Unknown says:

    wow gold wow gold wow gold wow power leveling wow power leveling wow power leveling wow power leveling World of Warcraft Gold wow gold wow power leveling wow gold wow gold wow gold wow power leveling wow power leveling Rolex Replica rolex Rolex Replica rolex Rolex changyongkuivip

  3. Fernando says:

    Very useful man thanks a lot

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s