Attribute 类
表示自定义属性的基类。
**命名空间:**System
**程序集:**mscorlib（在 mscorlib.dll 中）
语法
声明
<SerializableAttribute> _
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
<ComVisibleAttribute(True)> _
<AttributeUsageAttribute(AttributeTargets.All, Inherited:=True, AllowMultiple:=False)> _
Public MustInherit Class Attribute
Implements _Attribute
用法
Dim instance As Attribute
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
[AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false)]
public abstract class Attribute : _Attribute
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType::None)]
[ComVisibleAttribute(true)]
[AttributeUsageAttribute(AttributeTargets::All, Inherited=true, AllowMultiple=false)]
public ref class Attribute abstract : _Attribute
/** @attribute SerializableAttribute() */
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */
/** @attribute ComVisibleAttribute(true) */
/** @attribute AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false) */
public abstract class Attribute implements _Attribute
SerializableAttribute
ClassInterfaceAttribute(ClassInterfaceType.None)
ComVisibleAttribute(true)
AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false)
public abstract class Attribute implements _Attribute
备注
Attribute 类将预定义的系统信息或用户定义的自定义信息与目标元素相关联。目标元素可以是程序集、类、构造函数、委托、枚举、事件、字段、接口、方法、可移植可执行文件模块、参数、属性 (Property)、返回值、结构或其他属性 (Attribute)。
属性所提供的信息也称为元数据。元数据可由应用程序在运行时进行检查以控制程序处理数据的方式，也可以由外部工具在运行前检查以控制应用程序处理或维护自身的方式。例如，.NET Framework 预定义属性类型并使用属性类型控制运行时行为，某些编程语言使用属性类型表示 .NET Framework 公共类型系统不直接支持的语言功能。
所有属性类型都直接或间接地从 Attribute 类派生。属性可应用于任何目标元素；多个属性可应用于同一目标元素；并且属性可由从目标元素派生的元素继承。使用 AttributeTargets 类可以指定属性所应用到的目标元素。
Attribute 类提供检索和测试自定义属性的简便方法。有关使用属性的更多信息，请参见 利用属性扩展元数据。
示例
下面的代码示例演示 Attribute 的用法。
Imports System
Imports System.Reflection
Public Module CustomAttrVB
' An enumeration of animals. Start at 1 (0 = uninitialized).
Public Enum Animal
' Pets
Dog = 1
Cat
Bird
End Enum
' Visual Basic requires the AttributeUsage be specified.
' A custom attribute to allow a target to have a pet.
<AttributeUsage(AttributeTargets.Method)> _
Public Class AnimalTypeAttribute
Inherits Attribute
' The constructor is called when the attribute is set.
Public Sub New(ByVal animal As Animal)
Me.thePet = animal
End Sub
' Keep a variable internally ...
Protected thePet As Animal
' .. and show a copy to the outside world.
Public Property Pet() As Animal
Get
Return thePet
End Get
Set(ByVal Value As Animal)
thePet = Value
End Set
End Property
End Class
' A test class where each method has its own pet.
Class AnimalTypeTestClass
<AnimalType(Animal.Dog)> _
Public Sub DogMethod()
End Sub
<AnimalType(Animal.Cat)> _
Public Sub CatMethod()
End Sub
<AnimalType(Animal.Bird)> _
Public Sub BirdMethod()
End Sub
End Class
' The runtime test.
Sub Main()
Dim testClass As New AnimalTypeTestClass()
Dim tcType As Type = testClass.GetType()
Dim mInfo As MethodInfo
' Iterate through all the methods of the class.
For Each mInfo In tcType.GetMethods()
Dim attr As Attribute
' Iterate through all the attributes of the method.
For Each attr In Attribute.GetCustomAttributes(mInfo)
If TypeOf attr Is AnimalTypeAttribute Then
Dim attrCustom As AnimalTypeAttribute = _
CType(attr, AnimalTypeAttribute)
Console.WriteLine("Method {0} has a pet {1} attribute.", _
mInfo.Name(), attrCustom.Pet.ToString())
End If
Next
Next
End Sub
End Module
' Output:
' Method DogMethod has a pet Dog attribute.
' Method CatMethod has a pet Cat attribute.
' Method BirdMethod has a pet Bird attribute.
using System;
using System.Reflection;
namespace CustomAttrCS {
// An enumeration of animals. Start at 1 (0 = uninitialized).
public enum Animal {
// Pets.
Dog = 1,
Cat,
Bird,
}
// A custom attribute to allow a target to have a pet.
public class AnimalTypeAttribute : Attribute {
// The constructor is called when the attribute is set.
public AnimalTypeAttribute(Animal pet) {
thePet = pet;
}
// Keep a variable internally ...
protected Animal thePet;
// .. and show a copy to the outside world.
public Animal Pet {
get { return thePet; }
set { thePet = Pet; }
}
}
// A test class where each method has its own pet.
class AnimalTypeTestClass {
[AnimalType(Animal.Dog)]
public void DogMethod() {}
[AnimalType(Animal.Cat)]
public void CatMethod() {}
[AnimalType(Animal.Bird)]
public void BirdMethod() {}
}
class DemoClass {
static void Main(string[] args) {
AnimalTypeTestClass testClass = new AnimalTypeTestClass();
Type type = testClass.GetType();
// Iterate through all the methods of the class.
foreach(MethodInfo mInfo in type.GetMethods()) {
// Iterate through all the Attributes for each method.
foreach (Attribute attr in
Attribute.GetCustomAttributes(mInfo)) {
// Check for the AnimalType attribute.
if (attr.GetType() == typeof(AnimalTypeAttribute))
Console.WriteLine(
"Method {0} has a pet {1} attribute.",
mInfo.Name, ((AnimalTypeAttribute)attr).Pet);
}
}
}
}
}
/*
* Output:
* Method DogMethod has a pet Dog attribute.
* Method CatMethod has a pet Cat attribute.
* Method BirdMethod has a pet Bird attribute.
*/
using namespace System;
using namespace System::Reflection;
// An enumeration of animals. Start at 1 (0 = uninitialized).
public enum class Animal
{
// Pets.
Dog = 1,
Cat, Bird
};
// A custom attribute to allow a target to have a pet.
public ref class AnimalTypeAttribute: public Attribute
{
public:
// The constructor is called when the attribute is set.
AnimalTypeAttribute( Animal pet )
{
thePet = pet;
}
protected:
// Keep a variable internally ...
Animal thePet;
public:
property Animal Pet
{
// .. and show a copy to the outside world.
Animal get()
{
return thePet;
}
void set( Animal value )
{
thePet = value;
}
}
};
// A test class where each method has its own pet.
ref class AnimalTypeTestClass
{
public:
[AnimalType(Animal::Dog)]
void DogMethod(){}
[AnimalType(Animal::Cat)]
void CatMethod(){}
[AnimalType(Animal::Bird)]
void BirdMethod(){}
};
int main()
{
AnimalTypeTestClass^ testClass = gcnew AnimalTypeTestClass;
Type^ type = testClass->GetType();
// Iterate through all the methods of the class.
System::Collections::IEnumerator^ myEnum = type->GetMethods()->GetEnumerator();
while ( myEnum->MoveNext() )
{
MethodInfo^ mInfo = safe_cast<MethodInfo^>(myEnum->Current);
// Iterate through all the Attributes for each method.
System::Collections::IEnumerator^ myEnum1 = Attribute::GetCustomAttributes( mInfo )->GetEnumerator();
while ( myEnum1->MoveNext() )
{
Attribute^ attr = safe_cast<Attribute^>(myEnum1->Current);
// Check for the AnimalType attribute.
if ( attr->GetType() == AnimalTypeAttribute::typeid )
Console::WriteLine( "Method {0} has a pet {1} attribute.", mInfo->Name, (dynamic_cast<AnimalTypeAttribute^>(attr))->Pet );
}
}
}
/*
* Output:
* Method DogMethod has a pet Dog attribute.
* Method CatMethod has a pet Cat attribute.
* Method BirdMethod has a pet Bird attribute.
*/
package CustomAttrJSL;
import System.*;
import System.Reflection.*;
public class Animal
{
protected int pet;
public static final int dog = 1;
public static final int cat = 2;
public static final int bird = 3;
public Animal()
{
pet = 0;
} //Animal
public Animal(int p)
{
pet = p;
} //Animal
public String getPet()
{
switch (pet) {
case 1 :
return "Dog";
case 2 :
return "Cat";
case 3 :
return "Bird";
default :
return null;
}
} //getPet
} //Animal
// A custom attribute to allow a target to have a pet.
/** @attribute System.AttributeUsageAttribute(AttributeTargets.Method)
*/
public class AnimalTypeAttribute extends Attribute
{
public AnimalTypeAttribute() { }
// The constructor is called when the attribute is set.
public AnimalTypeAttribute(int pet)
{
thePet = new Animal(pet);
} //AnimalTypeAttribute
// Keep a variable internally...
protected Animal thePet;
//.. and show a copy to the outside world.
/** @property
*/
public Animal get_Pet()
{
return thePet;
} //get_Pet
/** @property
*/
public void set_Pet(Animal value)
{
thePet = value;
} //set_Pet
} //AnimalTypeAttribute
// A test class where each method has its own pet.
class AnimalTypeTestClass
{
/** @attribute AnimalType(Animal.dog)
*/
public void DogMethod()
{
} //DogMethod
/** @attribute AnimalType(Animal.cat)
*/
public void CatMethod()
{
} //CatMethod
/** @attribute AnimalType(Animal.bird)
*/
public void BirdMethod()
{
} //BirdMethod
} //AnimalTypeTestClass
class DemoClass
{
public static void main(String[] args)
{
AnimalTypeTestClass testClass = new AnimalTypeTestClass();
Type type = testClass.GetType();
// Iterate through all the methods of the class.
for (int iCtr1 = 0; iCtr1 < type.GetMethods().length; iCtr1++) {
MethodInfo mInfo = type.GetMethods()[iCtr1];
// Iterate through all the Attributes for each method.
for (int iCtr2 = 0;
iCtr2 < Attribute.GetCustomAttributes(mInfo).length;
iCtr2++) {
Attribute attr = Attribute.GetCustomAttributes(mInfo)[iCtr2];
// Check for the AnimalType attribute.
if (attr.GetType().
Equals(AnimalTypeAttribute.class.ToType())) {
Console.WriteLine("Method {0} has a pet {1} attribute.",
mInfo.get_Name(),
((AnimalTypeAttribute)attr).get_Pet().getPet());
}
}
}
} //main
} //DemoClass
/*
Output:
Method DogMethod has a pet Dog attribute.
Method CatMethod has a pet Cat attribute.
Method BirdMethod has a pet Bird attribute.
*/
import System;
import System.Reflection;
import CustomAttrJS;
package CustomAttrJS {
// An enumeration of animals. Start at 1 (0 = uninitialized).
public enum Animal {
// Pets.
Dog = 1,
Cat,
Bird,
}
// A custom attribute to allow a target to have a pet.
public AttributeUsage(AttributeTargets.Method) class AnimalTypeAttribute extends Attribute {
// The constructor is called when the attribute is set.
public function AnimalTypeAttribute(pet : Animal) {
thePet = pet;
}
// Keep a variable internally ...
protected var thePet : Animal;
// .. and show a copy to the outside world.
public function get Pet() : Animal {
return thePet;
}
public function set Pet(pet : Animal) {
thePet = pet;
}
}
// A test class where each method has its own pet.
class AnimalTypeTestClass {
public AnimalTypeAttribute(Animal.Dog)
function DogMethod() {}
public AnimalTypeAttribute(Animal.Cat)
function CatMethod() {}
public AnimalTypeAttribute(Animal.Bird)
function BirdMethod() {}
}
}
var testClass : AnimalTypeTestClass = new AnimalTypeTestClass();
var type : Type = testClass.GetType();
// Iterate through all the methods of the class.
var mInfo : MethodInfo[] = type.GetMethods();
for (var i : int = 0; i < mInfo.length; i++) {
// Iterate through all the Attributes for each method.
var attr : Attribute[] = Attribute.GetCustomAttributes(mInfo[i]);
for (var j : int = 0; j < attr.length; j++)
{
// Check for the AnimalType attribute.
if (attr[j].GetType() == AnimalTypeAttribute)
Console.WriteLine(
"Method {0} has a pet {1} attribute.",
mInfo[i].Name, AnimalTypeAttribute(attr[j]).Pet);
}
}
/*
* Output:
* Method BirdMethod has a pet Bird attribute.
* Method CatMethod has a pet Cat attribute.
* Method DogMethod has a pet Dog attribute.
*/
继承层次结构
System.Object
System.Attribute
派生类
线程安全
该类型对于多线程操作是安全的。
平台
Windows 98、Windows 2000 SP4、Windows CE、Windows Millennium Edition、Windows Mobile for Pocket PC、Windows Mobile for Smartphone、Windows Server 2003、Windows XP Media Center Edition、Windows XP Professional x64 Edition、Windows XP SP2、Windows XP Starter Edition
.NET Framework 并不是对每个平台的所有版本都提供支持。有关受支持版本的列表，请参见系统要求。
版本信息
.NET Framework
受以下版本支持：2.0、1.1、1.0
.NET Compact Framework
受以下版本支持：2.0、1.0