C# Silverlight。手工解析与反射解析

如果我使用反射而不是手工将每个XML值解析为类，Silverlight浏览器应用程序的运行速度会慢多少

UPD 下面是一些示例（反射将不同，但非常相似）：

手工解析：

//...
IEnumerable<XElement> XMLProfiles = xmlDocument.Element("response").Elements(xmlDocument.Element("response").Element("user").Name);

foreach (XElement userElement in XMLProfiles)
{
    this.Id = userElement.Element("UserID").Value;
    this.Name = userElement.Element("someName").Value;
    this.Phone= userElement.Element("mobile").Value;
    // ...
    this.p20 = userElement.Element("someName20").Value;
}
//...

//...
[XmlElement("UserID")]
public string Id  { get; set; }

[XmlElement("someName")]
public string Name{ get; set; }

[XmlElement("mobile")]
public string Phone{ get; set; }

/* other parems */

[XmlElement("someName20")]
public string p20 { get; set; }
//...

public void Load(XDocument data)
{
    XElement XML;
    Type T = this.GetType();
    PropertyInfo[] PI = T.GetProperties();

    foreach (PropertyInfo item in PI)
    {
        var AObj = item.GetCustomAttributes(false);
        XMLProfiles = data.Element("user").Element(((XmlElementAttribute)AObj[0]).ElementName);
        object Value = Parse(item, XML.Value);
            if (Value != null)
                item.SetValue(this, Value, null);
    }
}

---

假设一个反射调用可能需要1ms的时间（应该比这个快）。这意味着您可能每秒进行1000次反射调用。当您进行分析时，您会发现它更像是每次调用的微秒，对于您指定的每秒60次，它应该足够快。

假设反射调用可能需要1毫秒（应该比这快）。这意味着您可能每秒进行1000次反射调用。当您进行评测时，您会发现它更像是每次调用的微秒，对于您指定的每秒60次来说，这应该足够快了。

好的。这有点傻。。。但是对有充分的理由使用这样的序列化/反序列化技术。第一种选择肯定比第二种快。。。但是这里有很多话要说

首先，.Net已经有两种可以使用的XML序列化技术。它们都可能比你的方法更快。调查一下这个问题。不要再发明轮子了。利用已经存在的东西

接下来，通过缓存基于元数据的映射，您自己的第二个选项的代码可以更快。执行一次反射，然后在反序列化时使用查找表

这就引出了我的下一个观点：如果你只做一次，差别可以忽略不计。你根本不会注意到的。如果你做了数千次，基于反射的技术肯定会更慢。。。多少钱？计时并找出答案

不过，在我看来，如果你不提高工作效率，那么做时间安排就是浪费时间

---

但是，根据我的经验，有效地使用声明式序列化/反序列化是一种很好的方法。它大大降低了代码的复杂性，这是非常值得的。我将回到我的第一点。不要再发明轮子了。如果可以，请使用两种现有机制之一。

确定。这有点傻。。。但是对有充分的理由使用这样的序列化/反序列化技术。第一种选择肯定比第二种快。。。但是这里有很多话要说

首先，.Net已经有两种可以使用的XML序列化技术。它们都可能比你的方法更快。调查一下这个问题。不要再发明轮子了。利用已经存在的东西

接下来，通过缓存基于元数据的映射，您自己的第二个选项的代码可以更快。执行一次反射，然后在反序列化时使用查找表

这就引出了我的下一个观点：如果你只做一次，差别可以忽略不计。你根本不会注意到的。如果你做了数千次，基于反射的技术肯定会更慢。。。多少钱？计时并找出答案

不过，在我看来，如果你不提高工作效率，那么做时间安排就是浪费时间

---

但是，根据我的经验，有效地使用声明式序列化/反序列化是一种很好的方法。它大大降低了代码的复杂性，这是非常值得的。我将回到我的第一点。不要再发明轮子了。如果可以，请使用两种现有机制中的一种。

