Question

再次拔出我的头发。我花了一整天的时间在研究这个问题，无法弄清楚它是否可行，或者我做错了什么。

我已经创建了一个自定义对象集合。

 public class ObjectCollection<T> : IEnumerable<T>, IEnumerable where T : IUniqueObjectIdentifier
{

    protected List<T> List = new List<T>();
    protected Dictionary<Guid, int> Keys = new Dictionary<Guid, int>();
    protected Dictionary<int, Guid> Inverse = new Dictionary<int, Guid>();
    protected Dictionary<string, Guid> Name = new Dictionary<string, Guid>();
    public void Add(T item)
    {
        if (item is IUniqueObjectIdentifier itemIdentifier)
            if (!Keys.ContainsKey(itemIdentifier.Id))
            {
                List.Add(item);
                Keys.Add(itemIdentifier.Id, List.IndexOf(item));
                Inverse.Add(List.IndexOf(item), itemIdentifier.Id);
            }
    }
    public void Remove(T item)
    {
        if (item is IUniqueObjectIdentifier itemIdentifier)
            if (List.Contains(item))
            {
                int index = List.IndexOf(item);
                Guid key = Inverse[index];
                Keys.Remove(itemIdentifier.Id);
                Inverse.Remove(index);
                List.Remove(item);
            }
    }
    public void Remove(int index)
    {
        if (index < List.Count)
        {
            Guid key = Inverse[index];
            Keys.Remove(key);
            List.RemoveAt(index);
            Inverse.Remove(index);
        }
    }

    public void Remove(Guid key)
    {
        if (Keys.ContainsKey(key))
        {
            int index = Keys[key];
            Keys.Remove(key);
            List.RemoveAt(index);
            Inverse.Remove(index);
        }
    }

    public void Clear()
    {
        Keys.Clear();
        List.Clear();
        Inverse.Clear();
    }

    public int Count => List.Count;

    public bool Contains(T item)
    {
        return List.Contains(item);
    }

    public bool ContainsKey(Guid key)
    {
        return Keys.ContainsKey(key);
    }

    public T this[int index]
    {
        get
        {
            if (index < List.Count)
                return List[index];
            else
                return default(T);
        }
    }

    public T this[Guid key]
    {
        get
        {
            if (Keys.ContainsKey(key))
                return List[Keys[key]];
            else
                return default(T);
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return List.GetEnumerator();
    }

    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    { return List.GetEnumerator(); }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return List.GetEnumerator();
    }

然后我有了一件东西：

public class Thing
{
    //Collections
    [XmlElement(ElementName = "Fields")]
    public Fields Fields { get; set; }

Fields对象继承自ObjectCollection：

[XmlRoot(ElementName = "Field")]
public class Fields:ObjectCollection<Field>
{

}

最后，我有一个包含所有属性的字段类：

[XmlRoot(ElementName = "Field")]
public class Field : IUniqueObjectIdentifier
{
    [XmlElement(ElementName = "FLAGS")]
    public int Flags{ get; set; }

这似乎唯一可行的方法是，如果我这样创建字段类：

[XmlRoot(ElementName = "Fields")]
public class Fields
{
    [XmlElement(ElementName = "Field")] private List<Field> Items { get; set; }
}

我讨厌。必须访问它，例如Thing.Fields.Items.Add，而不是Thing.Fields.Add。对我来说毫无意义。

XML如下：

<Thing ID="BD825D4AD7F44C00B41E8827646EE196" Name="Thingy">
  <Fields>
    <Field ID="02A5DA70FD94495E963DA5D7E414E30B" NAME="Fieldy">
      <FLAGS>1</FLAGS>
    </Field>
    <Field ID="DAF609FFD05B413F9F9D0DA8DD241CB3" NAME="Fieldy2">
      <FLAGS>1</FLAGS>

当我尝试对其进行反序列化时，我只会得到一个Default字段，即它添加到objectcollection中，但是只有一个项目，并且它显然未能对该字段进行反序列化，因为它实际上是空的。

我尝试查看是否可以找出哪些属性可能有所帮助，但不确定。我还研究了如何创建自定义反序列化，但这似乎有些过头。

任何人都可以帮我指出正确的方向。我只想要一个整洁的解决方案-最少的复杂性！！！就像我们所有人一样：-)

在我跳下当地码头之前，任何帮助将不胜感激。

干杯

斯图。

Answer 1

好的，我在帖子中简化了以下示例：

<Thing ID="BD825D4AD7F44C00B41E8827646EE196" Name="Thingy">
  <Fields>
    <AField ID="02A5DA70FD94495E963DA5D7E414E30B" NAME="Fieldy">
      <FLAGS>1</FLAGS>
    </AField>
    <AField ID="DAF609FFD05B413F9F9D0DA8DD241CB3" NAME="Fieldy2">
      <FLAGS>1</FLAGS>

收件人：

<Thing ID="BD825D4AD7F44C00B41E8827646EE196" Name="Thingy">
  <Fields>
    <Field ID="02A5DA70FD94495E963DA5D7E414E30B" NAME="Fieldy">
      <FLAGS>1</FLAGS>
    </Field>
    <Field ID="DAF609FFD05B413F9F9D0DA8DD241CB3" NAME="Fieldy2">
      <FLAGS>1</FLAGS>

AND：

[XmlRoot(ElementName = "AField")]
public class Fields:ObjectCollection<Field>
{

}

收件人：

[XmlRoot(ElementName = "Field")]
public class Fields:ObjectCollection<Field>
{

}

答案是，即使您指定了根，它也不会自动正确映射到对象。您显然需要指定[XmlType（“ AField”）]，除非它们相同。在发布的情况下：XmlRoot(ElementName = "Field")] = <Field ID="02A5DA70FD94495E963DA5D7E414E30B" NAME="Fieldy">

这可行：

[XmlRoot(ElementName = "AField")]
[XmlType("AField")]
public class Fields:ObjectCollection<Field>
{

}

经验教训：

不仅仅是您的例子；按原样发布！
遇到问题时，将其分解为最小的解决方案。

考虑到您已将其与根元素映射的事实，我不禁感到有点倒退，但是。感谢dbc在此方面的帮助，否则我会陷入困境。投票全力以赴。

Ph！

斯图。

c＃XML反序列化

1 个答案: