03 and 04 solve the same business problem, but 2 different ways. 

03 is the cursor model.  04 is the udf model.

Read the comments, and try to make a decent sized database (row count) so you see the massive and significant time difference.

Here is the downloadable example.  (Right Click and "Save Target As" is your best bet).  This is 1.1 code, fyi.

Go Here to get to the download. Or try www.microsoft.com/sql and search for "MSDE".

You will download the file.  Once downloaded, you will run the exe and it will decompress the files.

Let's assume you extract the files to c:\wutemp\msde\

The trick with the install is that running the "setup.exe" file (in c:\wutemp\msde\ folder) won't really do anything.

The program installs from the command line prompt.  Here are some short cuts.

Inside the c:\wutemp\msde\ folder, create 2 new files.

InstallMSDEWithMyParameters.bat

MyParameters.INI

The contents of InstallMSDEWithMyParameters.bat will be:

setup /settings "MyParameters.ini" SAPWD="sapassword" /L*v C:/MSDELog.log

The contents of MyParameters.ini will be:

[Options]
DISABLENETWORKPROTOCOLS=0
SECURITYMODE=SQL

You can read more about the options in the ReadmeMSDE2000A.htm file (which is a part of the extraction process)

Now, double click the InstallMSDEWithMyParameters.bat file, and it will be off to the races.

You'll notice that your sa password will be "sapassword".  You can alter this if you'd like, but make it something you can remember, because you're dead in the water without it.

I'd reboot after the install, so the MSSQLSERVER services will start up.

Now you have a functional, local, legal development server.

You main tool of trade will be osql.exe.  Google it, and you'll find more info.

While MSDE is free, Microsoft makes you jump thru some hoops to use it.  They really want you to buy the full version.  But the hoops are much better than using Access for any decent sized relational database.

(Right Click , and 'Save Target As' is probably the best approach)
Download the code HERE

NOTE

Before reading or implementing this strategy, please review the following Microsoft KB's.
Considerations for server-side Automation of Office
http://support.microsoft.com/kb/257757/

My original need was an importer for a winforms application, and NOT an asp.net application.

 Now to the post:

(Hey, I made the "big time".  Here is a line to this blog getting posted at somebody's site besides my own.)

http://www.sqlservercentral.com/columnists/sholliday/leveragingxpexcelxmlandopenxmlfordataimports.asp

(Now, onto the blog.)

If you deal with clients, then you've probably at some point or another dealt with importing "their" data.
Alot of times, this data will come as a Microsoft Excel document.

I've had my tricks in the past.  Opening Excel in one window, and opening an Access database in another window (linked to Sql Server), I could copy and paste.

But this was very, very manual.  With the release of Excel XP, I have a new trick.

Excel XP comes with the ability to save to Xml.  Thus, I decided to match this new functionality with the wonderful ability of Sql Server 2000's ability to use xml data, as relational data, with the OPENXML statement.

Below is some sample code to get you started.  The C# code will save an Excel file to Xml.  I then have a usp (Sql Server User Stored Procedure) which can import that data.

Getting the namespace syntax inside the stored procedure was the only thing that took a little time to wade through.  But now that I have it, importing Excel data to Sql Server 2000 as quick as editing some columnnames in the stored procedure.

..

// Start ExcelXMLConverter.cs file

using System;

namespace GranadaCoder.ImportExportLib.ExcelLib

{

/// <summary>

/// Summary description for ExcelXMLConverter.

/// This class is used as a wrapper to take an existing excel spreadsheet

/// and to save it as a xml file using the

/// Microsoft Excel XP ability (aka, "Save As Xml" is a MS Excel XP new functionality)

///

/// Microsoft URL: for reference

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

/// and

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

///

///

/// You'll need to add a reference to the (COM object) Microsoft Excel library.

/// This will NOT work with Excel 2000 or Excel 97.

///

///

/// </summary>

public class ExcelXMLConverter

{

//Excel variables, Worksheet is not needed for a simple "Save As XML" function

Excel.Application xlApp = null;

Excel.Workbook xlBook = null;

//Excel.Worksheet xlSheet =null;

string m_inputExcelFileName = null;

string m_outputXMLFileName = null;

private bool m_overwriteExistingFile = true;

string debugMsg = null;

private void checkParameters()

{

string error_msg=string.Empty;

bool return_val = true; //default is actually true...

//there are at least 8 chars in the smallest of filenames //ex: (c:\a.ext) has 8 chars

if (this.m_outputXMLFileName.Length < 8)

{

error_msg +="Output File '" + this.m_outputXMLFileName + "' does\n.not appear to be a valid filename.";

return_val= false;

}

System.IO.FileInfo fi = new System.IO.FileInfo(this.m_inputExcelFileName );

if (!fi.Exists)

{

// the input file (excel) does not exist

error_msg +="Input File '" + this.m_inputExcelFileName + "' does not exist\n.";

return_val= false;

}

if (!this.m_overwriteExistingFile)

{

// the bool check is on the "outerloop" to prevent

// a new fi object, if the check is not needed

// this says "the user said 'do not overwrite', yet the file does exist

fi = new System.IO.FileInfo(this.m_outputXMLFileName );

if (fi.Exists)

{

error_msg +="Output File '" + this.m_outputXMLFileName + "' exists and\n'OverWriteExisting' flag set to false.";

return_val= false;

}

}

if (return_val == false)

{

throw new ArgumentException(error_msg);

}

return;

}

public void ConvertExcelToXml()

{

checkParameters(); // make sure the file names passed in are good

try

{

xlApp = null;

//xlSheet = null;

xlApp = new Excel.Application();

//this turns OFF message box alerts, especially in case of existing files.

xlApp.DisplayAlerts=false;

Console.Out.WriteLine (xlApp.Name);

Console.Out.WriteLine(xlApp.Workbooks.Count);

xlBook = xlApp.Workbooks.Open(@m_inputExcelFileName,

Type.Missing, Type.Missing, Type.Missing, Type.Missing,

Type.Missing, Type.Missing, Type.Missing, Type.Missing,

Type.Missing, Type.Missing, Type.Missing, Type.Missing,

Type.Missing, Type.Missing);

//Notice the Second argument, its the magic flag for XML

xlApp.ActiveWorkbook.SaveAs(this.m_outputXMLFileName,

Excel.XlFileFormat.xlXMLSpreadsheet, Type.Missing, Type.Missing,

Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange,

Type.Missing, Type.Missing, Type.Missing, Type.Missing,

Type.Missing);

xlBook.Close(false, Type.Missing, Type.Missing);

xlApp.Quit();

xlApp = null;

xlBook = null;

//xlSheet = null;

}

catch (System.Runtime.InteropServices.COMException)

{

// ignore this error, user probably cancelled a file overwrithe

}

catch(Exception ex)

{

// better error handling and log event needed here

debugMsg = ex.Message;

throw ex;

}

}

public ExcelXMLConverter(string inputExcelFileName , string outputXMLFileName , bool overwriteExistingFile)

{

this.m_inputExcelFileName = inputExcelFileName;

this.m_outputXMLFileName = outputXMLFileName;

this.m_overwriteExistingFile = overwriteExistingFile;

}

}

}

// End ExcelXMLConverter.cs file

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