c# - সি#এ Enum নিক্ষেপ int




enums casting (14)

কিভাবে একটি int # সি একটি enum নিক্ষেপ করা যাবে?


অনুসরণ সামান্য ভাল এক্সটেনশান পদ্ধতি

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;
        }

আপনি যদি 4.0 .NET ফ্রেমওয়ার্কের জন্য প্রস্তুত হন তবে একটি নতুন Enum.TryParse () ফাংশন যা খুব দরকারী এবং [ফ্ল্যাগ] বৈশিষ্ট্যটির সাথে ভাল খেলে। Enum.TryParse পদ্ধতি দেখুন (স্ট্রিং, TENUM%)


আমি আমার enum int আঁকা কোডের এই টুকরা ব্যবহার করছি:

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

আমি এটা সবচেয়ে ভাল সমাধান খুঁজে।


আমি এই enum এক্সটেনশান অংশ যেখানে আমি আর জানি না, কিন্তু এটি থেকে। আমি এই জন্য দুঃখিত! কিন্তু আমি এই এক গ্রহণ এবং পতাকা সঙ্গে enums জন্য এটি সংশোধন করা হয়েছে। পতাকা দিয়ে enums জন্য আমি এই কাজ করেছেন:

  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;
     }
  }

উদাহরণ:

[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;

একটি স্ট্রিং থেকে: (Enum.Parse তারিখ শেষ হয়ে গেছে, Enum.TryParse ব্যবহার করুন)

enum Importance
{}

Importance importance;

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

একটি স্ট্রিং থেকে:

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.")

একটি int থেকে:

YourEnum foo = (YourEnum)yourInt;

হালনাগাদ:

নম্বর থেকে আপনি করতে পারেন

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

এটি উপরে টাভানি এর ইউটিলিটি ক্লাসের মত জেনেরিক্স ব্যবহার করে ডট নেট 4.0 এ আংশিক মেলিংয়ের সাথে একটি লক্ষ্য enum এ পূর্ণসংখ্যা বা স্ট্রিংগুলিকে বহন করে। আমি কমান্ড লাইন সুইচ ভেরিয়েবল রূপান্তর করতে এটি ব্যবহার করছি যা অসম্পূর্ণ হতে পারে। যেহেতু একটি enum নাল হতে পারে না, আপনি যুক্তিযুক্তভাবে একটি ডিফল্ট মান প্রদান করা উচিত। এটি এভাবে বলা যেতে পারে:

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

এখানে কোডটি রয়েছে:

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;
                }
            }
        }
    }
}

FYI: প্রশ্ন পূর্ণসংখ্যার সম্পর্কে ছিল, যে কেউ উল্লেখ করেনি Enum মধ্যে explicitly রূপান্তর করা হবে। TryParse ()


এটি একটি পতাকা গণনার সচেতন নিরাপদ রূপান্তর পদ্ধতি:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: struct
{
  var enumType = typeof (T);
  if (!enumType.IsEnum)
  {
    throw new ArgumentException("The generic type must be an enum.");
  }
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}

নিচে Enums জন্য একটি চমৎকার ইউটিলিটি বর্গ

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;
    }
}

নিম্নলিখিত উদাহরণ নিন:

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

যদি আপনার একটি পূর্ণসংখ্যা আছে যা বিটমাস্ক হিসাবে কাজ করে এবং [ফ্ল্যাগ] গণনার মধ্যে এক বা একাধিক মান উপস্থাপিত করতে পারে তবে আপনি এই কোডটি একটি তালিকাতে আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা আলাদা প্যারামিটার ব্যবহার করতে পারেন।

for (var flagIterator = 0x1; flagIterator <= 0x80000000; flagIterator <<= 1)
{
    // Check to see if the current flag exists in the bit mask
    if ((intValue & flagIterator) != 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), flagIterator))
            ListOfEnumValues.Add((MyEnum)flagIterator);
    }
}

শুধু এটা নিক্ষেপ:

MyEnum e = (MyEnum)3;

Enum.IsDefined ব্যবহার করে এটি পরিসীমা কিনা তা আপনি পরীক্ষা করতে পারেন:

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

সামান্য মূল প্রশ্ন থেকে দূরে পেয়ে, কিন্তু আমি স্ট্যাক ওভারফ্লো প্রশ্ন একটি উত্তর পাওয়া enum দরকারী থেকে int মান পানpublic const int বৈশিষ্ট্যের সাথে একটি স্ট্যাটিক ক্লাস তৈরি করুন, যা আপনাকে সহজেই সম্পর্কিত int স্টোনগুলির একটি গোষ্ঠীকে একত্রিত করার অনুমতি দেয় এবং তারপরে তাদের ব্যবহার করার সময় int নিক্ষেপ করতে হয় না।

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;
}

স্পষ্টতই, এনম টাইপের কিছু কার্যকারিতা হারিয়ে যাবে, কিন্তু ডাটাবেস আইডি স্টোনগুলির গুচ্ছ সংরক্ষণ করার জন্য, এটি একটি সুন্দর পরিচ্ছন্ন সমাধান বলে মনে হয়।


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);


 }
}






casting