C# XmlSerialization - Generating XSD from XML, Classes from XSD, Serializing Array of Custom Type and Enumerations etc

Generating XSD from XML:

XSD.exe tool can be used to generate schema file from an XML file. XSD.exe will be available with Visual Studio installation. 

• Open Visual Studio Command Prompt 
• Type in the command "xsd <xml file name(including path) to be used for schema generation>"
• Done. XSD gets generated in the same folder where you XSD command is executed.

Now you have the XSD, What next? 

Note: Generated XSD might not be exactly what you want. It is only according to the XML provided. Enumeration Types or Complex Types might not be created in XSD as you are expecting. Example: Printer Type below looks like an enumeration field, but it isn't obvious from the given XML file.

Example XML File:

<XmlSerializable xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">    <Printers>       <Printer Name="Denali" Type="Mfp"/>       <Printer Name="Garnet" Type="NetworkScanner"/>    </Printers> </XmlSerializable>

Generate XSD File:

<?xml version="1.0" encoding="utf-8"?> <xs:schema id="XmlSerializable" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">   <xs:element name="XmlSerializable" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">     <xs:complexType>       <xs:choice minOccurs="0" maxOccurs="unbounded">         <xs:element name="Printers">           <xs:complexType>             <xs:sequence>               <xs:element name="Printer" minOccurs="0" maxOccurs="unbounded">                 <xs:complexType>                   <xs:attribute name="Name" type="xs:string" />                   <xs:attribute name="Type" type="xs:string" />                 </xs:complexType>               </xs:element>             </xs:sequence>           </xs:complexType>         </xs:element>       </xs:choice>     </xs:complexType>   </xs:element> </xs:schema>

Generate Class from XSD(Schema file):

Again, XSD utility is our buddy here. Run XSD tool with /classes options and provided XSD generated in previous step as input. There you go, XSD generates classes for you.

Auto generated class will have properties and classes generated the way those were present in XSD. In above example, There would be three classes generated, one "XmlSerializable" element, another for element Printers and another for element Printer. Each of these types will "contain" other type as defined by complex types in XSD. 

That said, most of the day to day development activities involve writing classes by serializable by ourselves instead of defining XSDs.  Let's see in brief about how to write xml serializable class in C#.

Coding a Serializable class:

[Everything pertaining to xml serialization is available under the namespace " System.Xml.Serialization"]

Create a class with properties for data that you want to contain in that class. Each of these property can again be a type that is serializable. Attributes on the top of properties control the way the data gets serialized or organized in the XML file. You can find the complete list of attributes available here. Each type which is part of another serializable type can be thought of as Complex type in XSD.

Note: Adding wrong attributes may result in a different xml than what you expect. Read through use the attributes list and their usage for creating serializable class

Example: Marking a property as XmlArray indicates that the property will hold array of items,where you need also to mark the item type by specifying XmlArrayItem.

Enumeration values can be marked by attribute "XmlEnum". Serializer will then place the Enumeration Type in place of Enumeration value in the Serialized Xml.

Steps involved in serialization:

1. Create a XML Serializer isntance by proving the type which you are intending to serialize.
2. Open a stream to the ouput xml file.
3. Provide this stream and instance to the serialize method of serializer instance created.
4. Close the stream and serialized data will be in output file mentioned in step 2.

Serializing Code :

XmlSerializable x = new XmlSerializable();
            x.Printers = new Printer[2];

            x.Printers[0] = new Printer();
            x.Printers[0].Type = PrinterType.Mfp;
            x.Printers[0].Name = "Denali";

            x.Printers[1] = new Printer();
            x.Printers[1].Type = PrinterType.NetworkScanner;
            x.Printers[1].Name = "Garnet";

            XmlSerializer serializer = new XmlSerializer(typeof(XmlSerializable));
            XmlWriter writer = XmlWriter.Create("D:\\output.xml");
            serializer.Serialize(writer,x);
            writer.Close();

Serializable Class example which covers serializing a class which contains array of other class type and also enumerations:

    [Serializable]
    [XmlRoot()]
    public class XmlSerializable
    {
        Printer[] printers;

        [XmlArray("Printers")]
        [XmlArrayItem("Printer")] 
        public Printer[] Printers
        {
            get
            {
                return printers;
            }
            set
            {
                printers = value;
            }
        }
    }
   
    [XmlType("Printer")]         
    public class Printer
    {
        PrinterType type;

        [XmlAttribute()]

        public PrinterType Type
        {
            get
            {
                return type;
            }
            set
            {
                type = value;
            }
        }

        [XmlAttribute()]
        public string Name;


    }
 
    public enum PrinterType
    {
        [XmlEnum]
        None =0,
        [XmlEnum]
        Mfp,
        [XmlEnum]
        Sfp,
        [XmlEnum]
        NetworkScanner
    }

Catching Exceptions from a different thread, Exception Handling in multithreaded environment - C#

Note: Examples are on .NET 3.5 and does not consider .NET 4.0 features like Parallel Task Library.

If there is any exception in a method that is being executed on a different thread, those exception details will not shared with the main thread. It is necessary to catch any exception on a worker\different thread to debug issues especially in multithreaded environment.

// Wrong example: Attempting to catch exception from a thread in caller method
try
{
    Thread t = new Thread(new ThreadStart(LocalMethod));


t.Start();
}
catch (Exception ex)
{
    //do something with ex
}

