Comment créer une nouvelle instance de l'objet à partir d'un Type de

On ne peut pas toujours savoir la Type d'un objet au moment de la compilation, mais peuvent avoir besoin de créer une instance de la Type. Comment voulez-vous obtenir une nouvelle instance de l'objet à partir d'un Type?

InformationsquelleAutor tags2k | 2008-08-03
  1. 815

    La Activator classe à l'intérieur de la racine System espace de noms est assez puissant.

    Il y a beaucoup de surcharges pour passer des paramètres au constructeur et à de telles. Consultez la documentation sur:

    http://msdn.microsoft.com/en-us/library/system.activator.createinstance.aspx

    ou (nouvelle voie)

    https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance

    Voici quelques exemples simples:

    ObjectType instance = (ObjectType)Activator.CreateInstance(objectType);

ObjectType instance = (ObjectType)Activator.CreateInstance("MyAssembly","MyNamespace.ObjectType");
    • Heureux d'avoir enfin trouvé ceci, mais la deuxième appel n'est pas exactement droit, manquant un devis et parms inversé, devrait être: ObjectType instance = (ObjectType)Activateur.CreateInstance("MyAssembly","MyNamespace.ObjectType");
    • Vous avez besoin d'appeler " Unwrap()' pour obtenir le type réel de l'objet que vous souhaitez: ConcreteType instance = (ConcreteType)Activateur.CreateInstance(objectType).Unwrap();
    • Comment ObjectType instance match de l'OP de l'état "On ne peut pas toujours connaître le type d'un objet au moment de la compilation" ? 😛
    • bon alors, object instance = Activator.CreateInstance(...);.
    • Quelqu'un sait comment faire cela dans .NET de Base? La méthode Unwrap n'est pas disponible sur l'objet.
    • Oui, ajouter la question et je vais y répondre

    InformationsquelleAutor Karl Seguin
  2. 130
    ObjectType instance = (ObjectType)Activator.CreateInstance(objectType);

    La Activator classe a un générique variante qui le rend un peu plus facile:

    ObjectType instance = Activator.CreateInstance<ObjectType>();
    • Sauf que ça ne fonctionne pas pour l'exécution Type t.
    • Bien sûr. Une telle opération vous ne pouvez pas travailler dans un langage statiquement typé, car il ne fait pas de sens. Vous ne pouvez pas appeler des méthodes sur un objet de type inconnu. Dans l'intervalle (= depuis la rédaction de cette réponse) C# a obtenu le dynamic construire qui t autoriser de telles constructions, mais pour la plupart des fins, la réponse encore le couvre.
    • Pas tout à fait vrai. Première de c# t vous permettent de créer de nouveaux types à l'exécution. Vous ne pouvez pas appeler à rien statiquement moyen sûr. Donc oui, vous êtes à moitié correct. Mais de manière plus réaliste, vous avez besoin de cette lorsque vous chargez des assemblées au moment de l'exécution, ce qui signifie que le type n'est pas connu au moment de la compilation. C# sera très limité si vous ne pouvait pas le faire. Je veux dire que vous venez de prouver par vous-même, comment d'autre ne l'Activateur méthode qui prend un type d'une instance de travail? Quand MS a écrit la classe Activator ils n'avaient pas au moment de la compilation de connaissances des futurs types d'utilisateurs de l'écriture.
    • Mon commentaire ne dit rien sur la création de types à l'exécution. Bien sûr, vous pouvez le faire, mais vous ne pouvez pas les utiliser statique dans le même contexte (vous pouvez héberger un plein compilé statiquement programme de cours). C'est tout mon commentaire, c'est dire.
    • Ah désolé, mal interprété "une telle opération" le sens de l'instanciation d'un type qui est connu au moment de l'exécution; au lieu de la signification à l'aide d'un runtime type comme un paramètre de type générique.
    • techniquement, vous pouvez créer de nouveaux types à l'exécution ET appeler des méthodes sur eux statiquement moyen sûr si votre nouveau type implémente une interface connue ou hérite d'un connu de la classe de base. -- L'une de ces approches permettront de vous donner une statique de votre contrat d'exécution objet créé.

    InformationsquelleAutor Konrad Rudolph
  3. 108

    Compilé expression est le meilleur moyen! (pour la performance à plusieurs reprises de créer une instance dans l'exécution).

    static readonly Func<X> YCreator = Expression.Lambda<Func<X>>(
   Expression.New(typeof(Y).GetConstructor(Type.EmptyTypes))
 ).Compile();

X x = YCreator();

    De la statistique (2012):

        Iterations: 5000000
    00:00:00.8481762, Activator.CreateInstance(string, string)
    00:00:00.8416930, Activator.CreateInstance(type)
    00:00:06.6236752, ConstructorInfo.Invoke
    00:00:00.1776255, Compiled expression
    00:00:00.0462197, new

    Statistiques (2015, .net 4.5, x64):

        Iterations: 5000000
    00:00:00.2659981, Activator.CreateInstance(string, string)
    00:00:00.2603770, Activator.CreateInstance(type)
    00:00:00.7478936, ConstructorInfo.Invoke
    00:00:00.0700757, Compiled expression
    00:00:00.0286710, new

    Statistiques (2015, .net 4.5, x86):

        Iterations: 5000000
    00:00:00.3541501, Activator.CreateInstance(string, string)
    00:00:00.3686861, Activator.CreateInstance(type)
    00:00:00.9492354, ConstructorInfo.Invoke
    00:00:00.0719072, Compiled expression
    00:00:00.0229387, new

    Statistiques (2017, LINQPad 5.22.02/x64/.NET 4.6):

        Iterations: 5000000
    No args
    00:00:00.3897563, Activator.CreateInstance(string assemblyName, string typeName)
    00:00:00.3500748, Activator.CreateInstance(Type type)
    00:00:01.0100714, ConstructorInfo.Invoke
    00:00:00.1375767, Compiled expression
    00:00:00.1337920, Compiled expression (type)
    00:00:00.0593664, new
    Single arg
    00:00:03.9300630, Activator.CreateInstance(Type type)
    00:00:01.3881770, ConstructorInfo.Invoke
    00:00:00.1425534, Compiled expression
    00:00:00.0717409, new

    Statistiques (2019, x64/.NET 4.8):

    Iterations: 5000000
No args
00:00:00.3287835, Activator.CreateInstance(string assemblyName, string typeName)
00:00:00.3122015, Activator.CreateInstance(Type type)
00:00:00.8035712, ConstructorInfo.Invoke
00:00:00.0692854, Compiled expression
00:00:00.0662223, Compiled expression (type)
00:00:00.0337862, new
Single arg
00:00:03.8081959, Activator.CreateInstance(Type type)
00:00:01.2507642, ConstructorInfo.Invoke
00:00:00.0671756, Compiled expression
00:00:00.0301489, new

    Statistiques (2019, x64/.NET Core 3.0):

    Iterations: 5000000
No args
00:00:00.3226895, Activator.CreateInstance(string assemblyName, string typeName)
00:00:00.2786803, Activator.CreateInstance(Type type)
00:00:00.6183554, ConstructorInfo.Invoke
00:00:00.0483217, Compiled expression
00:00:00.0485119, Compiled expression (type)
00:00:00.0434534, new
Single arg
00:00:03.4389401, Activator.CreateInstance(Type type)
00:00:01.0803609, ConstructorInfo.Invoke
00:00:00.0554756, Compiled expression
00:00:00.0462232, new

    Code complet:

    static X CreateY_New()
{
return new Y();
}
static X CreateY_New_Arg(int z)
{
return new Y(z);
}
static X CreateY_CreateInstance()
{
return (X)Activator.CreateInstance(typeof(Y));
}
static X CreateY_CreateInstance_String()
{
return (X)Activator.CreateInstance("Program", "Y").Unwrap();
}
static X CreateY_CreateInstance_Arg(int z)
{
return (X)Activator.CreateInstance(typeof(Y), new object[] { z, });
}
private static readonly System.Reflection.ConstructorInfo YConstructor =
typeof(Y).GetConstructor(Type.EmptyTypes);
private static readonly object[] Empty = new object[] { };
static X CreateY_Invoke()
{
return (X)YConstructor.Invoke(Empty);
}
private static readonly System.Reflection.ConstructorInfo YConstructor_Arg =
typeof(Y).GetConstructor(new[] { typeof(int), });
static X CreateY_Invoke_Arg(int z)
{
return (X)YConstructor_Arg.Invoke(new object[] { z, });
}
private static readonly Func<X> YCreator = Expression.Lambda<Func<X>>(
Expression.New(typeof(Y).GetConstructor(Type.EmptyTypes))
).Compile();
static X CreateY_CompiledExpression()
{
return YCreator();
}
private static readonly Func<X> YCreator_Type = Expression.Lambda<Func<X>>(
Expression.New(typeof(Y))
).Compile();
static X CreateY_CompiledExpression_Type()
{
return YCreator_Type();
}
private static readonly ParameterExpression YCreator_Arg_Param = Expression.Parameter(typeof(int), "z");
private static readonly Func<int, X> YCreator_Arg = Expression.Lambda<Func<int, X>>(
Expression.New(typeof(Y).GetConstructor(new[] { typeof(int), }), new[] { YCreator_Arg_Param, }),
YCreator_Arg_Param
).Compile();
static X CreateY_CompiledExpression_Arg(int z)
{
return YCreator_Arg(z);
}
static void Main(string[] args)
{
const int iterations = 5000000;
Console.WriteLine("Iterations: {0}", iterations);
Console.WriteLine("No args");
foreach (var creatorInfo in new[]
{
new {Name = "Activator.CreateInstance(string assemblyName, string typeName)", Creator = (Func<X>)CreateY_CreateInstance},
new {Name = "Activator.CreateInstance(Type type)", Creator = (Func<X>)CreateY_CreateInstance},
new {Name = "ConstructorInfo.Invoke", Creator = (Func<X>)CreateY_Invoke},
new {Name = "Compiled expression", Creator = (Func<X>)CreateY_CompiledExpression},
new {Name = "Compiled expression (type)", Creator = (Func<X>)CreateY_CompiledExpression_Type},
new {Name = "new", Creator = (Func<X>)CreateY_New},
})
{
var creator = creatorInfo.Creator;
var sum = 0;
for (var i = 0; i < 1000; i++)
sum += creator().Z;
var stopwatch = new Stopwatch();
stopwatch.Start();
for (var i = 0; i < iterations; ++i)
{
var x = creator();
sum += x.Z;
}
stopwatch.Stop();
Console.WriteLine("{0}, {1}", stopwatch.Elapsed, creatorInfo.Name);
}
Console.WriteLine("Single arg");
foreach (var creatorInfo in new[]
{
new {Name = "Activator.CreateInstance(Type type)", Creator = (Func<int, X>)CreateY_CreateInstance_Arg},
new {Name = "ConstructorInfo.Invoke", Creator = (Func<int, X>)CreateY_Invoke_Arg},
new {Name = "Compiled expression", Creator = (Func<int, X>)CreateY_CompiledExpression_Arg},
new {Name = "new", Creator = (Func<int, X>)CreateY_New_Arg},
})
{
var creator = creatorInfo.Creator;
var sum = 0;
for (var i = 0; i < 1000; i++)
sum += creator(i).Z;
var stopwatch = new Stopwatch();
stopwatch.Start();
for (var i = 0; i < iterations; ++i)
{
var x = creator(i);
sum += x.Z;
}
stopwatch.Stop();
Console.WriteLine("{0}, {1}", stopwatch.Elapsed, creatorInfo.Name);
}
}
public class X
{
public X() { }
public X(int z) { this.Z = z; }
public int Z;
}
public class Y : X
{
public Y() {}
public Y(int z) : base(z) {}
}
    • +1 pour toutes les statistiques! Je n'ai pas vraiment besoin de ce genre de performance, pour le moment, mais toujours très intéressant. 🙂
    • Il y a aussi TypeDescriptor.CreateInstance (voir stackoverflow.com/a/17797389/1242) qui peut être plus rapide si elle est utilisée avec TypeDescriptor.AddProvider
    • Est-ce encore utile lorsque vous ne savez pas quel type X est au moment de l'exécution?
    • Oui. Changement typeof(T) de Type.GetType(..).
    • Exemple peut-être?
    • Non, cela ne fonctionnera pas si le type X est un moteur d'exécution Type.

    InformationsquelleAutor Serj-Tm
  4. 42

    Une mise en œuvre de ce problème consiste à tenter d'appeler le paramètre moins constructeur de Type:

    public static object GetNewObject(Type t)
{
try
{
return t.GetConstructor(new Type[] { }).Invoke(new object[] { });
}
catch
{
return null;
}
}

    Ici est la même approche, figurant dans une méthode générique:

    public static T GetNewObject<T>()
{
try
{
return (T)typeof(T).GetConstructor(new Type[] { }).Invoke(new object[] { });
}
catch
{
return default(T);
}
}
    • Exception piloté par la programmation? Cela semble être une très mauvaise mise en œuvre quand vous pouvez simplement réfléchir sur le type pour déterminer les constructeurs.
    InformationsquelleAutor tags2k
  5. 14

    Son assez simple. Supposons que votre nom de classe est Car et de l'espace de noms est Vehicles, puis passez le paramètre que Vehicles.Car qui renvoie un objet de type Car. Comme cela, vous pouvez créer une instance d'une classe dynamiquement.

    public object GetInstance(string strNamesapace)
{         
Type t = Type.GetType(strNamesapace); 
return  Activator.CreateInstance(t);         
}

    Si votre Nom Complet(c'est à dire, Vehicles.Car dans ce cas) est dans une autre assemblée, le Type.GetType sera nulle. Dans de tels cas, vous devez faire une boucle par toutes les assemblées et de trouver la Type. Pour cela, vous pouvez utiliser le code ci-dessous

    public object GetInstance(string strFullyQualifiedName)
{
Type type = Type.GetType(strFullyQualifiedName);
if (type != null)
return Activator.CreateInstance(type);
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
type = asm.GetType(strFullyQualifiedName);
if (type != null)
return Activator.CreateInstance(type);
}
return null;
}

    Et vous pouvez obtenir de l'instance en appel de la méthode ci-dessus.

    object objClassInstance = GetInstance("Vehicles.Car");
    • Dans votre deuxième cas (assembly externe), vous avez juste à passer dans "les Véhicules.Voiture,OtherAssembly" pour votre première méthode et elle fonctionne. Évidemment OtherAssembly est le nom de l'assemblée dans laquelle il vit.
    • Qui a besoin de codage en dur le nom de l'assembly. Afin de mettre en œuvre la flexibilité que je suis la vérification de la valeur null et le code fonctionne en mode dynamique 🙂
    InformationsquelleAutor Sarath Avanavu
  6. 12

    Si c'est pour quelque chose qui va être appelé un lot dans une instance de l'application, c'est beaucoup plus rapide à compiler et de mettre en cache dynamique de code au lieu de l'aide de l'activateur ou ConstructorInfo.Invoke(). Deux options pour la compilation dynamique sont compilés Les Expressions Linq ou une simple IL opcodes et DynamicMethod. De toute façon, la différence est énorme lorsque vous commencez à recevoir en boucles serrées ou plusieurs appels.

    • "IL opcodes et DynamicMethod" le lien est mort.
    InformationsquelleAutor Tom Mayfield
  7. 9

    Sans utiliser de Réflexion:

    private T Create<T>() where T : class, new()
{
return new T();
}
    • Comment est-ce utile? Vous devez connaître le type déjà appeler cette méthode, et si vous connaissez le type, vous pouvez le construire sans une méthode spéciale.
    • Si T peut varier lors de l'exécution. Utile si vous travaillez avec deríved Types.
    • un nouveau T(); échouerait si T n'est pas un type de référence avec le constructeur sans paramètre, Cette méthode utilise les contraintes pour garantir T est le type de référence et a un constructeur.
    • Comment peut-T varier au moment de l'exécution? Vous n'avez pas à savoir T au moment de la conception, afin de l'appeler Créer <>?
    • Si vous travaillez avec des génériques de classes et d'interfaces dans les usines, les types qui implémente l'interface doit être instanciée peut varier.
    • Vous connaissez tous les types possibles au moment de la compilation, mais vous ne savez pas à qui la mise en œuvre sera utilisé lors de l'exécution.
    • Vous pouvez créer de nouveaux types à l'exécution. Il n'y a pas de règle qui dit que vous savez tous les types au moment de la compilation. Et non, je ne veux pas dire avec les médicaments génériques. Vous pouvez créer entièrement de nouveaux types et ajoutez tous les champs, les propriétés et les méthodes, etc. au moment de l'exécution. Il y a aussi le cas simple où vous souhaitez créer une instance d'un type qui est dans une assemblée qui n'est pas connu au moment de la compilation. C'est plutôt commun.

    InformationsquelleAutor
  8. 9

    Ne serait pas le générique T t = new T(); travail?

    • En fait, il serait dans une classe générique/méthode, mais pas pour un "Type".
    • Suppose que le type T est le " new()' contrainte.
    InformationsquelleAutor Brady Moritz
  9. 8

    Si vous souhaitez utiliser le constructeur par défaut, puis la solution à l'aide de System.Activator présentée plus haut est probablement la plus pratique. Toutefois, si le type en manque un constructeur par défaut ou vous devez utiliser un non-par défaut, une option est d'utiliser la réflexion ou System.ComponentModel.TypeDescriptor. Dans le cas de la réflexion, il est suffisant de connaître le nom du type (avec son espace de noms).

    Exemple à l'aide de la réflexion:

    ObjectType instance = 
(ObjectType)System.Reflection.Assembly.GetExecutingAssembly().CreateInstance(
typeName: objectType.FulName, //string including namespace of the type
ignoreCase: false,
bindingAttr: BindingFlags.Default,
binder: null,  //use default binder
args: new object[] { args, to, constructor },
culture: null, //use CultureInfo from current thread
activationAttributes: null
);

    Exemple à l'aide de TypeDescriptor:

    ObjectType instance = 
(ObjectType)System.ComponentModel.TypeDescriptor.CreateInstance(
provider: null, //use standard type description provider, which uses reflection
objectType: objectType,
argTypes: new Type[] { types, of, args },
args: new object[] { args, to, constructor }
);
    InformationsquelleAutor BSharp
  10. 5

    Compte tenu de ce problème, l'Activateur fonctionne quand il est sans paramètre ctor. Si c'est une contrainte d'envisager l'utilisation 

    System.Runtime.Serialization.FormatterServices.GetSafeUninitializedObject()
    InformationsquelleAutor Thulani Chivandikwa
  11. 3

    Je peux à travers cette question, parce que je cherchais à mettre en œuvre un simple CloneObject méthode pour arbitraire de la classe (avec un constructeur par défaut)

    Avec méthode générique, vous pouvez exiger que le type implémente de Nouvelles().

    Public Function CloneObject(Of T As New)(ByVal src As T) As T
Dim result As T = Nothing
Dim cloneable = TryCast(src, ICloneable)
If cloneable IsNot Nothing Then
result = cloneable.Clone()
Else
result = New T
CopySimpleProperties(src, result, Nothing, "clone")
End If
Return result
End Function

    Avec les non-générique assumer le type a un constructeur par défaut et de l'attraper
    une exception si elle ne le fait pas.

    Public Function CloneObject(ByVal src As Object) As Object
Dim result As Object = Nothing
Dim cloneable As ICloneable
Try
cloneable = TryCast(src, ICloneable)
If cloneable IsNot Nothing Then
result = cloneable.Clone()
Else
result = Activator.CreateInstance(src.GetType())
CopySimpleProperties(src, result, Nothing, "clone")
End If
Catch ex As Exception
Trace.WriteLine("!!! CloneObject(): " & ex.Message)
End Try
Return result
End Function
    InformationsquelleAutor Darrel Lee
  12. 3
    public AbstractType New
{
get
{
return (AbstractType) Activator.CreateInstance(GetType());
}
}
    InformationsquelleAutor vikram nayak