─░nt nas─▒l numaraland─▒rmak i├žin?


Al─▒nan cevaba git


int Bir enum in C # 'a nas─▒l aktar─▒labilir ?


2971









Cevap say─▒s─▒n─▒ say: 27






Bir dizeden:

 YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString);
// the foo.ToString().Contains(",") check is necessary for enumerations marked with an [Flags] attribute
if (!Enum.IsDefined(typeof(YourEnum), foo) && !foo.ToString().Contains(","))
  throw new InvalidOperationException($"{yourString} is not an underlying value of the YourEnum enumeration.")
 

Bir int'den:

 YourEnum foo = (YourEnum)yourInt;
 

G├╝ncelle┼čtirme:

Numaradan da yapabilirsiniz

 YourEnum foo = (YourEnum)Enum.ToObject(typeof(YourEnum) , yourInt);
 

3559







Sadece f─▒rlat:

 MyEnum e = (MyEnum)3;
 

Enum.IsDefined kullanarak aral─▒kta olup olmad─▒─č─▒n─▒ kontrol edebilirsiniz :

 if (Enum.IsDefined(typeof(MyEnum), 3)) { ... }
 

834







Alternatif olarak, bir astar yerine bir uzatma y├Ântemi kullan─▒n:

 public static T ToEnum<T>(this string enumString)
{
    return (T) Enum.Parse(typeof (T), enumString);
}
 

Kullan─▒m─▒:

 Color colorEnum = "Red".ToEnum<Color>();
 

VEYA

 string color = "Red";
var colorEnum = color.ToEnum<Color>();
 

223







Tam bir cevap alabilece─čimi d├╝┼č├╝n├╝yorum, insanlar .NET'te dahili olarak nas─▒l ├žal─▒┼čt─▒klar─▒n─▒ bilmek zorunda.

─░┼čler nas─▒l ├žal─▒┼č─▒r?

.NET'deki bir enum, bir de─čer k├╝mesini (alanlar) temel bir t├╝re (varsay─▒lan) e┼čleyen bir yap─▒d─▒r int . Ancak, enum'unuzun haritaland─▒rd─▒─č─▒ integral t├╝r├╝n├╝ ger├žekten se├žebilirsiniz:

 public enum Foo : short
 

Bu durumda, enum short veri tipine e┼členir , yani bellekte k─▒sa s├╝rede saklan─▒r ve kullan─▒p kulland─▒─č─▒n─▒zda k─▒sa kal─▒r.

Bir IL a├ž─▒s─▒ndan bakarsan─▒z, (normal, int) enum ┼č├Âyle g├Âr├╝n├╝r:

 .class public auto ansi serializable sealed BarFlag extends System.Enum
{
    .custom instance void System.FlagsAttribute::.ctor()
    .custom instance void ComVisibleAttribute::.ctor(bool) = { bool(true) }

    .field public static literal valuetype BarFlag AllFlags = int32(0x3fff)
    .field public static literal valuetype BarFlag Foo1 = int32(1)
    .field public static literal valuetype BarFlag Foo2 = int32(0x2000)

    // and so on for all flags or enum values

    .field public specialname rtspecialname int32 value__
}
 

Burada dikkat etmeniz gereken value__ nokta, enum de─čerlerinden ayr─▒ olarak depolanmas─▒d─▒r. Foo Yukar─▒daki enum durumunda , t├╝r value__ int16'd─▒r. Bu, temel olarak, t├╝rler e┼čle┼čti─či s├╝rece bir numarada istedi─činiz ┼čeyi saklayabilece─činiz anlam─▒na gelir .

Bu noktada System.Enum , bir de─čer t├╝r├╝ oldu─čunu belirtmek isterim ki bu temelde BarFlag bellekte 4 bayt Foo alaca─č─▒ ve 2'yi alaca─č─▒ anlam─▒na gelir - ├Ârne─čin, temel t├╝r├╝n boyutu (asl─▒nda bundan daha karma┼č─▒kt─▒r, ancak Hey...).

