Support replication of attributss defined in AttributesToAlwaysReplicate

- This is complementary to AttributesToAvoidReplicating
- This will allow consumers to specify attributes which should always be
  copied to generated proxy. It is especially useful where we do not own
  target interfeces and/or cannot override attributes, e.g. attributes
  used by various frameworks. This was mentioned in castleproject#593
- Similar effect could by achieved in Castle.Core Version 4.4.1 by simply extending various generator classes but in 5.0 all those classes were marked internal, without this fix we now have to override half the library, So this fix offers an alternative path.
- Fixes castleproject#607

Author: Shoaib Shakeel

ref/Castle.Core-net462.cs

@@ -2768,6 +2768,12 @@ protected virtual void PreProceed(Castle.DynamicProxy.IInvocation invocation) {
 }
 namespace Castle.DynamicProxy.Generators
 {
+    public static class AttributesToAlwaysReplicate
+    {
+        public static void Add(System.Type attribute) { }
+        public static void Add<T>() { }
+        public static bool Contains(System.Type attribute) { }
+    }
     public static class AttributesToAvoidReplicating
     {
         public static void Add(System.Type attribute) { }

ref/Castle.Core-net6.0.cs

@@ -2723,6 +2723,12 @@ protected virtual void PreProceed(Castle.DynamicProxy.IInvocation invocation) {
 }
 namespace Castle.DynamicProxy.Generators
 {
+    public static class AttributesToAlwaysReplicate
+    {
+        public static void Add(System.Type attribute) { }
+        public static void Add<T>() { }
+        public static bool Contains(System.Type attribute) { }
+    }
     public static class AttributesToAvoidReplicating
     {
         public static void Add(System.Type attribute) { }

ref/Castle.Core-netstandard2.0.cs

@@ -2721,6 +2721,12 @@ protected virtual void PreProceed(Castle.DynamicProxy.IInvocation invocation) {
 }
 namespace Castle.DynamicProxy.Generators
 {
+    public static class AttributesToAlwaysReplicate
+    {
+        public static void Add(System.Type attribute) { }
+        public static void Add<T>() { }
+        public static bool Contains(System.Type attribute) { }
+    }
     public static class AttributesToAvoidReplicating
     {
         public static void Add(System.Type attribute) { }

ref/Castle.Core-netstandard2.1.cs

@@ -2721,6 +2721,12 @@ protected virtual void PreProceed(Castle.DynamicProxy.IInvocation invocation) {
 }
 namespace Castle.DynamicProxy.Generators
 {
+    public static class AttributesToAlwaysReplicate
+    {
+        public static void Add(System.Type attribute) { }
+        public static void Add<T>() { }
+        public static bool Contains(System.Type attribute) { }
+    }
     public static class AttributesToAvoidReplicating
     {
         public static void Add(System.Type attribute) { }

src/Castle.Core/DynamicProxy/Generators/AttributesToAlwaysReplicate.cs

@@ -0,0 +1,59 @@
+// Copyright 2004-2021 Castle Project - http://www.castleproject.org/
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Castle.DynamicProxy.Generators
+{
+	using System;
+	using System.Collections.Generic;
+	using System.Linq;
+
+	public static class AttributesToAlwaysReplicate
+	{
+		private static readonly object lockObject = new object();
+
+		private static IList<Type> attributes;
+
+		static AttributesToAlwaysReplicate()
+		{
+			attributes = new List<Type>()
+			{
+				typeof(ParamArrayAttribute)
+			};
+		}
+
+		public static void Add(Type attribute)
+		{
+			// note: this class is made thread-safe by replacing the backing list rather than adding to it
+			lock (lockObject)
+			{
+				attributes = new List<Type>(attributes) { attribute };
+			}
+		}
+
+		public static void Add<T>()
+		{
+			Add(typeof(T));
+		}
+
+		public static bool Contains(Type attribute)
+		{
+			return attributes.Contains(attribute);
+		}
+
+		internal static bool ShouldAdd(Type attribute)
+		{
+			return attributes.Any(attr => attr == attribute);
+		}
+	}
+}

src/Castle.Core/DynamicProxy/Internal/AttributeUtil.cs

@@ -181,15 +181,11 @@ private static bool ShouldSkipAttributeReplication(Type attribute, bool ignoreIn
 				return true;
 			}
 
-			// Later, there might be more special cases requiring attribute replication,
-			// which might justify creating a `SpecialCaseAttributeThatShouldBeReplicated`
-			// method and an `AttributesToAlwaysReplicate` class. For the moment, `Param-
-			// ArrayAttribute` is the only special case, so keep it simple for now:
-			if (attribute == typeof(ParamArrayAttribute))
+			if (AttributesToAlwaysReplicate.ShouldAdd(attribute))
 			{
 				return false;
 			}
-
+			
 			if (!ignoreInheritance)
 			{
 				var attrs = attribute.GetCustomAttributes<AttributeUsageAttribute>(true).ToArray();