特性
 
引
 
先看一个例子：
 在VS中添加一个类库项目和一个控制台项目，在控制台项目中编写以下代码。（控制台项目添加类库项目的程序集）
 
        static void Main(string[] args)
        {
            Assembly assembly = Assembly.GetAssembly(typeof(Class1));
            Console.WriteLine("程序集名称："+assembly.FullName);
            assembly.GetCustomAttributes();
            Console.WriteLine("程序集Title：" + 
assembly.GetCustomAttribute<AssemblyTitleAttribute>().Title);
            Console.WriteLine("程序集描述：" + 
assembly.GetCustomAttribute<AssemblyDescriptionAttribute>().Description);
            Console.WriteLine("程序集公司：" + 
assembly.GetCustomAttribute<AssemblyCompanyAttribute>().Company);
            Console.Read();
        }
 
其中Class1是类库项目的类。
 执行后可以得到该类库项目输出的程序集的信息。例如：
 
 
在VS创建类库项目（以及其他的一些项目）时，会添加一个名为“AssemblyInfo.cs”的文件，其中内容如下：
 
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 有关程序集的一般信息由以下
// 控制。更改这些特性值可修改
// 与程序集关联的信息。
[assembly: AssemblyTitle("ClassLibrary1")]
[assembly: AssemblyDescription("测试程序集")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("程序开发公司")]
[assembly: AssemblyProduct("ClassLibrary1")]
[assembly: AssemblyCopyright("Copyright ©  2019")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 将 ComVisible 设置为 false 会使此程序集中的类型
//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
//请将此类型的 ComVisible 特性设置为 true。
[assembly: ComVisible(false)]
// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
[assembly: Guid("e15c7334-bcfc-4c09-a0bc-3798f7742fc8")]
// 程序集的版本信息由下列四个值组成: 
//
//      主版本
//      次版本
//      生成号
//      修订号
//
// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号
//通过使用 "*"，如下所示:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
 
这个文件并不是某个类文件，而是为程序集添加额外说明信息的文件，其中运用了很多特性——即使用"[]"包括起来的内容。
 
特性
 
特性可以可以为程序添加更多的元数据信息。上面的例子中，使用程序集特性为程序集class1添加了标题，程序集描述，创建公司，版权声明等等信息。除此之外，特性还可以用于如：
 
类
委托
枚举
事件
字段
泛型参数
接口
方法
属性
 ····
 （可以参考AttributeTargets提供的选项）
 
特性可以作为一种特殊的类来对待，只是特性类统一继承于System.Attribute,使用特性时，通常可以不带Attribute后缀。
 
一个自定义特性的例子
 
一个普通的类继承System.Attribute之后，就成为了一个特性类。在命名类名通常会加上Attribute，例如:
 
      [System.AttributeUsage(AttributeTargets.Property, Inherited = false, 
AllowMultiple = true)]
      sealed class RequiredAttribute : Attribute
    {
        private bool flag;
        public RequiredAttribute(bool flag)
        {
            this.flag = flag;
        }
        public bool Flag
        {
            get { return flag; }
        }
    }
 
上面的特性Required标记了某个属性是必须的，并且通过AttributeTargets确定了只能用于属性字段。
 可以看到：
 特性类是密封类；
 特性类也有构造器；
 其中System.AttributeUsage可以用来限定自定义特性，（相当于特性的特性）
 
使用特性修饰
 
如下代码，定义了一个类，并限定某些字段为必须的
 
    public class FormClass
    {
        [Required(true)]
        public string ID { get; set; }
        [Required(true)]
        public string Name { get; set; }
        public string Birthday { get; set; }
    }
 
在网页提交表单是通常要做一些验证，常常就有检验字段是否为空的（当然，表单验证通常不会放在后台来做）。对于FormClass,验证其是否符合要求，可以用反射的方法获取所有的属性，获取属性上的特性标记，判断是否符合特性的要求。
 
  public class Validator<T>
    {
        private T data;
        public Validator(T data){
           this.data = data;
        }
        //是否已经验证
        bool isValidate { get; set; }
        //验证方法
        bool Validate()
        {
            PropertyInfo[] properties = data.GetType().GetProperties();
            foreach (var item in properties)
            {
                RequiredAttribute required = 
item.GetCustomAttribute<RequiredAttribute>();
                if (required!= null&&required.Flag == true && item.GetValue(data) == 
null)
                {
                    return false;
                }
                else
                {
                    continue;
                }
            }
            return true;
        }
    }

<1>
 
 
 
 C#特性学习笔记
 

 特性标签的本质：
 

 1>特性是一个类，这个类的声明我们有一个规范，即：以Attribute结尾，例如MyClassAttribute 。当着仅仅是一个规范，如果你是在不以Attribute结尾也没关系。
 

 2>这个类一定要继承自Attribute类。只有继承Attribute类，这个类才是一个特性
 

 注意点：比如一个特性类的名称是MyClassAttribute ，当我们在某个类，方法，属性，字段贴这个特性标签的时候，可以省略它后面的Attribute 直接这样贴就可以 ，如：[MyClass]  当然 你也可以写全称，如[MyClassAttribute]
 

 
 
 

 既然[MyClass] 等于 new MyClassAttribute()  那么很多逻辑就在特性的构造函数中去实现。然后再有需要的类或者其成员上打上特性标签
 
 
 
系统自带特性的介绍
 
 
 
 
 
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WebApplication1
{
    //Attribute 类
    //TypeId属性： 当在派生类中实现时，获取该 Attribute 的唯一标识符。


    //AttributeUsageAttribute 类   (AttributeUsageAttribute 类是继承自 Attribute 的)
    //AttributeUsageAttribute.Inherited 属性:获取或设置一个布尔值，该值指示指示的属性能否由派生类和重写成员继承。如果该属性可由派生类和重写成员继承，则为 true，否则为 false。默认为 true。
    //AttributeUsageAttribute.AllowMultiple 属性:获取或设置一个布尔值，该值指示能否为一个程序元素指定多个指示属性实例。如果允许指定多个实例，则为 true；否则为 false。默认为 false。
    //AttributeUsageAttribute.ValidOn 属性:获取一组值，这组值标识指示的属性可应用到的程序元素。属性值:一个或多个 AttributeTargets 值。默认为 All。


    //注意：对于一个特性类使用Attribute后缀是一个惯例。然而，如果不添加编译器会自动添加匹配。


    //限定特性类的应用范围  (这里规定ClassMsg这个特性类只能用于类和字段)
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
    //定制MsgAttribute特性类，继承于Attribute  
    public class ClassMsgAttribute : Attribute
    {
        //定义_msg字段和Msg属性//Msg属性用于读写msg字段  
        string _msg;
        public string Msg { get { return _msg; } set { _msg = value; } }
        public ClassMsgAttribute() { }
        //重载构造函数接收一个参数，赋值给_msg字段  
        public ClassMsgAttribute(string s) { _msg = s; }
    }



    //---------------------调用ClassMsg这个特性---------------------//

    //在Person类上标记ClassMsg特性  
    [ClassMsg(Msg = "这是关于人的姓名信息的类")]
    class Person
    {
        //在_name字段上应用ClassMsg特性  
        [ClassMsg("这是存储姓名的字段")]
        string _name;
        //以下特性无法应用，因为MsgAttribute定义的特性只能用于类和字段  
        //[ClassMsg("这是读写姓名字段的属性")]  
        public string Name { get { return _name; } set { _name = value; } }
    }  

}
 
 另外我们在来看看系统自带的一个
 [Obsolete] 特性，这个特性的作用就是标记某个方法是否已经过时的
 

 例如：
 

 定义一个Pigcs类
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace 特性学习
{
    public class Pigcs
    {
        [Obsolete("此方法已经过时，请调用新的方法NewEat()")] //这个Obsolete特性是专门用来告诉用户某些方法或成员已经过时的消息
        public string OldEat()
        {
            return "我是老的方法";
        }

         public string  NewEat()
        {
            return "我是新的方法";
        }
    }
}
我们定义了这个Pigcs类，并在它的OldEat()方法上使用了[Obsolete]这个系统特性。看看效果怎么样
 

 
 
 
 

 我们在来看看微软自带的这个ObsoleteAttribute特性类
 

 
 
 
 

 
 
 
自定义特性，及自定义特性的继承
 
自定义特性的定义
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace 特性学习
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
    public class VipAttribute : Attribute //自定义一个Vip特性
    {

    }


    public class Vip5Attribute : VipAttribute //此时Vip5Attribute类也是一个特性了。它默认继承了父类的[AttributeUsage(AttributeTargets.Class| AttributeTargets.Method,AllowMultiple=true,Inherited=true)]
    {

    }

    //现在问题来了： Vip5Attribute继承了VipAttribute，因为VipAttribute这个特性只能用于类和方法，那么这个Vip5Attribute也就只能用在类，和方法上面，那假如我们这个Vip5Attribute想用在类和方法和属性上怎么办呢？
    //答案很简单，只要在Vip5Attribute这个特性上加系统特性就好了，如下：
    //只要在Vip5Attribute类上打上 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method |AttributeTargets.Property] 就可以了。

    //特别要注意，如果在子类上不打特性标签，就默认继承父类的特性标签，但是如果在子类上打了特性标签，就等于覆盖了父类的特性标签。
    //例如在子类上打： [AttributeUsage(AttributeTargets.Class] 那么它就只能用于类，而不能像父类那样用于方法 
    //[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method |AttributeTargets.Property, AllowMultiple = true, Inherited = true)]
    //public class Vip5Attribute : VipAttribute
    //{

    //}
}
 
 
 
