C# System.MarshalByRefObject类代码示例

		public MockServer(MarshalByRefObject mock, IChannel channel, string uri)
		{
			this.mock = mock;
			this.channel = channel;
			ChannelServices.RegisterChannel(channel, true);
			mockRef = RemotingServices.Marshal(mock, uri);
		}

        public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink nextSink)
        {
            if (obj.GetType().GetCustomAttributes(typeof(ONContextAttribute), true).Length > 0)
                nextSink = new ONContextInterceptor(obj, nextSink, mOnContextClass);

            return nextSink;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AOPSinkProcessor" /> class.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="nextSink">The next sink.</param>
        /// <param name="messageDelegates">The message delegates.</param>
        public AOPSinkProcessor(MarshalByRefObject sender, IMessageSink nextSink, MessageProcessDelegates messageDelegates)
        {
            this.NextSink = nextSink;
            this.Sender = sender;

            this.messageDelegates = messageDelegates;
        }

 internal RedirectionProxy(MarshalByRefObject proxy, Type serverType)
 {
     _proxy = proxy;
     _realProxy = RemotingServices.GetRealProxy(_proxy);
     _serverType = serverType;
     _objectMode = WellKnownObjectMode.Singleton;
 } // RedirectionProxy

		public MockingProxy(MarshalByRefObject wrappedInstance, IInterceptor interceptor, IMockMixin mockMixin)
			: base(wrappedInstance.GetType())
		{
			this.WrappedInstance = wrappedInstance;
			this.interceptor = interceptor;
			this.mockMixin = mockMixin;
		}

 /// <summary>
 /// Constructs an instance of the LocalPerformer class.
 /// </summary>
 /// <param name="msg">The invocation to be executed.</param>
 /// <param name="resultCollector">The Result Collector.</param>
 /// <param name="mbr">The target.</param>
 public LocalPerformer(IMessage msg, ResultCollector resultCollector, MarshalByRefObject mbr)
 {
     this._msg = msg;
     this._resultCollector = resultCollector;
     this._mbr = mbr;
     this._mbrUri = RemotingServices.GetObjectUri(mbr);
 }

 public void StartRunner(string runnerType, MarshalByRefObject remotePublisher)
 {
     // TODO -- if fails, do a Thread.Sleep and try again
     Type type = Type.GetType(runnerType);
     _runner = (TestRunner)Activator.CreateInstance(type);
     _publisher = (IEventPublisher)remotePublisher;
     _runner.FixtureObserver = new FixtureObserver(_publisher);
 }

        /// <summary>
        /// Veröffentlicht ein beliebiges von MarshalByRef abgeleitetes Objekt über einen TCP-Kanal für entfernten Zugriff.
        ///
        /// Bei aktivierung der Sicherheit über den Parameter "enableSecurity", wird die Kommunikation 
        /// vom Absender signiert, um die Integrität sicherzustellen und zusätzlich verschlüsselt. 
        /// Über den Parameter "impersonate" kann Impersonierung eingeschaltet werden. Bei eingeschalteter
        /// Impersonierung, wird der Remoteaufruf im Kontext des Client-Benutzers ausgeführt.
        /// </summary>
        /// <remarks>
        /// Der TCP-Kanal wird automatisch konfiguriert und registriert. Die Kanal-Registrierung bleibt 
        /// über diesen Prozeduraufruf hinaus gültig. Wenn sie die selbe TCP-Anschlussnummer mehrmals an
        /// diese Methode übergeben, wird der bestehene Kanal verwendet. Die Sicherheitskonfiguration des 
        /// ersten Aufrufs ist deshalb entscheidend. Wenn sie für spätere Aufrufe andere Werte für die
        /// Parameter "enableSecurity" oder "impersonate" angeben, werden diese nicht berücksichtigt, 
        /// da der bestehende Kanal verwendet wird!
        /// </remarks>
        /// <param name="instance">Zu veröffentlichendes Objekt</param>
        /// <param name="publicName">Öffentlicher Name (Über diesen Namen greifen Clients entfernt auf das Objekt zu!)</param>
        /// <param name="tcpPort">TCP-Anschlussnummer</param>
        /// <param name="enableSecurity">Schalter für Sicherheit</param>
        /// <param name="impersonate">Schalter für Impersonierung</param>
        public static void PublishObjectOverTCP(MarshalByRefObject instance,string publicName,int tcpPort, bool enableSecurity,bool impersonate)
        {
            // Kanal einrichten (Falls dies noch nicht geschehen ist!)
            SetupServerChannel(tcpPort, enableSecurity, impersonate);

            // Objektinstanz über den TCP-Kanal für entfernten Zugriff veröffentlichen
            System.Runtime.Remoting.RemotingServices.Marshal(instance, publicName);
        }

        public void Exceptionprocess(MarshalByRefObject inst, IMessage msg, Exception exception)
        {
            // Extract Action
            ONAction lAction = inst as ONAction;

            // Pop the OID from Class Stack
            if (mInStack)
                lAction.OnContext.TransactionStack.Pop();
        }

 protected void AttachServer(MarshalByRefObject s)
 {
     object transparentProxy = this.GetTransparentProxy();
     if (transparentProxy != null)
     {
         RemotingServices.ResetInterfaceCache(transparentProxy);
     }
     this.AttachServerHelper(s);
 }

		public void Unregister(MarshalByRefObject obj) {
			ILease lease = (ILease)RemotingServices.GetLifetimeService(obj);
			Debug.Assert(lease.CurrentState == LeaseState.Active);
			lease.Unregister(this);
			lock(this._lock) {
				this._leaseList.Remove(lease);
				Logger.Debug(this, "Stopped sponsoring lease #" + lease.GetHashCode() + " for proxy to " + obj.GetType().Name + ", id = #" + obj.GetHashCode() + ", url = " + RemotingServices.GetObjectUri(obj));
			}
		}

 internal void AttachServerHelper(MarshalByRefObject s)
 {
     if ((s == null) || (this._serverObject != null))
     {
         throw new ArgumentException(Environment.GetResourceString("ArgumentNull_Generic"), "s");
     }
     this._serverObject = s;
     this.SetupIdentity();
 }

        public MarshallableProxy(Type type1, MarshalByRefObject targetObject, InvocationDelegate invoker)
            : base(type1)
        {
            ProxyTargetTyped = targetObject;
            InvocationHandler = invoker;

            ObjRef myObjRef = RemotingServices.Marshal(ProxyTargetTyped);
            URI = myObjRef.URI;
        }

        public void Exceptionprocess(MarshalByRefObject inst, IMessage msg, Exception exception)
        {
            // Extract Server
            ONServer lServer = inst as ONServer;

            // Pop the OID from Class Stack
            if (mInStack)
                lServer.OnContext.OperationStack.Pop();
        }

		public bool Register (MarshalByRefObject obj)
		{
			if (registered_objects.ContainsKey (obj)) return false;
			ILease lease = obj.GetLifetimeService () as ILease;
			if (lease == null) return false;
			lease.Register (this);
			registered_objects.Add (obj,obj);
			return true;
		}