ASP.Net Core中使用枚举类而不是枚举的方法

2024-09-28 20:37:58

前言：

我相信大家在编写代码时经常会遇到各种状态值，而且为了避免硬编码和代码中出现魔法数，通常我们都会定义一个枚举，来表示各种状态值，直到我看到Java中这样使用枚举，我再想C# 中可不可以这样写，今天就分享一下我的感悟。

一、通常我们是这样使用枚举的

（1）switch中使用枚举

 public enum EmployeeType
 {
 Manager,
 Servant,
 AssistantToTheRegionalManager
 }

public class Employee
 {
 public EmployeeType Type { get; set; }
 public decimal Bonus { get; set; }
 }

static void ProcessBonus(Employee employee)
 {
  switch (employee.Type)
  {
  case EmployeeType.Manager:
   employee.Bonus = 1000m;
   break;
  case EmployeeType.Servant:
   employee.Bonus = 0.01m;
   break;
  case EmployeeType.AssistantToTheRegionalManager:
   employee.Bonus = 1.0m;
   break;
  default:
   throw new ArgumentOutOfRangeException();
  }
 }

在没有进某唐时我也是这样的写的，代码很烂，违法了开闭原则，扩展性极差。在代码规范中是不允许出现这样的写法的。对于上面的写法可以使用设计模式来重构。后面会继续更新设计模式的文章。

（2）类型转换

EnumTricks.IsVolumeHigh((Volume)27);
EnumTricks.High((int)Medium);

二、枚举的不好之处

关于枚举的MSDN文档说了什么：

“The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list. Every enumeration type has an underlying type, which can be any integral type except char. The default underlying type of the enumeration elements is int. By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1.

（1）没有类型安全

枚举是简单的值类型，可以提供对无效值的保护，并且不会出现任何行为。他们是有用的，因为他们是魔法数字的改进，但就是这样。如果要约束类型可能的值，枚举不一定能帮助您，因为仍然可以提供无效类型。例如，此枚举有三个值，默认情况下将具有int类型。值范围为1到3。

 public enum Volume
 {
 Low = 1,
 Medium,
 High
 }

public static class EnumTricks
 {
 public static bool IsVolumeHigh(Volume volume)
 {
  var result = false;

  switch (volume)
  {
  case Volume.Low:
   Console.WriteLine("Volume is low.");
   break;

  case Volume.Medium:
   Console.WriteLine("Volume is medium.");
   break;

  case Volume.High:
   Console.WriteLine("Volume is high.");
   result = true;
   break;
  }

  return result;
 }
 }

static void Main(string[] args)
 {
  EnumTricks.IsVolumeHigh((Volume)27);

  Console.ReadKey();
 }

public static class EnumTricks
 {
 public static bool IsVolumeHigh(Volume volume)
 {
  var result = false;

  switch (volume)
  {
  case Volume.Low:
   Console.WriteLine("Volume is low.");
   break;

  case Volume.Medium:
   Console.WriteLine("Volume is medium.");
   break;

  case Volume.High:
   Console.WriteLine("Volume is high.");
   result = true;
   break;
  }

  return result;
 }

 public static int EnumToInt(Volume volume)
 {
  return (int)volume;
 }

 public static Volume IntToEnum(int intValue)
 {
  return (Volume)intValue;
 }

 public static Volume StringToEnum(string stringValue)
 {
  return (Volume)Enum.Parse(typeof(Volume), stringValue);
 }

 public static int StringToInt(string stringValue)
 {
  var volume = StringToEnum(stringValue);
  return EnumToInt(volume);
 }
 public static string EnumToString(Volume volume)
 {
  return volume.ToString();
 }
 }

这应该失败，至少在运行时。它没有。这真的很奇怪......在编译期间或运行期间都不会检测到错误的调用。你会觉得自己处于一个虚假的安全状态。如果，我们把传进去的枚举转换为string时，来看看这两种情况有什么不同：

我不知道大家平时在使用枚举的时候，是否有意识检查传入的是否是有效的值。可以使用Enum.IsDefined()来检查int值是否是一个有效的值

解决方案：如果int值在枚举值的定义范围内，则使用Enum.IsDefined()查找。如果在范围内，则返回True，否则返回False。

（2）转化

您是否尝试过将enum转换为int，int转换为enum，string转换为enum，将字符串转换为enum的int值？如下代码：

