有什么办法可以将这两种方法合并为一种方法或重载方法？

Question

这是一个棘手的问题。也许某人的C＃-fu比我的优越，因为我找不到解决方案。

我有一个方法，它需要一个参数，该参数包含一个枚举或一个指示枚举值的字符串，并返回该枚举的一个实例。它基本上是Enum.Parse的实现，但作为一种通用方法实现。为什么.NET Framework没有内置的功能超出了我的想象。现在

public static T Parse<T>(object value) where T : struct 
{ 
    if (!typeof (T).IsEnum) 
     throw new ArgumentException("T must be an Enum type."); 

    if (value == null || value == DBNull.Value) 
    { 
     throw new ArgumentException("Cannot parse enum, value is null."); 
    } 

    if (value is String) 
    { 
     return (T)Enum.Parse(typeof(T), value.ToString()); 
    } 

    return (T)Enum.ToObject(typeof(T), value); 
} 

，我可以这样做：

MyEnum foo = Parse<MyEnum>(obj); 

，并得到MyEnum一个实例。如果obj为空，则会抛出异常。

但是，有时obj是null，我想这样做。在这种情况下，我希望能够做到：

MyEnum? foo = Parse<MyEnum?>(obj); 

但是，对于我的生活，我不能想出一个办法来获取工作。首先，尽管Nullable<MyEnum>是struct，但它不能用作Parse<T>的类型参数。我认为这跟编译器用Nullable<>所做的所有魔法有关，所以我不会质疑它。

它没有出现，你可以超载的方法，只区分它的基础上约束T。例如，如果我这样做：

public static T Parse<T>(object value) where T : new() 
{ 
    // This should be called if I pass in a Nullable, in theory 
} 

我会得到错误：成员具有相同签名已经宣布

所以，这给我留下了只剩下一个方法：实现一个完全独立的方法设计为可空类型：

MyEnum? foo = ParseNullable<T>(obj); 

：

public static T? ParseNullable<T>(object value) where T : struct 
{ 
    if (!typeof (T).IsEnum) 
     throw new ArgumentException("T must be an Enum type."); 

    if (value == null || value == DBNull.Value) 
     return null; 

    if (value is String) 
     return Enum.Parse(typeof (T), value.ToString()) as T?; 

    return Enum.ToObject(typeof (T), value) as T?; 
} 

现在我可以把这个

我的问题：有没有办法将这两种方法结合成一种方法，根据类型参数做对，或者创建一个重载，其中一个重载将用于类型参数是可空的<>而另一个超载在不是时调用？

Answer 1

它需要在方法中的情侣额外的类型检查，你必须跳过通用的限制，但它绝对有可能：

public static T Parse<T>(object value) 
{ 
    var isNullable = typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>); 
    var itemType = isNullable ? typeof(T).GetGenericArguments()[0] : typeof(T); 

    if (!itemType.IsEnum) 
     throw new ArgumentException("T must be an Enum type or Nullable<> of Enum type."); 

    if (value == null || value == DBNull.Value) 
    { 
     if (isNullable) 
      return default(T); // default(Nullable<>) is null 

     throw new ArgumentException("Cannot parse enum, value is null."); 
    } 

    if (value is String) 
    { 
     return (T)Enum.Parse(itemType, value.ToString()); 
    } 

    return (T)Enum.ToObject(itemType, value); 
} 

使用范例：

var items = new object[] { "A", "B", 0, 10, null, DBNull.Value }; 

var results = items.Select(x => new { x, e = Parse<Test?>(x) }).ToArray(); 

foreach (var r in results) 
    Console.WriteLine("{0} - {1}", r.x, r.e.ToString()); 

打印

A - A 
B - B 
0 - A 
10 - B 
- 
- 

Answer 2

创建一个像TryParse这样的方法，并处理返回值==假大小写，以便根据空值执行所需操作。然后，您可以实现另一个方法来包装该调用，并在返回值为false时返回null。 （另外，一定要使用Enum.IsDefined为枚举的类型的任何值分配，即使它不是由枚举定义枚举）

public static bool TryParseEnum<T>(object value, out T result) where T : struct 
{ 
    if(!typeof(T).IsEnum) 
     throw new ArgumentException("T must be an Enum type."); 

    if(value == null || value == DBNull.Value) 
    { 
     result = default(T); 

     return false; 
    } 

    if(value is String) 
    { 
     return Enum.TryParse<T>((string)value, out result); 
    } 

    result = (T)Enum.ToObject(typeof(T), value); 

    return Enum.IsDefined(typeof(T), result); 
} 

