Come trasmettere Oggetto al suo tipo effettivo?

Question

Se ho:

void MyMethod(Object obj) { ... } 

Come posso lanciare obj a ciò che il suo tipo effettivo è?

Answer 1

Se si conosce il tipo effettivo, poi basta:

SomeType typed = (SomeType)obj; 
typed.MyFunction(); 

Se non si conosce il tipo effettivo, quindi: non proprio, no. Si dovrebbe utilizzare invece uno dei:

• riflessione
• implementare un'interfaccia ben nota
• dinamica

Ad esempio:

// reflection 
obj.GetType().GetMethod("MyFunction").Invoke(obj, null); 

// interface 
IFoo foo = (IFoo)obj; // where SomeType : IFoo and IFoo declares MyFunction 
foo.MyFunction(); 

// dynamic 
dynamic d = obj; 
d.MyFunction(); 

Answer 2

Casting di tipo effettivo è facile:

void MyMethod(Object obj) { 
    ActualType actualyType = (ActualType)obj; 
} 

Answer 3

Non credo puoi (non senza riflettere), dovresti anche fornire un tipo alla tua funzione:

void MyMethod(Object obj, Type t) 
{ 
    var convertedObject = Convert.ChangeType(obj, t); 
    ... 
} 

UPD:

Questo può funzionare per voi:

void MyMethod(Object obj) 
{ 
    if (obj is A) 
    { 
     A a = obj as A; 
     ... 
    } 
    else if (obj is B) 
    { 
     B b = obj as B; 
     ... 
    } 
} 

Answer 4

Implement an interface to call your function in your method 
interface IMyInterface 
{ 
void MyinterfaceMethod(); 
} 

IMyInterface MyObj = obj as IMyInterface; 
if (MyObj != null) 
{ 
MyMethod(IMyInterface MyObj); 
} 

Answer 5

Se il metodo MyFunction() è definito solo in una classe (e le sue discendenti), provate

void MyMethod(Object obj) 
{ 
    var o = obj as MyClass; 
    if (o != null) 
     o.MyFunction(); 
} 

Se si dispone di un gran numero di classi non correlate definire la funzione che si desidera chiamare, si dovrebbe definire un'interfaccia e fare le vostre classi definiscono tale interfaccia:

interface IMyInterface 
{ 
    void MyFunction(); 
} 

void MyMethod(Object obj) 
{ 
    var o = obj as IMyInterface; 
    if (o != null) 
     o.MyFunction(); 
} 

Answer 6

Fusioni al suo tipo reale se ora il tipo per esempio è orientato dalla classe di nome abc. È possibile chiamare la funzione in questo modo:

(abc)(obj)).MyFunction(); 

se non si conosce la funzione può essere fatto in modo diverso. Non è sempre facile. Ma puoi trovarlo in qualche modo dalla sua firma. Se questo è il tuo caso, dovresti comunicarcelo.

Answer 7

Nel mio caso AutoMapper funziona bene.

automapper può mappare da/per gli oggetti dinamici senza alcuna configurazione esplicita:

public class Foo { 
    public int Bar { get; set; } 
    public int Baz { get; set; } 
} 
dynamic foo = new MyDynamicObject(); 
foo.Bar = 5; 
foo.Baz = 6; 

Mapper.Initialize(cfg => {}); 

var result = Mapper.Map<Foo>(foo); 
result.Bar.ShouldEqual(5); 
result.Baz.ShouldEqual(6); 

dynamic foo2 = Mapper.Map<MyDynamicObject>(result); 
foo2.Bar.ShouldEqual(5); 
foo2.Baz.ShouldEqual(6); 

Allo stesso modo è possibile mappare direttamente dalla dizionari di oggetti, automapper schiererà i tasti con i nomi di proprietà.

maggiori informazioni https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping