Choisir la valeur par défaut d'un type Enum sans avoir à changer de valeur
En C #, est-il possible de décorer un type Enum avec un attribut ou de faire autre chose pour spécifier la valeur par défaut, sans avoir à modifier les valeurs? Les chiffres requis pourraient être gravés dans la pierre pour une raison quelconque, et il serait pratique de toujours avoir le contrôle sur les valeurs par défaut.
enum Orientation
{
None = -1,
North = 0,
East = 1,
South = 2,
West = 3
}
Orientation o; // Is 'North' by default.
La valeur par défaut pour un enum (en fait, tout type de valeur) est 0, même s'il ne s'agit pas d'une valeur valide pour ce enum. Cela ne peut pas être changé.
La valeur par défaut de n'importe quelle énumération est zéro. Donc, si vous voulez définir un énumérateur comme valeur par défaut, définissez-le sur zéro et tous les autres énumérateurs sur une valeur différente de zéro (le premier énumérateur ayant la valeur zéro sera la valeur par défaut de cette énumération s'il existe plusieurs énumérateurs avec la valeur zéro).
enum Orientation
{
None = 0, //default value since it has the value '0'
North = 1,
East = 2,
South = 3,
West = 4
}
Orientation o; // initialized to 'None'
Si vos énumérateurs n'ont pas besoin de valeurs explicites, assurez-vous simplement que le premier énumérateur est celui que vous souhaitez utiliser comme énumérateur par défaut, car "Par défaut, le premier énumérateur a la valeur 0 et la valeur de chaque énumérateur successif est augmentée de 1." ( référence C # )
enum Orientation
{
None, //default value since it is the first enumerator
North,
East,
South,
West
}
Orientation o; // initialized to 'None'
Si zéro ne fonctionne pas comme valeur par défaut appropriée, vous pouvez utiliser le modèle de composant pour définir une solution de contournement pour l'énumération:
[DefaultValue(None)]
public enum Orientation
{
None = -1,
North = 0,
East = 1,
South = 2,
West = 3
}
public static class Utilities
{
public static TEnum GetDefaultValue<TEnum>() where TEnum : struct
{
Type t = typeof(TEnum);
DefaultValueAttribute[] attributes = (DefaultValueAttribute[])t.GetCustomAttributes(typeof(DefaultValueAttribute), false);
if (attributes != null &&
attributes.Length > 0)
{
return (TEnum)attributes[0].Value;
}
else
{
return default(TEnum);
}
}
}
et ensuite vous pouvez appeler:
Orientation o = Utilities.GetDefaultValue<Orientation>();
System.Diagnostics.Debug.Print(o.ToString());
Remarque: vous devrez inclure la ligne suivante en haut du fichier:
using System.ComponentModel;
Cela ne modifie pas la valeur par défaut de l'énum en langage C #, mais donne un moyen d'indiquer (et d'obtenir) la valeur par défaut souhaitée.
La valeur par défaut d'une énumération correspond à l'énumération égale à zéro. Je ne crois pas que cela puisse changer par attribut ou par d’autres moyens.
(MSDN indique: "La valeur par défaut d'un enum E est la valeur produite par l'expression (E) 0.")
Vous ne pouvez pas, mais si vous voulez, vous pouvez faire un tour. :)
public struct Orientation
{
...
public static Orientation None = -1;
public static Orientation North = 0;
public static Orientation East = 1;
public static Orientation South = 2;
public static Orientation West = 3;
}
utilisation de cette structure comme simple énumération.
où vous pouvez créer p.a == Orientation.East (ou toute autre valeur de votre choix) par défaut
Pour utiliser le truc lui-même, vous devez convertir int par code.
la mise en oeuvre:
#region ConvertingToEnum
private int val;
static Dictionary<int, string> dict = null;
public Orientation(int val)
{
this.val = val;
}
public static implicit operator Orientation(int value)
{
return new Orientation(value - 1);
}
public static bool operator ==(Orientation a, Orientation b)
{
return a.val == b.val;
}
public static bool operator !=(Orientation a, Orientation b)
{
return a.val != b.val;
}
public override string ToString()
{
if (dict == null)
InitializeDict();
if (dict.ContainsKey(val))
return dict[val];
return val.ToString();
}
private void InitializeDict()
{
dict = new Dictionary<int, string>();
foreach (var fields in GetType().GetFields(BindingFlags.Public | BindingFlags.Static))
{
dict.Add(((Orientation)fields.GetValue(null)).val, fields.Name);
}
}
#endregion
Une autre façon qui pourrait être utile - d'utiliser une sorte de "pseudonyme". Par exemple:
public enum Status
{
New = 10,
Old = 20,
Actual = 30,
// Use Status.Default to specify default status in your code.
Default = New
}
En réalité, la valeur par défaut de enum est le premier élément du enum dont la valeur est 0.
Donc par exemple:
public enum Animals
{
Cat,
Dog,
Pony = 0,
}
//its value will actually be Cat not Pony unless you assign a non zero value to Cat.
Animals animal;
The default value of enum is the enummember equal to 0 or the first element(if value is not specified) ... Mais j'ai rencontré des problèmes critiques en utilisant enum dans mes projets et j'ai surmonté mes problèmes en faisant quelque chose en dessous ... Mon besoin était toujours lié au niveau de la classe ...
class CDDtype
{
public int Id { get; set; }
public DDType DDType { get; set; }
public CDDtype()
{
DDType = DDType.None;
}
}
[DefaultValue(None)]
public enum DDType
{
None = -1,
ON = 0,
FC = 1,
NC = 2,
CC = 3
}
et obtenir le résultat attendu
CDDtype d1= new CDDtype();
CDDtype d2 = new CDDtype { Id = 50 };
Console.Write(d1.DDType);//None
Console.Write(d2.DDType);//None
Maintenant que se passe-t-il si la valeur provient de DB .... Ok dans ce scénario ... transmettez la valeur dans la fonction ci-dessous et il convertira la valeur en enum ... la fonction ci-dessous gèrera divers scénarios et sera générique .. et croyez moi c'est très rapide ..... :)
public static T ToEnum<T>(this object value)
{
//Checking value is null or DBNull
if (!value.IsNull())
{
return (T)Enum.Parse(typeof(T), value.ToStringX());
}
//Returanable object
object ValueToReturn = null;
//First checking whether any 'DefaultValueAttribute' is present or not
var DefaultAtt = (from a in typeof(T).CustomAttributes
where a.AttributeType == typeof(DefaultValueAttribute)
select a).FirstOrNull();
//If DefaultAttributeValue is present
if ((!DefaultAtt.IsNull()) && (DefaultAtt.ConstructorArguments.Count == 1))
{
ValueToReturn = DefaultAtt.ConstructorArguments[0].Value;
}
//If still no value found
if (ValueToReturn.IsNull())
{
//Trying to get the very first property of that enum
Array Values = Enum.GetValues(typeof(T));
//getting very first member of this enum
if (Values.Length > 0)
{
ValueToReturn = Values.GetValue(0);
}
}
//If any result found
if (!ValueToReturn.IsNull())
{
return (T)Enum.Parse(typeof(T), ValueToReturn.ToStringX());
}
return default(T);
}
La valeur par défaut pour un type d’énumération est 0:
" Par défaut, le premier énumérateur a la valeur 0 et la valeur de chaque énumérateur successif est augmentée de 1. "
" Le type de valeur enum a la valeur produite par l'expression (E) 0, où E est l'identificateur enum. "
Vous pouvez consulter la documentation pour C # enum ici et la documentation pour le tableau des valeurs par défaut C # ici .
Si vous définissez l'énumération par défaut comme l'énumération ayant la plus petite valeur, vous pouvez utiliser ceci:
public enum MyEnum { His = -1, Hers = -2, Mine = -4, Theirs = -3 }
var firstEnum = ((MyEnum[])Enum.GetValues(typeof(MyEnum)))[0];
firstEnum == Mine.
Cela ne suppose pas que l'énumération a une valeur nulle.
La valeur par défaut est la première de la définition. Par exemple:
public enum MyEnum{His,Hers,Mine,Theirs}
Enum.GetValues(typeOf(MyEnum)).GetValue(0);
Ceci retournera His
enum Orientations
{
None, North, East, South, West
}
private Orientations? _orientation { get; set; }
public Orientations? Orientation
{
get
{
return _orientation ?? Orientations.None;
}
set
{
_orientation = value;
}
}
Si vous définissez la propriété sur null, vous obtiendrez Orientations.None on get. La propriété _orientation est null par défaut.