Cevap

Bu nedenle, bir numaraland─▒rmaya e┼člemek istedi─činiz bir tamsay─▒ya sahipseniz, ├žal─▒┼čma zaman─▒ yaln─▒zca 2 ┼čey yapmal─▒d─▒r: 4 bayt─▒ kopyalay─▒n ve ba┼čka bir ad─▒ (enumun ad─▒) adland─▒r─▒n. Veriler de─čer t├╝r├╝ olarak sakland─▒─č─▒ndan, kopyalama i┼člemi ├Ârt├╝kt├╝r - bu temel olarak, y├Ânetilmeyen kod kullan─▒rsan─▒z, verileri kopyalamadan yaln─▒zca enumleri ve tamsay─▒lar─▒ de─či┼čtirebilece─činiz anlam─▒na gelir.

G├╝venli k─▒lmak i├žin , altta yatan t├╝rlerin ayn─▒ ya da dolayl─▒ olarak d├Ân├╝┼čt├╝r├╝lebilir oldu─čunu bilmek ve enum de─čerlerinin varl─▒─č─▒n─▒ sa─člamak (varsay─▒lan olarak kontrol edilmezler!) En iyi y├Ântem oldu─čunu d├╝┼č├╝n├╝yorum .

Bunun nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ g├Ârmek i├žin a┼ča─č─▒daki kodu deneyin:

 public enum MyEnum : int
{
    Foo = 1,
    Bar = 2,
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)5;
    var e2 = (MyEnum)6;

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}
 

D├Âk├╝m e2 de i┼če yar─▒yor! Bu markalar─▒ anlamda yukar─▒daki derleyici a├ž─▒s─▒ndan bak─▒ld─▒─č─▒nda: value__ Alan basit├že ya 5 ya da 6 ve dolu Console.WriteLine aramalar─▒n ToString() , ad─▒ e1 ismi olurken ├ž├Âz├╝lene e2 de─čildir.

─░stedi─činiz bu Enum.IsDefined(typeof(MyEnum), 6) de─čilse, yay─▒nlad─▒─č─▒n─▒z de─čerin tan─▒mlanm─▒┼č bir enuma e┼členip e┼čle┼čmedi─čini kontrol etmek i├žin kullan─▒n .

Ayr─▒ca, derleyicinin ger├žekten bunu kontrol etmesine ra─čmen, enumun alt─▒nda yatan t├╝r hakk─▒nda net oldu─čumu unutmay─▒n. Bunu yolun a┼ča─č─▒s─▒nda s├╝rprizlerle kar┼č─▒la┼čmamam─▒ sa─člamak i├žin yap─▒yorum. Bu s├╝rprizleri ├žal─▒┼č─▒rken g├Ârmek i├žin a┼ča─č─▒daki kodu kullanabilirsiniz (asl─▒nda bunun veritaban─▒ kodunda ├žok oldu─čunu g├Ârd├╝m):

 public enum MyEnum : short
{
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)32769; // will not compile, out of bounds for a short

    object o = 5;
    var e2 = (MyEnum)o;     // will throw at runtime, because o is of type int

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}
 

144







A┼ča─č─▒daki ├Ârne─či ele alal─▒m:

 int one = 1;
MyEnum e = (MyEnum)one;
 

112







Enum'a int vermek i├žin bu kod par├žas─▒n─▒ kullan─▒yorum:

 if (typeof(YourEnum).IsEnumDefined(valueToCast)) return (YourEnum)valueToCast;
else { //handle it here, if its not defined }
 

En iyi ├ž├Âz├╝m├╝ buluyorum.


61







A┼ča─č─▒da Enums i├žin g├╝zel bir yard─▒mc─▒ program s─▒n─▒f─▒d─▒r

 public static class EnumHelper
{
    public static int[] ToIntArray<T>(T[] value)
    {
        int[] result = new int[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = Convert.ToInt32(value[i]);
        return result;
    }

    public static T[] FromIntArray<T>(int[] value) 
    {
        T[] result = new T[value.Length];
        for (int i = 0; i < value.Length; i++)
            result[i] = (T)Enum.ToObject(typeof(T),value[i]);
        return result;
    }


    internal static T Parse<T>(string value, T defaultValue)
    {
        if (Enum.IsDefined(typeof(T), value))
            return (T) Enum.Parse(typeof (T), value);

        int num;
        if(int.TryParse(value,out num))
        {
            if (Enum.IsDefined(typeof(T), num))
                return (T)Enum.ToObject(typeof(T), num);
        }

        return defaultValue;
    }
}
 

49







Say─▒sal de─čerler i├žin, ne olursa olsun bir nesneyi d├Ând├╝rece─či i├žin bu daha g├╝venlidir:

 public static class EnumEx
{
    static public bool TryConvert<T>(int value, out T result)
    {
        result = default(T);
        bool success = Enum.IsDefined(typeof(T), value);
        if (success)
        {
            result = (T)Enum.ToObject(typeof(T), value);
        }
        return success;
    }
}
 

43







4.0 .NET Framework i├žin haz─▒rsan─▒z , ├žok kullan─▒┼čl─▒ ve [Flags] ├Âzniteli─či ile iyi oynayan yeni bir Enum.TryParse () i┼člevi var. Enum.TryParse Y├Ântemine bak─▒n (String, TEnum%)


42







Bir bit maskesi i┼člevi g├Âren ve bir [Flags] numaraland─▒rmada bir veya daha fazla de─čeri temsil edebilen bir tamsay─▒ya sahipseniz, tek tek bayrak de─čerlerini bir listeye ayr─▒┼čt─▒rmak i├žin bu kodu kullanabilirsiniz:

 for (var flagIterator = 0; flagIterator < 32; flagIterator++)
{
    // Determine the bit value (1,2,4,...,Int32.MinValue)
    int bitValue = 1 << flagIterator;

    // Check to see if the current flag exists in the bit mask
    if ((intValue & bitValue) != 0)
    {
        // If the current flag exists in the enumeration, then we can add that value to the list
        // if the enumeration has that flag defined
        if (Enum.IsDefined(typeof(MyEnum), bitValue))
            Console.WriteLine((MyEnum)bitValue);
    }
}
 

Bunun altta yatan t├╝r├╝n enum i┼čaretli bir 32 bit tam say─▒ oldu─čunu varsayd─▒─č─▒n─▒ unutmay─▒n . Farkl─▒ bir say─▒sal t├╝r olsayd─▒, kodlanm─▒┼č 32'yi, bu t├╝rdeki bitleri yans─▒tacak ┼čekilde de─či┼čtirmek zorunda kal─▒rd─▒n─▒z (ya da bunu kullanarak programl─▒ olarak t├╝retirdiniz Enum.GetUnderlyingType() )


31







Bazen MyEnum t├╝r├╝n bir nesnesi vard─▒r . Sevmek

 var MyEnumType = typeof(MyEnumType);
 

Sonra:

 Enum.ToObject(typeof(MyEnum), 3)
 

26







Bu, g├╝venli d├Ân├╝┼čt├╝rme y├Ânteminin fark─▒nda olan bir bayrak say─▒m─▒d─▒r:

 public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: Enum
{
  var enumType = typeof (T);
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}
 

23








g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

Bir dizeyi ENUM'a veya int'yi ENUM sabitine d├Ân├╝┼čt├╝rmek i├žin Enum.Parse i┼člevini kullanmam─▒z gerekir. ─░┼čte asl─▒nda youtube videosu olan https://www.youtube.com/watch?v=4nhx4VwdRDk , ger├žekte string ile g├Âsteriliyor ve ayn─▒s─▒ int i├žin de ge├žerli.

Kod, a┼ča─č─▒da "k─▒rm─▒z─▒" ifadesinin g├Âsterildi─či gibi gider ve "MyColors", renk sabitlerine sahip ENUM rengidir.

 MyColors EnumColors = (MyColors)Enum.Parse(typeof(MyColors), "Red");
 

19







Biraz uzakta as─▒l soruya ald─▒─č─▒m ama bulundu y─▒─č─▒n ta┼čmas─▒ soru bir cevap enum Al int de─čeri yararl─▒d─▒r. public const int Bir s├╝r├╝ ilgili int sabitleri kolayca bir araya toplaman─▒za izin veren ve ard─▒ndan bunlar─▒ int kullan─▒rken bunlar─▒ kullanman─▒za gerek kalmayan ├Âzelliklere sahip statik bir s─▒n─▒f olu┼čturun .

 public static class Question
{
    public static readonly int Role = 2;
    public static readonly int ProjectFunding = 3;
    public static readonly int TotalEmployee = 4;
    public static readonly int NumberOfServers = 5;
    public static readonly int TopBusinessConcern = 6;
}
 

A├ž─▒k├žas─▒, enum tipi i┼člevsellikten baz─▒lar─▒ kaybolacak, ancak bir grup veritaban─▒ kimli─či sabitini saklamak i├žin olduk├ža d├╝zenli bir ├ž├Âz├╝m gibi g├Âr├╝n├╝yor.


18


2014-07-17





Bu, yukar─▒daki Tawani'nin yard─▒mc─▒ s─▒n─▒f─▒nda oldu─ču gibi jenerikler kullanarak dot.NET 4.0'da k─▒smi e┼čle┼čmeyle tamsay─▒lar─▒ veya dizeleri bir hedef numaras─▒na ayr─▒┼čt─▒r─▒r. Tamamlanmam─▒┼č olabilecek komut sat─▒r─▒ anahtar─▒ de─či┼čkenlerini d├Ân├╝┼čt├╝rmek i├žin kullan─▒yorum. Bir enum bo┼č olamayaca─č─▒ndan, mant─▒ksal olarak bir varsay─▒lan de─čer sa─člamal─▒s─▒n─▒z. Bu ┼čekilde adland─▒r─▒labilir:

 var result = EnumParser<MyEnum>.Parse(valueToParse, MyEnum.FirstValue);
 

─░┼čte kod:

 using System;

public class EnumParser<T> where T : struct
{
    public static T Parse(int toParse, T defaultVal)
    {
        return Parse(toParse + "", defaultVal);
    }
    public static T Parse(string toParse, T defaultVal) 
    {
        T enumVal = defaultVal;
        if (defaultVal is Enum && !String.IsNullOrEmpty(toParse))
        {
            int index;
            if (int.TryParse(toParse, out index))
            {
                Enum.TryParse(index + "", out enumVal);
            }
            else
            {
                if (!Enum.TryParse<T>(toParse + "", true, out enumVal))
                {
                    MatchPartialName(toParse, ref enumVal);
                }
            }
        }
        return enumVal;
    }

    public static void MatchPartialName(string toParse, ref T enumVal)
    {
        foreach (string member in enumVal.GetType().GetEnumNames())
        {
            if (member.ToLower().Contains(toParse.ToLower()))
            {
                if (Enum.TryParse<T>(member + "", out enumVal))
                {
                    break;
                }
            }
        }
    }
}
 

Bilginize: Soru tamsay─▒larla ilgiliydi, kimsenin bahsetmedi─či de Enum'da a├ž─▒k├ža d├Ân├╝┼čt├╝─č├╝n├╝ s├Âyledi.


14







Bir dizeden: (Enum.Parse G├╝ncel De─čil, Enum.TryParse kullan─▒n)

 enum Importance
{}

Importance importance;

if (Enum.TryParse(value, out importance))
{
}
 

13







A┼ča─č─▒daki biraz daha iyi uzatma y├Ântemidir

 public static string ToEnumString<TEnum>(this int enumValue)
        {
            var enumString = enumValue.ToString();
            if (Enum.IsDefined(typeof(TEnum), enumValue))
            {
                enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
            }
            return enumString;
        }
 

11







Benim durumumda, enumu bir WCF servisinden geri g├Ândermem gerekiyordu. Ayr─▒ca sadece enum.ToString () i├žin kolay bir isme ihtiyac─▒m vard─▒.

─░┼čte WCF S─▒n─▒f─▒m.

 [DataContract]
public class EnumMember
{
    [DataMember]
    public string Description { get; set; }

    [DataMember]
    public int Value { get; set; }

    public static List<EnumMember> ConvertToList<T>()
    {
        Type type = typeof(T);

        if (!type.IsEnum)
        {
            throw new ArgumentException("T must be of type enumeration.");
        }

        var members = new List<EnumMember>();

        foreach (string item in System.Enum.GetNames(type))
        {
            var enumType = System.Enum.Parse(type, item);

            members.Add(
                new EnumMember() { Description = enumType.GetDescriptionValue(), Value = ((IConvertible)enumType).ToInt32(null) });
        }

        return members;
    }
}
 

─░┼čte A├ž─▒klama'y─▒ Enum'dan alan Extension y├Ântemi.

     public static string GetDescriptionValue<T>(this T source)
    {
        FieldInfo fileInfo = source.GetType().GetField(source.ToString());
        DescriptionAttribute[] attributes = (DescriptionAttribute[])fileInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);            

        if (attributes != null && attributes.Length > 0)
        {
            return attributes[0].Description;
        }
        else
        {
            return source.ToString();
        }
    }
 

Uygulama:

 return EnumMember.ConvertToList<YourType>();
 

10







D├Âk├╝m i├žin farkl─▒ yollar─▒ ve gelen Enum

 enum orientation : byte
{
 north = 1,
 south = 2,
 east = 3,
 west = 4
}

class Program
{
  static void Main(string[] args)
  {
    orientation myDirection = orientation.north;
    Console.WriteLine(ÔÇťmyDirection = {0}ÔÇŁ, myDirection); //output myDirection =north
    Console.WriteLine((byte)myDirection); //output 1

    string strDir = Convert.ToString(myDirection);
        Console.WriteLine(strDir); //output north

    string myString = ÔÇťnorthÔÇŁ; //to convert string to Enum
    myDirection = (orientation)Enum.Parse(typeof(orientation),myString);


 }
}
 

8







Art─▒k bu enum uzant─▒s─▒n─▒n bir b├Âl├╝m├╝n├╝ nereden buldu─čumu bilmiyorum, ancak stackoverflow'tan geliyor. Bunun i├žin ├╝zg├╝n├╝m! Ama bunu ald─▒m ve Flags'l─▒ numaraland─▒rma i├žin de─či┼čtirdim. Bayrakl─▒ numaralar i├žin bunu yapt─▒m

   public static class Enum<T> where T : struct
  {
     private static readonly IEnumerable<T> All = Enum.GetValues(typeof (T)).Cast<T>();
     private static readonly Dictionary<int, T> Values = All.ToDictionary(k => Convert.ToInt32(k));

     public static T? CastOrNull(int value)
     {
        T foundValue;
        if (Values.TryGetValue(value, out foundValue))
        {
           return foundValue;
        }

        // For enums with Flags-Attribut.
        try
        {
           bool isFlag = typeof(T).GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
           if (isFlag)
           {
              int existingIntValue = 0;

              foreach (T t in Enum.GetValues(typeof(T)))
              {
                 if ((value & Convert.ToInt32(t)) > 0)
                 {
                    existingIntValue |= Convert.ToInt32(t);
                 }
              }
              if (existingIntValue == 0)
              {
                 return null;
              }

              return (T)(Enum.Parse(typeof(T), existingIntValue.ToString(), true));
           }
        }
        catch (Exception)
        {
           return null;
        }
        return null;
     }
  }
 

├ľrnek:

 [Flags]
public enum PetType
{
  None = 0, Dog = 1, Cat = 2, Fish = 4, Bird = 8, Reptile = 16, Other = 32
};

integer values 
1=Dog;
13= Dog | Fish | Bird;
96= Other;
128= Null;
 

8







Herhangi bir giri┼č verisini kullan─▒c─▒n─▒n istedi─či enum de─čerine d├Ân├╝┼čt├╝rmenize yard─▒mc─▒ olabilir . Varsay─▒lan olarak int olan a┼ča─č─▒daki gibi bir enum oldu─čunu varsayal─▒m . L├╝tfen enum'unuzun ba┼č─▒na bir Varsay─▒lan de─čer ekleyin . Girdi de─čeriyle e┼čle┼čme bulunmad─▒─č─▒nda yard─▒mc─▒ medtodlarda kullan─▒l─▒r.

 public enum FriendType  
{
    Default,
    Audio,
    Video,
    Image
}

public static class EnumHelper<T>
{
    public static T ConvertToEnum(dynamic value)
    {
        var result = default(T);
        var tempType = 0;

        //see Note below
        if (value != null &&
            int.TryParse(value.ToString(), out  tempType) && 
            Enum.IsDefined(typeof(T), tempType))
        {
            result = (T)Enum.ToObject(typeof(T), tempType); 
        }
        return result;
    }
}
 

Not: Burada de─čeri int olarak ayr─▒┼čt─▒rmaya ├žal─▒┼č─▒yorum, ├ž├╝nk├╝ enum varsay─▒lan olarak int Enum'u bu ┼čekilde bayt t├╝r├╝ olarak tan─▒mlarsan─▒z .

 public enum MediaType : byte
{
    Default,
    Audio,
    Video,
    Image
} 
 

Yard─▒mc─▒ y├Ântemde ayr─▒┼čt─▒rmay─▒

 int.TryParse(value.ToString(), out  tempType)
 

i├žin

byte.TryParse(value.ToString(), out tempType)

A┼ča─č─▒daki giri┼čler i├žin y├Ântemimi kontrol ediyorum

 EnumHelper<FriendType>.ConvertToEnum(null);
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("-1");
EnumHelper<FriendType>.ConvertToEnum("6");
EnumHelper<FriendType>.ConvertToEnum("");
EnumHelper<FriendType>.ConvertToEnum("2");
EnumHelper<FriendType>.ConvertToEnum(-1);
EnumHelper<FriendType>.ConvertToEnum(0);
EnumHelper<FriendType>.ConvertToEnum(1);
EnumHelper<FriendType>.ConvertToEnum(9);
 

─░ngilizcem i├žin ├╝zg├╝n├╝m


7







─░┼čte yay─▒n Int32 yapan bir uzatma y├Ântemi Enum .

De─čer, m├╝mk├╝n olan maksimum de─čerden daha y├╝ksek olsa bile, bitsel bayraklar─▒ onurland─▒r─▒r. ├ľrne─čin , 1 , 2 ve 4 olas─▒l─▒klar─▒na sahip bir numaraya sahipseniz , ancak int 9 ise , 8 olmad─▒─č─▒nda 1 olarak anlar . Bu, veri g├╝ncellemelerini kod g├╝ncellemesinden ├Ânce yapman─▒z─▒ sa─člar.

    public static TEnum ToEnum<TEnum>(this int val) where TEnum : struct, IComparable, IFormattable, IConvertible
    {
        if (!typeof(TEnum).IsEnum)
        {
            return default(TEnum);
        }

        if (Enum.IsDefined(typeof(TEnum), val))
        {//if a straightforward single value, return that
            return (TEnum)Enum.ToObject(typeof(TEnum), val);
        }

        var candidates = Enum
            .GetValues(typeof(TEnum))
            .Cast<int>()
            .ToList();

        var isBitwise = candidates
            .Select((n, i) => {
                if (i < 2) return n == 0 || n == 1;
                return n / 2 == candidates[i - 1];
            })
            .All(y => y);

        var maxPossible = candidates.Sum();

        if (
            Enum.TryParse(val.ToString(), out TEnum asEnum)
            && (val <= maxPossible || !isBitwise)
        ){//if it can be parsed as a bitwise enum with multiple flags,
          //or is not bitwise, return the result of TryParse
            return asEnum;
        }

        //If the value is higher than all possible combinations,
        //remove the high imaginary values not accounted for in the enum
        var excess = Enumerable
            .Range(0, 32)
            .Select(n => (int)Math.Pow(2, n))
            .Where(n => n <= val && n > 0 && !candidates.Contains(n))
            .Sum();

        return Enum.TryParse((val - excess).ToString(), out asEnum) ? asEnum : default(TEnum);
    }
 

5







int # 'ye bir int atman─▒n kolay ve a├ž─▒k yolu:

  public class Program
    {
        public enum Color : int
        {
            Blue = 0,
            Black = 1,
            Green = 2,
            Gray = 3,
            Yellow =4
        }

        public static void Main(string[] args)
        {
            //from string
            Console.WriteLine((Color) Enum.Parse(typeof(Color), "Green"));

            //from int
            Console.WriteLine((Color)2);

            //From number you can also
            Console.WriteLine((Color)Enum.ToObject(typeof(Color) ,2));
        }
    }
 

4







Basit├že a├ž─▒k├ža kullan─▒n: Cast int enum veya enum - int

 class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)Number.three); //Output=3

            Console.WriteLine((Number)3);// Outout three
            Console.Read();
        }

        public enum Number 
        {
            Zero = 0,
            One = 1,
            Two = 2,
            three = 3           
        }
    }
 

