C# redéfinir une variable dans la classe

Question

Je suis sûr du problème "types" en C#. Supposons que j'ai une classe avec le nom de travail "item". Cette classe a un champ tel que "variable". Ce champ doit correspondre à ceux d'un élément de mon programme, par ex. Booléen int16, int32, int64, double, uint, uint16.

Y a-t-il une possibilité de redéfinir le type d'une variable dans les besoins de dépendance? Ou y a-t-il une autre approche à ce problème?

J'ai pensé à la définition de cette variable en tant que var ou objet, mais en la projetant sur un type donné.

Le problème est que plus tard la vérification lors de l'attribution des valeurs ne dépasse pas la gamme?

Answer 1

Vous pouvez utiliser des génériques, ou dynamic, selon la manière dont vous voulez utiliser Item.

Pour utiliser l'approche des génériques, définir Item en tant que tels:

class Item<T> { 
    public T Variable { get; set; } 
} 

Lorsque vous voulez un élément dont Variable est un int, faites ceci:

var intItem = new Item<int>() 
// you can set the Variable property to an int now! 
intItem.Variable = -1; 

Lorsque vous voulez un élément dont Variable est un octet, faites ceci:

var byteItem = new Item<byte>() 
// you can set the Variable property to a byte 
byteItem.Variable = 10; 

Et ainsi de suite et ainsi de suite

Une caractéristique de cette approche est que le type de Variable de l'article ne peut pas être changé une fois que l'article est créé.Donc, ce n'est pas possible:

intItem.Variable = "Hello"; 

Si vous voulez changer son type à quelque chose d'autre sans créer un nouvel élément, vous devez utiliser une variable dynamique:

class Item { 
    public dynamic Variable {get; set;} 
} 

Vous pouvez maintenant faire quelque chose comme ça :

var myItem = new Item(); 
myItem.Variable = "Hello"; 
myItem.Variable = 10; 

Ceci est fondamentalement la même que la définition Variable que object, mais il permet d'économiser votre temps d'incantation entre object et la type désiré.

Et en ce qui concerne votre souci de vérifier si la valeur est hors plage, il peut être un peu difficile à vérifier si vous utilisez dynamic. Mais je l'ai fait ce petit test et a constaté que lorsque la valeur débordait, il va juste enrouler autour de:

var item = new Item(); 
item.Variable = byte.MaxValue; 
item.Variable++; 
Console.WriteLine(item.Variable); // prints 0 

Answer 2

Vous pouvez utiliser les génériques. Il créera automatiquement une définition de classe dans le code lorsque vous créez un objet avec un nouveau type.

public class GenericClass<T> 
{ 
    public T MyProperty { get; set; } 

    public void TestMethod() 
    { 
     Console.WriteLine(MyProperty.ToString()); 
    } 
} 

Ensuite, vous pouvez l'utiliser avec différents types

 var myIntClass = new GenericClass<int>(); 
     var myStringClass = new GenericClass<string>(); 
     myIntClass.MyProperty = 1; 
     myStringClass.MyProperty = "test"; 

     myIntClass.TestMethod(); 
     myStringClass.TestMethod(); 

Vous pouvez aussi mettre des contraintes de sorte que la classe générique doit être mettre en œuvre une interface spécifique, être classe, ont constructeur. interface publique IPrintable { void Imprimer(); }

public class GenericClassWithConstraint<T> where T : IPrintable 
{ 
    public T MyProperty { get; set; } 

    void Print() 
    { 
     MyProperty.Print(); 
    } 
} 

vous pouvez également vérifier le nouveau mot-clé dynamique. Il vous permettra de travailler sur un objet en cours d'exécution