C# (CSharp) XmlDeserializer.deserialize Examples

Programming Language: C# (CSharp)

Class/Type: XmlDeserializer

Method/Function: deserialize

Examples at hotexamples.com: 1

The XmlDeserializer class in C# is used to deserialize XML data into C# objects. It is a part of the System.Xml.Serialization namespace which is included in the .NET Framework.

Example 1: Deserializing a simple XML string

string xmlString = "John30";
var serializer = new XmlSerializer(typeof(Person));
using (TextReader reader = new StringReader(xmlString))
{
    Person person = (Person)serializer.Deserialize(reader);
    Console.WriteLine(person.Name); // Output: John
    Console.WriteLine(person.Age); // Output: 30
}

In this example, we are deserializing a simple XML string into a C# object of type Person. We create an instance of the XmlSerializer class by specifying the type of the object we want to deserialize. Then we create a TextReader from a StringReader that reads the XML string. Finally, we call the Deserialize method of the serializer object and cast the result to the appropriate object type.

Example 2: Using XmlAttributes to control deserialization

[XmlRoot("book")]
public class Book
{
    [XmlAttribute("id")]
    public string Id { get; set; }

    [XmlElement("title")]
    public string Title { get; set; }

    [XmlElement("author")]
    public string Author { get; set; }
}

string xmlString = "The Great GatsbyF. Scott Fitzgerald";
var serializer = new XmlSerializer(typeof(Book));
using (TextReader reader = new StringReader(xmlString))
{
    Book book = (Book)serializer.Deserialize(reader);
    Console.WriteLine(book.Title); // Output: The Great Gatsby
    Console.WriteLine(book.Author); // Output: F. Scott Fitzgerald
    Console.WriteLine(book.Id); // Output: 1
}

In this example, we are deserializing an XML string into a Book object. We use XmlAttributes to specify how the serialization should be performed. The XmlRoot attribute specifies that the root element should be named "book". The XmlAttribute attribute specifies that the "id" attribute of the "book" element should be mapped to the Id property of the Book object. Finally, the XmlElement attribute specifies that the "title" and "author" elements should be mapped to the Title and Author properties, respectively. The package library for the XmlSerializer class is System.Xml.Serialization.

C# (CSharp) XmlDeserializer.deserialize - 1 examples found. These are the top rated real world C# (CSharp) examples of XmlDeserializer.deserialize extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

Deserialize(30)

DeserializeList(7)

DeserializeType(5)

DeserializeInto(2)

GetValue(2)

Read(2)

DeserializeComponent(1)

Finish(1)

From(1)

GetCompilerForType(1)

GetString(1)

Load(1)

TryGetXmlElement(1)

UpdateType(1)

deserialize(1)

Example #1

Show file

        public Task loadTask()
        {
            string     taskFilePath = string.Empty;
            FileStream stream       = null;

            try
            {
                taskFilePath = getNextTaskFile();
                if (taskFilePath == string.Empty)
                {
                    return(null);
                }

                //XmlSerializer serializer = new XmlSerializer(typeof(TaskXmlNode));
                //stream = new FileStream(taskFilePath, FileMode.Open);
                //TaskXmlNode taskXmlNode = serializer.Deserialize(stream) as TaskXmlNode;
                //stream.Close();

                TaskXmlNode taskXmlNode = XmlDeserializer.deserialize <TaskXmlNode>(taskFilePath);

                Task task = new Task();
                task.ReportName = taskXmlNode.ReportSetting.ReportName;
                taskXmlNode.ReportSetting.ReportFilePath = Application.StartupPath + @"\Report" + taskXmlNode.ReportSetting.ReportFilePath;
                task.ReportSetting = taskXmlNode.ReportSetting;

                foreach (DataSourceXmlNode dataSourceXmlNode in taskXmlNode.DataSourceList)
                {
                    List <object> dataSourceValue = new List <object>();
                    string        prefix          = Application.StartupPath + @"\Assembly";
                    Type          type            = ReflectionHelper.getType(prefix + dataSourceXmlNode.AssemblyPath, dataSourceXmlNode.TypeFullName);

                    foreach (RecordXmlNode recordXmlNode in dataSourceXmlNode.RecordList)
                    {
                        Object obj = createEntity(type);
                        initEntity(type, obj, recordXmlNode.PropertyList);
                        dataSourceValue.Add(obj);
                    }
                    string     dataSourceName = generateDataSourceName(dataSourceXmlNode.TypeFullName);
                    DataSource dataSource     = new DataSource(dataSourceName, dataSourceValue);
                    task.addDataSource(dataSource);
                }

                task.CurrentFilePath = handleProcessedTask(taskFilePath);
                return(task);
            }
            catch (Exception ex)
            {
                if (stream != null)
                {
                    stream.Close();
                }

                if (File.Exists(taskFilePath))
                {
                    FileInfo info         = new FileInfo(taskFilePath);
                    string   dir          = GlobalVariable.getDeletedDirectory();
                    string   destFilePath = dir + @"\" + info.Name;
                    if (File.Exists(destFilePath))
                    {
                        File.Delete(destFilePath);
                    }
                    File.Move(taskFilePath, destFilePath);
                    throw new Exception(ex.Message + string.Format(" Failed to load task. Task file '{0}' has been moved to directory '{1}'.", new FileInfo(taskFilePath).Name, dir));
                }
                else
                {
                    throw new Exception(ex.Message + " Failed to load task.");
                }
            }
            finally
            {
                if (stream != null)
                {
                    stream.Close();
                }
            }
        }