bir numaralandırmayı başka tür bir numaralandırmaya dönüştürme

Örneğin ' Gender' ( Male =0 , Female =1) gibi bir numaram var ve kendi Cinsiyet numarasına ( Male =0 , Female =1, Unknown =2) sahip bir hizmetten başka bir numaram var

Sorum şu ki, kendi numaralandırmadan benimkine dönüştürmek için hızlı ve güzel bir şeyi nasıl yazabilirim?

Bir uzantı yöntemi kullanmak, Nate tarafından önerilen iki dönüştürme yöntemini kullanırken oldukça düzgün çalışır:

public static class TheirGenderExtensions
{
    public static MyGender ToMyGender(this TheirGender value)
    {
        // insert switch statement here
    }
}

public static class MyGenderExtensions
{
    public static TheirGender ToTheirGender(this MyGender value)
    {
        // insert switch statement here
    }
}

Açıkçası, istemiyorsanız ayrı sınıflar kullanmanıza gerek yok. Tercihim, uzantı yöntemlerini uyguladıkları sınıflara / yapılara / numaralandırmalara göre gruplandırmaktır.

Verilse Enum1 value = ..., o zaman adıyla demek istiyorsan:

Enum2 value2 = (Enum2) Enum.Parse(typeof(Enum2), value.ToString());

Sayısal değerle kastediyorsanız, genellikle şunları çevirebilirsiniz:

Enum2 value2 = (Enum2)value;

(cast ile, Enum.IsDefinedgeçerli değerleri kontrol etmek için kullanmak isteyebilirsiniz , ancak)

Sadece birini int'e çevirin ve sonra diğer numaraya çevirin (eşlemenin değere göre yapılmasını istediğinizi düşünerek):

Gender2 gender2 = (Gender2)((int)gender1);

Kapsamlı olmak için, normalde Enum 1'i alıp Enum 2'yi döndüren ve Enum 2'yi alıp Enum 1'i döndüren bir çift işlev oluşturuyorum. Her biri, girdileri çıktılara eşleyen bir case deyiminden oluşur ve varsayılan durum, bir istisna atar. beklenmedik bir değerden şikayet eden mesaj.

Bu özel durumda, Erkek ve Kadın'ın tamsayı değerlerinin aynı olduğu gerçeğinden yararlanabilirsiniz, ancak gelecekte enum değişirse kırılmaya maruz kaldığı için bundan kaçınırım.

Eğer sahipsek:

enum Gender
{
    M = 0,
    F = 1,
    U = 2
}

ve

enum Gender2
{
    Male = 0,
    Female = 1,
    Unknown = 2
}

Güvenle yapabiliriz

var gender = Gender.M;
var gender2   = (Gender2)(int)gender;

Ya da

var enumOfGender2Type = (Gender2)0;

'=' İşaretinin sağ tarafındaki bir numaralandırmanın sol taraftaki numaralandırmadan daha fazla değere sahip olduğu durumu ele almak istiyorsanız - diğerlerinin önerdiği şekilde bunu kapsayacak şekilde kendi yönteminizi / sözlüğünüzü yazmanız gerekecektir.

Bunun gibi basit bir genel uzatma yöntemi yazabilirsiniz

public static T ConvertTo<T>(this object value)            
    where T : struct,IConvertible
{
    var sourceType = value.GetType();
    if (!sourceType.IsEnum)
        throw new ArgumentException("Source type is not enum");
    if (!typeof(T).IsEnum)
        throw new ArgumentException("Destination type is not enum");
    return (T)Enum.Parse(typeof(T), value.ToString());
}

aşağıdaki gibi basit bir işlev yazabilirsiniz:

public static MyGender ConvertTo(TheirGender theirGender)
{
    switch(theirGender)
    {
        case TheirGender.Male:
            break;//return male
        case TheirGender.Female:
            break;//return female
        case TheirGender.Unknown:
            break;//return whatever
    }
}

