it-swarm.com.de

Wie gibst du den Objekttyp aus?

Wenn ich habe:

void MyMethod(Object obj) {   ...   }

Wie kann ich obj in den tatsächlichen Typ umwandeln?

87
Paul Lassiter

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 verwenden:

  • reflexion
  • implementierung einer bekannten Schnittstelle
  • dynamisch

Zum Beispiel:

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

Ich glaube nicht, dass Sie (nicht ohne Nachdenken) können, Sie sollten Ihrer Funktion auch einen Typ zuweisen:

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

UPD:

Das 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;
        ...
    }
}
34
Maksim Vi.

Die Umstellung auf den tatsächlichen Typ ist einfach:

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

In meinem Fall funktioniert AutoMapper gut.

AutoMapper kann dynamischen Objekten ohne explizite Konfiguration zuordnen:

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

Auf ähnliche Weise können Sie direkt von Wörterbüchern zu Objekten zuordnen. AutoMapper ordnet die Schlüssel mit den Eigenschaftennamen an.

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

0
Soren

Wenn Sie jetzt den Typ aus der Klasse mit dem Namen abc ..__ ausrichten, können Sie ihn in seinen echten Typ umwandeln. Sie können Ihre Funktion folgendermaßen aufrufen:

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

wenn Sie die Funktion nicht kennen, kann sie auf andere Weise ausgeführt werden. Nicht immer einfach. Sie können es aber irgendwie anhand seiner Signatur finden. Wenn dies Ihr Fall ist, sollten Sie uns Bescheid geben.

0
Masoud

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 von nicht verknüpften Klassen definieren, die die aufzurufende Funktion definieren, 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();
}
0
devio