如果重写现有机制，则可以省去反射所需的大部分时间

    Dictionary<PropertyInfo, object[]> PI;
    public void InitClass()
    {
        PI = new Dictionary<PropertyInfo, object[]>();
        Type T = this.GetType();
        PropertyInfo[] propInfos = T.GetProperties();
        foreach (PropertyInfo info in propInfos)
        {
            var AObj = info.GetCustomAttributes(false);
            PI.Add(info, AObj);
        }
    }

    public void Load(XDocument data)
    {
        XElement XML;
        PropertyInfo item;
        object[] AObj;
        foreach (var keyValPair in PI)
        {
            item = keyValPair.Key;
            AObj = keyValPair.Value;
            XMLProfiles = data.Element("user").Element(((XmlElementAttribute)AObj[0]).ElementName);
            object Value = Parse(item, XML.Value);
            if (Value != null)
                item.SetValue(this, Value, null);
        }
    }

字典PI；
公共类（）
{
PI=新字典（）；
Type T=this.GetType（）；
PropertyInfo[]PropInfo=T.GetProperties（）；
foreach（PropInfo中的PropertyInfo信息）
{
var AObj=info.GetCustomAttributes（false）；
PI.Add（信息，AObj）；
}
}
公共无效荷载（XDocument数据）
{
XElement XML；
财产信息项；
对象[]AObj；
foreach（PI中的var键对）
{
item=keyValPair.Key；
AObj=keyValPair.Value；
XMLProfiles=data.Element（“用户”）.Element（（（xmlementattribute）AObj[0]）.ElementName）；
object Value=Parse（item，XML.Value）；
if（值！=null）
item.SetValue（this，Value，null）；
}
}

如果你重写了你所拥有的，你就可以省去大部分反思所需的时间

    Dictionary<PropertyInfo, object[]> PI;
    public void InitClass()
    {
        PI = new Dictionary<PropertyInfo, object[]>();
        Type T = this.GetType();
        PropertyInfo[] propInfos = T.GetProperties();
        foreach (PropertyInfo info in propInfos)
        {
            var AObj = info.GetCustomAttributes(false);
            PI.Add(info, AObj);
        }
    }

    public void Load(XDocument data)
    {
        XElement XML;
        PropertyInfo item;
        object[] AObj;
        foreach (var keyValPair in PI)
        {
            item = keyValPair.Key;
            AObj = keyValPair.Value;
            XMLProfiles = data.Element("user").Element(((XmlElementAttribute)AObj[0]).ElementName);
            object Value = Parse(item, XML.Value);
            if (Value != null)
                item.SetValue(this, Value, null);
        }
    }

字典PI；
公共类（）
{
PI=新字典（）；
Type T=this.GetType（）；
PropertyInfo[]PropInfo=T.GetProperties（）；
foreach（PropInfo中的PropertyInfo信息）
{
var AObj=info.GetCustomAttributes（false）；
PI.Add（信息，AObj）；
}
}
公共无效荷载（XDocument数据）
{
XElement XML；
财产信息项；
对象[]AObj；
foreach（PI中的var键对）
{
item=keyValPair.Key；
AObj=keyValPair.Value；
XMLProfiles=data.Element（“用户”）.Element（（（xmlementattribute）AObj[0]）.ElementName）；
object Value=Parse（item，XML.Value）；
if（值！=null）
item.SetValue（this，Value，null）；
}
}

我们不知道！这取决于你在做什么以及多久一次……请求的最大频率是每秒3次。Som类最多可以有20个参数，那么是什么阻止了你比较计时呢？1）API调用尚未实现2）所有调用都是异步的3）现在是早上6点，我今天没有睡觉：）我想有人有过这样的经验，我们不知道！这取决于你在做什么以及多久一次……请求的最大频率是每秒3次。Som类最多可以有20个paremeters那么停止什么呢