How to limit a generic type parameter to System.Enum [duplicate]

25

Possible Duplicates:
Anyone know a good workaround for the lack of an enum generic constraint?
Create Generic method constraining T to an Enum

Is is possible to limit the generic type parameter [I don't know if that's the right name] to an Enum?

For example how do I do something like this?

//VB.NET
Function GetValues(Of T As System.Enum)(ByVal value As T) As IEnumerable(Of T)
    Return [Enum].GetValues(value.GetType)
End Function

//C#
public IEnumerable<T> GetValues<T>(T value) where T : System.Enum
{
    return Enum.GetValues(value.GetType());
}

Update

I eventually used Jon Skeet's Unconstrained Melody for that purpose. Thanks to you all for your contributions.

Alex Essilfie

출처 c# .net vb.net enums

4 답변

7

Unfortunately, you cannot - Microsoft closed this one out as a won't fix item.

You can treat enums as structs and use that as the constraint instead (I think that was how Jon Skeet did it in Unconstrained Melody?) but that is kind of unsightly.

  • Thanks for pointing out Jon Skeet's Unconstrained Melody. It was very helpful. - Alex Essilfie
  • Link is broken. - AbleArcher
  • C# 7.3 actually added the ability to constrain generic restraints by enums directly - source - Tyler Gill
16

You can't. An alternative solution is using struct and run-time check.

public IEnumerable<T> GetValues<T>(T value) where T : struct
{  
    if (!typeof(T).IsEnum) throw new NotSupportedException();
    return (IEnumerable<T>)Enum.GetValues(value.GetType()); 
}

  • This won't return the desired result, if it even compiles. Enum.GetValues returns an Array (whose elements are just Objects), which does not cast implicitly to an IEnumerable<T>. - KeithS
  • Unfortunately, your solution will not return a generic enumerable list. It provided me with some insight though. Thanks. - Alex Essilfie
  • As an aside, I implemented your solution and @Keiths' for a different, though related, purpose. - Alex Essilfie
5

Matt's and Danny's answers both have half the answer. This should actually get you what you need:

public IEnumerable<T> GetValues<T>() where T : struct
{   
    if (!typeof(T).IsEnum) throw new InvalidOperationException("Generic type argument is not a System.Enum");
    return Enum.GetValues(typeof(T)).OfType<T>(); 
}

Changes from Danny's answer:

  • Though having a parameter of the generic type allows for type inference, since the value is not actually used it is more proper to explicitly specify the generic type (like with the Linq methods that don't take parameters).
  • Enum.GetValues() returns an Array of Objects, which will not cast implicitly to an IEnumerable of T. The extra Linq method to cast the results (technically OfType is a filter operation but in this case it'll return everything) is necessary to conform to the return type.
  • Optional: though NotSupportedException is as good a choice as any for an exception to throw, there are other options; ArgumentException, InvalidOperationException, InvalidCastException, etc. I chose InvalidOperationException because that's what it is; an invalid attempt to get enum values from a non-enum type. This is semantic and I'm not going to argue with anyone else's logic.

  • Why not just use the Cast method? return Enum.GetValues(typeof(T)).Cast<T>() - Metro Smurf
  • it would probably work in this case, however there are several questions on this site dealing with cases where it doesn't work the way users expect. I prefer to avoid it in favor of OfType or Select, which will do the job in an unambiguous way. - KeithS
  • As an aside, I implemented your solution and @Danny Chen's for a different, though related, purpose. - Alex Essilfie
2

There is no need to make your method generic in this way.

You can just use the System.Enum as the type parameter in your return type:

using System.Linq;
.
.
.
public IEnumerable<Enum> GetValues(Enum value)
{
    return Enum.GetValues(value.GetType()).OfType<Enum>();
}

  • Unfortunately, this isn't strongly typed to the Enum that was passed in; you get a list containing System.Enums that you then have to cast to the proper type. - KeithS
  • @KeithS: as you would with Danny Chen's answer, and the OP's original code (that wouldn't even work, in fact, as Array isn't generic). - Matt Ellen
  • No. The generic returns a strongly-typed list of values of that particular enum type; no casting of the return type is necessary (unless you want the numbers, or strings, etc). However, his doesn't work for other reasons. - KeithS

Linked

Related

Latest