Passaggio di un contesto contenente proprietà a un TypeConverter

Question

Sto cercando un modo per passare informazioni aggiuntive a TypeConverter per fornire un contesto per le conversioni senza creare un costruttore personalizzato.

Le informazioni aggiuntive passate sarebbero oggetto originale (noto al momento della compilazione come interfaccia) che contiene la proprietà che sto convertendo. Contiene proprietà come Id che sono utili per le ricerche per convertire le informazioni correlate.

Ho dato un'occhiata alla documentazione di ITypeDescriptorContext ma non ho trovato un chiaro esempio di come implementare quell'interfaccia. Non sono nemmeno convinto che sia lo strumento di cui ho bisogno.

Al momento, nel mio codice Chiamo:

// For each writeable property in my output class. 

// If property has TypeConverterAttribute 
var converted = converter.ConvertFrom(propertyFromOriginalObject) 

propertyInfo.SetValue(output, converted, null); 

Quello che mi piacerebbe fare è qualcosa di simile.

// Original object is an interface at compile time. 
var mayNewValue = converter.ConvertFrom(originalObject, propertyFromOriginalObject) 

mi piacerebbe essere in grado di utilizzare uno dei sovraccarichi di fare quello che mi serve in modo che eventuali convertitori personalizzati possono ereditare da TypeConverter piuttosto che una classe base con un costruttore personalizzato come che avrebbe reso la vita più facile con dipendenza da iniezione e utilizzare DependencyResolver.Current.GetService(type) da MVC per inizializzare il mio convertitore.

Qualche idea?

Answer 1

Il metodo che si desidera utilizzare è chiaramente questo sovraccarico: TypeConverter.ConvertFrom Method (ITypeDescriptorContext, CultureInfo, Object)

che vi permetterà di passare un contesto piuttosto generica. La proprietà Instance rappresenta l'istanza dell'oggetto su cui si sta lavorando e la proprietà PropertyDescriptor rappresenta la definizione della proprietà del valore della proprietà da convertire.

Ad esempio, la griglia delle proprietà di Winforms fa esattamente questo.

Quindi, dovrai fornire il tuo contesto. Ecco un esempio uno:

public class MyContext : ITypeDescriptorContext 
{ 
    public MyContext(object instance, string propertyName) 
    { 
     Instance = instance; 
     PropertyDescriptor = TypeDescriptor.GetProperties(instance)[propertyName]; 
    } 

    public object Instance { get; private set; } 
    public PropertyDescriptor PropertyDescriptor { get; private set; } 
    public IContainer Container { get; private set; } 

    public void OnComponentChanged() 
    { 
    } 

    public bool OnComponentChanging() 
    { 
     return true; 
    } 

    public object GetService(Type serviceType) 
    { 
     return null; 
    } 
} 

Quindi, consideriamo un convertitore personalizzato, come si vede può afferrare valore della proprietà dell'oggetto esistente utilizzando una riga di codice (notare che questo codice è compatibile con lo standard ITypeDescriptorContext esistente come la proprietà griglia di uno, anche se in scenari di vita reale, è necessario verificare il contesto di nullità):

public class MyTypeConverter : TypeConverter 
{ 
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) 
    { 
     // get existing value 
     object existingPropertyValue = context.PropertyDescriptor.GetValue(context.Instance); 

     // do something useful here 
     ... 
    } 
} 

Ora, se si dispone di questo oggetto personalizzato venga modificato:

public class MySampleObject 
{ 
    public MySampleObject() 
    { 
     MySampleProp = "hello world"; 
    } 

    public string MySampleProp { get; set; } 
} 

È possibile chiamare il convertitore in questo modo:

MyTypeConverter tc = new MyTypeConverter(); 
object newValue = tc.ConvertFrom(new MyContext(new MySampleObject(), "MySampleProp"), null, "whatever");