C# xml序列化后具有空属性的项列表

我尝试将xml序列化到我的类：

[XmlRoot(ElementName = "order")]
public class OrderModel
{
    [XmlElement(ElementName = "purchaser")]
    public CompanyModel Purchaser { get; set; }

    [XmlElement(ElementName = "deliverver")]
    public CompanyModel Deliverver { get; set; }

    [XmlElement(ElementName = "position")]
    public List<OrderPositionModel> Positions { get; set; }
}

public class OrderPositionModel
{
    [XmlElement(ElementName = "id")]
    public int id { get; set; }

    [XmlElement(ElementName = "lp")]
    public int OrdinalNumber { get; set; }

    [XmlElement(ElementName = "name")]
    public string Name { get; set; }

    [XmlElement(ElementName = "quantity")]
    public int Quantity { get; set; }
}

类似这样的东西，然后我使用block添加

更新#2 我尝试使用这种xml

<order>
<purchaser>
    <name>name1</name>
    <address>address1</address>
</purchaser>
<deliverver>
    <name>name2</name>
    <address>address2</address>
</deliverver>
<position id="17" name="pos1" lp="1" quantity="1"/>
<position id="21" name="pos2" lp="2" quantity="2"/>
</order>

名称1
地址1
姓名2
地址2

最简单的工作示例：

请注意，您的一些属性是用

xmlement

修饰的，而它们是属性，因此应该改为用

xmltattribute

修饰

（我还删除了所有不必要的内容）

使用System.Collections.Generic；
使用System.Xml；
使用System.Xml.Serialization；
命名空间控制台应用程序1
{
内部课程计划
{
私有静态void Main（字符串[]args）
{
var filename=@“.\..\XMLFile1.xml”；
var model=Read（文件名）；
}
私有静态OrderModel读取（字符串文件名）
{
使用（var reader=XmlReader.Create（文件名））
{
var serializer=newxmlserializer（typeof（OrderModel））；
var model=（OrderModel）序列化程序。反序列化（reader）；
收益模型；
}
}
}
[XmlRoot（ElementName=“order”）]
公共类排序模型
{
[XmlElement（ElementName=“买方”）]
上市公司模型购买者{get；set；}
[XmlElement（ElementName=“DeliverServer”）]
公共公司模型交付服务器{get；set；}
[xmlement（ElementName=“position”）]
公共列表位置{get；set；}
}
公共类模型
{
[XmlAttribute（“id”）]
公共int id{get；set；}
[XmlAttribute（“lp”）]
公共整数序号{get；set；}
[XmlAttribute（“名称”）]
公共字符串名称{get；set；}
[XmlAttribute（“数量”）]
公共整数数量{get；set；}
}
公共类公司模型
{
[xmlement（ElementName=“name”）]
公共字符串名称{get；set；}
[xmlement（ElementName=“address”）]
公共字符串地址{get；set；}
}
}

试着用那种方式序列化，它对我很有用

       Example of using the class "ObjectSerialization"

        try
        {
            parmExtRoute viagens = new parmExtRoute();
            Stream streamXml = arquivoRecebido.InputStream;
            var document = new XmlDocument();
            document.Load(streamXml);

            string stream = document.OuterXml;
            viagens = ObjectSerialization.DeserializeObject<parmExtRoute>(stream);
            retorno.Result = viagens;
        }
        catch (Exception ex)
        {
            retorno.ListErrors.Add(ex.Message);
        }

        return retorno;
    



public static class ObjectSerialization
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
            return string.Empty;

        try
        {
            using (var stringWriter = new StringWriter())
            {
                var namespaces = new XmlSerializerNamespaces();
                var settings = new XmlWriterSettings();
                settings.Encoding = new UnicodeEncoding(false, false);
                settings.Indent = false;
                settings.NewLineChars = string.Empty;
                settings.NewLineHandling = NewLineHandling.None;
                settings.OmitXmlDeclaration = true;
                namespaces.Add(string.Empty, string.Empty);
                var serializer = new XmlSerializer(typeof(T));

                using (var xmlWriter = XmlWriter.Create(stringWriter, settings))
                    serializer.Serialize(xmlWriter, dataObject, namespaces);

                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("Erro ao serializar objeto. ", ex.Message) + DateTime.Now.ReturnDateLocale());
            return string.Empty;
        }
    }
    public static T DeserializeObject<T>(string xml) where T : class
    {
        if (string.IsNullOrEmpty(xml))
            return Activator.CreateInstance<T>();

        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T), new Type[] { typeof(T) }); ;
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("Erro ao deserializar objeto. ", ex.Message) + DateTime.Now.ReturnDateLocale());
            return Activator.CreateInstance<T>();
        }
    }
    public static string ObjectParamWs<T>(T dataObject)
    {
        string conteudo = SerializeObject<T>(dataObject);
        string xml = conteudo;
        return xml;
    }
}

