ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

谈谈对Enum的使用

2020-07-08 17:35:17  阅读:255  来源: 互联网

标签:return string Enum 枚举 谈谈 使用 var public


前言:

  软件开发中,最离不开的就是枚举的使用了,比如:用户状态管理,用户权限管理等。凡是用bool值不能满足需求时,都可以枚举值来定义,既方便,又好用。还省心。既然有这么多好处,为什么不使用呢

正文:

我们准备如下的枚举定义,以下测试的整个过程中,都会使用到如下的枚举类:

/// <summary>
/// user state enum
/// </summary>
public enum UserState
{
    /// <summary>
    /// 在线
    /// </summary>
    [Description("在线")]
    Online,

    /// <summary>
    /// 离线
    /// </summary>
    [Description("离线")]
    Offline,

    /// <summary>
    /// 已删除
    /// </summary>
    [Description("已删除")]
    Deleted
}

  

  

通过枚举值Value获取枚举Name

//获取枚举Name
var enumName = Enum.GetName(typeof(UserState), 1);
// enumName = Offline

  

通过GetValues获取枚举值列表  

var enumValues = Enum.GetValues(typeof(UserState));

//enumValues值如下:
{BitwiseDemo.UserState[3]}
    [0]: Online
    [1]: Offline
    [2]: Deleted

通过如下方式获取值
for (int i = 0; i < enumValues.Length; i++)
{
    var value = enumValues.GetValue(i);
} 

  

通过GetNames获取枚举的字符串值

var enumNames = Enum.GetNames(typeof(UserState));

//enumNames值如下:
{string[3]}
    [0]: "Online"
    [1]: "Offline"
    [2]: "Deleted"

  

有时候,需要判断值是不是在定义的枚举范围内,可以使用IsDefined来进行判断

var isDefine = Enum.IsDefined(typeof(UserState), 3);
//isDefine = false

   

一下是封装过的枚举扩展类EnumExtension.cs,方便我们平时在调用过程中使用

    public static class EnumExtension
    {
        class EnumCache : ReaderWriterCache<Type, Dictionary<long, EnumItem>>
        {
            public Dictionary<long, EnumItem> GetEnumMap(Type t, Creator<Dictionary<long, EnumItem>> cr)
            {
                return FetchOrCreateItem(t, cr);
            }
        }
        #region 私有成员
        static readonly EnumCache Instance = new EnumCache();

        static Dictionary<long, EnumItem> FetchOrCreateEnumMap(Type t)
        {
            return Instance.GetEnumMap(t, () => CreateEnumMap(t));
        }
        static Dictionary<long, EnumItem> CreateEnumMap(Type t)
        {
            Dictionary<long, EnumItem> map = new Dictionary<long, EnumItem>();
            FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.Static);

            foreach (FieldInfo f in fields)
            {
                long v = Convert.ToInt64(f.GetValue(null));
                DescriptionAttribute[] ds = (DescriptionAttribute[])f.GetCustomAttributes(typeof(DescriptionAttribute), false);
                if (ds.Length > 0)
                {
                    map[v] = new EnumItem { Value = v, Name = f.Name, Description = ds[0].Description };
                }
            }
            return map;
        }


        #endregion

        /// <summary>
        /// 返回该枚举类型的所有枚举项成员以及描述 
        /// </summary>
        /// <returns></returns>
        public static List<EnumItem> GetTypeItemList<EnumType>()
        {
            Type t = typeof(EnumType);
            return FetchOrCreateEnumMap(t).Values.ToList();
        }

        /// <summary>
        ///返回单枚举值的描述信息
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public static string GetDescription(this Enum v)
        {
            Type t = v.GetType();
            var map = FetchOrCreateEnumMap(t);

            if (map.TryGetValue(Convert.ToInt64(v), out var item))
            {
                return item.Description;
            }

            return string.Empty;
        }

        /// <summary>
        /// 从枚举名称转换成枚举类型
        /// </summary>
        /// <typeparam name="T">枚举类型</typeparam>
        /// <param name="name"></param>
        /// <returns></returns>
        public static T GetEnumType<T>(string name)
        {
            try
            {
                if (string.IsNullOrEmpty(name))
                {
                    return default(T);
                }
                return (T)System.Enum.Parse(typeof(T), name);
            }
            catch (Exception)
            {
                return default(T);
            }
        }

        /// <summary>
        /// 检查枚举值是否存在
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool IsDefined<T>(this object obj)
        {
            return Enum.IsDefined(typeof(T), obj);
        }

        /// <summary>
        /// 根据enumName 获取 value
        /// </summary>
        /// <param name="enumType"></param>
        /// <param name="enumName"></param>
        /// <returns></returns>
        public static int GetEnumValue<T>(this string enumName)
        {
            try
            {
                if (string.IsNullOrEmpty(enumName))
                {
                    return -1;
                }
                var values = Enum.GetValues(typeof(T));
                var ht = new Hashtable();
                foreach (var val in values)
                {
                    ht.Add(Enum.GetName(typeof(T), val), val);
                }
                return (int)ht[enumName];
            }
            catch (Exception e)
            {
                throw e;
            }
        }
    }

  

