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
        }

		public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)
		{
			foreach (var collector in CollectElementsToProxyInternal(hook))
			{
				foreach (var method in collector.Methods)
				{
					model.AddMethod(method);
					methods.Add(method);
				}
				foreach (var @event in collector.Events)
				{
					model.AddEvent(@event);
					events.Add(@event);
				}
				foreach (var property in collector.Properties)
				{
					model.AddProperty(property);
					properties.Add(property);
				}
			}
		}

        protected override MetaMethod GetMethodToGenerate(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)
        {
#if SILVERLIGHT
            if(method.IsFamily)
            {
                // we can't proxy protected methods like this on Silverlight
                return null;
            }
#endif
            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);
        }

		public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)
		{
			foreach (var collector in CollectElementsToProxyInternal(hook))
			{
				foreach (var method in collector.Methods)
				{
                    if (!IsInterceptable(collector, method.Method))
                        continue;

					model.AddMethod(method);
					methods.Add(method);
				}
				foreach (var @event in collector.Events)
                {
                    if (!IsInterceptable(collector, @event.Event))
                        continue;

					model.AddEvent(@event);
					events.Add(@event);
				}
				foreach (var property in collector.Properties)
                {
                    if (!IsInterceptable(collector, property.Property))
                        continue;

					model.AddProperty(property);
					properties.Add(property);

                    foreach (var method in collector.Methods
                        .Where(m => (property.CanRead && m.Method == property.GetMethod) || (property.CanWrite && m.Method == property.SetMethod)))
                    {
                        model.AddMethod(method);
                        methods.Add(method);
                    }
				}
			}
		}

        private void AddEvent(EventInfo @event, IProxyGenerationHook hook)
        {
            var addMethod = @event.GetAddMethod(true);
            var removeMethod = @event.GetRemoveMethod(true);
            MetaMethod adder = null;
            MetaMethod remover = null;

            if (addMethod != null)
            {
                adder = AddMethod(addMethod, hook, false);
            }

            if (removeMethod != null)
            {
                remover = AddMethod(removeMethod, hook, false);
            }

            if (adder == null && remover == null)
            {
                return;
            }

            events[@event] = new MetaEvent(@event.Name,
                                           @event.DeclaringType, @event.EventHandlerType, adder, remover, EventAttributes.None);
        }

 public override void CollectMembersToProxy(IProxyGenerationHook hook)
 {
     base.CollectMembersToProxy(hook);
     CollectFields(hook);
     // TODO: perhaps we should also look for nested classes...
 }