Compartir vía


IServerChannelSink Interfaz

Definición

Proporciona los métodos utilizados para los receptores de seguridad y transporte.

public interface class IServerChannelSink : System::Runtime::Remoting::Channels::IChannelSinkBase
public interface IServerChannelSink : System.Runtime.Remoting.Channels.IChannelSinkBase
[System.Runtime.InteropServices.ComVisible(true)]
public interface IServerChannelSink : System.Runtime.Remoting.Channels.IChannelSinkBase
type IServerChannelSink = interface
    interface IChannelSinkBase
[<System.Runtime.InteropServices.ComVisible(true)>]
type IServerChannelSink = interface
    interface IChannelSinkBase
Public Interface IServerChannelSink
Implements IChannelSinkBase
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestra una implementación de la IServerChannelSink interfaz .

using namespace System::Runtime::InteropServices;
using namespace System;
using namespace System::Collections;
using namespace System::IO;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Messaging;

[System::Security::Permissions::PermissionSet(System::Security::
   Permissions::SecurityAction::Demand, Name = "FullTrust")]
public ref class ServerSink: public BaseChannelSinkWithProperties, public IServerChannelSink
{
private:

   // This class inherits from BaseChannelSinkWithPropertes
   // to get an implementation of IChannelSinkBase.
   // The next sink in the chain.
   IServerChannelSink^ nextSink;

public:
   property IServerChannelSink^ NextChannelSink 
   {
      virtual IServerChannelSink^ get()
      {
         return (nextSink);
      }
   }

   virtual Stream^ GetResponseStream( IServerResponseChannelSinkStack^ /*sinkStack*/, Object^ /*state*/, IMessage^ /*message*/, ITransportHeaders^ /*responseHeaders*/ )
   {
      return nullptr;
   }

   virtual ServerProcessing ProcessMessage( IServerChannelSinkStack^ sinkStack, IMessage^ requestMessage, ITransportHeaders^ requestHeaders, Stream^ requestStream, [Out]IMessage^% responseMessage, [Out]ITransportHeaders^% responseHeaders, [Out]Stream^% responseStream )
   {
      // Hand off to the next sink for processing.
      sinkStack->Push( this, nullptr );
      ServerProcessing status = nextSink->ProcessMessage( sinkStack, requestMessage, requestHeaders, requestStream, responseMessage, responseHeaders, responseStream );

      // Print the response message properties.
      Console::WriteLine( "---- Message from the server ----" );
      IDictionary^ dictionary = ( *responseMessage).Properties;
      IEnumerator^ myEnum = dictionary->Keys->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Object^ key = safe_cast<Object^>(myEnum->Current);
         Console::WriteLine( "{0} = {1}", key, dictionary[ key ] );
      }

      Console::WriteLine( "---------------------------------" );
      return (status);
   }

   virtual void AsyncProcessResponse( IServerResponseChannelSinkStack^ /*sinkStack*/, Object^ /*state*/, IMessage^ /*message*/, ITransportHeaders^ /*responseHeaders*/, Stream^ /*responseStream*/ )
   {
      throw gcnew NotImplementedException;
   }

   property System::Collections::IDictionary^ Properties 
   {
      virtual System::Collections::IDictionary^ get() override
      {
         return (dynamic_cast<BaseChannelSinkWithProperties^>(this))->Properties;
      }
   }

   // Constructor
   ServerSink( IServerChannelSink^ sink )
   {
      if ( sink == nullptr )
            throw gcnew ArgumentNullException( "sink" );

      nextSink = sink;
   }
};
using System;
using System.Collections;
using System.IO;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Messaging;

public class ServerSink : BaseChannelSinkWithProperties, IServerChannelSink
{
    // This class inherits from BaseChannelSinkWithProperties
    // to get an implementation of IChannelSinkBase.

    // The next sink in the chain.
    private IServerChannelSink nextSink;

    public IServerChannelSink NextChannelSink
    {
        get
        {
            return(nextSink);
        }
    }

    public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
                                     Object state,
                                     IMessage message,
                                     ITransportHeaders responseHeaders)
    {
        return(null);
    }

    public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,
                                            IMessage requestMessage,
                                            ITransportHeaders requestHeaders,
                                            Stream requestStream,
                                            out IMessage responseMessage,
                                            out ITransportHeaders responseHeaders,
                                            out Stream responseStream)
    {

        // Hand off to the next sink for processing.
        sinkStack.Push(this, null);
        ServerProcessing status = nextSink.ProcessMessage(
          sinkStack, requestMessage, requestHeaders, requestStream,
          out responseMessage, out responseHeaders, out responseStream
        );

        // Print the response message properties.
        Console.WriteLine("---- Message from the server ----");
        IDictionary dictionary = responseMessage.Properties;
        foreach (Object key in dictionary.Keys)
        {
            Console.WriteLine("{0} = {1}", key, dictionary[key]);
        }
        Console.WriteLine("---------------------------------");

        return(status);
    }

    public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack,
                                      Object state,
                                      IMessage message,
                                      ITransportHeaders responseHeaders,
                                      Stream responseStream)
    {
        throw new NotImplementedException();
    }

    // Constructor
    public ServerSink (IServerChannelSink sink) {
      if (sink == null) throw new ArgumentNullException("sink");
      nextSink = sink;
    }
}

Consulte la documentación de la IServerChannelSinkProvider interfaz para obtener un ejemplo de la implementación del proveedor receptor del servidor correspondiente.

Comentarios

Los receptores de canal proporcionan un punto de complemento que permite el acceso a los mensajes subyacentes que fluyen a través del canal, así como la secuencia utilizada por el mecanismo de transporte para enviar mensajes a un objeto remoto. Los receptores de canal se vinculan juntos en una cadena de proveedores de receptores de canal y todos los mensajes de canal fluyen a través de esta cadena de receptores antes de que el mensaje se serialice y transporte.

Propiedades

NextChannelSink

Obtiene el siguiente receptor de canal del servidor de la cadena de receptores del servidor.

Properties

Obtiene un diccionario a través del cual se puede obtener acceso a las propiedades del receptor.

(Heredado de IChannelSinkBase)

Métodos

AsyncProcessResponse(IServerResponseChannelSinkStack, Object, IMessage, ITransportHeaders, Stream)

Solicita que el receptor actual procese la respuesta de una llamada a un método enviada de forma asincrónica.

GetResponseStream(IServerResponseChannelSinkStack, Object, IMessage, ITransportHeaders)

Devuelve Stream donde se va a serializar el mensaje de respuesta proporcionado.

ProcessMessage(IServerChannelSinkStack, IMessage, ITransportHeaders, Stream, IMessage, ITransportHeaders, Stream)

Solicita el procesamiento de mensajes del receptor actual.

Se aplica a