使用类“ObjectSerialization”的示例
尝试
{
parmExtRoute viagens=新的parmExtRoute（）；
streamXml=arquivoRecebido.InputStream；
var document=新的XmlDocument（）；
document.Load（streamXml）；
字符串流=document.OuterXml；
viagens=ObjectSerialization.DeserializeObject（流）；
结果=维亚根斯；
}
捕获（例外情况除外）
{
returno.ListErrors.Add（例如Message）；
}
返回号；
公共静态类对象序列化
{
公共静态字符串序列化对象（T dataObject）
{
if（dataObject==null）
返回字符串。空；
尝试
{
使用（var stringWriter=new stringWriter（））
{
var namespace=新的XmlSerializerNamespaces（）；
var设置=新的XmlWriterSettings（）；
settings.Encoding=新的Unicode编码（false，false）；
settings.Indent=false；
settings.NewLineChars=string.Empty；
settings.NewLineHandling=NewLineHandling.None；
settings.OmitXmlDeclaration=true；
添加（string.Empty，string.Empty）；
var serializer=newxmlserializer（typeof（T））；
使用（var xmlWriter=xmlWriter.Create（stringWriter，设置））
serializer.Serialize（xmlWriter、dataObject、命名空间）；
返回stringWriter.ToString（）；
}
}
捕获（例外情况除外）
{
WriteLine（string.Format（“Erro ao serializar objeto.”，ex.Message）+DateTime.Now.ReturnDateLocale（））；
返回字符串。空；
}
}
公共静态T反序列化对象（字符串xml），其中T:class
{
if（string.IsNullOrEmpty（xml））
返回Activator.CreateInstance（）；
尝试
{
使用（var stringReader=newstringreader（xml））
{
var serializer=newxmlserializer（typeof（T），newtype[]{typeof（T）}）；
返回（T）序列化程序。反序列化（stringReader）；
}
}
捕获（例外情况除外）
{
WriteLine（string.Format（“Erro ao deserializar objeto.”，ex.Message）+DateTime.Now.ReturnDateLocale（））；
返回Activator.CreateInstance（）；
}
}
公共静态字符串ObjectParamWs（T dataObject）
{
字符串conteudo=序列化对象（dataObject）；
字符串xml=conteudo；
返回xml；
}
}

你能显示你的序列化代码吗？并粘贴你试图加载的XML。@Aybe question updated请更新你的答案以显示它与OP问题相关。一堆代码（尤其是与原始问题无关的代码）本身并不能提供足够的上下文。谢谢，我改进了标题。

using System.Collections.Generic;
using System.Xml;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var filename = @"..\..\XMLFile1.xml";
            var model = Read(filename);
        }

        private static OrderModel Read(string filename)
        {
            using (var reader = XmlReader.Create(filename))
            {
                var serializer = new XmlSerializer(typeof(OrderModel));
                var model = (OrderModel) serializer.Deserialize(reader);
                return model;
            }
        }
    }

    [XmlRoot(ElementName = "order")]
    public class OrderModel
    {
        [XmlElement(ElementName = "purchaser")]
        public CompanyModel Purchaser { get; set; }

        [XmlElement(ElementName = "deliverver")]
        public CompanyModel Deliverver { get; set; }

        [XmlElement(ElementName = "position")]
        public List<OrderPositionModel> Positions { get; set; }
    }

    public class OrderPositionModel
    {
        [XmlAttribute("id")]
        public int id { get; set; }

        [XmlAttribute("lp")]
        public int OrdinalNumber { get; set; }

        [XmlAttribute("name")]
        public string Name { get; set; }

        [XmlAttribute("quantity")]
        public int Quantity { get; set; }
    }

    public class CompanyModel

    {
        [XmlElement(ElementName = "name")]
        public string Name { get; set; }

        [XmlElement(ElementName = "address")]
        public string Address { get; set; }
    }
}

       Example of using the class "ObjectSerialization"

        try
        {
            parmExtRoute viagens = new parmExtRoute();
            Stream streamXml = arquivoRecebido.InputStream;
            var document = new XmlDocument();
            document.Load(streamXml);

            string stream = document.OuterXml;
            viagens = ObjectSerialization.DeserializeObject<parmExtRoute>(stream);
            retorno.Result = viagens;
        }
        catch (Exception ex)
        {
            retorno.ListErrors.Add(ex.Message);
        }

        return retorno;
    



public static class ObjectSerialization
{
    public static string SerializeObject<T>(T dataObject)
    {
        if (dataObject == null)
            return string.Empty;

        try
        {
            using (var stringWriter = new StringWriter())
            {
                var namespaces = new XmlSerializerNamespaces();
                var settings = new XmlWriterSettings();
                settings.Encoding = new UnicodeEncoding(false, false);
                settings.Indent = false;
                settings.NewLineChars = string.Empty;
                settings.NewLineHandling = NewLineHandling.None;
                settings.OmitXmlDeclaration = true;
                namespaces.Add(string.Empty, string.Empty);
                var serializer = new XmlSerializer(typeof(T));

                using (var xmlWriter = XmlWriter.Create(stringWriter, settings))
                    serializer.Serialize(xmlWriter, dataObject, namespaces);

                return stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("Erro ao serializar objeto. ", ex.Message) + DateTime.Now.ReturnDateLocale());
            return string.Empty;
        }
    }
    public static T DeserializeObject<T>(string xml) where T : class
    {
        if (string.IsNullOrEmpty(xml))
            return Activator.CreateInstance<T>();

        try
        {
            using (var stringReader = new StringReader(xml))
            {
                var serializer = new XmlSerializer(typeof(T), new Type[] { typeof(T) }); ;
                return (T)serializer.Deserialize(stringReader);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(string.Format("Erro ao deserializar objeto. ", ex.Message) + DateTime.Now.ReturnDateLocale());
            return Activator.CreateInstance<T>();
        }
    }
    public static string ObjectParamWs<T>(T dataObject)
    {
        string conteudo = SerializeObject<T>(dataObject);
        string xml = conteudo;
        return xml;
    }
}