Comment convertir un objet dans son type réel?

Si j'ai:

void MyMethod(Object obj) {   ...   }

Comment puis-je convertir objce type de contenu?

Si vous connaissez le type réel, alors juste:

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

Si vous ne connaissez pas le type réel, alors: pas vraiment, non. Vous devrez à la place utiliser l'un des éléments suivants:

• réflexion
• implémenter une interface bien connue
• dynamique

Par exemple:

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

Je ne pense pas que vous puissiez (non sans réflexion), vous devriez également fournir un type à votre fonction:

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

UPD :

Cela peut fonctionner pour vous:

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

Que diriez-vous de JsonConvert.DeserializeObject (object.ToString ());

Dans mon cas, AutoMapper fonctionne bien.

AutoMapper peut mapper vers / depuis des objets dynamiques sans aucune configuration explicite:

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 même, vous pouvez mapper directement des dictionnaires aux objets, AutoMapper alignera les clés avec les noms de propriété.

plus d'infos https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping

Cette méthode n'est peut-être pas la plus efficace, mais elle est simple et fait le travail.

Il effectue deux opérations: d'abord il appelle .ToString () qui est fondamentalement une sérialisation, puis la désérialisation à l'aide de Newtonsoft nuget (que vous devez installer).

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

Si votre MyFunction()méthode est définie uniquement dans une classe (et ses descendants), essayez

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

Si vous avez un grand nombre de classes non liées définissant la fonction que vous souhaitez appeler, vous devez définir une interface et faire en sorte que vos classes définissent cette interface:

interface IMyInterface
{
    void MyFunction();
}

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

Transformez-le en son type réel si vous maintenant le type, par exemple, il est orienté à partir de la classe nommée abc. Vous pouvez appeler votre fonction de cette manière:

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

si vous ne connaissez pas la fonction, cela peut être fait d'une manière différente. Pas toujours facile. Mais vous pouvez le trouver d'une certaine manière par sa signature. Si tel est votre cas, vous devez nous le faire savoir.

La diffusion au type réel est 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 );
}