2







Daha sa─člam olmas─▒ i├žin baz─▒ e┼čle┼čtirme rahatlamalar─▒ olu┼čturmal─▒s─▒n─▒z.

 public static T ToEnum<T>(dynamic value)
{
    if (value == null)
    {
        // default value of an enum is the object that corresponds to
        // the default value of its underlying type
        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table
        value = Activator.CreateInstance(Enum.GetUnderlyingType(typeof(T)));
    }
    else if (value is string name)
    {
        return (T)Enum.Parse(typeof(T), name);
    }

    return (T)Enum.ToObject(typeof(T),
             Convert.ChangeType(value, Enum.GetUnderlyingType(typeof(T))));
}
 

Test durumu

 [Flags]
public enum A : uint
{
    None  = 0, 
    X     = 1 < 0,
    Y     = 1 < 1
}

static void Main(string[] args)
{
    var value = EnumHelper.ToEnum<A>(7m);
    var x = value.HasFlag(A.X); // true
    var y = value.HasFlag(A.Y); // true

    var value2 = EnumHelper.ToEnum<A>("X");

    var value3 = EnumHelper.ToEnum<A>(null);

    Console.ReadKey();
}
 

2


2019-07-02





Sadece a┼ča─č─▒daki gibi yap─▒n:

 int intToCast = 1;
TargetEnum f = (TargetEnum) intToCast ;
 

Yaln─▒zca do─čru de─čerleri verdi─činizden ve ba┼čka bir istisna atabildi─činizden emin olmak i├žin:

 int intToCast = 1;
if (Enum.IsDefined(typeof(TargetEnum), intToCast ))
{
    TargetEnum target = (TargetEnum)intToCast ;
}
else
{
   // Throw your exception.
}
 

IsDefined'i kullanman─▒n sadece d├Âk├╝m yapmaktan daha pahal─▒ ve hatta daha fazla oldu─čuna dikkat edin, bu y├╝zden onu kullan─▒p kullanmamaya karar vermeniz uygulaman─▒za ba─čl─▒.


0







 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace SamplePrograme
{
    public class Program
    {
        public enum Suit : int
        {
            Spades = 0,
            Hearts = 1,
            Clubs = 2,
            Diamonds = 3
        }

        public static void Main(string[] args)
        {
            //from string
            Console.WriteLine((Suit) Enum.Parse(typeof(Suit), "Clubs"));

            //from int
            Console.WriteLine((Suit)1);

            //From number you can also
            Console.WriteLine((Suit)Enum.ToObject(typeof(Suit) ,1));
        }
    }
}
 

0