Se ho:
void MyMethod(Object obj) { ... }
Come posso eseguire il cast obj
su qual è il suo tipo effettivo?
obj.MyFunction();
non si compila, anche se so che l'oggetto reale ha quella funzione.
MyFunction
metodo?
Se ho:
void MyMethod(Object obj) { ... }
Come posso eseguire il cast obj
su qual è il suo tipo effettivo?
obj.MyFunction();
non si compila, anche se so che l'oggetto reale ha quella funzione.
MyFunction
metodo?
Risposte:
Se conosci il tipo effettivo, allora semplicemente:
SomeType typed = (SomeType)obj;
typed.MyFunction();
Se non conosci il tipo effettivo, allora: non proprio, no. Dovresti invece usare uno di:
Per 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();
as
per typecasting e type(of: ClassName)
funzione per controllare il tipo di istanza.
Non penso che tu possa (non senza riflessione), dovresti fornire anche un tipo alla tua funzione:
void MyMethod(Object obj, Type t)
{
var convertedObject = Convert.ChangeType(obj, t);
...
}
UPD :
Questo potrebbe funzionare per te:
void MyMethod(Object obj)
{
if (obj is A)
{
A a = obj as A;
...
}
else if (obj is B)
{
B b = obj as B;
...
}
}
Che ne dici di JsonConvert.DeserializeObject (object.ToString ());
var myType = JsonConvert.DeserializeObject<MyType>(object.ToString());
Nel mio caso AutoMapper funziona bene.
AutoMapper può eseguire il mapping a / da 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 puoi mappare direttamente dai dizionari agli oggetti, AutoMapper allineerà le chiavi con i nomi delle proprietà.
maggiori informazioni https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping
Questo metodo potrebbe non essere il più efficiente ma è semplice e fa il lavoro.
Esegue due operazioni: in primo luogo chiama .ToString () che è fondamentalmente una serializzazione, e poi la deserializzazione utilizzando Newtonsoft nuget (che devi installare).
public T Format<T>(Object obj) =>
JsonConvert.DeserializeObject<T>(obj.ToString());
Se il tuo MyFunction()
metodo è definito solo in una classe (e nei suoi discendenti), prova
void MyMethod(Object obj)
{
var o = obj as MyClass;
if (o != null)
o.MyFunction();
}
Se hai un numero elevato di classi non correlate che definiscono la funzione che desideri chiamare, dovresti definire un'interfaccia e fare in modo che le tue classi definiscano quell'interfaccia:
interface IMyInterface
{
void MyFunction();
}
void MyMethod(Object obj)
{
var o = obj as IMyInterface;
if (o != null)
o.MyFunction();
}
Trasmettilo al suo tipo reale se ora il tipo ad esempio è orientato dalla classe chiamata abc. Puoi chiamare la tua funzione in questo modo:
(abc)(obj)).MyFunction();
se non conosci la funzione puoi farlo in modo diverso. Non sempre facile. Ma puoi trovarlo in qualche modo dalla sua firma. Se questo è il tuo caso, dovresti farcelo sapere.
Trasmettere al tipo reale è facile:
void MyMethod(Object obj) {
ActualType actualyType = (ActualType)obj;
}
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 );
}