C# Assembly.GetAttributes方法代码示例

		/// <summary>
		///   Determines whether this assembly has internals visible to dynamic proxy.
		/// </summary>
		/// <param name = "asm">The assembly to inspect.</param>
		public bool IsInternalToDynamicProxy(Assembly asm)
		{
			using (var locker = internalsToDynProxyLock.ForReadingUpgradeable())
			{
				if (internalsToDynProxy.ContainsKey(asm))
				{
					return internalsToDynProxy[asm];
				}

				locker.Upgrade();

				if (internalsToDynProxy.ContainsKey(asm))
				{
					return internalsToDynProxy[asm];
				}

                var internalsVisibleTo = asm.GetAttributes<InternalsVisibleToAttribute>();
                var found = internalsVisibleTo.Any(attr => {
                            var parts = attr.AssemblyName.Split(',');
                            return parts.Length > 0
                                && (parts[0] == this.moduleScope.StrongAssemblyName
                                    || parts[0] == this.moduleScope.WeakAssemblyName);
                        });

				internalsToDynProxy.Add(asm, found);
				return found;
			}
		}

        // ReSharper restore SuggestBaseTypeForParameter
        // ReSharper disable SuggestBaseTypeForParameter
        internal static Result<string> GetAssemblyConfiguration(Assembly callingAssembly)
        {
            var attributes = callingAssembly
                .GetAttributes<AssemblyConfigurationAttribute>(true);

            if (attributes.Length == 0)
                return Result<string>.CreateError("Attribute is not present");
            return Result.CreateSuccess(attributes[0].Configuration);
        }

        public static ITestAction[] GetActionsFromAttributeProvider(Assembly attributeProvider)
        {
            if (attributeProvider == null)
                return new ITestAction[0];

            var actions = attributeProvider.GetAttributes<ITestAction>().ToList();
            actions.Sort(SortByTargetDescending);

            return actions.ToArray();
        }

        /// <summary>
        ///     Add a compression stream to the library.  Zlib is the default.
        /// </summary>
        /// <param name="a">
        ///     The assembly containing the stream definition.
        /// </param>
        public static void AddCompression(Assembly a)
        {
            Log.Debug("Loading compression algorithms from {Assembly}", a.FullName);

            IEnumerable<CompressionAttribute> tags = a.GetAttributes<CompressionAttribute>();
            foreach (CompressionAttribute tag in tags)
            {
                Log.Debug("Loading algorithm {Algorithm}", tag.Algorithm);
                RegisteredItems.Add(tag.Algorithm, tag.ClassType);
            }
        }

        /// <summary>
        /// Add a compression stream to the library.  Zlib is the default.
        /// </summary>
        /// <param name="a">
        /// The assembly containing the stream definition.
        /// </param>
        public static void AddCompression(Assembly a)
        {
            Logger.DebugFormat(typeof(CompressionRegistry), "Adding assembly {0}", a.FullName);

            var tags = a.GetAttributes<CompressionAttribute>();
            foreach (var tag in tags)
            {
                Logger.DebugFormat(typeof(CompressionRegistry), "Adding {0}", tag.Algorithm);
                RegisteredItems.Add(tag.Algorithm, tag.ClassType);
            }
        }

 /// <summary>
 /// Modify a newly constructed test by applying any of NUnit's common
 /// attributes, based on a supplied ICustomAttributeProvider, which is
 /// usually the reflection element from which the test was constructed,
 /// but may not be in some instances. The attributes retrieved are 
 /// saved for use in subsequent operations.
 /// </summary>
 /// <param name="provider">An object deriving from MemberInfo</param>
 public void ApplyAttributesToTest(Assembly provider)
 {
     foreach (IApplyToTest iApply in provider.GetAttributes<IApplyToTest>())
         iApply.ApplyToTest(this);
 }