实现一个登陆验证的特性
 
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.SessionState;

namespace 检查登陆验证.Attributes
{
    [AttributeUsage(AttributeTargets.Class)]  //这个特性只能用于类
    public class CheckLoginAttribute : Attribute //定义一个名字叫CheckLoginAttribute 的特性，用户检查用户是否已经登录
    {

        //我们知道在一个类上打上[CheckLogin] 就等于 new CheckLoginAttribute() 所以我们在这里定义了这个CheckLoginAttribute特性的不带参数的构造函数，在构造函数中判断用户是否已经登录。如果用户未登录，那么就跳到Login.aspx页面
        public  CheckLoginAttribute()
        {
            if (HttpContext.Current.Session["UserName"] == null)
            {
                HttpContext.Current.Response.Redirect("Login.aspx");
            }
        }
       
    }
}
 
 
 
特性还有其他的用法
 
 

 
 
 

 定义一个特性
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace 特性学习
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method|AttributeTargets.Field|AttributeTargets.Property, AllowMultiple = true, Inherited = true)]
    public class VipAttribute : Attribute //自定义一个Vip特性
    {
        string name;
        public string Name { get { return name; } }

        public VipAttribute(string disName)
        {
            this.name = disName; //构造函数初始化私有字段name         
        }
    }
}
 
 假如我有两个类。一个是Pig类（猪） 一个是Dog类 （狗）
 

 Pig类
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace 特性学习
{
    public class Pig
    {
        [Vip("猪名字")]
        public string Name { get; set; }

        [Vip("猪年龄")]
        public int Age { get; set; }

    }
}
Dog类
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace 特性学习
{
    public class Dog
    {
        [Vip("狗名字")]
        public string Name { get; set; }
        [Vip("狗年龄")]
        public int Age { get; set; }
    }
}
 
 

 根据需求，其实实际就是根据类型来获取类型属性上的的特性标签里的参数值 
 

 
 

 
 
 
 用法：
 

 首先创建一个WebFrom页面
 

 WebForm1.aspx文件
 
 
 

 
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="特性学习.WebForm1" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    
    </div>
        <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
        <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
        <br />
        <asp:Label ID="Label2" runat="server" Text="Label"></asp:Label>
        <asp:TextBox ID="TextBox2" runat="server"></asp:TextBox>
    </form>
