Xsd2Code Wiki & Documentation Rss Feed

Updated Wiki: Home

pcabanel — Sat, 18 Aug 2012 07:09:18 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

If you feel that the work I provide to the community is worth it,
you can donate by using the Donate button below. Thank you.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Xsd2Code is an AddIn for visual studio 2008.
Right clic on xsd schema in solution explorer, choose options and generate code.

Xsd2Code has a CustomTool which allows automatic generation when schema is modified.

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

From pascal cabanel.
About me : http://fr.viadeo.com/profile/0022904hc8vzkt3t/en/

Updated Wiki: Home

pcabanel — Sat, 09 Oct 2010 16:52:46 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

From pascal cabanel.
My blog (French only) : http://blog.mydotnet.fr

Updated Wiki: Home

pcabanel — Sat, 09 Oct 2010 16:41:04 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

For exemple, full generated csharp file : dvd.cs
XmlSchema exemple : dvd.xsd
XmlSchema exemple : Actor.xsd

This project is based on the work originally done by Daniel Cazzulino in 2004
You can find the original project here :
http://msdn.microsoft.com/en-us/library/aa302301.aspx

From pascal cabanel.
My blog (French only) : http://blog.mydotnet.fr

Updated Wiki: Home

pcabanel — Sat, 09 Oct 2010 16:38:17 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Sat, 09 Oct 2010 16:37:47 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Xsd2Code is an AddIn for visual studio 2008.
Right clic on xsd schema in solution explorer, choose options and generate code.

Cannot resolve image macro, invalid image name or id.

Xsd2Code has a CustomTool which allows automatic generation when schema is modified.

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Sat, 09 Oct 2010 16:14:34 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Serialize/deserilize to string or from object.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Read an write xml with UTF-8/32, ASCII, Unicode, Default. (new in 3.4).
Generate CS, VB code.
Save into file and load from file.
Include Xsd2CodeCustomTool.
Mask private field in IDE (use EditorBrowsableState.Never attribute).

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Sun, 19 Sep 2010 09:08:19 GMT

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Sun, 19 Sep 2010 09:04:21 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

If you feel that the work I provide to the community is worth it, you can donate by using the Donate button below. Thank you.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Thu, 16 Sep 2010 12:24:33 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Thu, 16 Sep 2010 12:24:05 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Wed, 18 Aug 2010 16:23:02 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Wed, 18 Aug 2010 14:06:32 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

This is a free open source project that I have developed in my personal time.
I really appreciate your feedback and support for xsd2Code and its future development.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Wed, 18 Aug 2010 14:06:11 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

This is a free open source project that I have developed in my personal time.
I really appreciate your feedback and support for xsd2Code and its future development.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Mon, 16 Aug 2010 20:50:00 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Mon, 16 Aug 2010 20:44:44 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

This is a free open source project that I have developed in my personal time.
I really appreciate your feedback and support for xsd2Code and its future development.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Mon, 16 Aug 2010 20:44:07 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

Xsd2Code is a free open source project that I have developed in my personal time. I really appreciate your feedback and support for xsd2Code and its future development.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Mon, 16 Aug 2010 20:43:38 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

Xsd2Code is a free open source project that I have developed in my personal time. I really appreciate your feedback and support for xsd2Code and its future development.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Mon, 16 Aug 2010 20:31:35 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

<form action="https://www.paypal.com/cgi-bin/webscr" method="post">
<input type="hidden" name="cmd" value="_s-xclick">
<input type="hidden" name="hosted_button_id" value="GG8Y7HWG93UV8">
<input type="image" src="https://www.paypal.com/fr_FR/FR/i/btn/btn_donateCC_LG.gif" border="0" name="submit" alt="PayPal - la solution de paiement en ligne la plus simple et la plus sécurisée !">
<img alt="" border="0" src="https://www.paypal.com/fr_FR/i/scr/pixel.gif" width="1" height="1">
</form>

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Wed, 23 Dec 2009 22:08:41 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...

Updated Wiki: Home

pcabanel — Thu, 22 Oct 2009 20:50:55 GMT

Project Description
Xsd2Code is a CSharp or Visual Basic Business Entity class Generator from XSD schema.

What Xsd2Code can do ?

Generate partial class.
Support generic and custom collection (List<T>, ObservableCollection<T>, MyCustomCollection<T>).
Support automatic properties when no special get or set is required.
Can generate WCF attributes (DataContract/DataMember).
Support nillable type.
Mask private field in IDE (use EditorBrowsableState.Never attribute).
Generate object allocation in constructor.
Implement INotifyPropertyChanged for enable DataBinding for wpf or Silverlight.
Improves productivity with visual studio add-in.
Generate summary documentation from xsd annotation.
Check if the new and old values int setter are the same before raising property changed event.
backup options generation in cs or vb header.
Save and load Xml document into isolated file storage for silverlight app (new in 3.0).
Generate CS, VB or CPP code.
Serialize/deserilize object.
Save into file and load from file.
Include Xsd2CodeCustomTool.

How to use it ?

Enable databinding.

      <xs:element name="show" type="xs:boolean" nillable="true"/>

Result :

        [System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
        public System.Nullable<bool> show {
            get {
                return this.showField;
            }
            set {
                if ((showField.Equals(value) != true)) {
                    this.showField = value;
                    OnPropertyChanged("show");
                }
            }
        }

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
        
        private void OnPropertyChanged(string info) {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) {
                handler(this, new PropertyChangedEventArgs(info));
            }
        }

