Serializing and Deserializing Objects…to and from…XML

Over on the Asp.Net forums I recently had the opportunity* to help a few lost souls by showing them how to serialize objects to XML and deserialize the XML back into objects. Since the question has come up more than once, I decided to BLOG it so I could refer similar questions in the future to this post.
*I use the word opportunity because by helping others I am forced to think hard about the technology and to think even harder about how to communicate the technology. It makes me better at what I do. All right then, enough after-school-special-feel-good-about-yourself-I'm-ok-you're-ok fluffy nonsense… on with the code:
Here is a simple class I'm going to work with. It has both properties and fields:

public class MyClass

{

    // old school property

    private int _Age;  

    public int Age  

    {

        get { return _Age; }

        set { _Age = value; }

    }

    // new school property

    public bool Citizen { get; set; }

    // there's nothing wrong with using fields

    public string Name;  

}

Here are the two functions to Serialize and Deserialize an object:

/// ---- SerializeAnObject -----------------------------
/// <summary>
/// Serializes an object to an XML string
/// </summary>
/// <param name="AnObject">The Object to serialize</param>
/// <returns>XML string</returns>
 
public static string SerializeAnObject(object AnObject)
{
    XmlSerializer Xml_Serializer = new XmlSerializer(AnObject.GetType());
    StringWriter Writer = new StringWriter();      
 
    Xml_Serializer.Serialize(Writer, AnObject);
    return Writer.ToString();
}

 

/// ---- DeSerializeAnObject ------------------------------

/// <summary>

/// DeSerialize an object

/// </summary>

/// <param name="XmlOfAnObject">The XML string</param>

/// <param name="ObjectType">The type of object</param>

/// <returns>A deserialized object...must be cast to correct type</returns>

public static Object DeSerializeAnObject(string XmlOfAnObject, Type ObjectType)

{       

    StringReader StrReader = new StringReader(XmlOfAnObject);

    XmlSerializer Xml_Serializer = new XmlSerializer(ObjectType);

    XmlTextReader XmlReader = new XmlTextReader(StrReader);

    try

    {

        Object AnObject = Xml_Serializer.Deserialize(XmlReader);

        return AnObject;

    }

    finally

    {

        XmlReader.Close();

        StrReader.Close();

    }

}

Here is some sample code showing how to use the functions.
Note: I keep these functions (and other functions) in a class I call MiscUtilities. You will have to modify the code…depending on where you place the functions.

protected void Button1_Click(object sender, EventArgs e)

{

    // create and initialize an object

    MyClass Test = new MyClass();

    Test.Age = 18;

    Test.Name = "Rocky Balboa";

    Test.Citizen = true;

    //  Serialize it

    String XML;

    XML = MiscUtilities.SerializeAnObject(Test);

    // Deserialize it

    MyClass Test2;

    Test2 = MiscUtilities.DeSerializeAnObject(XML, typeof(MyClass)) as MyClass;

    // TODO:  Get a cup of coffee and bask in the glory of rock solid code.

}

Here is what the XML string looks like (after formatting):

<?xml version="1.0"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Rocky Balboa</Name>
  <Age>18</Age>
  <Citizen>true</Citizen>
</MyClass>

There are limitations: XmlSerializer does not serialize private fields, methods, indexers or read-only fields.
Once you have the XML string, you can email it, store it in a database, save it to disk, or…print a copy of it and have your mom tape it to the refrigerator next to the picture of a turkey you made in second grade by tracing around your hand with a Crayola crayon.

refer: http://weblogs.asp.net/stevewellens/archive/2009/07/02/serializing-and-deserializing-objects-to-and-from-xml.aspx

Simple FTP file upload in C# 2.0

Sometimes you just want a simple function to perform a simple task. There are a lot of FTP libraries for free download on the Internet, but if you simply want to upload a file to an FTP server in C#, these libraries are overkill for that simple little task. That's what I thought when I browsed the web for such a simple little function. Maybe I'm slower than normal people, but I couldn't find any simple method on the web. They where all too complicated, so I thought to myself that I could do better.
Here's what I came up with:
private static void Upload(string ftpServer, string userName, string password, string filename)
{
   using (System.Net.WebClient client = new System.Net.WebClient())
   {
      client.Credentials = new System.Net.NetworkCredential(userName, password);
      client.UploadFile(ftpServer + "/" + new FileInfo(filename).Name, "STOR", filename);
   }
}
Then call the method with the right parameters, and you're set to go:
Upload("ftp://ftpserver.com", "TheUserName", "ThePassword", @"C:\file.txt");
Can it get any simpler than that?

Builder (Design Patterns)

definition

Separate the construction of a complex object from its representation so that the same construction process can create different representations. UML class diagram participants     The classes and/or objects participating in this pattern are: Builder  (VehicleBuilder) specifies an abstract interface for creating parts of a Product object ConcreteBuilder  (MotorCycleBuilder, CarBuilder, ScooterBuilder) constructs and assembles parts of the product by implementing the Builder interface defines and keeps track of the representation it creates provides an interface for retrieving the product Director  (Shop) constructs an object using the Builder interface Product  (Vehicle) represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it's assembled includes classes that define the constituent parts, including interfaces for assembling the parts into the final result sample code in C# This structural code demonstrates the Builder pattern in which complex objects are created in a step-by-step fashion. The construction process can create different object representations and provides a high level of control over the assembly of the objects. using System; using System.Collections.Generic; namespace DoFactory.GangOfFour.Builder.Structural {   /// <summary>   /// MainApp startup class for Structural   /// Builder Design Pattern.   /// </summary>   public class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       // Create director and builders       Director director = new Director();       Builder b1 = new ConcreteBuilder1();       Builder b2 = new ConcreteBuilder2();       // Construct two products       director.Construct(b1);       Product p1 = b1.GetResult();       p1.Show();       director.Construct(b2);       Product p2 = b2.GetResult();       p2.Show();       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Director' class   /// </summary>   class Director   {     // Builder uses a complex series of steps     public void Construct(Builder builder)     {       builder.BuildPartA();       builder.BuildPartB();     }   }   /// <summary>   /// The 'Builder' abstract class   /// </summary>   abstract class Builder   {     public abstract void BuildPartA();     public abstract void BuildPartB();     public abstract Product GetResult();   }   /// <summary>   /// The 'ConcreteBuilder1' class   /// </summary>   class ConcreteBuilder1 : Builder   {     private Product _product = new Product();     public override void BuildPartA()     {       _product.Add("PartA");     }     public override void BuildPartB()     {       _product.Add("PartB");     }     public override Product GetResult()     {       return _product;     }   }   /// <summary>   /// The 'ConcreteBuilder2' class   /// </summary>   class ConcreteBuilder2 : Builder   {     private Product _product = new Product();     public override void BuildPartA()     {       _product.Add("PartX");     }     public override void BuildPartB()     {       _product.Add("PartY");     }     public override Product GetResult()     {       return _product;     }   }   /// <summary>   /// The 'Product' class   /// </summary>   class Product   {     private List<string> _parts = new List<string>();     public void Add(string part)     {       _parts.Add(part);     }     public void Show()     {       Console.WriteLine("\nProduct Parts -------");       foreach (string part in _parts)         Console.WriteLine(part);     }   } } Output Product Parts ------- PartA PartB Product Parts ------- PartX PartY This real-world code demonstates the Builder pattern in which different vehicles are assembled in a step-by-step fashion. The Shop uses VehicleBuilders to construct a variety of Vehicles in a series of sequential steps. using System; using System.Collections.Generic; namespace DoFactory.GangOfFour.Builder.RealWorld {   /// <summary>   /// MainApp startup class for Real-World   /// Builder Design Pattern.   /// </summary>   public class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       VehicleBuilder builder;       // Create shop with vehicle builders       Shop shop = new Shop();       // Construct and display vehicles       builder = new ScooterBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       builder = new CarBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       builder = new MotorCycleBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Director' class   /// </summary>   class Shop   {     // Builder uses a complex series of steps     public void Construct(VehicleBuilder vehicleBuilder)     {       vehicleBuilder.BuildFrame();       vehicleBuilder.BuildEngine();       vehicleBuilder.BuildWheels();       vehicleBuilder.BuildDoors();     }   }   /// <summary>   /// The 'Builder' abstract class   /// </summary>   abstract class VehicleBuilder   {     protected Vehicle vehicle;     // Gets vehicle instance     public Vehicle Vehicle     {       get { return vehicle; }     }     // Abstract build methods     public abstract void BuildFrame();     public abstract void BuildEngine();     public abstract void BuildWheels();     public abstract void BuildDoors();   }   /// <summary>   /// The 'ConcreteBuilder1' class   /// </summary>   class MotorCycleBuilder : VehicleBuilder   {     public MotorCycleBuilder()     {       vehicle = new Vehicle("MotorCycle");     }     public override void BuildFrame()     {       vehicle["frame"] = "MotorCycle Frame";     }     public override void BuildEngine()     {       vehicle["engine"] = "500 cc";     }     public override void BuildWheels()     {       vehicle["wheels"] = "2";     }     public override void BuildDoors()     {       vehicle["doors"] = "0";     }   }   /// <summary>   /// The 'ConcreteBuilder2' class   /// </summary>   class CarBuilder : VehicleBuilder   {     public CarBuilder()     {       vehicle = new Vehicle("Car");     }     public override void BuildFrame()     {       vehicle["frame"] = "Car Frame";     }     public override void BuildEngine()     {       vehicle["engine"] = "2500 cc";     }     public override void BuildWheels()     {       vehicle["wheels"] = "4";     }     public override void BuildDoors()     {       vehicle["doors"] = "4";     }   }   /// <summary>   /// The 'ConcreteBuilder3' class   /// </summary>   class ScooterBuilder : VehicleBuilder   {     public ScooterBuilder()     {       vehicle = new Vehicle("Scooter");     }     public override void BuildFrame()     {       vehicle["frame"] = "Scooter Frame";     }     public override void BuildEngine()     {       vehicle["engine"] = "50 cc";     }     public override void BuildWheels()     {       vehicle["wheels"] = "2";     }     public override void BuildDoors()     {       vehicle["doors"] = "0";     }   }   /// <summary>   /// The 'Product' class   /// </summary>   class Vehicle   {     private string _vehicleType;     private Dictionary<string,string> _parts =       new Dictionary<string,string>();     // Constructor     public Vehicle(string vehicleType)     {       this._vehicleType = vehicleType;     }     // Indexer     public string this[string key]     {       get { return _parts[key]; }       set { _parts[key] = value; }     }     public void Show()     {       Console.WriteLine("\n---------------------------");       Console.WriteLine("Vehicle Type: {0}", _vehicleType);       Console.WriteLine(" Frame : {0}", _parts["frame"]);       Console.WriteLine(" Engine : {0}", _parts["engine"]);       Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);       Console.WriteLine(" #Doors : {0}", _parts["doors"]);     }   } } Output --------------------------- Vehicle Type: Scooter  Frame  : Scooter Frame  Engine : none  #Wheels: 2  #Doors : 0 --------------------------- Vehicle Type: Car  Frame  : Car Frame  Engine : 2500 cc  #Wheels: 4  #Doors : 4 --------------------------- Vehicle Type: MotorCycle  Frame  : MotorCycle Frame  Engine : 500 cc  #Wheels: 2  #Doors : 0 This .NET optimized code demonstrates the same real-world situation as above but uses modern, built-in .NET features, such as, generics, reflection, object initializers, automatic properties, etc.