</body>
</html>
WebFrom1.aspx.cs文件
 

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace 特性学习
{
    public partial class WebForm1 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

            /*
             Pig p = new Pig();
            Type t = p.GetType();

            //获取Pig类中的Name属性
            PropertyInfo propName = t.GetProperty("Name");
            PropertyInfo propAge = t.GetProperty("Age");

            //检查Name这个属性上有没有[Vip]这个特性标签
            bool bName = propName.IsDefined(typeof(VipAttribute));

            bool bAge = propAge.IsDefined(typeof(VipAttribute));


            if (bName)
            {
                //如果Name属性上有[Vip]这个特性标签，那么就获取这个特性标签
                Attribute attr = propName.GetCustomAttribute(typeof(VipAttribute));

                VipAttribute vip = attr as VipAttribute; //转换一下类型

                this.Label1.Text = vip.Name;
               
            }

            if (bAge)
            {
                //如果Name属性上有[Vip]这个特性标签，那么就获取这个特性标签
                Attribute attr = propAge.GetCustomAttribute(typeof(VipAttribute));

                VipAttribute vip = attr as VipAttribute; //转换一下类型

                this.Label2.Text = vip.Name;

            }
            */
            //----------------------优化一下代码------------------------


            Pig pp = new Pig();  //根据类型来获取类型对应的属性特性标记值，如获取这个[VIP(猪名字)]特性标记里的”猪名字“
            // Dog pp = new Dog();

            Type tt = pp.GetType();

            //获取Pig类型的所有属性
            PropertyInfo[] pros = tt.GetProperties();

            //遍历属性
            foreach (var a in pros)
            {
                //VipAttribute vipattr = a.GetCustomAttribute<VipAttribute>(); //这样写。或者下面的写法

                //获取这个属性上的[vip]标签
                Attribute attr = a.GetCustomAttribute(typeof(VipAttribute));
                //类型转换
                VipAttribute vip = attr as VipAttribute;
                switch (a.Name)
                {
                    case "Name": this.Label1.Text = vip.Name; break;
                    case "Age": this.Label2.Text = vip.Name; break;

                }
            }

        }
    }
}
 
 
 
 
 

 
 
 
 
 

 
 
 
 
 
 

.NET C# Web开发学习之路——C#特性
 
C#历史办版本及特性
 
语言版本
发布时间
.NET Framework要求
Visual版本
C# 1.0
2002.1
.NET Framework 1.0
Visual Studio .NET 2002
C# 1.1\1.2
2003.4
.NET Framework 1.1
Visual Studio .NET 2003
C# 2.0
2005.11
.NET Framework 2.0
Visual Studio 2005
C# 3.0
2007.11
.NET Framework2.0\3.0\3.5
Visual Studio 2008
C# 4.0
2010.4
.NET Framework 4.0
Visual Studio 2010
C# 5.0
2012.8
.NET Framework 4.5
Visual Studio 2012/2013
C# 6.0
2015.7
.NET Framework 4.6
Visual Studio 2015
C# 7.0
2017.3
.NET Framework 4.6.2
Visual Studio 2017
C# 7.1
2017.6
.NET Framework
Visual Studio 2017 v15.3 预览版
C# 8.0
待发布
 
 
C# 1.0 特性
 
Classes：面向对象特性，支持类类型
Structs：结构
Interfaces：接口
Events：事件
Properties：属性，类的成员，提供访问字段的灵活方法
Delegates：委托,一种引用类型，表示对具有特定参数列表和返回类型的方法的引用
Expressions,Statements,Operators：表达式、语句、操作符
Attributes：特性，为程序代码添加元数据或声明性信息，运行时，通过反射可以访问特性信息
Literals：字面值（或理解为常量值），区别常量，常量是和变量相对的 
 
  
 
C# 2特性 (VS 2005)
 
Generics：泛型
Partial types：分部类型，可以将类、结构、接口等类型定义拆分到多个文件中
Anonymous methods：匿名方法
Iterators：迭代器
Nullable types：可以为Null的类型，该类可以是其它值或者null
Getter/setter separate accessibility：属性访问控制
Method group conversions (delegates)：方法组转换，可以将声明委托代表一组方法，隐式调用
Co- and Contra-variance for delegates and interfaces：委托、接口的协变和逆变
Static classes：静态类
Delegate inference：委托推断，允许将方法名直接赋给委托变量
 
 
C# 3特性 (VS 2008)
 
Implicitly typed local variables：
Object and collection initializers：对象和集合初始化器
Auto-Implemented properties：自动属性，自动生成属性方法，声明更简洁
Anonymous types：匿名类型
Extension methods：扩展方法
Query expressions：查询表达式
Lambda expression：Lambda表达式
Expression trees：表达式树，以树形数据结构表示代码，是一种新数据类型
Partial methods：部分方法 
 
  
 
C# 4特性 (VS 2010)
 
Dynamic binding:动态绑定
Named and optional arguments：命名参数和可选参数
Generic co- and contravariance：泛型的协变和逆变
Embedded interop types (“NoPIA”)：开启嵌入类型信息，增加引用COM组件程序的中立性 
 
  
 
C# 5特性 (VS 2012)
 
Asynchronous methods：异步方法
Caller info attributes：调用方信息特性，调用时访问调用者的信息
 
 
C# 6特征 (VS 2015)
 
Compiler-as-a-service (Roslyn)
Import of static type members into namespace：支持仅导入类中的静态成员
Exception filters：异常过滤器
Await in catch/finally blocks：支持在catch/finally语句块使用await语句
Auto property initializers：自动属性初始化
Default values for getter-only properties：设置只读属性的默认值
Expression-bodied members：支持以表达式为主体的成员方法和只读属性
Null propagator (null-conditional operator, succinct null checking)：Null条件操作符
String interpolation：字符串插值，产生特定格式字符串的新方法
nameof operator：nameof操作符，返回方法、属性、变量的名称
Dictionary initializer：字典初始化 
 
  
 
C# 7 特征 (Visual Studio 2017)
 
Out variables：out变量直接声明，例如可以out in parameter
Pattern matching：模式匹配，根据对象类型或者其它属性实现方法派发
Tuples：元组
Deconstruction：元组解析
Discards：没有命名的变量，只是占位，后面代码不需要使用其值
Local Functions：局部函数
Binary Literals：二进制字面量
Digit Separators：数字分隔符
Ref returns and locals：引用返回值和局部变量
Generalized async return types：async中使用泛型返回类型
More expression-bodied members：允许构造器、解析器、属性可以使用表达式作为body
Throw expressions：Throw可以在表达式中使用 
 
  
 
C# 7.1 特征 (Visual Studio 2017 version 15.3)
 