İlgilenen varsa işte bir uzantı yöntemi sürümü

public static TEnum ConvertEnum<TEnum >(this Enum source)
    {
        return (TEnum)Enum.Parse(typeof(TEnum), source.ToString(), true);
    }

// Usage
NewEnumType newEnum = oldEnumVar.ConvertEnum<NewEnumType>();

public static TEnum ConvertByName<TEnum>(this Enum source, bool ignoreCase = false) where TEnum : struct
{
    // if limited by lack of generic enum constraint
    if (!typeof(TEnum).IsEnum)
    {
        throw new InvalidOperationException("enumeration type required.");
    }

    TEnum result;
    if (!Enum.TryParse(source.ToString(), ignoreCase, out result))
    {
        throw new Exception("conversion failure.");
    }

    return result;
}

Bir süre önce birkaç farklı tür için çalışan bir küme genişletme yöntemi yazdım Enum. Eğer başarmak için çalışıyoruz ve kolları ne için özellikle eserlerinde biri Enumolan lar FlagsAttributeyanı sıra Enumfarklı altta yatan türleriyle s.

public static tEnum SetFlags<tEnum>(this Enum e, tEnum flags, bool set, bool typeCheck = true) where tEnum : IComparable
{
    if (typeCheck)
    {
        if (e.GetType() != flags.GetType())
            throw new ArgumentException("Argument is not the same type as this instance.", "flags");
    }

    var flagsUnderlyingType = Enum.GetUnderlyingType(typeof(tEnum));

    var firstNum = Convert.ToUInt32(e);
    var secondNum = Convert.ToUInt32(flags);

    if (set)
        firstNum |= secondNum;

    else
        firstNum &= ~secondNum;

    var newValue = (tEnum)Convert.ChangeType(firstNum, flagsUnderlyingType);

    if (!typeCheck)
    {
        var values = Enum.GetValues(typeof(tEnum));
        var lastValue = (tEnum)values.GetValue(values.Length - 1);

        if (newValue.CompareTo(lastValue) > 0)
            return lastValue;
    }

    return newValue;
}

Oradan, diğer daha spesifik uzatma yöntemlerini ekleyebilirsiniz.

public static tEnum AddFlags<tEnum>(this Enum e, tEnum flags) where tEnum : IComparable
{
    SetFlags(e, flags, true);
}

public static tEnum RemoveFlags<tEnum>(this Enum e, tEnum flags) where tEnum : IComparable
{
    SetFlags(e, flags, false);
}

Bu Enum, yapmaya çalıştığınız gibi türlerini değiştirecek .

public static tEnum ChangeType<tEnum>(this Enum e) where tEnum : IComparable
{
    return SetFlags(e, default(tEnum), true, false);
}

Yine de, bayrakları olmayanlar da dahil olmak üzere, bu yöntemi kullanarak herhangi biri Enumve diğerleri arasında dönüşüm YAPABİLECEĞİNİZ konusunda uyarılmalıdır Enum. Örneğin:

public enum Turtle
{
    None = 0,
    Pink,
    Green,
    Blue,
    Black,
    Yellow
}

[Flags]
public enum WriteAccess : short
{
   None = 0,
   Read = 1,
   Write = 2,
   ReadWrite = 3
}

static void Main(string[] args)
{
    WriteAccess access = WriteAccess.ReadWrite;
    Turtle turtle = access.ChangeType<Turtle>();
}

Değişkenin turtledeğeri olacakTurtle.Blue .

Bununla birlikte, Enumbu yöntem kullanıldığında tanımlanmamış değerlerden güvenlik vardır . Örneğin:

static void Main(string[] args)
{
    Turtle turtle = Turtle.Yellow;
    WriteAccess access = turtle.ChangeType<WriteAccess>();
}

Bu durumda, accessayarlanacak WriteAccess.ReadWriteberi, WriteAccess Enum3 maksimum değere sahiptir.

EnumS ile FlagsAttributeve onsuz olanları karıştırmanın bir başka yan etkisi de , dönüştürme işleminin değerleri arasında 1'e 1 eşleşme ile sonuçlanmamasıdır.

public enum Letters
{
    None = 0,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H
}

[Flags]
public enum Flavors
{
    None = 0,
    Cherry = 1,
    Grape = 2,
    Orange = 4,
    Peach = 8
}

static void Main(string[] args)
{
    Flavors flavors = Flavors.Peach;
    Letters letters = flavors.ChangeType<Letters>();
}

Bu durumda, lettersbir değere sahip olacaktır Letters.Hyerine Letters.Darkalık değeri için, Flavors.Peachaynı zamanda 8 olan bir dönüşüm, Flavors.Cherry | Flavors.Grapeiçin Lettersdoğuracak Letters.C, unintuitive görünebilir olan.

Justin'in yukarıdaki cevabına dayanarak şunu buldum:

    /// <summary>
    /// Converts Enum Value to different Enum Value (by Value Name) See https://stackoverflow.com/a/31993512/6500501.
    /// </summary>
    /// <typeparam name="TEnum">The type of the enum to convert to.</typeparam>
    /// <param name="source">The source enum to convert from.</param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public static TEnum ConvertTo<TEnum>(this Enum source)
    {
        try
        {
            return (TEnum) Enum.Parse(typeof(TEnum), source.ToString(), ignoreCase: true);
        }
        catch (ArgumentException aex)
        {
            throw new InvalidOperationException
            (
                $"Could not convert {source.GetType().ToString()} [{source.ToString()}] to {typeof(TEnum).ToString()}", aex
            );
        }
    }

Bunun eski bir soru olduğunu ve pek çok cevabı olduğunu biliyorum, Ancak kabul edilen cevapta olduğu gibi bir switch ifadesini kullanmanın biraz zahmetli olduğunu görüyorum, işte 2 sentim:

Kişisel favori yöntemim, anahtarın kaynak enum olduğu ve değerin hedef enum olduğu bir sözlük kullanmaktır - bu nedenle soruda sunulan durumda kodum şöyle görünür:

var genderTranslator = new Dictionary<TheirGender, MyGender>();
genderTranslator.Add(TheirGender.Male, MyGender.Male);
genderTranslator.Add(TheirGender.Female, MyGender.Female);
genderTranslator.Add(TheirGender.Unknown, MyGender.Unknown);

// translate their to mine    
var myValue = genderTranslator[TheirValue];

// translate mine to their
var TheirValue = genderTranslator .FirstOrDefault(x => x.Value == myValue).Key;;

Tabii ki, bu statik bir sınıfa sarılabilir ve bir uzantı yöntemi olarak kullanılabilir:

public static class EnumTranslator
{

    private static Dictionary<TheirGender, MyGender> GenderTranslator = InitializeGenderTranslator();

    private static Dictionary<TheirGender, MyGender> InitializeGenderTranslator()
    {
        var translator = new Dictionary<TheirGender, MyGender>();
        translator.Add(TheirGender.Male, MyGender.Male);
        translator.Add(TheirGender.Female, MyGender.Female);
        translator.Add(TheirGender.Unknown, MyGender.Unknown);
        return translator;
    }

    public static MyGender Translate(this TheirGender theirValue)
    {
        return GenderTranslator[theirValue];
    }

    public static TheirGender Translate(this MyGender myValue)
    {
        return GenderTranslator.FirstOrDefault(x => x.Value == myValue).Key;
    }

}

İlk numaralandırmayı adına dönüştürmek için ToString () ve ardından dizeyi diğer Enum'a dönüştürmek için Enum.Parse () kullanabilirsiniz. Bu, değer hedef enum tarafından desteklenmiyorsa bir istisna oluşturur (yani "Bilinmeyen" bir değer için)