Esiste un modo rapido ed elegante per mappare un oggetto su un dizionario e viceversa?
IDictionary<string,object> a = new Dictionary<string,object>();
a["Id"]=1;
a["Name"]="Ahmad";
// .....
diventa
SomeClass b = new SomeClass();
b.Id=1;
b.Name="Ahmad";
// ..........
Risposte:
Usando un po 'di riflessione e generici in due metodi di estensione puoi farlo.
Giusto, altri hanno fatto per lo più la stessa soluzione, ma questo utilizza meno riflessione che è più saggio in termini di prestazioni e molto più leggibile:
public static class ObjectExtensions
{
public static T ToObject<T>(this IDictionary<string, object> source)
where T : class, new()
{
var someObject = new T();
var someObjectType = someObject.GetType();
foreach (var item in source)
{
someObjectType
.GetProperty(item.Key)
.SetValue(someObject, item.Value, null);
}
return someObject;
}
public static IDictionary<string, object> AsDictionary(this object source, BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
{
return source.GetType().GetProperties(bindingAttr).ToDictionary
(
propInfo => propInfo.Name,
propInfo => propInfo.GetValue(source, null)
);
}
}
class A
{
public string Prop1
{
get;
set;
}
public int Prop2
{
get;
set;
}
}
class Program
{
static void Main(string[] args)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
dictionary.Add("Prop1", "hello world!");
dictionary.Add("Prop2", 3893);
A someObject = dictionary.ToObject<A>();
IDictionary<string, object> objectBackToDictionary = someObject.AsDictionary();
}
}
GetType()non sia più richiamato someObjectper ogni proprietà nel primo metodo.
Converti prima il dizionario in stringa JSON con Newtonsoft.
var json = JsonConvert.SerializeObject(advancedSettingsDictionary, Newtonsoft.Json.Formatting.Indented);
Quindi deserializza la stringa JSON nel tuo oggetto
var myobject = JsonConvert.DeserializeObject<AOCAdvancedSettings>(json);
Sembra che la riflessione aiuti solo qui .. Ho fatto un piccolo esempio di conversione di oggetti in dizionario e viceversa:
[TestMethod]
public void DictionaryTest()
{
var item = new SomeCLass { Id = "1", Name = "name1" };
IDictionary<string, object> dict = ObjectToDictionary<SomeCLass>(item);
var obj = ObjectFromDictionary<SomeCLass>(dict);
}
private T ObjectFromDictionary<T>(IDictionary<string, object> dict)
where T : class
{
Type type = typeof(T);
T result = (T)Activator.CreateInstance(type);
foreach (var item in dict)
{
type.GetProperty(item.Key).SetValue(result, item.Value, null);
}
return result;
}
private IDictionary<string, object> ObjectToDictionary<T>(T item)
where T: class
{
Type myObjectType = item.GetType();
IDictionary<string, object> dict = new Dictionary<string, object>();
var indexer = new object[0];
PropertyInfo[] properties = myObjectType.GetProperties();
foreach (var info in properties)
{
var value = info.GetValue(item, indexer);
dict.Add(info.Name, value);
}
return dict;
}
Consiglio vivamente il Castle DictionaryAdapter , facilmente uno dei segreti meglio custoditi di quel progetto. Devi solo definire un'interfaccia con le proprietà che desideri e in una riga di codice l'adattatore genererà un'implementazione, la istanzerà e sincronizzerà i suoi valori con un dizionario che passi. Lo uso per digitare fortemente le mie AppSettings in un progetto web:
var appSettings =
new DictionaryAdapterFactory().GetAdapter<IAppSettings>(ConfigurationManager.AppSettings);
Si noti che non era necessario creare una classe che implementasse IAppSettings: l'adattatore lo fa al volo. Inoltre, sebbene in questo caso sto solo leggendo, in teoria se stessi impostando i valori delle proprietà su appSettings, l'adattatore manterrebbe il dizionario sottostante sincronizzato con tali modifiche.
La riflessione può portarti da un oggetto a un dizionario iterando sulle proprietà.
Per andare dall'altra parte, dovrai usare un ExpandoObject dinamico (che, in effetti, eredita già da IDictionary, e quindi lo ha fatto per te) in C #, a meno che tu non possa dedurre il tipo dalla raccolta di voci nel dizionario in qualche modo.
Quindi, se sei in .NET 4.0, usa un ExpandoObject, altrimenti hai molto lavoro da fare ...
Penso che dovresti usare la riflessione. Qualcosa come questo:
private T ConvertDictionaryTo<T>(IDictionary<string, object> dictionary) where T : new()
{
Type type = typeof (T);
T ret = new T();
foreach (var keyValue in dictionary)
{
type.GetProperty(keyValue.Key).SetValue(ret, keyValue.Value, null);
}
return ret;
}
Prende il dizionario e lo scorre e imposta i valori. Dovresti migliorarlo, ma è un inizio. Dovresti chiamarlo così:
SomeClass someClass = ConvertDictionaryTo<SomeClass>(a);
public class SimpleObjectDictionaryMapper<TObject>
{
public static TObject GetObject(IDictionary<string, object> d)
{
PropertyInfo[] props = typeof(TObject).GetProperties();
TObject res = Activator.CreateInstance<TObject>();
for (int i = 0; i < props.Length; i++)
{
if (props[i].CanWrite && d.ContainsKey(props[i].Name))
{
props[i].SetValue(res, d[props[i].Name], null);
}
}
return res;
}
public static IDictionary<string, object> GetDictionary(TObject o)
{
IDictionary<string, object> res = new Dictionary<string, object>();
PropertyInfo[] props = typeof(TObject).GetProperties();
for (int i = 0; i < props.Length; i++)
{
if (props[i].CanRead)
{
res.Add(props[i].Name, props[i].GetValue(o, null));
}
}
return res;
}
}
Basandosi sulla risposta di Matías Fidemraizer, ecco una versione che supporta l'associazione a proprietà degli oggetti diverse dalle stringhe.
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace WebOpsApi.Shared.Helpers
{
public static class MappingExtension
{
public static T ToObject<T>(this IDictionary<string, object> source)
where T : class, new()
{
var someObject = new T();
var someObjectType = someObject.GetType();
foreach (var item in source)
{
var key = char.ToUpper(item.Key[0]) + item.Key.Substring(1);
var targetProperty = someObjectType.GetProperty(key);
if (targetProperty.PropertyType == typeof (string))
{
targetProperty.SetValue(someObject, item.Value);
}
else
{
var parseMethod = targetProperty.PropertyType.GetMethod("TryParse",
BindingFlags.Public | BindingFlags.Static, null,
new[] {typeof (string), targetProperty.PropertyType.MakeByRefType()}, null);
if (parseMethod != null)
{
var parameters = new[] { item.Value, null };
var success = (bool)parseMethod.Invoke(null, parameters);
if (success)
{
targetProperty.SetValue(someObject, parameters[1]);
}
}
}
}
return someObject;
}
public static IDictionary<string, object> AsDictionary(this object source, BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
{
return source.GetType().GetProperties(bindingAttr).ToDictionary
(
propInfo => propInfo.Name,
propInfo => propInfo.GetValue(source, null)
);
}
}
}
Se stai usando Asp.Net MVC, dai un'occhiata a:
public static RouteValueDictionary AnonymousObjectToHtmlAttributes(object htmlAttributes);
che è un metodo pubblico statico nella classe System.Web.Mvc.HtmlHelper.
public Dictionary<string, object> ToDictionary<T>(string key, T value)
{
try
{
var payload = new Dictionary<string, object>
{
{ key, value }
};
} catch (Exception e)
{
return null;
}
}
public T FromDictionary<T>(Dictionary<string, object> payload, string key)
{
try
{
JObject jObject = (JObject) payload[key];
T t = jObject.ToObject<T>();
return (t);
}
catch(Exception e) {
return default(T);
}
}