以下是使用到的Cache类 ReaderWriterCache.cs 文件类

public abstract class ReaderWriterCache<TKey, TValue> {
        /// <summary>
        /// 创建数据选择性的将其缓存
        /// </summary>
        /// <typeparam name="T">数据的类型</typeparam>
        /// <param name="cacheResult">是否缓存数据</param>
        /// <returns></returns>
        public delegate T CreatorOrCache<T>(out bool cacheResult);
        /// <summary>
        /// 创建数据
        /// </summary>
        /// <typeparam name="T">数据的类型</typeparam>
        /// <returns></returns>
        public delegate T Creator<T>();
        private readonly ReaderWriterLockSlim _rwLockSlim = new ReaderWriterLockSlim();

        protected ReaderWriterCache()
            : this(null) {
        }

        protected Dictionary<TKey, TValue> Cache { get; }
        protected ReaderWriterCache(IEqualityComparer<TKey> comparer) {
            Cache = new Dictionary<TKey, TValue>(comparer);
        }

        /// <summary>
        /// 如果存在则返回原来的数据否则就创建并且将其缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="creator"></param>
        /// <returns></returns>
        protected TValue FetchOrCreateItem(TKey key, CreatorOrCache<TValue> creator) {

            _rwLockSlim.EnterReadLock();
            try {
                TValue existingEntry;
                if (Cache.TryGetValue(key, out existingEntry)) {
                    return existingEntry;
                }
            } finally {
                _rwLockSlim.ExitReadLock();
            }

            bool cache;
            TValue newEntry = creator(out cache);
            //如果需要缓存
            if (cache) {
                _rwLockSlim.EnterWriteLock();
                try {
                    TValue existingEntry;
                    if (Cache.TryGetValue(key, out existingEntry)) {
                        return existingEntry;
                    }

                    Cache[key] = newEntry;

                } finally {
                    _rwLockSlim.ExitWriteLock();
                }
            }
            return newEntry;
        }

        /// <summary>
        /// 如果存在则返回原来的数据否则就创建并且将其缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="creator"></param>
        /// <returns></returns>
        protected TValue FetchOrCreateItem(TKey key, Creator<TValue> creator) {
            return FetchOrCreateItem(key, (out bool b) => {
                b = true;
                return creator();
            });
        }
    }

  

封装类中,使用到的枚举类如下:

    public class EnumItem {
        /// <summary>
        /// 枚举值
        /// </summary>
        public long Value { get; internal set; }
        /// <summary>
        /// 枚举名
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 枚举的描述
        /// </summary>
        public string Description { get; internal set; }
    }

  

以下代码是调用示例:

private void EnumExtensionUse()
{
    //获取枚举列表(name value description)
    var getenumList = EnumExtension.GetTypeItemList<UserState>();

    //获取枚举描述
    var getDescription = ((UserState)UserState.Online).GetDescription();

    //通过name 获取value值
    var getValueByName = EnumExtension.GetEnumValue<UserState>("Online");

    //检查值是否在枚举中定义
    var value = 4;
    var checkEnumValue = value.IsDefined<UserState>();
   //checkEnumValue : false //将string name 转枚举 var enumItem = EnumExtension.GetEnumType<UserState>("Online");
   //enumItem :Online -- 枚举类型的Online }

结束:  

  以上测值的结果值,我就不贴了,就当留给你们亲手实践的作业吧。

  

标签:return,string,Enum,枚举,谈谈,使用,var,public
来源: https://www.cnblogs.com/yuyoho/p/13268053.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有