演练C＃特性

最新推荐文章于 2022-05-11 13:04:59 发布

寒冰屋

最新推荐文章于 2022-05-11 13:04:59 发布

阅读量303

点赞数

分类专栏： CSharp.NET 文章标签： C＃特性 Attributes

原文链接：https://www.codeproject.com/Articles/5277368/A-Walkthrough-Csharp-Attributes

版权

CSharp.NET 专栏收录该内容

1164 篇文章 54 订阅

订阅专栏

介绍

如果您已经使用C＃语言已有一段时间了，那么您正在使用内置特性（例如[Serializable], [Obsolete]），但是您还没有对此进行深入的考虑？在本文中，我们将探讨特性的基础知识，常见的特性，如何创建和读取特性。令人兴奋的是，您将看到如何使用System.Reflection来获取内置特性。好，那就开始吧。

背景

这有点题外话，但可以分享。你知道吗？当我们放松和阅读书籍时，我们的头脑往往会开始怀疑。而且，当我读一本C＃书籍时，这件事发生在我身上，我开始想知道如何通过System.Reflection来获取那些内置特性。因此，这篇文章变得生动起来。

什么是特性？

特性很重要，它提供了其他信息，为开发人员提供了线索。尤其是在期望的情况下，具有类的行为以及应用程序中类的特性和/或方法。

简而言之，特性就像形容词，描述类型、程序集、模块、方法等。

关于特性要记住的事情

特性是派生自System.Attribute的类
特性可以具有参数
在代码中使用特性时，特性可以省略特性名称的Attribute部分。框架将以任何一种方式正确处理特性。

特性类型

内在特性

这些特性也称为预定义或内置特性。.NET Framework / .NET Core提供了数百甚至数千个内置特性。它们中的大多数是专门的，但是我们将尝试以编程方式提取它们，并讨论一些最常见的方法。

常用的内置特性

特性	描述
[Obsolete]	System.ObsoleteAttribute 帮助您识别代码应用程序中的过时位。
[Conditional]	System.Diagnostics.ConditionalAttribute 使您能够执行条件编译。
[Serializable]	System.SerializableAttribute 表明一个类可以序列化。
[NonSerialized]	System.NonSerializedAttribute 表明不应将可序列化类的字段序列化。
[DLLImport]	System.DllImportAttribute 显示方法由非托管动态链接库（DLL）公开为静态入口点。

使用C＃通过反射提取内置类型

如所承诺的，我们将看到如何使用C＃提取内置特性。请参见下面的示例代码：

using System;
using System.Linq;
using System.Reflection;
using Xunit;
using Xunit.Abstractions;

namespace CSharp_Attributes_Walkthrough {
    public class UnitTest_Csharp_Attributes {
        private readonly ITestOutputHelper _output;

        private readonly string assemblyFullName = "System.Private.CoreLib, 
                Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e";

        public UnitTest_Csharp_Attributes (ITestOutputHelper output) {
            this._output = output;
        }

        [Fact]
        public void Test_GetAll_BuiltIn_Attributes () {
            var assembly = Assembly.Load (assemblyFullName);

            var attributes = assembly
                .DefinedTypes
                .Where (type =>
                    type
                    .IsSubclassOf (typeof (Attribute)));

            foreach (var attribute in attributes) {
                
                string attr = attribute
                    .Name
                    .Replace ("Attribute", "");

                this._output
                    .WriteLine ("Attribute: {0} and Usage: [{1}]", attribute.Name, attr);
            }
        }
    }
}

请参见下面的输出：

在运行时读取特性

现在，我们已经回答了什么是特性，什么是常用特性，以及如何通过System.Reflection提取内置特性的方法，让我们看看如何在运行时读取这些特性，当然使用System.Reflection。

在运行时检索特性值时，有两种方法可以检索值。

使用GetCustomAttributes()方法，这将返回一个包含指定类型的所有特性的数组。当您不确定哪些特性适用于特定类型时，可以使用此方法，可以遍历此数组。

使用GetCustomAttribute()方法，这将返回所需的特定特性的详细信息。

好的，接下来让我们来看一个例子。

让我们首先尝试创建一个类，并使用一些随机特性对其进行标记。

using System;
using System.Diagnostics;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    [Serializable]
    public class Product
    {
        public string Name { get; set; }
        public string Code { get; set; }

        [Obsolete("This method is already obselete. Use the ProductFullName instead.")]
        public string GetProductFullName()
        {
            return $"{this.Name} {this.Code}";
        }

        [Conditional("DEBUG")]
        public void RunOnlyOnDebugMode()
        {

        }
    }
}