Hide private field in Visual studio.

     [EditorBrowsable(EditorBrowsableState.Never)]
     private List <dvds> dvdsField;

Generic collection.

<xs:element name="Product">
    <xs:complexType>
      <xs:sequence maxOccurs="unbounded">
        <xs:element name="ProductName" type="xs:string" />
        <xs:element name="ProductVersion" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
</xs:element>

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Product() {
            if ((this.productVersionField == null)) {
                this.productVersionField = new List<System.String>();
            }
            if ((this.productNameField == null)) {
                this.productNameField = new List<System.String>();
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("ProductName")]
        public List<System.String> ProductName {
            get {
                return this.productNameField;
            }
            set {
                if ((this.productNameField != null)) {
                    if ((productNameField.Equals(value) != true)) {
                        this.productNameField = value;
                        OnPropertyChanged("ProductName");
                    }
                }
                else {
                    this.productNameField = value;
                    OnPropertyChanged("ProductName");
                }
            }
        }

Lazy loading pattern.

        [System.Xml.Serialization.XmlElementAttribute("Dvds")]
        public List<dvd> Dvds {
            get {
                if ((this.dvdsField == null)) {
                    this.dvdsField = new List<dvd>();
                }
                return this.dvdsField;
            }
            set {
                this.dvdsField = value;
            }
        }

Serialize/Deserialize method.

/// <summary>
        /// Serializes current EntityBase object into an XML document
        /// </summary>
        // <returns>string XML value</returns>
        public virtual string Serialize() {
            System.IO.StreamReader streamReader = null;
            System.IO.MemoryStream memoryStream = null;
            try {
                memoryStream = new System.IO.MemoryStream();
                Serializer.Serialize(memoryStream, this);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                streamReader = new System.IO.StreamReader(memoryStream);
                return streamReader.ReadToEnd();
            }
            finally {
                if (streamReader != null) {
                    streamReader.Dispose();
                }
                if (memoryStream != null) {
                    memoryStream.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool Deserialize(string xml, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = Deserialize(xml);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool Deserialize(string xml, out T obj) {
            System.Exception exception = null;
            return Deserialize(xml, out obj, out exception);
        }
        
        public static T Deserialize(string xml) {
            System.IO.StringReader stringReader = null;
            try {
                stringReader = new System.IO.StringReader(xml);
                return ((T)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
            }
            finally {
                if (stringReader != null) {
                    stringReader.Dispose();
                }
            }
        }

SaveToFile and LoadFromFile method.

       /// <summary>
        /// Serializes current EntityBase object into file
        /// </summary>
        // <param name="fileName">full path of outupt xml file</param>
        // <param name="exception">output Exception value if failed</param>
        // <returns>true if can serialize and save into file; otherwise, false</returns>
        public virtual bool SaveToFile(string fileName, out System.Exception exception) {
            exception = null;
            try {
                SaveToFile(fileName);
                return true;
            }
            catch (System.Exception e) {
                exception = e;
                return false;
            }
        }
        
        public virtual void SaveToFile(string fileName) {
            System.IO.StreamWriter streamWriter = null;
            try {
                string xmlString = Serialize();
                System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName);
                streamWriter = xmlFile.CreateText();
                streamWriter.WriteLine(xmlString);
                streamWriter.Close();
            }
            finally {
                if (streamWriter != null) {
                    streamWriter.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Deserializes workflow markup from file into an EntityBase object
        /// </summary>
        // <param name="xml">string workflow markup to deserialize</param>
        // <param name="obj">Output EntityBase object</param>
        // <param name="exception">output Exception value if deserialize failed</param>
        // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
        public static bool LoadFromFile(string fileName, out T obj, out System.Exception exception) {
            exception = null;
            obj = default(T);
            try {
                obj = LoadFromFile(fileName);
                return true;
            }
            catch (System.Exception ex) {
                exception = ex;
                return false;
            }
        }
        
        public static bool LoadFromFile(string fileName, out T obj) {
            System.Exception exception = null;
            return LoadFromFile(fileName, out obj, out exception);
        }
        
        public static T LoadFromFile(string fileName) {
            System.IO.FileStream file = null;
            System.IO.StreamReader sr = null;
            try {
                file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
                sr = new System.IO.StreamReader(file);
                string xmlString = sr.ReadToEnd();
                sr.Close();
                file.Close();
                return Deserialize(xmlString);
            }
            finally {
                if (file != null) {
                    file.Dispose();
                }
                if (sr != null) {
                    sr.Dispose();
                }
            }
        }

Default value.

<xs:attribute name="nationality" type="xs:string" default="US">

Result :

        /// <summary>
        /// .ctor class constructor
        /// </summary>
        public Actor() {
            this.nationalityField = "US";
        }

Code xml comment.

 <xs:element name="firstname" type="xs:string">
     <xs:annotation>
        <xs:documentation>
        Gets or sets the firstname of the actor
        </xs:documentation>
     </xs:annotation>
 </xs:element>

Result :

        /// <summary>
        /// Gets or sets the firstname of the actor
        /// </summary>
        public string firstname {get;set;}

Backup options generation in cs or vb header

// ------------------------------------------------------------------------------
//  <auto-generated>
//    Generated by Xsd2Code. Version 2.1.3148.17485
//   <NameSpace>XSD2Code.Test</NameSpace><Collection>List</Collection>...
//  <auto-generated>
// ------------------------------------------------------------------------------
namespace XSD2Code.Test {
    using System;
    using System.Diagnostics;
    ...