¿Cómo convertir un objeto a su tipo real?

Si tengo:

void MyMethod(Object obj) {   ...   }

¿Cómo puedo convertir obja cuál es su tipo real?

Si conoce el tipo real, simplemente:

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

Si no conoce el tipo real, entonces: no realmente, no. En su lugar, tendría que usar uno de:

• reflexión
• implementando una interfaz conocida
• dinámica

Por ejemplo:

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

No creo que pueda (no sin reflexión), también debe proporcionar un tipo a su función:

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

UPD :

Esto puede funcionar para usted:

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

¿Qué tal JsonConvert.DeserializeObject (object.ToString ());

En mi caso, AutoMapper funciona bien.

AutoMapper puede mapear hacia / desde objetos dinámicos sin ninguna configuración explícita:

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

De manera similar, puede mapear directamente desde diccionarios a objetos, AutoMapper alineará las claves con los nombres de las propiedades.

más información https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping

Puede que este método no sea el más eficaz, pero es sencillo y funciona.

Realiza dos operaciones: primero llama a .ToString () que es básicamente una serialización, y luego la deserialización usando Newtonsoft nuget (que debe instalar).

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

Si su MyFunction()método está definido solo en una clase (y sus descendientes), intente

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

Si tiene una gran cantidad de clases no relacionadas que definen la función que desea llamar, debe definir una interfaz y hacer que sus clases definan esa interfaz:

interface IMyInterface
{
    void MyFunction();
}

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

Conviértalo a su tipo real si ahora el tipo, por ejemplo, está orientado desde la clase llamada abc. Puede llamar a su función de esta manera:

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

si no conoce la función, se puede hacer de otra manera. No siempre es fácil. Pero puedes encontrarlo de alguna manera por su firma. Si este es tu caso, háznoslo saber.

Transmitir al tipo real es fácil:

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