public virtual void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
 {
     for (int i = 0; i < this._cp.Count; i++)
     {
         ctorMsg.ContextProperties.Add(this._cp[i]);
     }
 }

 public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
 {
     if (ctorMsg.Properties.Contains("Remote"))
     {
         string remActivatorURL = (string) ctorMsg.Properties["Remote"];
         AppDomainLevelActivator activator = new AppDomainLevelActivator(remActivatorURL);
         IActivator nextActivator = ctorMsg.Activator;
         if (nextActivator.Level < ActivatorLevel.AppDomain)
         {
             activator.NextActivator = nextActivator;
             ctorMsg.Activator = activator;
         }
         else if (nextActivator.NextActivator != null)
         {
             while (nextActivator.NextActivator.Level >= ActivatorLevel.AppDomain)
             {
                 nextActivator = nextActivator.NextActivator;
             }
             activator.NextActivator = nextActivator.NextActivator;
             nextActivator.NextActivator = activator;
         }
         else
         {
             nextActivator.NextActivator = activator;
         }
     }
 }

		/// <summary>
		/// Adds the current context property to the given message.
		/// </summary>
		/// <param name="ctorMsg">The <see cref="T:System.Runtime.Remoting.Activation.IConstructionCallMessage"/> to which to add the context property.</param>
		/// <exception cref="T:System.ArgumentNullException">
		/// The <paramref name="ctorMsg"/> parameter is null.
		/// </exception>
		/// <PermissionSet>
		/// 	<IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure"/>
		/// </PermissionSet>
		public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
		{
			if (AspectConfiguration.Instance.Enabled)
			{
				ctorMsg.ContextProperties.Add(new AspectProperty());
			}
		}

		public IConstructionReturnMessage Activate (IConstructionCallMessage ctorCall)
		{
			IConstructionReturnMessage response;

			// Create the object by calling the remote activation service

			IActivator remoteActivator = (IActivator) RemotingServices.Connect (typeof (IActivator), _activationUrl);
			ctorCall.Activator = ctorCall.Activator.NextActivator;

			try
			{
				response = remoteActivator.Activate (ctorCall);
			}
			catch (Exception ex)
			{
				return new ConstructionResponse (ex, ctorCall);
			}

			// Create the client identity for the remote object

			ObjRef objRef = (ObjRef) response.ReturnValue;
			if (RemotingServices.GetIdentityForUri (objRef.URI) != null)
				throw new RemotingException("Inconsistent state during activation; there may be two proxies for the same object");

			object proxy;
			
			// We pass null for proxyType because we don't really to attach the identity
			// to a proxy, we already have one.
			Identity identity = RemotingServices.GetOrCreateClientIdentity (objRef, null, out proxy);
			RemotingServices.SetMessageTargetIdentity (ctorCall, identity);
			return response;
		}

 internal static IConstructionReturnMessage Activate(RemotingProxy remProxy, IConstructionCallMessage ctorMsg)
 {
     IConstructionReturnMessage message = null;
     if (((ConstructorCallMessage) ctorMsg).ActivateInContext)
     {
         message = ctorMsg.Activator.Activate(ctorMsg);
         if (message.Exception != null)
         {
             throw message.Exception;
         }
         return message;
     }
     GetPropertiesFromAttributes(ctorMsg, ctorMsg.CallSiteActivationAttributes);
     GetPropertiesFromAttributes(ctorMsg, ((ConstructorCallMessage) ctorMsg).GetWOMAttributes());
     GetPropertiesFromAttributes(ctorMsg, ((ConstructorCallMessage) ctorMsg).GetTypeAttributes());
     IMethodReturnMessage message2 = (IMethodReturnMessage) Thread.CurrentContext.GetClientContextChain().SyncProcessMessage(ctorMsg);
     message = message2 as IConstructionReturnMessage;
     if (message2 == null)
     {
         throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
     }
     if (message2.Exception != null)
     {
         throw message2.Exception;
     }
     return message;
 }

		public void GetPropertiesForNewContext(IConstructionCallMessage ctor)
		{
			if (_contextProperties != null)
			{
				foreach (object prop in _contextProperties)
					ctor.ContextProperties.Add (prop);
			}
		}

        public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
        {
            if (ctorMsg == null)
                throw new ArgumentNullException("ctorMsg");

            IContextProperty cachedProperty = new CachedContextProperty();
            ctorMsg.ContextProperties.Add(cachedProperty);
        }

 public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
 {
     // We are not interested in contributing any properties to the
     // new context since the only purpose of this property is to force
     // the creation of the context and the server object inside it at
     // the specified URL.
     return;
 }

	// Get the properties for a new construction context.
	public virtual void GetPropertiesForNewContext
				(IConstructionCallMessage ctorMsg)
			{
				if(ctorMsg == null)
				{
					throw new ArgumentNullException("ctorMsg");
				}
				ctorMsg.ContextProperties.Add(this);
			}

 private static MethodBase GetMethodBase(IConstructionCallMessage msg)
 {
     MethodBase methodBase = msg.MethodBase;
     if (null == methodBase)
     {
         throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Message_MethodMissing"), new object[] { msg.MethodName, msg.TypeName }));
     }
     return methodBase;
 }

 public override bool IsContextOK(Context ctx, IConstructionCallMessage ctorMsg)
 {
     var p = ctx.GetProperty("Reporting") as ReportingProperty;
     if (p == null)
     {
         return false;
     }
     return true;
 }

        //Le runtime .NET interroge pour savoir si le contexte courant est valide.
        //Si cette fonction false, le runtime créé un nouveau contexte et appelle GetPropertiesForNewContext()
        // pour vérifier si le context est valid, on vérifie la présence (et la validité si besoin) d'un propriété
        public override bool IsContextOK(Context ctx,IConstructionCallMessage ctorMsg)
        {
            //return false;	// Seulement si vous souhaitez un contexte par instance !
            DataValidationProperty prop=ctx.GetProperty("DataValidation") as DataValidationProperty;
            if (prop!=null)	// on a une propriété appelé ValidationData dans le contexte ?
                return true;	// Oui -> on accepte le contexte

            return false;	// Non -> on refuse le contexte
        }

		public static IMessage RemoteActivate (IConstructionCallMessage ctorCall)
		{
			try 
			{
				return ctorCall.Activator.Activate (ctorCall);
			}
			catch (Exception ex) 
			{
				return new ReturnMessage (ex, ctorCall);
			}		
		}

        public static IConstructionReturnMessage CreateConstructionReturnMessage(IConstructionCallMessage ctorMsg, MarshalByRefObject retObj) 
        {
            IConstructionReturnMessage ctorRetMsg = null; 

            // Create the return message
            ctorRetMsg = new ConstructorReturnMessage(retObj, null, 0, null, ctorMsg);
 
            // NOTE: WE ALLOW ONLY DEFAULT CTORs on SERVICEDCOMPONENTS
 
            return ctorRetMsg; 
        }

        public override void GetPropertiesForNewContext(IConstructionCallMessage msg)
        {
            if (msg == null)
            {
                throw new ArgumentNullException("msg");
            }

            msg.ContextProperties.Add(new CoreTestProperty<TestTimerAspect>());
            msg.ContextProperties.Add(new CoreTestProperty<TestTransactionAspect>());
            msg.ContextProperties.Add(new CoreTestProperty<ExpectedExceptionMessageAspect>());
        }

		public override bool IsContextOK (Context ctx, IConstructionCallMessage msg)
		{
			SyncContext sctx = SyncContext.GetContext ();
			if (sctx == null || (sctx.GetType() != contextType)) {
				syncContext = (SyncContext) Activator.CreateInstance (contextType);
				return false;
			}
			else {
				syncContext = sctx;
				return true;
			}
		}

        //Le runtime .NET interroge l'attribut pour savoir si le contexte courant est valide.
        //Si cette fonction renvoi false, le runtime créé un nouveau contexte et appelle GetPropertiesForNewContext()
        // pour vérifier si le context est valid, on vérifie la présence (et la validité si besoin) d'une propriété
        public override bool IsContextOK(Context ctx,IConstructionCallMessage ctorMsg)
        {
            //le return false permet de forcer systématiquement un nouveau contexte pour chaqueinstance
            // utilise si une instance d'un type créé des instance de ce meme type : vous pouvez intercepter
            // les appels entre instance d'un meme type ( car il y aura changement de contexte )
            //return false;

            InterceptionAppelProperty prop=ctx.GetProperty("InterceptionAppelProperty") as InterceptionAppelProperty;
            if (prop!=null)	// on a une propriété appelé InterceptionAppelProperty dans le contexte ?
                return true;	// Oui -> on accepte le contexte

            return false;	// Non -> on refuse le contexte
        }

		public IConstructionReturnMessage Activate (IConstructionCallMessage msg)
		{
			if (!RemotingConfiguration.IsActivationAllowed (msg.ActivationType))
				throw new RemotingException ("The type " + msg.ActivationTypeName + " is not allowed to be client activated");

			object[] activationAttributes = new object[] { new RemoteActivationAttribute (msg.ContextProperties) };
			MarshalByRefObject newObject = (MarshalByRefObject) Activator.CreateInstance (msg.ActivationType, msg.Args, activationAttributes);

			// The activator must return a ConstructionResponse with an ObjRef as return value.
			// It avoids the automatic creation of a proxy in the client.

			ObjRef objref = RemotingServices.Marshal (newObject);
			return new ConstructionResponse (objref, null, msg);
		}

 internal static IConstructionReturnMessage DoRemoteActivation(IConstructionCallMessage ctorMsg)
 {
     IActivator activator = null;
     string url = (string) ctorMsg.Properties["Remote"];
     try
     {
         activator = (IActivator) RemotingServices.Connect(typeof(IActivator), url);
     }
     catch (Exception exception)
     {
         throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Activation_ConnectFailed"), new object[] { exception }));
     }
     ctorMsg.Properties.Remove("Remote");
     return activator.Activate(ctorMsg);
 }

 /// <summary>
 /// Проверка типа подключения при создании объекта
 /// </summary>
 /// <param name="msg">Дескриптор конструктора объекта</param>
 private void ConnectionTypeValidation(IConstructionCallMessage msg)
 {
     if (msg.ArgCount > 0)
     {
         foreach (var arg in msg.Args)
         {
             if (arg is IDbConnection)
             {
                 Type type = arg.GetType();
                 Require.That(connectionType.IsAssignableFrom(type),
                     "Данный провайдер использует подключения типа [{0}]. При инициализации провайдера было указано подключение типа [{1}]", connectionType.FullName, type.FullName);
             }
         }
     }
 }