Product-class是很容易理解。在下面的示例中，我们要检查以下内容：

检查Product-class是否确实具有[Serializable]特性。
检查Product-class是否具有两个方法。
检查每个方法是否确实具有特性。
检查方法GetProductFullName是否正在使用[Obsolete]特性。
检查方法RunOnlyDebugMode是否正在使用[Conditional]特性。

/*
*This test will read the Product-class at runtime to check for attributes. 
*1. Check if [Serializable] has been read. 
*2. Check if the product-class has two methods 
*3. Check if each methods does have attributes. 
*4. Check if the method GetProudctFullName is using the Obsolete attribute. 
*5. Check if the method RunOnlyOnDebugMode is using the Conditional attribute.
*/
[Fact]
public void Test_Read_Attributes()
{
    //get the Product-class
    var type = typeof(Product);

    //Get the attributes of the Product-class and we are expecting the [Serializable]
    var attribute = (SerializableAttribute)type.
                    GetCustomAttributes(typeof(SerializableAttribute), false).FirstOrDefault();

    Assert.NotNull(attribute);

    //Check if [Serializable] has been read.
    //Let's check if the type of the attribute is as expected
    Assert.IsType<SerializableAttribute>(attribute);

    //Let's get only those 2 methods that we have declared 
    //and ignore the special names (these are the auto-generated setter/getter)
    var methods = type.GetMethods(BindingFlags.Instance | 
                                    BindingFlags.Public | 
                                    BindingFlags.DeclaredOnly)
                        .Where(method => !method.IsSpecialName).ToArray();

    //Check if the product-class has two methods 
    //Let's check if the Product-class has two methods.
    Assert.True(methods.Length == 2);

    Assert.True(methods[0].Name == "GetProductFullName");
    Assert.True(methods[1].Name == "RunOnlyOnDebugMode");

    //Check if each methods does have attributes. 
    Assert.True(methods.All( method =>method.GetCustomAttributes(false).Length ==1));

    //Let's get the first method and its attribute. 
    var obsoleteAttribute = methods[0].GetCustomAttribute<ObsoleteAttribute>();

    // Check if the method GetProudctFullName is using the Obsolete attributes. 
    Assert.IsType<ObsoleteAttribute>(obsoleteAttribute);

    //Let's get the second method and its attribute. 
    var conditionalAttribute = methods[1].GetCustomAttribute<ConditionalAttribute>();

    //Check if the method RunOnlyOnDebugMode is using the Conditional attributes.
    Assert.IsType<ConditionalAttribute>(conditionalAttribute);
}

希望您喜欢上面的示例。然后让我们进入自定义特性。

自定义特性

内置特性是有用且重要的，但是在大多数情况下，它们具有特定用途。此外，如果您认为出于某种原因需要特性而不考虑内置特性，则可以创建自己的特性。

创建自定义特性

在本部分中，您将看到我们如何创建自定义特性，以及在创建自定义特性时需要记住的内容。

要创建自定义特性，请定义一个派生自System.Attribute的类。

using System;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    public class AliasAttribute : Attribute
    {
        //This is how to define a custom attributes.
    }
}

位置参数——如果您的自定义特性的构造函数中有任何参数，它将成为必需的位置参数。

using System;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    public class AliasAttribute : Attribute
    {
        /// <summary>
        /// These parameters will become mandatory once have you decided to use this attribute.
        /// </summary>
        /// <param name="alias"></param>
        /// <param name="color"></param>
        public AliasAttribute(string alias, ConsoleColor color)
        {
            this.Alias = alias;
            this.Color = color;
        }

        public string  Alias { get; private set; }
        public ConsoleColor Color { get; private set; }
    }
}

可选参数 ——这些是从System.Attribute派生的类的public字段和public可写特性。

using CSharp_Attributes_Walkthrough.My_Custom_Attributes;
using System;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    public class AliasAttribute : Attribute
    {
        //....

        //Added an optional-parameter
        public string AlternativeName { get; set; }
    }
}

请参见下面的完整示例代码：

using System;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    public class AliasAttribute : Attribute
    {
        /// <summary>
        /// These parameters will become mandatory once have you decided to use this attribute.
        /// </summary>
        /// <param name="alias"></param>
        /// <param name="color"></param>
        public AliasAttribute(string alias, ConsoleColor color)
        {
            this.Alias = alias;
            this.Color = color;
        }

        #region Positional-Parameters
        public string Alias { get; private set; }
        public ConsoleColor Color { get; private set; }
        #endregion 

        //Added an optional-parameter
        public string AlternativeName { get; set; }
    }
}

请参见下图，以可视化位置参数和可选参数之间的差异。

现在我们已经创建了一个自定义特性，让我们尝试在一个类中使用它。

在类中应用自定义特性

using System;
using System.Linq;

namespace CSharp_Attributes_Walkthrough.My_Custom_Attributes
{
    [Alias("Filipino_Customers", ConsoleColor.Yellow)]
    public class Customer
    {
        [Alias("Fname", ConsoleColor.White, AlternativeName = "Customer_FirstName")]
        public string Firstname { get; set; }

        [Alias("Lname", ConsoleColor.White, AlternativeName = "Customer_LastName")]
        public string LastName { get; set; }

        public override string ToString()
        {
            //get the current running instance.
            Type instanceType = this.GetType(); 

            //get the namespace of the running instance.
            string current_namespace = (instanceType.Namespace) ?? "";

            //get the alias.
            string alias = (this.GetType().GetCustomAttributes(false).FirstOrDefault() 
                            as AliasAttribute)?.Alias;

            return $"{current_namespace}.{alias}";
        }
    }
}

该示例的主要内容是ToString()方法，默认情况下将返回该类型的全限定名称。然而; 我们在这里所做的是，我们已经覆盖了ToString()返回特性的全限定名称和别名的方法。

现在让我们尝试调用该ToString()方法，看看它返回什么。请参见下面的示例，输出：

using CSharp_Attributes_Walkthrough.My_Custom_Attributes;
using System;

namespace Implementing_Csharp_Attributes_101
{
    class Program
    {
        static void Main(string[] args)
        {
            var customer = new Customer { Firstname = "Jin Vincent" , LastName = "Necesario" };
          
            var aliasAttributeType = customer.GetType();

            var attribute = 
                aliasAttributeType.GetCustomAttributes(typeof(AliasAttribute), false);

            Console.ForegroundColor = ((AliasAttribute)attribute[0]).Color;

            Console.WriteLine(customer.ToString());

            Console.ReadLine();
        }
    }
}

限制特性的使用

默认情况下，您可以将自定义特性应用于应用程序代码中的任何实体。因此，当您创建自定义特性时，它可以应用于类、方法、私有字段、特性、结构等。但是，如果您希望将自定义特性限制为仅出现在某些类型的实体上。您可以使用AttributeUsage特性来控制可以将其应用于哪些实体。

值	目标
AttributeTargets.All	可以应用于应用程序中的任何实体
AttributeTargets.Assembly	可以应用于程序集
AttributeTargets.Class	可以应用于类
AttributeTargets.Construtor	可以应用于构造函数
AttributeTargets.Delegate	可以应用于代理
AttributeTargets.Enum	可以应用于枚举
AttributeTargets.Event	可以应用于事件
AttributeTargets.Field	可以应用于字段
AttributeTargets.Interface	可以应用于接口
AttributeTargets.Method	可以应用于方法
AttributeTargets.Module	可以应用于模块
AttributeTargets.Parameter	可以应用于参数
AttributeTargets.Property	可以应用于属性
AttributeTargets.ReturnValue	可以应用于返回值
AttributeTargets.Struct	可以应用于结构

如果您想知道，我们如何在运行时获得这些AttributeTargets？请参阅以下示例：

[Fact]
public void Test_GetAll_AttributeTargets()
{
    var targets = Enum.GetNames(typeof(AttributeTargets));

    foreach (var target in targets)
    {
        this._output.WriteLine($"AttributeTargets.{target}");
    }
}

寒冰屋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
演练C＃特性

介绍如果您已经使用C＃语言已有一段时间了，那么您正在使用内置特性（例如[Serializable], [Obsolete]），但是您还没有对此进行深入的考虑？在本文中，我们将探讨特性的基础知识，常见的特性，如何创建和读取特性。令人兴奋的是，您将看到如何使用System.Reflection来获取内置特性。好，那就开始吧。背景这有点题外话，但可以分享。你知道吗？当我们放松和阅读书籍时，我们的头脑往往会开始怀疑。而且，当我读一本C＃书籍时，这件事发生在我身上，我开始想知道如何通过System....
复制链接

扫一扫

专栏目录