C# IProxyGenerationHook类代码示例

		private ProxyGenerationOptions(SerializationInfo info, StreamingContext context)
		{
			hook = (IProxyGenerationHook)info.GetValue("hook", typeof(IProxyGenerationHook));
			selector = (IInterceptorSelector)info.GetValue("selector", typeof(IInterceptorSelector));
			mixins = (List<object>)info.GetValue("mixins", typeof(List<object>));
			baseTypeForInterfaceProxy = Type.GetType(info.GetString("baseTypeForInterfaceProxy.AssemblyQualifiedName"));
		}

		protected override IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)
		{
			Debug.Assert(hook != null, "hook != null");
			var targetItem = new DelegateMembersCollector(targetType) { Logger = Logger };
			targetItem.CollectMembersToProxy(hook);
			yield return targetItem;
		}

		private void CollectEvents(IProxyGenerationHook hook)
		{
			EventInfo[] eventsFound = type.GetEvents(Flags);
			foreach (EventInfo @event in eventsFound)
			{
				AddEvent(@event, hook);
			}
		}

		private void CollectProperties(IProxyGenerationHook hook)
		{
			PropertyInfo[] propertiesFound = type.GetProperties(Flags);
			foreach (PropertyInfo property in propertiesFound)
			{
				AddProperty(property, hook);
			}
		}

 protected override IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)
 {
     foreach (var @interface in interfaces)
     {
         var item = new InterfaceMembersCollector(@interface);
         item.CollectMembersToProxy(hook);
         yield return item;
     }
 }

 private ProxyGenerationOptions(SerializationInfo info, StreamingContext context)
 {
     hook = (IProxyGenerationHook) info.GetValue ("hook", typeof (IProxyGenerationHook));
     selector = (IInterceptorSelector) info.GetValue ("selector", typeof (IInterceptorSelector));
     mixins = (ArrayList) info.GetValue ("mixins", typeof (ArrayList));
     baseTypeForInterfaceProxy = Type.GetType (info.GetString ("baseTypeForInterfaceProxy.AssemblyQualifiedName"));
     useSingleInterfaceProxy = info.GetBoolean ("useSingleInterfaceProxy");
     useSelector = info.GetBoolean ("useSelector");
 }

		protected override MetaMethod GetMethodToGenerate(IMethodInfo method, IProxyGenerationHook hook, bool isStandalone)
		{
			if (method.IsAccessible() == false)
			{
				return null;
			}

			var proxyable = AcceptMethod(method, false, hook);
			return new MetaMethod(method, method, isStandalone, proxyable, false);
		}

		protected override MetaMethod GetMethodToGenerate(IMethodInfo method, IProxyGenerationHook hook, bool isStandalone)
		{
			var accepted = AcceptMethod(method, true, hook);
			if (accepted == false)
			{
				//we don't need to do anything...
				return null;
			}

			return new MetaMethod(method, method, isStandalone, true, !method.IsAbstract);
		}

		protected override IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)
		{
			Debug.Assert(hook != null, "hook != null");

			foreach (var @interface in interfaces)
			{
				var item = GetCollectorForInterface(@interface);
				item.Logger = Logger;
				item.CollectMembersToProxy(hook);
				yield return item;
			}
		}

        private void CollectFields(IProxyGenerationHook hook)
        {
            var fields = Type.GetAllFields();
            foreach (var field in fields)
            {
                if (IsOKToBeOnProxy(field))
                {
                    continue;
                }

                hook.NonProxyableMemberNotification(Type, field);
            }
        }

		public void CollectMembersToProxy(IProxyGenerationHook hook)
		{
			if (checkedMethods == null)// this method was already called!
			{
				throw new InvalidOperationException("Can't call CollectMembersToProxy twice");
			}
			CollectProperties(hook);
			CollectEvents(hook);
			// Methods go last, because properties and events have methods too (getters/setters add/remove)
			// and we don't want to get duplicates, so we collect property and event methods first
			// then we collect methods, and add only these that aren't there yet
			CollectMethods(hook);

			checkedMethods = null; // this is ugly, should have a boolean flag for this or something
		}

		protected override IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)
		{
			Debug.Assert(hook != null, "hook != null");

			var targetItem = new ClassMembersCollector(targetType) { Logger = Logger };
			targetItem.CollectMembersToProxy(hook);
			yield return targetItem;

			foreach (var @interface in interfaces)
			{
				var item = new InterfaceMembersOnClassCollector(@interface, true,
					targetType.GetTypeInfo().GetRuntimeInterfaceMap(@interface)) { Logger = Logger };
				item.CollectMembersToProxy(hook);
				yield return item;
			}
		}

		protected override MetaMethod GetMethodToGenerate(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)
		{
			if (method.IsAccessible() == false)
			{
				return null;
			}

			var accepted = AcceptMethod(method, true, hook);
			if (!accepted && !method.IsAbstract)
			{
				//we don't need to do anything...
				return null;
			}

			return new MetaMethod(method, method, isStandalone, accepted, hasTarget: true);
		}

		protected override MetaMethod GetMethodToGenerate(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)
		{
			if (scope.Internals.IsAccessible(method) == false)
			{
				return null;
			}

			if (onlyProxyVirtual && IsVirtuallyImplementedInterfaceMethod(method))
			{
				return null;
			}

			var methodOnTarget = GetMethodOnTarget(method);

			var proxyable = AcceptMethod(method, onlyProxyVirtual, hook);
			return new MetaMethod(method, scope, methodOnTarget, isStandalone, proxyable, methodOnTarget.IsPrivate == false);
		}

        public virtual void CollectMembersToProxy(IProxyGenerationHook hook)
        {
            if (checkedMethods == null) // this method was already called!
            {
                throw new InvalidOperationException(
                    string.Format("Can't call 'CollectMembersToProxy' method twice. This usually signifies a bug in custom {0}.",
                                  typeof(ITypeContributor)));
            }
            CollectProperties(hook);
            CollectEvents(hook);
            // Methods go last, because properties and events have methods too (getters/setters add/remove)
            // and we don't want to get duplicates, so we collect property and event methods first
            // then we collect methods, and add only these that aren't there yet
            CollectMethods(hook);

            checkedMethods = null; // this is ugly, should have a boolean flag for this or something
        }