Esporta (0) Stampa
Espandi tutto

Interfaccia IMessageSink

Aggiornamento: novembre 2007

Definisce l'interfaccia per un sink di messaggi.

Spazio dei nomi:  System.Runtime.Remoting.Messaging
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IMessageSink
/** @attribute ComVisibleAttribute(true) */
public interface IMessageSink
public interface IMessageSink

Quando viene eseguita una chiamata di metodo sul proxy, l'infrastruttura remota fornisce il supporto necessario per il passaggio degli argomenti all'oggetto effettivo attraverso i confini remoti, chiamando il metodo dell'oggetto effettivo con gli argomenti e restituendo i risultati al client dell'oggetto proxy.

Una chiamata di metodo remota è un messaggio che passa dall'estremità client all'estremità server ed eventualmente viceversa. Quando lungo il tragitto attraversa confini remoti, la chiamata di metodo remota attraversa una catena di oggetti IMessageSink. Ogni sink della catena riceve l'oggetto messaggio, esegue un'operazione specifica e delega il sink successivo nella catena. L'oggetto proxy contiene un riferimento al primo IMessageSink che deve essere utilizzato per iniziare la catena.

Per le chiamate asincrone, al momento della delega ogni sink fornisce un sink di risposta (un altro IMessageSink) che verrà chiamato dal sink successivo durante il tragitto di ritorno della risposta.

I diversi tipi di sink eseguono operazioni diverse, a seconda del tipo di oggetto messaggio ricevuto. Un sink può, ad esempio, determinare l'esecuzione di un blocco, un altro attivare la sicurezza delle chiamate, un terzo eseguire servizi di controllo delle chiamate di flusso e dell'affidabilità e un altro ancora trasmettere la chiamata a un altro AppDomain, processo o computer. Due o più sink di messaggi della catena possono interagire fra loro nell'ambito di una determinata azione.

Note per gli implementatori:

È importante tenere presente che il codice che implementa l'interfaccia corrente deve fornire implementazioni sia per SyncProcessMessage sia per AsyncProcessMessage in quanto le chiamate sincrone possono essere convertite in chiamate asincrone e viceversa. Devono essere implementati entrambi i metodi, anche se il sink non supporta l'elaborazione asincrona.

Nell'esempio di codice riportato di seguito viene illustrata l'implementazione dell'interfaccia IMessageSink. Nell'esempio si presuppongono definizioni di tipi e riferimenti all'assembly che devono essere forniti per poter compilare il codice.

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 System.Security.Permissions;
using Share;	

namespace MyNameSpace
{

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

      [PermissionSet(SecurityAction.LinkDemand)]
      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);
         }
      }

      [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
      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
   {
      [PermissionSet(SecurityAction.LinkDemand)]
      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);
         }
      }
   }
}



Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft