Bagaimana cara mentransmisikan Object ke tipe aslinya?

Jika saya memiliki:

void MyMethod(Object obj) {   ...   }

Bagaimana cara mentransmisikan objke tipe sebenarnya?

Jika Anda tahu tipe sebenarnya, maka:

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

Jika Anda tidak tahu tipe sebenarnya, maka: tidak juga, tidak. Anda harus menggunakan salah satu dari:

• refleksi
• menerapkan antarmuka terkenal
• dinamis

Sebagai contoh:

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

Saya rasa Anda tidak bisa (bukan tanpa refleksi), Anda harus memberikan tipe untuk fungsi Anda juga:

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

UPD :

Ini mungkin berhasil untuk Anda:

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

Bagaimana dengan JsonConvert.DeserializeObject (object.ToString ());

Dalam kasus saya, AutoMapper berfungsi dengan baik.

AutoMapper dapat memetakan ke / dari objek dinamis tanpa konfigurasi eksplisit apa pun:

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

Demikian pula Anda dapat memetakan langsung dari kamus ke objek, AutoMapper akan membariskan kunci dengan nama properti.

info lebih lanjut https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping

Metode ini mungkin bukan yang paling efisien tetapi sederhana dan berhasil.

Ini melakukan dua operasi: pertama memanggil .ToString () yang pada dasarnya adalah serialisasi, dan kemudian deserialisasi menggunakan Newtonsoft nuget (yang harus Anda instal).

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

Jika MyFunction()metode Anda hanya ditentukan dalam satu kelas (dan turunannya), coba

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

Jika Anda memiliki jumlah besar di kelas yang tidak terkait yang mendefinisikan fungsi yang ingin Anda panggil, Anda harus menentukan antarmuka dan membuat kelas Anda menentukan antarmuka itu:

interface IMyInterface
{
    void MyFunction();
}

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

Transmisikan ke tipe aslinya jika Anda sekarang tipe, misalnya berorientasi dari kelas bernama abc. Anda dapat memanggil fungsi Anda dengan cara ini:

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

jika Anda tidak tahu fungsinya, itu bisa dilakukan dengan cara yang berbeda. Tidak selalu mudah. Tetapi Anda dapat menemukannya dengan beberapa cara melalui tanda tangannya. Jika ini kasus Anda, beri tahu kami.

Mentransmisi ke tipe sebenarnya itu mudah:

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