将字典<字符串，字符串>转换为字典<字符串，对象>的最简单方法是什么？

Question

我正在使用一个返回键值集合的API作为Dictionary<string, string>。我需要将其转换为Dictionary<string, object>。我有一种感觉，应该有一种方法可以在不通过每个键值对“手动”循环的情况下执行此转换/映射，但Google或者C＃对象引用不会立即产生解决方案。

Answer 1

请尝试以下

var newMap = oldMap.ToDictionary(pair => pair.Key, pair=>(object)pair.Value); 

Answer 2

您可以使用此扩展方法：

public static class ObjectExtensions 
{ 
    public static object GetPropertyValue(this object obj, string property) 
    { 
     return TypeDescriptor.GetProperties(obj)[property].GetValue(obj); 
    } 

    public static IDictionary<string, object> ToDictionary(this object obj) 
    { 
     IDictionary<string, object> result = new Dictionary<string, object>(); 
     PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj); 
     foreach (PropertyDescriptor property in properties) 
     { 
      result.Add(property.Name, property.GetValue(obj)); 
     } 
     return result; 
    } 
} 

您可以使用它喜欢：

new Dictionary<string, string>().ToDictionary(); 

Answer 3

没有循环，映射一个Dictionary{T, U}到Dictionary{T, object}在固定时间：

class DictionaryWrapper<T, U> : IDictionary<T, object> 
{ 
    readonly Dictionary<T, U> inner; 
    public DictionaryWrapper(Dictionary<T, U> wrapped) 
    { 
     this.inner = wrapped; 
    } 

    #region IDictionary<T,object> Members 

    public void Add(T key, object value) { inner.Add(key, (U)value); } 
    public bool ContainsKey(T key) { return inner.ContainsKey(key); } 
    public ICollection<T> Keys { get { return inner.Keys; } } 
    public bool Remove(T key) { return inner.Remove(key); } 

    public bool TryGetValue(T key, out object value) 
    { 
     U temp; 
     bool res = inner.TryGetValue(key, out temp); 
     value = temp; 
     return res; 
    } 

    public ICollection<object> Values { get { return inner.Values.Select(x => (object)x).ToArray(); } } 

    public object this[T key] 
    { 
     get { return inner[key]; } 
     set { inner[key] = (U)value; } 
    } 

    #endregion 

    #region ICollection<KeyValuePair<T,object>> Members 

    public void Add(KeyValuePair<T, object> item) { inner.Add(item.Key, (U)item.Value); } 
    public void Clear() { inner.Clear(); } 
    public bool Contains(KeyValuePair<T, object> item) { return inner.Contains(new KeyValuePair<T, U>(item.Key, (U)item.Value)); } 
    public void CopyTo(KeyValuePair<T, object>[] array, int arrayIndex) { throw new NotImplementedException(); } 
    public int Count { get { return inner.Count; } } 
    public bool IsReadOnly { get { return false; } } 
    public bool Remove(KeyValuePair<T, object> item) { return inner.Remove(item.Key); } 

    #endregion 

    #region IEnumerable<KeyValuePair<T,object>> Members 

    public IEnumerator<KeyValuePair<T, object>> GetEnumerator() 
    { 
     foreach (var item in inner) 
     { 
      yield return new KeyValuePair<T, object>(item.Key, item.Value); 
     } 
    } 

    #endregion 

    #region IEnumerable Members 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     foreach (var item in inner) 
     { 
      yield return new KeyValuePair<T, object>(item.Key, item.Value); 
     } 
    } 

    #endregion 
} 

多带几个通用的参数，可以你可以概括这类进一步使其一Dictionary{A, B}映射到Dictionary{C, D}。