public static class EnumTricks
 {
  public static bool IsVolumeHigh(Volume volume)
  {
   var result = false;

   switch (volume)
   {
    case Volume.Low:
     Console.WriteLine("Volume is low.");
     break;

    case Volume.Medium:
     Console.WriteLine("Volume is medium.");
     break;

    case Volume.High:
     Console.WriteLine("Volume is high.");
     result = true;
     break;
   }

   return result;
  }

  public static int EnumToInt(Volume volume)
  {
   return (int)volume;
  }

  public static Volume IntToEnum(int intValue)
  {
   return (Volume)intValue;
  }

  public static Volume StringToEnum(string stringValue)
  {
   return (Volume)Enum.Parse(typeof(Volume), stringValue);
  }

  public static int StringToInt(string stringValue)
  {
   var volume = StringToEnum(stringValue);
   return EnumToInt(volume);
  }
 }

是不是我们日常的代码中也有这样的类型转换代码，不是说不好，只是类型转换也是有性能损失的，如果能换中方式可以同样实现而且还避免以上问题岂不是更好，这样我们的代码也更好维护和扩展，下面我们通过使用枚举类的方式来解决这个问题。

三、使用枚举类而不是枚举类型

public class Enumeration: IComparable
 {
  private readonly int _value;
  private readonly string _displayName;

  protected Enumeration()
  {
  }

  protected Enumeration(int value, string displayName)
  {
   _value = value;
   _displayName = displayName;
  }

  public int Value
  {
   get { return _value; }
  }

  public string DisplayName
  {
   get { return _displayName; }
  }

  public override string ToString()
  {
   return DisplayName;
  }

  public static IEnumerable<T> GetAll<T>() where T : Enumeration, new()
  {
   var type = typeof(T);
   var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);

   foreach (var info in fields)
   {
    var instance = new T();
    var locatedValue = info.GetValue(instance) as T;

    if (locatedValue != null)
    {
     yield return locatedValue;
    }
   }
  }

  public override bool Equals(object obj)
  {
   var otherValue = obj as Enumeration;

   if (otherValue == null)
   {
    return false;
   }

   var typeMatches = GetType().Equals(obj.GetType());
   var valueMatches = _value.Equals(otherValue.Value);

   return typeMatches && valueMatches;
  }

  public override int GetHashCode()
  {
   return _value.GetHashCode();
  }

  public static int AbsoluteDifference(Enumeration firstValue, Enumeration secondValue)
  {
   var absoluteDifference = Math.Abs(firstValue.Value - secondValue.Value);
   return absoluteDifference;
  }

  public static T FromValue<T>(int value) where T : Enumeration, new()
  {
   var matchingItem = parse<T, int>(value, "value", item => item.Value == value);
   return matchingItem;
  }

  public static T FromDisplayName<T>(string displayName) where T : Enumeration, new()
  {
   var matchingItem = parse<T, string>(displayName, "display name", item => item.DisplayName == displayName);
   return matchingItem;
  }

  private static T parse<T, K>(K value, string description, Func<T, bool> predicate) where T : Enumeration, new()
  {
   var matchingItem = GetAll<T>().FirstOrDefault(predicate);

   if (matchingItem == null)
   {
    var message = string.Format("'{0}' is not a valid {1} in {2}", value, description, typeof(T));
    throw new ApplicationException(message);
   }

   return matchingItem;
  }

  public int CompareTo(object other)
  {
   return Value.CompareTo(((Enumeration)other).Value);
  }
 }

public class Volume: Enumeration
 {
  private Volume() { throw new Exception(""); }
  private Volume(int value, string displayName): base(value, displayName) { }

  public static readonly Volume Low = new Volume(1, nameof(Low).ToLowerInvariant());
  public static readonly Volume Medium = new Volume(2, nameof(Medium).ToLowerInvariant());
  public static readonly Volume High = new Volume(3, nameof(High).ToLowerInvariant());

  public static IEnumerable<Volume> List() =>
   new[] { Low, Medium, High };

  public static Volume From(int value)
  {
   var state = List().SingleOrDefault(s => s.Value == value);

   if (state == null)
   {
    throw new Exception($"Possible values for Volume: {String.Join(",", List().Select(s => s.Value))}");
   }

   return state;
  }

  public static Volume FromName(string name)
  {
   var state = List()
    .SingleOrDefault(s => String.Equals(s.DisplayName, name, StringComparison.CurrentCultureIgnoreCase));

   if (state == null)
   {
    throw new Exception($"Possible values for Volume: {String.Join(",", List().Select(s => s.DisplayName))}");
   }

   return state;
  }
 }

