Dynamique coulé en utilisant le Type de l'objet C#

J'ai une classe abstraite nommée, et d'autres classes B, C, D, E, ...) qui implémente Une

J'ai aussi une liste d'objets.

J'aimerais être en mesure de lancer dynamicly chaque objet dans cette liste à leur "base" de type (c'est à dire B, C, D, ...) pour être en mesure d'appeler leur constructeur dans une autre méthode.

Voici ce que j'ai fait pour l'instant :

abstract class A { }
class B : A { }
class C : A { }
class D : A { }
class E : A { }
//... 

class Program
{
    static void Main(string[] args)
    {
        List<A> list = new List<A> { new B(), new C(), new D(), new E() };
        //...

        foreach (A item in list)
        {
            A obj  = foo(item);
        }
    }

    public static A foo(A obj)
    {
        if (obj.GetType() == typeof(B))
        {
            return bar((B)obj);
        }
        else if (obj.GetType() == typeof(C))
        {
            return bar((C)obj);
        }
        //... same for D, E, ...
        return null;
    }

    public static T bar<T>(T obj) where T : class, new()
    {
        //To use the constructor, I can't have here an abstract class.
        T newObj = new T();
        return newObj;
    }

Il fonctionne, mais j'aimerais trouver une autre manière, mais à tester pour chaque classe qui implémente Une si leur type est égal au type de mon objet, et de le jeter par la suite.

J'ai près de 15 classes B, C, D, ... et je pourrais en avoir plus.
Afin d'avoir quelque chose de simple, clair et facile à gérer, j'aimerais éviter cela, des méthodes, et des 15+ "si(...) d'autre(...)".

Voyez-vous un moyen de le faire ?

Ce que vous essayez d'atteindre ici? Avez-vous envisager de définir une méthode abstraite dans Un et leur remplaçant, dans les sous-classes. Ainsi, au lieu de constructeurs, vous pouvez appeler des méthodes de remplacement dans une classe individuelle.

OriginalL'auteur Sharpac | 2013-01-14

  1. 9

    Modifier bar de cette façon:

    public static T bar<T>(T obj) where T : class
{
    var type = obj.GetType();
    return Activator.CreateInstance(type) as T;
}

    Ensuite modifier foo:

    public static A foo(A obj)
{
    return bar(obj);
}

    Noter que j'ai dû enlever le new() contrainte. Ce qui devait être fait pour éviter de jeter votre obj à l'intérieur de foo. Vous pouvez le vérifier lors de l'exécution si le type a un constructeur sans paramètre.

    Grand merci beaucoup pour votre réponse rapide. Il fonctionne parfaitement !
    Ce n'est pas en faisant usage de la classe abstraite ou génériques. Pas de sécurité de type
    La sécurité peut être atteint par le biais d'une Réflexion complémentaire vérifie dans le bar méthode. Il est de sa responsabilité de les écrire. Je crois qu'il n'y a pas d'autres moyens, compte tenu de l'auteur.
    Je suis d'accord c'est le meilleur moyen que nous pouvons faire à partir des informations qu'il a donné. Mais j'ai l'impression qu'il a écrit un peu de logique à l'intérieur de la ctors et essaie de faire en sorte que la logique est appelée pour chaque type. C'est certainement un anti-modèle. abstrait, virtuel et de substitution sont pour le même but.

    OriginalL'auteur Mir