C# 知识特性 Attribute,XMLSerialize,

C#知识--获取特性 Attribute

特性提供功能强大的方法，用以将元数据或声明信息与代码（程序集、类型、方法、属性等）相关联。特性与程序实体关联后，可在运行时使用“反射”查询特性，获取特性集合方法是GetCustomAttributes();

根据约定，所有特性名称都以单词“Attribute”结束，以便将它们与“.NET Framework”中的其他项区分。但是，在代码中使用特性时，不需要指定 attribute 后缀。在声明特性类时要以“Attribute”结束，使用时省略“Attribute”单词。

下面是几种使用特性的方法，菜鸟只是多看了一下总结一下，大神可以绕过：

类、程序集上的特性采用方法：

        /// <summary>
        /// 获取特性值方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string OutputDescription(Type t)
        {
            var attributes = t.GetCustomAttributes();
            foreach (Attribute attribute in attributes)
            {
                var attr = attribute as DescriptionAttribute;
                if (attr != null)
                {
                    return attr.Description;
                }
            }
            return t.ToString();
        }

方法、属性采用扩展方法：

/// <summary>
    /// 第一种获取特性值，适用只有单个特性
    /// </summary>
    public static class FingerGuessingGameTypeExtension
    {
        public static string GetEnumDescription(this FingerGuessingGameType enumType)
        {
            Type type = enumType.GetType();
            MemberInfo[] memberInfo = type.GetMember(enumType.ToString());
            if (memberInfo != null && memberInfo.Length > 0)
            {
                object[] attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
                if (attrs != null && attrs.Length > 0)
                {
                    return ((DescriptionAttribute)attrs[0]).Description;
                }
            }

            return enumType.ToString();
        }

        public static string GetEnumValue(this FingerGuessingGameType enumType)
        {
            Type type = enumType.GetType();
            MemberInfo[] memberInfo = type.GetMember(enumType.ToString());
            if (memberInfo != null && memberInfo.Length > 0)
            {
                object[] attrs = memberInfo[0].GetCustomAttributes(typeof(NameAttribute), false);
                if (attrs != null && attrs.Length > 0)
                {
                    return ((NameAttribute)attrs[0]).Name;
                }
            }

            return enumType.ToString();
        }
    }
    /// <summary>
    /// 第二种获取特性值，适用有多个特性
    /// </summary>
    public static class FingerExtension
    {
        private static Dictionary<Enum, ValueDescriptionPair> m_Dic=null;

        public static string GetDescription(this FingerGuessingGameType enumType)
        {
            if (m_Dic == null)
            {
                Type type = enumType.GetType();
                var allValues = Enum.GetValues(type).OfType<Enum>();
                m_Dic = allValues.ToDictionary(p => p, p => GetDescriptionValue(type, p));
            }

            ValueDescriptionPair valueDescription;
            if (m_Dic.TryGetValue(enumType, out valueDescription))
            {
                return valueDescription.Description;
            }
            return enumType.ToString(); 
        }

        public static string GetValue(this FingerGuessingGameType enumType)
        {
            if (m_Dic == null)
            {
                Type type = enumType.GetType();
                var allValues = Enum.GetValues(type).OfType<Enum>();
                m_Dic = allValues.ToDictionary(p => p, p => GetDescriptionValue(type, p));
            }

            ValueDescriptionPair valueDescription;
            if (m_Dic.TryGetValue(enumType, out valueDescription))
            {
                return valueDescription.Name;
            }
            return enumType.ToString(); 
        }
        
        private static ValueDescriptionPair GetDescriptionValue(Type type, Enum value)
        {
            var valueDescriptionPair=new ValueDescriptionPair();
            var enumName=Enum.GetName(type,value);
            var description=type.GetField(enumName)
                .GetCustomAttributes(typeof (DescriptionAttribute), false)
                .OfType<DescriptionAttribute>().FirstOrDefault();
            var enumValue = type.GetField(enumName)
                .GetCustomAttributes(typeof(NameAttribute), false)
                .OfType<NameAttribute>().FirstOrDefault();

            if (description != null)
            {
                valueDescriptionPair.Description = description.Description;
            }
            if (enumValue != null)
            {
                valueDescriptionPair.Name = enumValue.Name;
            }
            return valueDescriptionPair;
        }
    }

    public class NameAttribute:Attribute
    {
        public NameAttribute(string name)
        {
            Name = name;
        }
        public string Name { get; set; }
    }

    public class ValueDescriptionPair
    {
        //Description 特性
        public string Description { get; set; }
        //Value 特性
        public string Name { get; set; }
    }

 序列化XML(XMLSerialize):

using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

public static class XMLSerializeExtension
{
    public static string Serialize<T>(this T value)
    {
        var result = string.Empty;
        if (value == null)
        {
            return result;
        }
        try
        {
            var serializer = new XmlSerializer(typeof(T));
            var stringWriter = new StringWriter();
            using (var writer = XmlWriter.Create(stringWriter))
            {
                serializer.Serialize(writer, value);
                result = stringWriter.ToString();
            }
        }
        catch (Exception ex)
        {
            throw new Exception("An error occurred while XML serialize", ex);
        }
        return result;
    }

    public static T Deserialize<T>(this string value)
    {
        T retObj = default(T);
        if (string.IsNullOrWhiteSpace(value) == true)
        {
            return retObj;
        }
        try
        {
            using (var rdr = new StringReader(value))
            {
                var serializer = new XmlSerializer(typeof(T));
                retObj = (T)serializer.Deserialize(rdr);
            }
        }
        catch (Exception ex)
        {
            throw new Exception("An error occurred while XML Deserialize", ex);
        }
        return retObj;
    }
}

反射调用方法(Reflection)

            Assembly assembly = Assembly.Load("ConsoleFileDemo");
            Type classType = assembly.GetType("ConsoleFileDemo.XmlOperator");
            ICase obj = Activator.CreateInstance(classType) as ICase;
            //获取默认方法并调用方法
            MethodInfo showMethod = classType.GetMethod("Show");
            showMethod.Invoke(assembly, new object[]{"parameter"});
            //获取无参方法并调用无参方法
            MethodInfo show1 = classType.GetMethod("Show1",new Type[]{});
            show1.Invoke(assembly,null);
            //获取指定参数的方法并调用  int，string
            MethodInfo show2 = classType.GetMethod("Show2", new Type[] {typeof (int)});
            show2.Invoke(assembly, new object[] {10});

            MethodInfo show3 = classType.GetMethod("Show3", new Type[] { typeof(string) });
            show3.Invoke(assembly, new object[] {"name"});
            //获取指定私有方法并调用   string
            MethodInfo show4 = classType.GetMethod("Show4",
                BindingFlags.Instance |BindingFlags.Public | BindingFlags.NonPublic,
                null,new Type[]{typeof(string)}, null);
            show4.Invoke(assembly,new object[]{"name"});

            //创建单例模式,反射使用私有构造函数实例化单例
            Type typeSingle = assembly.GetType("ConsoleFileDemo.Singleton");
            object objectSingle = Activator.CreateInstance(typeSingle, true);