static void Main(string[] args)
  {
   //EnumTricks.IsVolumeHigh((Volume)27);

   //var tmp = Enum.IsDefined(typeof(Volume), 3);
   //var str = EnumTricks.EnumToString((Volume)27);
   //var str2 = EnumTricks.EnumToString((Volume)3);

   //Console.WriteLine($"Volume 27:{str}");
   //Console.WriteLine($"Volume 3:{str2}");

   Console.WriteLine("------------------------------------------------------------");

   Console.WriteLine(Volume.High.Value);
   Console.WriteLine(Volume.High.DisplayName);

   var volume = Volume.From(2);
   var volume2 = Volume.FromName("high");
   var none = Volume.From(27);

   Console.ReadKey();
  }

四、应用

代码如下：

Error文件下：

public interface ICommonError
 {
  int GetErrCode();
  string GetErrMsg();
  ICommonError SetErrMsg(string errMsg);
 }

public class Enumeration : IComparable
 {
  private readonly int _value;
  private readonly string _displayName;

  protected Enumeration()
  {
  }

  protected Enumeration(int value, string displayName)
  {
   _value = value;
   _displayName = displayName;
  }

  public int Value
  {
   get { return _value; }
  }

  public string DisplayName
  {
   get { return _displayName; }
  }

  public override string ToString()
  {
   return DisplayName;
  }

  public static IEnumerable<T> GetAll<T>() where T : Enumeration, new()
  {
   var type = typeof(T);
   var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);

   foreach (var info in fields)
   {
    var instance = new T();
    var locatedValue = info.GetValue(instance) as T;

    if (locatedValue != null)
    {
     yield return locatedValue;
    }
   }
  }

  public override bool Equals(object obj)
  {
   var otherValue = obj as Enumeration;

   if (otherValue == null)
   {
    return false;
   }

   var typeMatches = GetType().Equals(obj.GetType());
   var valueMatches = _value.Equals(otherValue.Value);

   return typeMatches && valueMatches;
  }

  public override int GetHashCode()
  {
   return _value.GetHashCode();
  }

  public static int AbsoluteDifference(Enumeration firstValue, Enumeration secondValue)
  {
   var absoluteDifference = Math.Abs(firstValue.Value - secondValue.Value);
   return absoluteDifference;
  }

  public static T FromValue<T>(int value) where T : Enumeration, new()
  {
   var matchingItem = parse<T, int>(value, "value", item => item.Value == value);
   return matchingItem;
  }

  public static T FromDisplayName<T>(string displayName) where T : Enumeration, new()
  {
   var matchingItem = parse<T, string>(displayName, "display name", item => item.DisplayName == displayName);
   return matchingItem;
  }

  private static T parse<T, K>(K value, string description, Func<T, bool> predicate) where T : Enumeration, new()
  {
   var matchingItem = GetAll<T>().FirstOrDefault(predicate);

   if (matchingItem == null)
   {
    var message = string.Format("'{0}' is not a valid {1} in {2}", value, description, typeof(T));
    throw new ApplicationException(message);
   }

   return matchingItem;
  }

  public int CompareTo(object other)
  {
   return Value.CompareTo(((Enumeration)other).Value);
  }
 }

public class EmBusinessError : Enumeration, ICommonError
 {
  private int errCode;
  private String errMsg;

  public static readonly EmBusinessError parameterValidationError = new EmBusinessError(10001, "参数不合法");

  private EmBusinessError() { throw new Exception("私有构造函数不能调用"); }
  private EmBusinessError(int value, string displayName) : base(value, displayName) {

   this.errCode = value;
   this.errMsg = displayName;
  }

  public int GetErrCode()
  {
   return this.errCode;
  }

  public string GetErrMsg()
  {
   return this.errMsg;
  }

  public void SetErrCode(int errCode)
  {
   this.errCode = errCode;
  }

  public ICommonError SetErrMsg(string errMsg)
  {
   this.errMsg = errMsg;

   return this;
  }
 }

//包装器业务异常类实现
 public class BusinessException : Exception, ICommonError
 {
  private ICommonError commonError;

  //直接接收EmBusinessError的传参用于构造业务异常
  public BusinessException(ICommonError commonError):base()
  {
   this.commonError = commonError;
  }
  public BusinessException(ICommonError commonError, string errMsg):base()
  {
   this.commonError = commonError;
   this.commonError.SetErrMsg(errMsg);
  }
  public int GetErrCode()
  {
   return this.commonError.GetErrCode();
  }

  public string GetErrMsg()
  {
   return this.commonError.GetErrMsg();
  }

  public ICommonError SetErrMsg(string errMsg)
  {
   this.commonError.SetErrMsg(errMsg);

   return this;
  }
  public ICommonError GetCommonError()
  {
   return commonError;
  }
 }

