Activateur.CreateInstance() troubles

J'ai une usine qui est censé créer des objets qui héritent de la classe Foo au moment de l'exécution. Je pense que ce Système.Activateur.CreateInstance type de retour est le même que le type d'un objet qu'il crée, mais à en juger par le message d'erreur suivant, son type de retour est l'Objet.

Erreur 1 Impossible de convertir implicitement le type 'object' à 'cs_sandbox.Foo'. Une conversion explicite existe (vous manque un plâtre?) F:\projects\cs_sandbox\Form1.cs 46 24 cs_sandbox

OK, alors peut-être je suis manquant d'un plâtre, mais

return (t)System.Activator.CreateInstance(t);

résultats dans un autre message d'erreur, qui, je dois l'avouer, -- n'a pas de sens pour moi:

Erreur 1 le type ou Le nom d'espace de noms 't' n'a pas pu être trouvée (vous manque une directive using ou une référence d'assembly?) F:\projects\cs_sandbox\Form1.cs 45 25 cs_sandbox

Et voici mon code:

class Foo { }
class FooChild1 : Foo { }
class FooChild2 : Foo { }

class MyFactory
{
    public static Foo CreateInstance(string s)
    {
        Type t;
        if (s.StartsWith("abcdef"))
        {
            t = typeof(FooChild1);
            return System.Activator.CreateInstance(t);
        }
        else
        {
            t = typeof(FooChild2);
            return System.Activator.CreateInstance(t);
        }
    }
}

Comment puis-je corriger ce code? Ou, si elle n'est pas réparable, ce sont d'autres façons de créer des objets qui héritent d'une classe spécifique au moment de l'exécution?

Tu veux dire Bar et Meh hériter de Foo?
Désolé! Correction du code.

OriginalL'auteur MiseryIndex | 2009-09-27

activator c#class instantiation

11

Vous avez besoin de convertir l'objet retourné Foo type. Il n'est pas judicieux de le jeter à un type défini dans une variable. Il doit être connu par le compilateur, comme le point de l'ensemble du casting à travers la hiérarchie d'héritage est satisfaisant compilateur de vérifier le type statique.
```
return (Foo)System.Activator.CreateInstance(t);
```
Il y a une version générique, System.Activator.CreateInstance<T>, ce qui crée un type connu (pas une variable mais un type d'un argument ou d'une manière statique de type connu, dans ce dernier cas, il n'a pas beaucoup de sens si):
```
return System.Activator.CreateInstance<FooChild1>();
```
OriginalL'auteur Mehrdad Afshari

J'ai eu à utiliser pour UnWrap() la méthode après l'activation, comme décrit sur le site MSDN:

//Creates an instance of MyType defined in the assembly called ObjectHandleAssembly.
ObjectHandle obj = domain.CreateInstance("ObjectHandleAssembly", "MyType");

//Unwrapps the proxy to the MyType object created in the other AppDomain.
MyType testObj = (MyType)obj.Unwrap();

Comme décrit sur MSDN. En outre, j'ai dû utiliser des paramètres comme ceci:

    ObjectHandle obj = domain.CreateInstance("Other.Assembly.Name", "Full.Class.Namespace.ClassName");

OriginalL'auteur Jochen van Wylick

1

Après avoir changé le code

Jeter vos résultats à Foo comme
```
return System.Activator.CreateInstance(t) as Foo;
```
ou
```
return (Foo)System.Activator.CreateInstance(t);
```
Le premier est un peu plus robuste, car vous n'obtiendrez pas une exception en cas de fonte n'est pas possible. Il suffit de retourner null. Mais cela dépend de ce que vous voulez.

Avant d'avoir modifié le code

~~Avez-vous essayé les génériques?~~
```
public static OutType CreateInstance<OutType>(string s)
{
    Type t;
    if (s.StartsWith("abcdef"))
    {
        t = typeof(Bar);
        return System.Activator.CreateInstance(t) as OutType;
    }
    else
    {
        t = typeof(Meh);
        return System.Activator.CreateInstance(t) as OutType;
    }
}
```
Mais vous avez un problème. Dans votre méthode statique que vous essayez de revenir Bar et Meh qui ne sont pas liées à la Foo en aucune façon. Ce sera toujours une exception à moins que votre méthode retourne un objet ou d'un ancêtre commun type (comme dans le casting).

~~Pour contrôler encore plus interne de types, vous pouvez définir plus d'un type générique que votre méthode utiliser en interne.~~

OriginalL'auteur Robert Koritnik
0

Je pense que vous devriez faire ceci:
```
public static Foo CreateInstance(string objectIdentifer)
{
   if (objectIdentifier == "Child1")
   {
      return (Foo)Activator.CreateInstance("Foo.FooChild1, FooChild1");
   }
   else
   {
      return (Foo)Activator.CreateInstance("Foo.FooChild1, FooChild2");
   }
}
```
Mon point est que dans ce code, la méthode CreateInstance a pas de référence directe à l'assemblée ou des assemblées contenant FooChild1 et FooChild2. Dans le code original, vous créez un type de nommer explicitement FooChild1 et FooChild2, de sorte que vous pourriez aussi bien à la nouvelle, au lieu de s'activer.

Cela fait-il sens pour vous?

OriginalL'auteur IanT8

Je pense que la bonne est:

public static Foo CreateInstance(string objectIdentifer)
{
   if (objectIdentifier == "Child1")
   {
      return (Foo)Activator.CreateInstance(Type.GetType("Foo.FooChild1, FooChild1"));
   }
   else
   {
      return (Foo)Activator.CreateInstance(Type.GetType("Foo.FooChild1, FooChild2"));
   }
}

Espoir qui peut vous aider à

OriginalL'auteur Quang Thuan

0

Peut-être un peu tard, mais si je ne connais pas le type (dans le cas où vous construisez votre propre codeparser) - je utiliser Convertir.ChangeType
```
  string original = "1";
  object value;
  value = Convert.ChangeType(original, typeof(int));
```
typeof(int) peut être n'importe quel type de vous ne savez pas par l'utilisation de l'objet.GetType();

OriginalL'auteur Silvermind

Vous devez vous connecter pour publier un commentaire.

Après avoir changé le code

Avant d'avoir modifié le code