Busque una cadena en Enum y devuelva el Enum

Tengo una enumeración:

public enum MyColours
{
    Red,
    Green,
    Blue,
    Yellow,
    Fuchsia,
    Aqua,
    Orange
}

y tengo una cadena:

string colour = "Red";

Quiero poder volver:

MyColours.Red

de:

public MyColours GetColour(string colour)

Hasta ahora tengo:

public MyColours GetColours(string colour)
{
    string[] colours = Enum.GetNames(typeof(MyColours));
    int[]    values  = Enum.GetValues(typeof(MyColours));
    int i;
    for(int i = 0; i < colours.Length; i++)
    {
        if(colour.Equals(colours[i], StringComparison.Ordinal)
            break;
    }
    int value = values[i];
    // I know all the information about the matched enumeration
    // but how do i convert this information into returning a
    // MyColour enumeration?
}

Como puede ver, estoy un poco atascado. ¿Hay alguna forma de seleccionar un enumerador por valor? Algo como:

MyColour(2) 

daría como resultado

MyColour.Green

echa un vistazo a System.Enum.Parse:

enum Colors {Red, Green, Blue}

// your code:
Colors color = (Colors)System.Enum.Parse(typeof(Colors), "Green");

Puedes convertir el int en una enumeración

(MyColour)2

También existe la opción de Enum.

(MyColour)Enum.Parse(typeof(MyColour), "Red")

Dados los últimos y mejores cambios en .NET (+ Core) y C # 7, esta es la mejor solución:

var ignoreCase = true;
Enum.TryParse("red", ignoreCase , out MyColours colour);

La variable de color se puede utilizar dentro del alcance de Enum. TryParse

Todo lo que necesitas es Enum .

Marqué la respuesta de OregonGhost +1, luego intenté usar la iteración y me di cuenta de que no estaba del todo bien porque Enum.GetNames devuelve cadenas. Desea Enum.GetValues:

public MyColours GetColours(string colour)
{  
   foreach (MyColours mc in Enum.GetValues(typeof(MyColours))) 
   if (mc.ToString() == surveySystem) 
      return mc;

   return MyColors.Default;
}

Puede usar Enum.Parsepara obtener un valor de enumeración del nombre. Puede iterar sobre todos los valores con Enum.GetNames, y simplemente puede convertir un int en una enumeración para obtener el valor de enumeración del valor int.

Así, por ejemplo:

public MyColours GetColours(string colour)
{
    foreach (MyColours mc in Enum.GetNames(typeof(MyColours))) {
        if (mc.ToString().Contains(colour)) {
            return mc;
        }
    }
    return MyColours.Red; // Default value
}

o:

public MyColours GetColours(string colour)
{
    return (MyColours)Enum.Parse(typeof(MyColours), colour, true); // true = ignoreCase
}

Este último arrojará una ArgumentException si no se encuentra el valor, es posible que desee atraparlo dentro de la función y devolver el valor predeterminado.

var color =  Enum.Parse<Colors>("Green");

Como se mencionó en las respuestas anteriores, puede transmitir directamente al tipo de datos subyacente (int -> tipo de enumeración) o analizar (cadena -> tipo de enumeración).

pero tenga cuidado: no hay. TryParse para las enumeraciones, por lo que necesitará un bloque try / catch alrededor del análisis para detectar fallas.

class EnumStringToInt // to search for a string in enum
{
    enum Numbers{one,two,hree};
    static void Main()
    {
        Numbers num = Numbers.one; // converting enum to string
        string str = num.ToString();
        //Console.WriteLine(str);
        string str1 = "four";
        string[] getnames = (string[])Enum.GetNames(typeof(Numbers));
        int[] getnum = (int[])Enum.GetValues(typeof(Numbers));
        try
        {
            for (int i = 0; i <= getnum.Length; i++)
            {
                if (str1.Equals(getnames[i]))
                {
                    Numbers num1 = (Numbers)Enum.Parse(typeof(Numbers), str1);
                    Console.WriteLine("string found:{0}", num1);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Value not found!", ex);
        }
    }
}

Una cosa que podría serle útil (además de las respuestas válidas / buenas proporcionadas hasta ahora) es la idea de StringEnum proporcionada aquí

Con esto puede definir sus enumeraciones como clases (los ejemplos están en vb.net):

<StringEnumRegisteredOnly (), DebuggerStepThrough (), ImmutableObject (True)> Public NotInheritable Class eAuthenticationMethod hereda StringEnumBase (Of eAuthenticationMethod)

Private Sub New(ByVal StrValue As String)
  MyBase.New(StrValue)   
End Sub

< Description("Use User Password Authentication")> Public Shared ReadOnly UsernamePassword As New eAuthenticationMethod("UP")   

< Description("Use Windows Authentication")> Public Shared ReadOnly WindowsAuthentication As New eAuthenticationMethod("W")   

Clase final

Y ahora podría usar esta clase como usaría una enumeración: eAuthenticationMethod.WindowsAuthentication y esto sería esencialmente como asignar ' W ' al valor lógico de WindowsAuthentication (dentro de la enumeración) y si fuera a ver este valor desde una propiedad ventana (u otra cosa que use la propiedad System.ComponentModel.Description) obtendría " Usar autenticación de Windows ".

He estado usando esto durante mucho tiempo y hace que el código sea más claro en su intención.

(MyColours)Enum.Parse(typeof(MyColours), "red", true); // MyColours.Red
(int)((MyColours)Enum.Parse(typeof(MyColours), "red", true)); // 0

También puede consultar algunas de las sugerencias en esta publicación de blog: Mi nuevo amigo, Enum <T>

La publicación describe una forma de crear una clase auxiliar genérica muy simple que le permite evitar la sintaxis de conversión fea inherente a Enum.Parse- en su lugar, termina escribiendo algo como esto en su código:

MyColours colour = Enum<MyColours>.Parse(stringValue); 

O echa un vistazo a algunos de los comentarios en la misma publicación que hablan sobre el uso de un método de extensión para lograr algo similar.