异常中间件：

public class ExceptionHandlerMiddleWare
 {
  private readonly RequestDelegate next;

  /// <summary>
  ///
  /// </summary>
  /// <param name="next"></param>
  public ExceptionHandlerMiddleWare(RequestDelegate next)
  {
   this.next = next;
  }

  public async Task Invoke(HttpContext context)
  {
   try
   {
    await next(context);
   }
   catch (Exception ex)
   {
    await HandleExceptionAsync(context, ex);
   }
  }

  private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
  {
   if (exception == null) return;
   await WriteExceptionAsync(context, exception).ConfigureAwait(false);
  }

  private static async Task WriteExceptionAsync(HttpContext context, Exception exception)
  {
   var response = context.Response;
   response.ContentType = "application/json;charset=utf-8";
   var result = new CommonReturnType();

   if (exception is BusinessException)
   {
    var businessException = (BusinessException)exception;

    var errModel = new { errCode= businessException.GetErrCode(), errMsg= businessException.GetErrMsg() };

    result = CommonReturnType.Create(errModel, "fail");

   }

   await response.WriteAsync(JsonConvert.SerializeObject(new { data = result.GetData(), status = result.GetStatus() }) ).ConfigureAwait(false);
  }

 }

Response文件夹：

public class CommonReturnType
 {
  //表明对应请求的返回处理结果 "success" 或 "fail"
  private string status;

  //若status=success,则data内返回前端需要的json数据
  //若status=fail，则data内使用通用的错误码格式
  private object data;

  //定义一个通用的创建方法
  public static CommonReturnType Create(object result)
  {
   return CommonReturnType.Create(result, "success");
  }

  public static CommonReturnType Create(object result, string status)
  {
   CommonReturnType type = new CommonReturnType();
   type.SetStatus(status);
   type.SetData(result);

   return type;
  }

  public string GetStatus()
  {
   return status;
  }

  public void SetStatus(string status)
  {
   this.status = status;
  }

  public object GetData()
  {
   return data;
  }

  public void SetData(object data)
  {
   this.data = data;
  }
 }

最后推荐一个类库，这是我在Nuget上发现的枚举类库，地址：https://github.com/ardalis/SmartEnum

好了，先分享到这里，希望对你有帮助和启发。

参考资料：

（1）https://docs.microsoft.com/zh-cn/dotnet/standard/microservices-architecture/microservice-ddd-cqrs-patterns/enumeration-classes-over-enum-types

（2）https://ardalis.com/enum-alternatives-in-c

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对我们的支持。

详解ASP.NET Core MVC四种枚举绑定方式

前言本节我们来讲讲在ASP.NET Core MVC又为我们提供了哪些方便,之前我们探讨过在ASP.NET MVC中下拉框绑定方式,这节我们来再来重点看看枚举绑定的方式,充分实现你所能想到的场景,满满的干货,你值得拥有. 探讨枚举绑定方式我们首先给出要绑定的枚举类. public enum Language { JavaScript, Java, C, Python, SQL, Oracle } 枚举绑定方式一(@Html.DropDownList) 接下来我们废话少说直接进入主题. 复制代
ASP.Net Core中使用枚举类而不是枚举的方法

前言: 我相信大家在编写代码时经常会遇到各种状态值,而且为了避免硬编码和代码中出现魔法数,通常我们都会定义一个枚举,来表示各种状态值,直到我看到Java中这样使用枚举,我再想C# 中可不可以这样写,今天就分享一下我的感悟. 一.通常我们是这样使用枚举的 (1)switch中使用枚举 public enum EmployeeType { Manager, Servant, AssistantToTheRegionalManager } public class Employee { public
ASP.NET Core中调整HTTP请求大小的几种方法详解

一.前言之所以称ASP.NET Core是一个Web开发平台,源于它具有一个极具扩展性的请求处理管道,我们可以通过这个管道的定制来满足各种场景下的HTTP处理需求.ASP. NET Core应用的很多特性,比如路由.认证.会话.缓存等,也同时定制消息处理管道来实现的.我们甚至可以通过管道定制在ASP.NET Core平台上创建我们自己的Web框架,实际上MVC和SingalR这两个重要的Web框架也是采用这样的方式创建的. HTTP协议自身的特性决定了任何一个Web应用的工作方式都是监听.接收
详解ASP.NET Core 中基于工厂的中间件激活的实现方法