Few points from MSDN about "there is no such thing called *Unhandled exception* in Managed code" after .NET version 2.0:

/** Straight from MSDN

The most significant change pertains to managed threads. In the .NET Framework versions 1.0 and 1.1, the common language runtime provides a backstop for unhandled exceptions in the following situations:

• There is no such thing as an unhandled exception on a thread pool thread. When a task throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then returns the thread to the thread pool.
• There is no such thing as an unhandled exception on a thread created with the Start method of the Thread class. When code running on such a thread throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then gracefully terminates the thread.
• There is no such thing as an unhandled exception on the finalizer thread. When a finalizer throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then allows the finalizer thread to resume running finalizers.

The foreground or background status of a managed thread does not affect this behavior.

For unhandled exceptions on threads originating in unmanaged code, the difference is more subtle. The runtime JIT-attach dialog preempts the operating system dialog for managed exceptions or native exceptions on threads that have passed through native code. The process terminates in all cases.

**/

Let us take a look at possible ways of handling exceptions from different threads:

a. Adding a method which in turn invokes the method that executes on a different thread and which might be process heavy will allow to catch the exceptions and execute some code to handle this exception. By handling exceptions this way, application can made sure of running even when there are exceptions on different threads.

This pattern is used widely across different multithreaded applications. This method which allows calling thread method and handling exceptions will receive "method to execute" and "exception handler method" as arguments. It invokes "method to invoke" in try block and call the exception handler in catch block. Below code explains this approach, though it is not real-time example.

static void SafeThreadCaller(Action method, Action handler)
        {
            try
            {
                if (method != null)
                {
                    method();
                }
            }
            catch (Exception e)
            {
                handler(e);
            }
        }

        static void ExceptionHandler(Exception e)
        {            
            Console.WriteLine("Handled at ExceptionHandler in SafeHandler thread: "+ e.Message+". Thread ID: "+ Thread.CurrentThread.ManagedThreadId);
        }

        static void ThreadMethod(values v)
        {
            if (v.a > v.b)
                throw new ArgumentException("Arguments Invalid");
        }

Invoking above SafeThreadCaller method is easy using lamda expressions. It expects two Action delegates. If the thread method expects argument, it is easy to use lamda expressions as substitute for delegate as below:

//Caller method
public static void ThreadExceptions()
        {
            Console.WriteLine("In Main Method Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            Thread t = new Thread(() => SafeThreadCaller(() => ThreadMethod(new values() { a = 5, b = 3 }), ExceptionHandler));
            t.Start();
        }

Note: "values" is a simple class created to hold two values a and b.

b. There is another way where information can be passed from thread method to caller through "out" parameters. I'm not big fan of this approach, since this might raise the need for the caller to wait for other thread to join.

public static void ThreadExcetionsAtCaller()
        {
            Exception ex = null;
            Thread t = new Thread(() => ThreadMethodWithOutParameter(new values() { a = 5, b = 3 }, out ex));
            t.Start();
            Console.WriteLine("In Main Method Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            t.Join();
            if (ex != null)
            {
                Console.WriteLine("Handled at Caller: " + ex.Message + ". Thread ID: " + Thread.CurrentThread.ManagedThreadId);
                File.AppendAllText(@"D:\temp\1.txt","Handled at Caller: " + ex.Message + ". Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            }
        }
static void ThreadMethodWithOutParameter(values v,out Exception ex)
        {
            ex = null;
            try
            {
                ThreadMethod(v);
            }
            catch(Exception e)
            {
                ex = e;
            }
        }
static void ThreadMethod(values v)
        {
            if (v.a > v.b)
                throw new ArgumentException("Arguments Invalid");
        }

c. If you like to handle all thread exceptions at once, AppDomain has support for AppDomain.CurrentDomain.UnhandledException and also ThreadException events. Your application can add a event handler to these events to print necessary information for any exception.

This method might work allows us to graceful exit the application on unhandled exception instead of crashing with "Unhandled exception occurred" message to the user. Little of house keeping pertaining to the current application domain can also be taken care before exiting the application.

//Not a perfect example :)
 AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler
                                                (CurrentDomain_UnhandledException);
     void CurrentDomain_UnhandledException(object o, UnhandledExceptionEventArgs u)
     {
          Console.WriteLine("UNHANDLED EXCEPTION IN THE APPLICATION!");        
     }

Note: UnhandledExceptionEventArgs will not have information about StackTrace. We can get information about whether CLR instance is terminating because of the current unhandled exception.

Opening Google Chrome in InCognito mode by default (Private Browsing by default on chrome)

If you like to open chrome always in incognito mode, follow below simple steps:

1. Right click on Google Chrome Shortcut (either on Desktop or Start Menu or wherever the shortcut is located.)
2. Click on Properties.
3. In the Shortcut tab, you will see something like below as Target for the shortcut: C:\..\..\AppData\Local\Google\Chrome\Application\chrome.exe 
4. Add a parameter "incognito" to the Target so that Chrome would always pick this parameter while getting launched through shortcut i.e. change to target to include "-incognito" like below: C:\..\..\AppData\Local\Google\Chrome\Application\chrome.exe  -incognito

Whenever you launch chrome next time using shortcut, by default it gets launched in incognito mode(your browsing history is safe by default.)

Happy Browsing!