C＃Typedef保留属性

Question

问题：我有Dictionary<String, String>，我需要一个别名，但我也需要序列化/反序列化它。

解决方案我已经试过：

class Foo : Dictionary<String, String> { } 

，但这项工作，因为我将要创建一个反序列化的构造，这将是一个有点傻的时候已经词典可以反序列化。

我也试过

using Foo = System.Collections.Generic.Dictionary<String, String>; 

，但我需要这在一个以上的文件工作，如果加上该行中需要的所有文件，我会删除的typedef一半的点（即是，如果我需要改变类型，我可以很容易地做到这一点）

我能做些什么呢？

Answer 1

使用别名方法属性被保留，但是您声明这是过多的开销（每个文件等）。

类型级别的属性被 genercally保留 - 但它取决于属性 - 为[Serializable]，请注意，它具有：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct 
| AttributeTargets.Enum | AttributeTargets.Delegate, Inherited = false)] 

的Inherited = false是显著 - 即它不继承。

就我个人而言，我可能会专注于获得序列化ctor/callbacks在第一个例子中工作 - 我怀疑它会需要更多的努力。下面似乎罚款：

[Serializable] 
public class Foo: Dictionary<string, string> { 
    public Foo() : base() { } 
    public Foo(SerializationInfo info, StreamingContext context) : base(info, context) { } 
    public Foo(int capacity) : base(capacity) { } 
    public Foo(IEqualityComparer<string> comparer): base(comparer) {} 
    public Foo(IDictionary<string,string> dictionary) : base(dictionary) { } 
    public Foo(int capacity, IEqualityComparer<string> comparer) : base(capacity, comparer) { } 
    public Foo(IDictionary<string, string> dictionary, IEqualityComparer<string> comparer) : base(dictionary, comparer) { } 
} 

然而，这里是通过封装一种替代方案：

[Serializable] 
public class Foo : IDictionary<string,string> 
{ 
    private readonly Dictionary<string, string> inner = new Dictionary<string, string>(); 

    public void Add(string key, string value) 
    { 
     inner.Add(key, value); 
    } 

    public bool ContainsKey(string key) 
    { 
     return inner.ContainsKey(key); 
    } 

    public ICollection<string> Keys 
    { 
     get { return inner.Keys; } 
    } 

    public bool Remove(string key) 
    { 
     return inner.Remove(key); 
    } 

    public bool TryGetValue(string key, out string value) 
    { 
     return inner.TryGetValue(key, out value); 
    } 

    public ICollection<string> Values 
    { 
     get { return inner.Values; } 
    } 

    public string this[string key] 
    { 
     get 
     { 
      return inner[key]; 
     } 
     set 
     { 
      inner[key] = value; 
     } 
    } 

    void ICollection<KeyValuePair<string, string>>.Add(KeyValuePair<string, string> item) 
    { 
     ((IDictionary<string,string>)inner).Add(item); 
    } 

    public void Clear() 
    { 
     inner.Clear(); 
    } 

    bool ICollection<KeyValuePair<string, string>>.Contains(KeyValuePair<string, string> item) 
    { 
     return ((IDictionary<string, string>)inner).Contains(item); 
    } 

    void ICollection<KeyValuePair<string, string>>.CopyTo(KeyValuePair<string, string>[] array, int arrayIndex) 
    { 
     ((IDictionary<string, string>)inner).CopyTo(array, arrayIndex); 
    } 

    public int Count 
    { 
     get { return inner.Count; } 
    } 

    bool ICollection<KeyValuePair<string, string>>.IsReadOnly 
    { 
     get { return ((IDictionary<string, string>)inner).IsReadOnly; } 
    } 

    bool ICollection<KeyValuePair<string, string>>.Remove(KeyValuePair<string, string> item) 
    { 
     return ((IDictionary<string, string>)inner).Remove(item); 
    } 

    public IEnumerator<KeyValuePair<string, string>> GetEnumerator() 
    { 
     return inner.GetEnumerator(); 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return inner.GetEnumerator(); 
    } 
} 

Answer 2

嗯“这将是一个有点傻的时候已经词典可以反序列化。”我不会说这是愚蠢调用构造函数基地在（几乎）任何情况下+这1次分钟的努力，所以我说做...

[Serializable] 
public class Foo : Dictionary<string, string> 
{ 
    public Foo() 
     : base() 
    { 
    } 
    public Foo(SerializationInfo info, StreamingContext context) 
     : base(info, context) 
    { 
    } 

} 

或

[Serializable] 
public class Foo<TKey,TValue> : Dictionary<TKey,TValue> 
{ 
    public Foo() 
     : base() 
    { 
    } 
    public Foo(SerializationInfo info, StreamingContext context) 
     : base(info, context) 
    { 
    } 

}