mengonversi enum ke jenis enum lain

Saya memiliki enum misalnya ' Gender' ( Male =0 , Female =1) dan saya memiliki enum lain dari layanan yang memiliki enum Gender sendiri ( Male =0 , Female =1, Unknown =2)

Pertanyaan saya adalah bagaimana saya bisa menulis sesuatu dengan cepat dan bagus untuk diubah dari enum mereka ke milik saya?

Menggunakan metode ekstensi berfungsi cukup baik, saat menggunakan dua metode konversi yang disarankan oleh Nate:

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

Jelas tidak perlu menggunakan kelas terpisah jika Anda tidak mau. Preferensi saya adalah menyimpan metode ekstensi yang dikelompokkan berdasarkan kelas / struktur / enumerasi yang mereka terapkan.

Diberikan Enum1 value = ..., maka jika yang Anda maksud dengan nama:

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

Jika yang Anda maksud dengan nilai numerik, biasanya Anda hanya dapat mentransmisikan:

Enum2 value2 = (Enum2)value;

(dengan cast, Anda mungkin ingin menggunakan Enum.IsDefineduntuk memeriksa nilai yang valid, meskipun)

Cukup lemparkan satu ke int dan kemudian lemparkan ke enum lain (mengingat Anda ingin pemetaan dilakukan berdasarkan nilai):

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

Untuk lebih teliti, saya biasanya membuat sepasang fungsi, yang mengambil Enum 1 dan mengembalikan Enum 2 dan lainnya yang mengambil Enum 2 dan mengembalikan Enum 1. Masing-masing terdiri dari input pemetaan pernyataan kasus ke output dan kasus default melempar pengecualian dengan a pesan yang mengeluh tentang nilai yang tidak terduga.

Dalam kasus khusus ini, Anda dapat memanfaatkan fakta bahwa nilai integer Pria dan Wanita adalah sama, tetapi saya akan menghindarinya karena bersifat hackish dan dapat rusak jika enum berubah di masa mendatang.

Jika kita memiliki:

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

dan

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

Kita bisa melakukannya dengan aman

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

Atau bahkan

var enumOfGender2Type = (Gender2)0;

Jika Anda ingin menutupi kasus di mana enum di sisi kanan tanda '=' memiliki lebih banyak nilai daripada enum di sisi kiri - Anda harus menulis metode / kamus Anda sendiri untuk menutupi itu seperti yang disarankan orang lain.

Anda dapat menulis metode ekstensi umum sederhana seperti ini

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

Anda bisa menulis fungsi sederhana seperti berikut:

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

Berikut adalah versi metode ekstensi jika ada yang tertarik

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

Saya menulis metode ekstensi set beberapa waktu lalu yang berfungsi untuk beberapa jenis yang berbeda Enum. Satu secara khusus bekerja untuk apa yang Anda coba capai dan tangani Enumdengan FlagsAttributeserta Enumdengan jenis dasar yang berbeda.

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

Dari sana Anda dapat menambahkan metode ekstensi lain yang lebih spesifik.

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

Yang ini akan mengubah jenis Enumseperti yang Anda coba lakukan.

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

Berhati-hatilah, meskipun, Anda BISA mengonversi antara salah satu Enumdan yang lain Enummenggunakan metode ini, bahkan yang tidak memiliki bendera. Sebagai contoh:

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

Variabel turtleakan memiliki nilai Turtle.Blue.

Namun, ada keamanan dari Enumnilai yang tidak ditentukan dengan menggunakan metode ini. Misalnya:

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

Dalam kasus ini, accessakan disetel ke WriteAccess.ReadWrite, karena WriteAccess Enummemiliki nilai maksimum 3.

Efek samping lain dari pencampuran Enums dengan FlagsAttributedan yang tanpanya adalah bahwa proses konversi tidak akan menghasilkan kecocokan 1 banding 1 di antara nilainya.

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

Dalam kasus ini, lettersakan memiliki nilai Letters.Halih - alih Letters.D, karena nilai dukungan Flavors.Peachadalah 8. Selain itu, konversi dari Flavors.Cherry | Flavors.Grapemenjadi Lettersakan menghasilkan Letters.C, yang tampaknya tidak intuitif.

Berdasarkan jawaban Justin di atas, saya mendapatkan ini:

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

Saya tahu itu pertanyaan lama dan memiliki banyak jawaban, Namun saya menemukan bahwa menggunakan pernyataan switch seperti pada jawaban yang diterima agak rumit, jadi inilah 2 sen saya:

Metode favorit pribadi saya adalah menggunakan kamus, di mana kuncinya adalah enum sumber dan nilainya adalah enum target - jadi dalam kasus yang disajikan pada pertanyaan, kode saya akan terlihat seperti ini:

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

Tentu saja, ini dapat digabungkan dalam kelas statis dan digunakan sebagai metode ekstensi:

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

}

Anda bisa menggunakan ToString () untuk mengonversi enum pertama ke namanya, lalu Enum.Parse () untuk mengonversi string kembali ke Enum lain. Ini akan memunculkan pengecualian jika nilai tidak didukung oleh enum tujuan (yaitu untuk nilai "Tidak diketahui")