IMessageSink Schnittstelle

Definition

Namespace:

System.Runtime.Remoting.Messaging

Assembly:

mscorlib.dll

Definiert die Schnittstelle für eine Meldungssenke.

C#

[System.Runtime.InteropServices.ComVisible(true)]
public interface IMessageSink

Abgeleitet

System.Runtime.Remoting.Channels.BinaryClientFormatterSink

System.Runtime.Remoting.Channels.IClientFormatterSink

System.Runtime.Remoting.Channels.SoapClientFormatterSink

System.Runtime.Remoting.Messaging.AsyncResult

Attribute

ComVisibleAttribute

Beispiele

Das folgende Codebeispiel zeigt die Implementierung der IMessageSink -Schnittstelle. Beachten Sie, dass im Beispiel Typdefinitionen und Assemblyverweise vorausgesetzt werden, die für die Kompilierung des Beispiels bereitgestellt werden müssen.

C#

using System;
using System.Collections;
using System.Threading;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;
using Share;	

namespace MyNameSpace
{

   public class MyProxy : RealProxy
   {
      string myUrl;
      string myObjectURI;
      IMessageSink myMessageSink;

      public MyProxy(Type myType, string myUrl1)
         : base(myType)
      {

         myUrl = myUrl1;

         IChannel[] myRegisteredChannels = ChannelServices.RegisteredChannels;
         foreach (IChannel channel in myRegisteredChannels )
         {
            if (channel is IChannelSender)
            {
               IChannelSender myChannelSender = (IChannelSender)channel;

               myMessageSink = myChannelSender.CreateMessageSink(myUrl, null, out myObjectURI);
               if (myMessageSink != null)
                  break;
            }
         }

         if (myMessageSink == null)
         {
            throw new Exception("A supported channel could not be found for myUrl1:"+ myUrl);
         }
      }

      public override IMessage Invoke(IMessage myMesg)
      {
         Console.WriteLine("MyProxy.Invoke Start");

         if (myMesg is IMethodCallMessage)
            Console.WriteLine("IMethodCallMessage");

         if (myMesg is IMethodReturnMessage)
            Console.WriteLine("IMethodReturnMessage");

         Console.WriteLine("Message Properties");
         IDictionary myDictionary = myMesg.Properties;
         IDictionaryEnumerator myEnum = (IDictionaryEnumerator) myDictionary.GetEnumerator();

         while (myEnum.MoveNext())
         {
            object myKey = myEnum.Key;
            string myKeyName = myKey.ToString();
            object myValue = myEnum.Value;

            Console.WriteLine("{0} : {1}", myKeyName, myEnum.Value);
            if (myKeyName == "__Args")
            {
               object[] myArgs = (object[])myValue;
               for (int myInt = 0; myInt < myArgs.Length; myInt++)
                  Console.WriteLine("arg: {0} myValue: {1}", myInt, myArgs[myInt]);
            }

            if ((myKeyName == "__MethodSignature") && (null != myValue))
            {
               object[] myArgs = (object[])myValue;
               for (int myInt = 0; myInt < myArgs.Length; myInt++)
                  Console.WriteLine("arg: {0} myValue: {1}", myInt, myArgs[myInt]);
            }
         }

         Console.WriteLine("myUrl1 {0} object URI{1}",myUrl,myObjectURI);

         myDictionary["__Uri"] = myUrl;
         Console.WriteLine("URI {0}", myDictionary["__URI"]);
         IMessage myRetMsg = myMessageSink.SyncProcessMessage(myMesg);

         if (myRetMsg is IMethodReturnMessage)
         {
            IMethodReturnMessage myMethodReturnMessage = (IMethodReturnMessage)myRetMsg;
         }

         Console.WriteLine("MyProxy.Invoke - Finish");
         return myRetMsg;
      }
   }

   //
   // Main class that drives the whole sample
   //
   public class ProxySample
   {
      public static void Main()
      {
         ChannelServices.RegisterChannel(new HttpChannel());

         Console.WriteLine("Remoting Sample:");

         Console.WriteLine("Generate a new MyProxy using the Type");
         Type myType = typeof(MyHelloService);
         string myUrl1 = "http://localhost/myServiceAccess.soap";
         MyProxy myProxy = new MyProxy(myType, myUrl1);

         Console.WriteLine("Obtain the transparent proxy from myProxy");
         MyHelloService myService = (MyHelloService)myProxy.GetTransparentProxy();

         Console.WriteLine("Calling the Proxy");
         string myReturnString = myService.myFunction("bill");

         Console.WriteLine("Checking result : {0}", myReturnString);

         if (myReturnString == "Hi there bill, you are using .NET Remoting")
         {
            Console.WriteLine("myService.HelloMethod PASSED : returned {0}", myReturnString);
         }
         else
         {
            Console.WriteLine("myService.HelloMethod FAILED : returned {0}", myReturnString);
         }
      }
   }
}

Hinweise

Wenn ein Methodenaufruf für den Proxy erfolgt, bietet die Remotinginfrastruktur die erforderliche Unterstützung für die Übergabe der Argumente an das tatsächliche Objekt über die Remotinggrenzen hinweg, das Aufrufen der tatsächlichen Objektmethode mit den Argumenten und die Rückgabe der Ergebnisse an den Client des Proxyobjekts.

Ein Remotemethodenaufruf ist eine Nachricht, die vom Clientende zum Serverende und möglicherweise wieder zurückgeht. Während er unterwegs Remotinggrenzen überschreitet, durchläuft der Remotemethodenaufruf eine Kette von IMessageSink Objekten. Jede Senke in der Kette empfängt das Nachrichtenobjekt, führt einen bestimmten Vorgang aus und delegiert an die nächste Senke in der Kette. Das Proxyobjekt enthält einen Verweis auf das erste IMessageSink Objekt, das zum Starten der Kette verwendet werden muss.

Für asynchrone Aufrufe stellt jede Senke zum Zeitpunkt der Delegierung eine Antwortsenke (eine andere IMessageSink) bereit, die von der nächsten Senke aufgerufen wird, wenn die Antwort auf dem Rückweg ist.

Je nach Typ des empfangenen Nachrichtenobjekts führen verschiedene Senkentypen unterschiedliche Vorgänge aus. Beispielsweise könnte eine Senke dazu führen, dass eine Sperre genommen wird, eine andere könnte die Anrufsicherheit erzwingen, eine andere könnte Ablaufsteuerungs- und Zuverlässigkeitsdienste ausführen, und eine andere könnte den Anruf an einen anderen AppDomain, Prozess oder Computer übertragen. Zwei oder mehr Nachrichtensenken in der Kette können in Bezug auf jede bestimmte Aktion miteinander interagieren.

Hinweise für Ausführende

Es ist wichtig zu beachten, dass code, der die aktuelle Schnittstelle implementiert, Implementierungen für und SyncProcessMessage(IMessage)AsyncProcessMessage(IMessage, IMessageSink)bereitstellen muss, da synchrone Aufrufe in asynchrone Aufrufe konvertiert werden können und umgekehrt. Beide Methoden müssen implementiert werden, auch wenn die Senke keine asynchrone Verarbeitung unterstützt.

Eigenschaften

NextSink

Ruft die nächste Meldungssenke in der Senkenkette ab.

Methoden

AsyncProcessMessage(IMessage, IMessageSink)	Verarbeitet die angegebene Meldung asynchron.
SyncProcessMessage(IMessage)	Verarbeitet die angegebene Meldung synchron.

Gilt für: