Immettere il tipo nel metodo, l'operatore "<" non può essere utilizzato sul tipo "Tipo"

Question

Stavo cercando di rendere il mio codice più pulito spostando qualcosa che chiamo molto in un metodo statico. Il codice originale è:

List<ListItem> listItems = Enum
  .GetValues(typeof(TimelineinfoEnums.StateEnum))
  .Cast<TimelineinfoEnums.StateEnum>()
  .Select(x => new ListItem { 
     Text  = x.ToString(), 
     Value = (int)x })
  .ToList();

TimelineinfoEnums.StateEnumè solo un segnaposto, il punto del mio metodo è essere in grado di chiamarlo, passare un valore e creare TimelineinfoEnums.StateEnumqualche altra enum con cui sto lavorando. Dopo aver letto altrove su SO, che devi usare una stringa di input per cose come questa perché "il tipo di entità non è letteralmente noto, o conoscibile, in fase di compilazione.", Ho provato questo codice:

 public static List<ListItem> GetDropdownList(string @enum)
 {     
     List<ListItem> listItems = Enum
       .GetValues(@enum.GetType())
       .Cast<@enum.GetType()>()
       .Select(
          x => new ListItem { Text = x.ToString(), Value = (int)x }).ToList();            
          return listItems;
        }

Tuttavia, quando ho tentato di farlo, il secondo @enum.GetType()ho ricevuto un errore di:

L'operatore "<" non può essere applicato agli operandi di tipo "gruppo di metodi" e "Tipo"

Ho provato a rimuovere il .GetType()bit ma poi ottengo un errore di

enum è una variabile ma è usata come un tipo

Non ho molta familiarità con Linq, quindi probabilmente mi mancherà qualcosa di semplice, grazie per qualsiasi aiuto!

Modifica: ListItem assomiglia a questo:

 public class ListItem
        {
            public int Value { get; set; }
            public string Text { get; set; }
        }

Answer 1

È comunque possibile utilizzare generics, ma utilizzare il struct, Enumvincolo aggiunto in C # 7.3:

Cambia il tuo codice in questo:

public static List<ListItem> GetDropdownList<TEnum>()
    where TEnum : struct, Enum
{     
     return Enum.GetValues( typeof(TEnum) )
        .Cast<TEnum>()
        .Select( e => new ListItem() { Text = e.ToString(), Value = Convert.ToInt32( e ) } );
        .ToList();

    public static IReadOnlyList<ListItem> Items => _items;
}

Si noti che le prestazioni del codice sopra possono essere migliorate spostandolo in una classe generica statica e memorizzando il risultato in un campo statico, poiché ciò memorizzerà il risultato nella cache (poiché i tipi generici esistono una volta per ogni tipo, quindi non è necessario eseguire questo calcolo più di una volta):

public static class EnumListItems<TEnum>
    where TEnum : struct, Enum
{
    private static readonly IReadOnlyList<ListItem> _items = Enum.GetValues( typeof(TEnum) )
        .Cast<TEnum>()
        .Select( e => new ListItem() { Text = e.ToString(), Value = Convert.ToInt32( e ) } );
        .ToList();

    public static IReadOnlyList<ListItem> Items => _items;
}

Usato così:

IReadOnlyList<ListItem> items = EnumListItems<MyEnum>.Items;

Se hai bisogno di un elenco modificabile, usa .ToList():

List<ListItem> items = EnumListItems<MyEnum>.Items.ToList();

Answer 2

il tipo di entità non è letteralmente noto, o conoscibile, in fase di compilazione

Sembra cheCast() tu debba usare per fare qualcosa di significativo con Linq , perché Enum.GetValues()il tipo di ritorno di non è mai stato aggiornato per supportare raccolte generiche per Linq. Inoltre, @enum.GetType()tornerà sempre System.String.

L'unica cosa che vuoi estrarre, sono il valore intero e testuale dei membri di enum, e puoi estrarli da qualsiasi enum. Così:

private static List<ListItem> GetListItems<TEnum>()
{
    var result = new List<ListItem>();
    
    foreach (object e in Enum.GetValues(typeof(TEnum)))
    {
        result.Add(new ListItem 
        { 
            Text = e.ToString(),
            Value = (int)e
        });
    }
               
    return result;
}

Quando si usa C # 7.3 e versioni successive, è necessario limitare TEnumaSystem.Enum . E se vuoi Linq invece di un ciclo, puoi usare Enum.GetValues(typeof(TEnum)).Cast<System.Enum>().

Ora, se non lo sai TEnumin fase di compilazione, guarda come chiamare un metodo generico con un determinato oggetto Type? e Type.GetType(enumName).