Comment générer une instance d'un type inconnu lors de l'exécution?

j'ai la suite en C#:

string typename = "System.Int32";
string value = "4";

de ces deux chaînes doivent être prises afin de générer un objet du type spécifié avec la valeur spécifiée...

résultat devrait être:

object o = CreateUnknownType(typename, value);
...
Int32 test = (Int32)o;

source d'informationauteur haze4real

.net c#runtime types

Est-ce que vous pensez?

object result = Convert.ChangeType("4", Type.GetType("System.Int32"));

15

Comme l'a dit, c'est trop large et ne peut pas être réglé.

Voici quelques options:
```
Type type = Type.GetType(typename);
object o = Activator.CreateInstance(type);
```
Cela va créer une instance du type qui typename est en train de décrire. Il appelle le constructeur sans paramètre de ce type. (Inconvénient: Pas tous les objets ont un constructeur sans paramètre. De plus, ce n'définir l'état de l'objet à l'aide value.)
```
Type type = Type.GetType(typename);
object o = Activator.CreateInstance(type, new[] { value });
```
Cela va créer une instance du type qui typename est en train de décrire. Il appelle un constructeur de ce type qui accepte un paramètre de type string. (Inconvénient: Pas tous les objets ont un tel constructeur. Par exemple, Int32 n'a pas un constructeur de sorte que vous l'expérience d'une exception d'exécution.)
```
Type type = Type.GetType(typename);
object o = Convert.ChangeType(value, type);
```
Il va tenter de convertir la chaîne value à une instance du type requis. Cela peut conduire à InvalidCastExceptions bien. Par exemple, Convert.ChangeType("4", typeof(FileStream)) sera évidemment pas, comme il se doit.

En fait, ce dernier exemple (créer une instance de type FileStream avec son état initial déterminé par la chaîne "4") montre comment l'absurde le problème général est. Il y a quelques constructions/conversions que tout ne peut pas être fait.

Vous voudrez peut-être repenser le problème que vous essayez de résoudre pour éviter ce bourbier.
3

La création d'une instance d'un type que vous connaissez par son nom (et qui doit avoir un constructeur par défaut):
```
   string typeName = "System.Int32";
   Type type = Type.GetType(type);
   object o = Activator.CreateInstance(type);
```
De l'analyse d'une valeur à partir d'une chaîne de toute évidence ne fonctionne que pour un nombre limité de types. Vous pourriez
- utilisation Convert.ChangeType comme l'a suggéré
  par PhilipW
- ou peut-être créer un
  Dictionary<Type,Func<string,object>>
  les cartes types connus connus analyser
  fonctions
- ou utiliser la réflexion pour invoquer la
  Parse(string) de la méthode sur le type,
  en supposant qu'il existe un:
```
   string valueText = "4";
   MethodInfo parseMethod = type.GetMethod("Parse");
   object value = parseMethod.Invoke(null, new object[] { valueText });
```
- ou peut-être vous pouvez utiliser la
  infrastructure fournie par le .NET
  un modèle de composant. Vous pouvez récupérer l'
  convertisseur de type d'un composant et l'utilisation
  comme ceci:
```
   TypeConverter converter = TypeDescriptor.GetConverter(type);
   object value = converter.ConvertFromString(valueText);
```
1

Votre logique semble un peu erronée ici. Évidemment, si vous êtes directement de moulage de l'objet au plus tard pour le type réel c'est le cas, vous devez connaître le type de commencer avec.

Si il y a autre chose qui manque à cette question, veuillez élaborer et peut-être qu'il est plus approprié de répondre que tout simplement, "Cela ne fait pas beaucoup de sens."
1

Peut-être vous avez un ensemble de types différents, tous de qui implémentent une interface connue?

Par exemple si vous avez plusieurs commandes de l'utilisateur et que vous souhaitez charger l'un d'entre eux dans un récipient, chacun peut mettre en œuvre IMyWobblyControl (une interface connue), mais vous pourriez ne pas savoir jusqu'à ce runtime lequel d'entre eux à la charge, éventuellement à partir de la lecture des chaînes à partir d'une certaine forme de fichier de configuration.

Dans ce cas, vous aurez besoin d'utiliser la réflexion pour charger le type réel de quelque chose comme l'assemblage complet nom, puis il la jeta dans votre type connu de l'utiliser.

Bien sûr, vous devez vous assurer que votre code ne gère pas valides exprimés, à l'assemblée de ne pas trouvé et toutes les autres exceptions qui sont susceptibles de venir à travers quelque chose d'aussi bancale que ce...
0

Cela semble comme un travail pour Int32.Parse(string). Mais d'accord avec les autres il semble que ce soit "unique" et il faut sans doute penser à des gants.
0

Voici un exemple du problème impliquant Azure SQL Fédérations...qui divise les données en db distinct, selon une clé de gamme.

De la plage de types sont:

SQL /.Net type SQL /CLR .Net

INT /SqlInt32 /Int32, Nullable

BIGINT /SqlInt64 /Int64, Nullable

UNIQUEIDENTIFIER /SqlGuid /Guid, Nullable

VARBINARY(n), max n 900 /SqlBytes, SqlBinary /Byte[]

Idéalement, un C# fonction param pourrait prendre .Net type SQL ou CLR .Net type, mais de s'installer sur une seule catégorie de type de est bon.

Serait un "objet" type de param être le chemin à parcourir? Et, est-il un moyen d'identifier le type et le convertir en conséquence?

Le concept est quelque chose comme:

public void fn(object obj, chaîne fedName, chaîne distName, bool filteringOn)

{

...comprendre à quel type obj est de s'assurer qu'il est l'un de l'acceptable types...

string clé = obj.toString();

chaîne de retour.Format("UTILISATION de la FÉDÉRATION {0} ({1}='{2}') AVEC le RESET, le FILTRAGE = {3}", fedName, distName, clé, (filteringOn ? "ON" : "OFF"));

}

Si le paramètre valeur est converti en chaîne de caractères, il sera refondue/vérifié sur le côté de sql server afin de le valider sur le côté app est souhaitée.

Après l'utilisation:

Type type = Type.GetType(typename);

Essayer cette méthode d'extension:

public static class ReflectionExtensions
{
    public static T CreateInstance<T>(this Type source, params object[] objects)
        where T : class
    {            
        var cons = source.GetConstructor(objects.Select(x => x.GetType()).ToArray());
        return cons == null ? null : (T)cons.Invoke(objects);
    }
}

Espère que cette aide.

Vous devez vous connecter pour publier un commentaire.