public static Nullable<T> ParseEnum<T>(this object value) where T: struct 
{ 
    T retVal; 

    if(!TryParseEnum(value, out retVal)) 
    { 
     return null; 
    } 

    return new Nullable<T>(retVal); 
} 

用法：

EnumXyz? nullableEnumValue = ParseEnum<EnumXyz>(someObject); 

Answer 3

我要去提供另一种方法...返回默认值。它是一个好主意，让代表反正没事（如果你忘了初始化等）enum SA默认值...即：

enum MyEnum { 
    Nothing = 0, 
    MeaningfulValue1, 
    MeaningfulValue2 
    // etc.. 
} 

然后你的方法只是变成：

if (value == null || value == DBNull.Value) 
    return default(T); 

。 。和致电地点：

var val = Parse<MyEnum>(obj); 

if (val == MyEnum.Nothing) 
    // it was null. 

Answer 4

由于您实际上没有通过更改返回类型来重载，所以答案是您无法按自己的意愿进行操作。

我会添加一个重载，它需要一个单独的参数来确定参数的可用性。

public static T Parse<T>(object value) where T : struct 
{ 
    return (T)Parse<T>(value, false); 
} 

public static T? Parse<T>(object value, bool nullable) where T : struct 
{ 
    T? enumValue = null; 

    if (! typeof(T).IsEnum) 
    { 
     throw new ArgumentException("T must be an Enum type."); 
    } 
    else if (value == null || value == DBNull.Value) 
    { 
     // this is the key difference 
     if (! nullable) 
     { 
      throw new ArgumentException("Cannot parse enum, value is null."); 
     } 
    } 
    else if (value is string) 
    { 
     enumValue = (T)Enum.Parse(typeof(T), value.ToString()); 
    } 
    else 
    { 
     enumValue = (T)Enum.ToObject(typeof(T), value); 
    } 

    return enumValue; 
} 

用法：

MyEnum value1 = Parse<MyEnum>("A"); 
// returns null 
MyEnum? value2 = Parse<MyEnum>(null, true); 
// throws exception 
MyEnum? value2 = Parse<MyEnum>(null, false); 

Answer 5

为什么不只是删除T上的约束，并且做这样的事情：

public static T Parse<T>(Object value) 
    { 
     Boolean isNullable = typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>); 
     if (!isNullable && !typeof(T).IsEnum) 
     { 
      throw new ArgumentException(); 
     } 

     if (value == null || value == DBNull.Value) 
     { 
      throw new ArgumentException(); 
     } 

     if (!(value is String)) 
     { 
      return (T) Enum.ToObject(typeof (T), value); 
     } 

     if (!isNullable) 
     { 
      return (T) Enum.Parse(typeof (T), value.ToString()); 
     } 

     Type underlyingType = Nullable.GetUnderlyingType(typeof(T)); 
     try 
     { 
      return (T)Enum.Parse(underlyingType, value.ToString()); 
     } 
     catch (ArgumentException) 
     { 
      return default(T); 
     } 
    } 

这应该工作，如果没有，让我知道。

Answer 6

我相信你的问题的简短答案是“否”在您问题开始时提供的示例中，您希望返回两种不同的返回类型T和T ?.这本身就需要具有不同名称的方法。

这是一个link到另一个问题，在泛型类型的可能的答案很好的答案，可能有助于澄清你的问题。

Answer 7

如果你真的想用一种方法，那么这个怎么样？ 缺点是您必须删除where T : struct约束。 如果你想保留约束条件，那么把它分成两个方法是唯一的方法。

public static T Parse<T>(object value) 
    { 
     Type underlyingType = Nullable.GetUnderlyingType(typeof(T)); 
     bool isNullable = underlyingType != null; 

     if (!typeof(T).IsEnum && !isNullable) 
      throw new ArgumentException("T must be an Enum type."); 

     if (value == null || value == DBNull.Value) 
     { 
      if (isNullable) 
       return default(T); 

      throw new ArgumentNullException("value"); 
     } 

     if (value is String) 
      return (T)Enum.Parse(underlyingType ?? typeof(T), value.ToString()); 

     if (!value.GetType().IsValueType) 
      throw new ArgumentException("value must be a primitive type", "value"); 

     return (T)Enum.ToObject(underlyingType ?? typeof(T), value); 
    }