IMiddlewareFactory/IMiddleware是中间件激活的扩展点. UseMiddleware扩展方法检查中间件的已注册类型是否实现IMiddleware.如果是,则使用在容器中注册的IMiddlewareFactory实例来解析IMiddleware实现,而不使用基于约定的中间件激活逻辑.中间件在应用的服务容器中注册为作用域或瞬态服务. 优点: 按客户端请求(作用域服务的注入)激活让中间件强类型化 IMiddleware按客户端请求(连接)激活,因此作用域服务可以注入到中间件
ASP.NET Core中Startup类、Configure()方法及中间件详解

ASP.NET Core 程序启动过程如下 1, Startup 类 ASP.NET Core 应用使用Startup类,按照约定命名为Startup.Startup类: 可选择性地包括ConfigureServices方法以配置应用的服务. 必须包括Configure方法以创建应用的请求处理管道. 当应用启动时,运行时调用ConfigureServices和Configure . Startup 方法体如下 public class Startup { // 使用此方法向容器添加服务 publ
ASP.NET Core 中的Main方法详解

在 ASP.NET Core 项目中,我们有一个名为Program.cs的文件.在这个文件中,我们有一个public static void Main()方法 . public class Program { public static void Main(string[] args) { CreateWebHostBuilder(args).Build().Run(); } public static IWebHostBuilder CreateWebHostBuilder(string[]
Asp.net Core中如何使用中间件来管理websocket

介绍我喜欢.NET CORE 这个东西,其实不仅仅源于它性能很高,可以跨平台,还因为它的设计模式确实令人着迷.以前没.NET CORE 的时候,.NET用websocket必须跑在windows server 2012上,但我一般不会这么干,都把websocket架在nodejs的服务器上.这么分出来,麻烦肯定是麻烦的,而且js这东西,写复杂和几年后再看都是头疼的问题.那么,如果.NET CORE是以kestrel运行的,那么就不再需要考虑服务器的版本运行,任何一个地方都可以用websocke
ASP.NET Core中的Http缓存使用

Http响应缓存可减少客户端或代理对web服务器发出的请求数.响应缓存还减少了web服务器生成响应所需的工作量.响应缓存由Http请求中的header控制. 而ASP.NET Core对其都有相应的实现,并不需要了解里面的工作细节,即可对其进行良好的控制. 了解Http缓存 Http协议中定义了许多缓存,但总体可以分为强缓存和协商缓存两类. 强缓存强缓存是指缓存命中时,客户端不会向服务器发请求,浏览器F12能看到响应状态码为200,size为from cache,它的实现有以下几种方式: Ex
如何在Asp.Net Core中集成Refit

在很多时候我们在不同的服务之间需要通过HttpClient进行及时通讯,在我们的代码中我们会创建自己的HttpClient对象然后去跨领域额进行数据的交互,但是往往由于一个项目有多个人开发所以在开发中没有人经常会因为不同的业务请求去写不同的代码,然后就会造成各种风格的HttpClient的跨域请求,最重要的是由于每个人对HttpClient的理解程度不同所以写出来的代码可能质量上会有参差不齐,即使代码能够达到要求往往也显得非常臃肿,重复高我们在正式介绍Refit这个项目之前,我们来看看我们在项目
详解如何在ASP.NET Core中编写高效的控制器

通过遵循最佳实践,可以编写更好的控制器.所谓的"瘦"控制器(指代码更少.职责更少的控制器)更容易阅读和维护.而且,一旦你的控制器很瘦,可能就不需要对它们进行太多测试了.相反,你可以专注于测试业务逻辑和数据访问代码.瘦控制器的另一个优点是,它更容易维护控制器的多个版本. 这篇文章讨论了使控制器变胖的坏习惯,然后探索了使控制器变瘦和易于管理的方法.我列出编写控制器的最佳实践可能并不全面,但我已经讨论了最重要的一些,并在适当的情况下提供了相关的源代码.在接下来的几节中,我们将研究什么是胖控制
如何在Asp.Net Core中集成ABP Dapper

在实际的项目中,除了集成ABP框架的EntityFrameworkCore以外,在有些特定的场景下不可避免地会使用一些SQL查询语句,一方面是由于现在的EntityFrameworkCore2.X有些问题没有解决,另外一方面是基于性能方面的考虑,在了解本篇内容之前,首先还是来看看官方文档来给出的说明. 按照官方的介绍整体可以分为下面的步骤:1 安装依赖包.2 添加DependsOn属性标签.3 Entity to Table Mapping. 4 Usage 通过上面的4个步骤我们就能够正常在A

ASP.Net Core中使用枚举类而不是枚举的方法

相关推荐

随机推荐