Wie kann man das Objekt auf seinen tatsächlichen Typ umwandeln?

Wenn ich habe:

void MyMethod(Object obj) {   ...   }

Wie kann ich objauf den tatsächlichen Typ umstellen?

Wenn Sie den tatsächlichen Typ kennen, dann einfach:

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

Wenn Sie den tatsächlichen Typ nicht kennen, dann: nicht wirklich, nein. Sie müssten stattdessen eines der folgenden Elemente verwenden:

• Reflexion
• Implementierung einer bekannten Schnittstelle
• dynamisch

Beispielsweise:

// 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();

Ich denke nicht, dass Sie dies können (nicht ohne Reflexion), Sie sollten auch einen Typ für Ihre Funktion angeben:

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

UPD :

Dies kann für Sie funktionieren:

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

Wie wäre es mit JsonConvert.DeserializeObject (object.ToString ());

In meinem Fall funktioniert AutoMapper gut.

AutoMapper kann dynamischen Objekten ohne explizite Konfiguration zugeordnet werden:

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

Ebenso können Sie Objekte direkt von Wörterbüchern zuordnen. AutoMapper richtet die Schlüssel mit Eigenschaftsnamen aus.

Weitere Informationen https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping

Wenn Ihre MyFunction()Methode nur in einer Klasse (und ihren Nachkommen) definiert ist, versuchen Sie es

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

Wenn Sie eine große Anzahl in nicht verwandten Klassen haben, die die Funktion definieren, die Sie aufrufen möchten, sollten Sie eine Schnittstelle definieren und Ihre Klassen diese Schnittstelle definieren lassen:

interface IMyInterface
{
    void MyFunction();
}

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

Wandeln Sie es in seinen realen Typ um, wenn Sie jetzt den Typ verwenden, der sich beispielsweise an der Klasse abc orientiert. Sie können Ihre Funktion folgendermaßen aufrufen:

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

Wenn Sie die Funktion nicht kennen, können Sie sie auf andere Weise ausführen. Nicht immer einfach. Aber Sie können es irgendwie durch seine Unterschrift finden. Wenn dies Ihr Fall ist, sollten Sie uns dies mitteilen.

Diese Methode ist möglicherweise nicht die effizienteste, aber einfach und erledigt die Aufgabe.

Es führt zwei Operationen aus: Erstens ruft es .ToString () auf, das im Grunde eine Serialisierung ist, und dann die Deserialisierung mit Newtonsoft Nuget (das Sie installieren müssen ).

public T Format<T>(Object obj) =>
    JsonConvert.DeserializeObject<T>(obj.ToString());

Das Casting auf den tatsächlichen Typ ist einfach:

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