Async main：在main方法用async方式
Default expressions：引入新的字面值default
Reference assemblies：
Inferred tuple element names：
Pattern-matching with generics：

 特性（attribute）是被指定给某一声明的一则附加的声明性信息。
 
 　　在C#中，有一个小的预定义特性集合。在学习如何建立我们自己的定制特性（custom attributes）之前，我们先来看看在我们的代码中如何使用预定义特性。
 
 　　C#特性之通俗演义
 
 　　首先要说的是，可能一些刚接触C#的朋友常常容易把属性（Property）跟特性（Attribute）弄混淆，其实这是两种不同的东西。属性就是面向对象思想里所说的封装在类里面的数据字段，其形式为：
 
 
    

      
     
 
    
 
 　　在HumanBase这个类里出现的字段都叫属性（Property），而C#特性（Attribute）又是怎样的呢？
 
 
    

      
     
 
    
 
 　　简单地讲，我们在HumanBase类声明的上一行加了一个[Serializable]，这就是特性（Attribute），它表示HumanBase是可以被序列化的，这对于网络传输是很重要的，不过你不用担心如何去理解它，如何理解就是我们下面要探讨的。
 
 　　C#特性可以应用于各种类型和成员。前面的例子将特性用在类上就可以被称之为“类特性”，同理，如果是加在方法声明前面的就叫方法特性。无论它们被用在哪里，无论它们之间有什么区别，特性的最主要目的就是自描述。并且因为特性是可以由自己定制的，而不仅仅局限于.NET提供的那几个现成的，因此给 C#程序开发带来了相当大的灵活性和便利。
 
 　　我们还是借用生活中的例子来介绍C#的特性机制吧。
 
 　　假设有一天你去坐飞机，你就必须提前去机场登机处换登机牌。登机牌就是一张纸，上面写着哪趟航班、由哪里飞往哪里以及你的名字、座位号等等信息，其实，这就是特性。它不需要你生理上包含这些属性（人类出现那会儿还没飞机呢），就像上面的HumanBase类没有IsSerializable这样的属性，特性只需要在类或方法需要的时候加上去就行了，就像你不总是在天上飞一样。
 
 　　当我们想知道HumanBase是不是可序列化的，可以通过：
 
 
    

      
     
 
    
 
 　　拿到了登机牌，就意味着你可以合法地登机起飞了。但此时你还不知道你要坐的飞机停在哪里，不用担心，地勤人员会开车送你过去，但是他怎么知道你是哪趟航班的呢？显然还是通过你手中的登机牌。所以，特性最大的特点就是自描述。
 
 　　既然是起到描述的作用，那目的就是在于限定。就好比地勤不会把你随便拉到一架飞机跟前就扔上去了事，因为标签上的说明信息就是起到限定的作用，限定了目的地、乘客和航班，任何差错都被视为异常。如果前面的HumanBase不加上Serializable特性就不能在网络上传输。
 
 　　我们在顺带来介绍一下方法特性，先给HumanProperty加上一个Run方法：
 
 
    

      
     
 
    
 
 　　只要是个四肢健全、身体健康的人就可以跑步，那这么说，跑步就是有前提条件的，至少是四肢健全，身体健康。由此可见，残疾人和老年人如果跑步就会出问题。假设一个HumanBase的对象代表的是一位耄耋老人，如果让他当刘翔的陪练，那就直接光荣了。如何避免这样的情况呢，我们可以在Run方法中加一段逻辑代码，先判断Age大小，如果小于2或大于60直接抛异常，但是2-60岁之间也得用Switch来分年龄阶段地判断speed参数是否合适，那么逻辑就相当臃肿。简而言之，如何用特性表示一个方法不能被使用呢？OK, here we go：
 
 
    

      
     
 
    
 
 　　上面大致介绍了一下特性的使用与作用，接下来我们要向大家展示的是如何通过自定义特性来提高程序的灵活性，如果特性机制仅仅能使用.NET提供的那几种特性，不就太不过瘾了么。
 
 　　首先，特性也是类。不同于其它类的是，特性都必须继承自System.Attribute类，否则编译器如何知道谁是特性谁是普通类呢。当编译器检测到一个类是特性的时候，它会识别出其中的信息并存放在元数据当中，仅此而已，编译器并不关心特性说了些什么，特性也不会对编译器起到任何作用，正如航空公司并不关心每个箱子要去哪里，只有箱子的主人和搬运工才会去关心这些细节。假设我们现在就是航空公司的管理人员，需要设计出前面提到的登机牌，那么很简单，我们先看看最主要的信息有哪些：
 
 
    

      
     
 
    
 
 　　我们简单列举这些属性作为航空公司登机牌上的信息，用法和前面的一样，贴到HumanBase上就行了，说明此人具备登机资格。这里要简单提一下，你可能已经注意到了，在使用BoardingCheckAttribute的时候已经把Attribute省略掉了，不用担心，这样做是对的，因为编译器默认会自己加上然后查找这个属性类的。哦，等一下，我突然想起来他该登哪架飞机呢？显然，在这种需求下，我们的特性还没有起到应有的作用，我们还的做点儿工作，否则乘客面对一张空白的机票一定会很迷茫。
 
 　　于是，我们必须给这个C#特性加上构造函数，因为它不仅仅表示登机的资格，还必须包含一些必要的信息才行：
 
 
    

      
     
 
    
 
 　　OK，我们的乘客就可以拿到一张正式的登机牌登机了，have a good flight！
         游戏蛮牛：http://www.unitymanual.com
 
 
 特性详解
 
 
 
 
  
  
 
   
 6.jpg (33.78 KB, 下载次数: 0)