C# 将值解析为可为null的枚举

假设我有这个：

PriorityType? priority;
string userInput = ...;

我无法更改其定义方式：

PriorityType？优先级

，因为它实际上是与另一段代码签订的合同的一部分

我试过这个，但不起作用：

if (Enum.TryParse<PriorityType?>(userInput, out priority)) {

if（Enum.TryParse（用户输入，输出优先级））{

正确的方法是什么？

最简单的方法：

PriorityType tempPriority;
PriorityType? priority;

if (Enum.TryParse<PriorityType>(userInput, out tempPriority))
    priority = tempPriority;

PriorityType-tempriority；
优先级类型？优先级；
if（Enum.TryParse（userInput，out tempriority））
优先级=临时优先级；

这是我能想到的最好办法：

public static class NullableEnum
{
    public static bool TryParse<T>(string value, out T? result) where T :struct, IConvertible
    {
        if (!typeof(T).IsEnum)
            throw new Exception("This method is only for Enums");

        T tempResult = default(T);

        if (Enum.TryParse<T>(value, out tempResult))
        {
            result = tempResult;
            return true;
        }

        result = null;
        return false;
    }
}

公共静态类NullableEnum
{
公共静态bool TryParse（字符串值，out T？结果），其中T:struct，IConvertible
{
if（！typeof（T）.IsEnum）
抛出新异常（“此方法仅用于枚举”）；
T tempResult=默认值（T）；
if（枚举TryParse（值，out tempResult））
{
结果=临时结果；
返回true；
}
结果=空；
返回false；
}
}

使用：

if（NullableEnum.TryParse（用户输入，输出优先级））

上面的类可以像Enum.TryParse一样使用，除了可为空的输入。您可以添加另一个重载函数，该函数接受不可为空的

T

，以便您可以在两个实例中都使用它（如果需要）。不幸的是，扩展方法在Enum类型上不能很好地工作（就我所能在短时间内尝试操作它而言）。

这是一篇经过一些重构的帖子：

 public static class NullableEnum
{
    public static bool TryParse<T>(string value, out T? result) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("Invalid Enum");

        result = Enum.TryParse(value, out T tempResult) ? tempResult : default(T?);

        return (result == null) ? false : true;
    }
}

公共静态类NullableEnum
{
公共静态bool TryParse（字符串值，out T？结果），其中T:struct，IConvertible
{
如果（！typeof（T）.IsEnum）抛出新的ArgumentException（“无效枚举”）；
结果=Enum.TryParse（值，out T tempResult）？tempResult：默认值（T？）；
返回值（结果==null）？false:true；
}
}

如果希望它是一行代码，可以这样做：

var priority = Enum.TryParse<PriorityType>(userInput, out var outPriority) ? outPriority : (PriorityType?) null;

var priority=Enum.TryParse（userInput，out-var-outPriority）？outPriority：（PriorityType？）null；

这里的另一种方法实际上可以让您处理可为空的枚举，而不是在获得它们时失败：

public static class EnumHelper {

    public static TEnum Parse<TEnum>( string value ){
        if( typeof(TEnum).IsEnum )
            return (TEnum)Enum.Parse( typeof(TEnum), value );

        Type? nullableType = Nullable.GetUnderlyingType( typeof(TEnum) );
        if( /*not a nullable type*/nullableType is null )
            throw new ArgumentException( $"Provided type {typeof(TEnum).Name} must be either an enum or a nullable enum" );

        return (TEnum?)Enum.Parse( nullableType, value );
    }

}

公共静态类EnumHelper{
公共静态TEnum解析（字符串值）{
if（类型（TEnum.IsEnum）
return（TEnum）Enum.Parse（typeof（TEnum），value）；
类型？nullableType=Nullable.GetUnderlyingType（typeof（TEnum））；
如果（/*不是可为null的类型*/nullableType为null）
抛出新ArgumentException（$“提供的类型{typeof（TEnum）.Name}必须是枚举或可为空的枚举”）；
return（TEnum？）Enum.Parse（nullableType，value）；
}
}

---

调用模式与使用

out

参数的基本库稍有不同，但如果您愿意，可以将其封装在相同的调用模式中。在大多数情况下，上述调用模式更易于使用。

您不能创建一个临时

PriorityType

，然后在解析后将其分配给

priority

？是的，我可以，只是想一想可能有更好的方法。将此作为答案发布，如果没有更好的方法，那么我将接受您的答案。：）我认为没有。

TEnum

通用参数设置为

where TEnum:struct

。工作得很好，但我想知道如果您只使用

默认值（
vs default（t？
），为什么不起作用。
public static class EnumHelper {

    public static TEnum Parse<TEnum>( string value ){
        if( typeof(TEnum).IsEnum )
            return (TEnum)Enum.Parse( typeof(TEnum), value );

        Type? nullableType = Nullable.GetUnderlyingType( typeof(TEnum) );
        if( /*not a nullable type*/nullableType is null )
            throw new ArgumentException( $"Provided type {typeof(TEnum).Name} must be either an enum or a nullable enum" );

        return (TEnum?)Enum.Parse( nullableType, value );
    }

}