web-dev-qa-db-ja.com

C＃属性はターゲットクラスにアクセスできますか？

リフレクションを使用して、属性クラスからクラスのプロパティにアクセスしたい。出来ますか？

例えば：

class MyAttribute : Attribute
{
    private void AccessTargetClass()
    {
        // Do some operations
    }
}

[MyAttribute]
class TargetClass
{
}
c#reflectionattributes
46
Selçuk Öztürk

直接ではありませんが、属性が何かを行うには、型/メンバーへのハンドルがすでにあり、そのGetCustomAttributesメソッドを呼び出す必要があるため、そこから単純に渡すことができます。

class MyAttribute : Attribute
{
    public void DoSomethingWithDeclaringType(Type t)
    {
    }
}

そのようにそれを使う：

Type classType = typeof(MyClass);
object[] attribs = classType.GetCustomAttributes(typeof(MyAttribute), true);
if(attribs.Length > 0)
{
    ((MyAttribute)attribs[0]).DoSomethingWithDeclaringType(classType);
}
16
Rex M

呼び出し元のコードを使用して型参照を渡すことができない場合があります。

以下は、私がこの問題を解決するために準備した解決策です。それはショットガンのアプローチの少しですが、それはうまくいきます...

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;


namespace Ethica.Reflection
{
    /// <summary>
    /// Helps in discovery of the target of an Attribute
    /// </summary>
    /// <typeparam name="TAttribute">An Attribute derived type</typeparam>
    /// <remarks>
    /// The .NET framework does not provide navigation from attributes back to their targets, principally for the reason that 
    /// in typical usage scenarios for attributes, the attribute is discovered by a routine which already has a reference to a 
    /// member type.
    /// 
    /// There are, however, bona-fide cases where an attribute needs to detect it's target - an example is a localizable sub-class of the 
    /// DescriptionAttribute. In order for the DescriptionAttribute to return a localized string, it requires a resource key and, ideally,
    /// a type reference as the base-key for the ResourceManager. A DescriptionAttribute could not provide this information without
    /// a reference to it's target type.
    /// 
    /// Note to callers:
    /// 
    /// Your Attribute-derived class must implement Equals and GetHashCode, otherwise a run-time exception will occur, since this class
    /// creates a dictionary of attributes in order to speed up target lookups.
    /// </remarks>
    public static class AttributeTargetHelper<TAttribute>
        where TAttribute : Attribute
    {
        /// <summary>
        /// Map of attributes and their respective targets
        /// </summary>
        private static Dictionary<TAttribute, object> targetMap;

        /// <summary>
        /// List of assemblies that should not be rescanned for types.
        /// </summary>
        private static List<string> skipAssemblies;

        /// <summary>
        /// Adds an attribute and it's target to the dictionary
        /// </summary>
        /// <param name="attribute"></param>
        /// <param name="item"></param>
        private static void Add(TAttribute attribute, object item)
        {
            targetMap.Add(attribute, item);
        }

        /// <summary>
        /// Scans an Assembly for all instances of the attribute.
        /// </summary>
        /// <param name="Assembly"></param>
        private static void ScanAssembly(Assembly assembly)
        {
            const BindingFlags memberInfoBinding = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;

            if (!skipAssemblies.Contains(Assembly.FullName))
            {
                skipAssemblies.Add(Assembly.FullName);

                Debug.WriteLine("Loading attribute targets for " + typeof(TAttribute).Name + " from Assembly " + Assembly.FullName);

                foreach (TAttribute attr in Assembly.GetCustomAttributes(typeof(TAttribute), false))
                    Add(attr, Assembly);

                foreach (Type type in Assembly.GetTypes())
                {
                    foreach (TAttribute attr in type.GetCustomAttributes(typeof(TAttribute), false))
                        Add(attr, type);

                    foreach (MemberInfo member in type.GetMembers(memberInfoBinding))
                    {
                        foreach (TAttribute attr in member.GetCustomAttributes(typeof(TAttribute), false))
                            Add(attr, member);

                        if (member.MemberType == MemberTypes.Method)
                            foreach (var parameter in ((MethodInfo)member).GetParameters())
                                foreach (TAttribute attr in parameter.GetCustomAttributes(typeof(TAttribute), false))
                                    Add(attr, parameter);
                    }
                }
            }

            foreach (var assemblyName in Assembly.GetReferencedAssemblies())
            {
                if (!skipAssemblies.Contains(assemblyName.FullName))
                    ScanAssembly(Assembly.Load(assemblyName));
            }
        }

        /// <summary>
        /// Returns the target of an attribute.
        /// </summary>
        /// <param name="attribute">The attribute for which a target is sought</param>
        /// <returns>The target of the attribute - either an Assembly, Type or MemberInfo instance.</returns>
        public static object GetTarget(TAttribute attribute)
        {
            object result;
            if (!targetMap.TryGetValue(attribute, out result))
            {
                // Since types can be loaded at any time, recheck that all assemblies are included...
                // Walk up the stack in a last-ditch effort to find instances of the attribute.
                StackTrace stackTrace = new StackTrace();           // get call stack
                StackFrame[] stackFrames = stackTrace.GetFrames();  // get method calls (frames)

                // write call stack method names
                foreach (StackFrame stackFrame in stackFrames)
                {
                    Console.WriteLine(stackFrame.GetMethod().Name);   // write method name
                    ScanAssembly(stackFrame.GetMethod().GetType().Assembly);
                }

                if (!targetMap.TryGetValue(attribute, out result))
                    throw new InvalidProgramException("Cannot find Assembly referencing attribute");
            }
            return result;
        }

        /// <summary>
        /// Static constructor for type.
        /// </summary>
        static AttributeTargetHelper()
        {
            targetMap = new Dictionary<TAttribute, object>();

            // Do not load any assemblies reference by the Assembly which declares the attribute, since they cannot possibly use the attribute
            skipAssemblies = new List<string>(typeof(TAttribute).Assembly.GetReferencedAssemblies().Select(c => c.FullName));

            // Skip common system assemblies
            skipAssemblies.Add("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
            skipAssemblies.Add("System.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
            skipAssemblies.Add("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
            skipAssemblies.Add("System.Data.SqlXml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
            skipAssemblies.Add("System.Configuration, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
            skipAssemblies.Add("System.Numerics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");

            // Scan the entire application
            ScanAssembly(Assembly.GetEntryAssembly());
        }

    }


    /// <summary>
    /// Extends attributes so that their targets can be discovered
    /// </summary>
    public static class AttributeTargetHelperExtension
    {
        /// <summary>
        /// Gets the target of an attribute
        /// </summary>
        /// <typeparam name="TAttribute"></typeparam>
        /// <param name="attribute">The attribute for which a target is sought</param>
        /// <returns>The target of the attribute - either an Assembly, Type or MemberInfo instance.</returns>
        public static object GetTarget<TAttribute>(this TAttribute attribute)
            where TAttribute : Attribute
        {
            return AttributeTargetHelper<TAttribute>.GetTarget(attribute);
        }
    }
}
19
Mark

属性の主な目的は注釈です：宣言しますか？そのクラス/メソッド/プロパティはこの方法で処理する必要がありますが、実際にそれらすべてを分析するコードは別の場所にある必要があります。したがって、属性内で何かを行う意図は、このパターンを壊すことです。私のアドバイス：別の解決策を検討してください。

12
Voice

.NET 4.5の CallerMemberNameAttribute を使用して、呼び出し元のタイプにアクセスできます。

public CustomAttribute([CallerMemberName] string propertyName = null)
{
    // ...
}

そして、単純な反射を使用します

1
AuthorProxy