¿Cuál es la forma más sencilla de convertir un Diccionario <cadena, cadena> a un Diccionario <cadena, objeto>?

Question

Estoy usando una API que devuelve una colección de clave-valor como Dictionary<string, string>. Necesito convertir eso a un Dictionary<string, object>. Tengo la sensación de que debería haber una manera de hacer esta conversión/mapeo sin hacer un ciclo "manual" a través de cada par de clave-valor, pero Google o la referencia del objeto C# no dieron inmediatamente una solución.

Answer 1

Pruebe lo siguiente

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

Answer 2

Puede utilizar este método de extensión:

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; 
    } 
} 

Usted usarlo como:

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

Answer 3

sin loop, asigna un Dictionary{T, U} a Dictionary{T, object} en tiempo constante:

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 
} 

Con algunos parametros más generales, se puede generalizar esta clase adicional para que se asigna un Dictionary{A, B} a un Dictionary{C, D}.