HttpServerChannel Classe

Referência

Definição

Namespace:: System.Runtime.Remoting.Channels.Http

Assembly:: System.Runtime.Remoting.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Implementa um canal de servidor para chamadas remotas, que usa o protocolo HTTP para transmitir mensagens.

public ref class HttpServerChannel : System::Runtime::Remoting::Channels::BaseChannelWithProperties, System::Runtime::Remoting::Channels::IChannelReceiver, System::Runtime::Remoting::Channels::IChannelReceiverHook

public class HttpServerChannel : System.Runtime.Remoting.Channels.BaseChannelWithProperties, System.Runtime.Remoting.Channels.IChannelReceiver, System.Runtime.Remoting.Channels.IChannelReceiverHook

type HttpServerChannel = class
    inherit BaseChannelWithProperties
    interface IChannelReceiver
    interface IChannel
    interface IChannelReceiverHook

Public Class HttpServerChannel
Inherits BaseChannelWithProperties
Implements IChannelReceiver, IChannelReceiverHook

Herança: Object

BaseChannelObjectWithProperties

BaseChannelWithProperties
HttpServerChannel

Implementações: IChannel IChannelReceiver IChannelReceiverHook

Exemplos

O exemplo de código a seguir mostra como usar um HttpServerChannel objeto para configurar um servidor de comunicação remota e seu cliente. O exemplo contém três partes:

Um servidor
Um cliente
Um objeto remoto usado pelo servidor e pelo cliente

O exemplo de código a seguir mostra um servidor.

#using <System.dll>
#using <System.Runtime.Remoting.dll>
#using "common.dll"
using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Http;

int main()
{
   // Create the server channel.
   HttpServerChannel^ serverChannel = gcnew HttpServerChannel( 9090 );
   
   // Register the server channel.
   ChannelServices::RegisterChannel( serverChannel );
   
   // Display the channel's scheme.
   Console::WriteLine( L"The channel scheme is {0}.", serverChannel->ChannelScheme );
   
   // Display the channel's URI.
   Console::WriteLine( L"The channel URI is {0}.", serverChannel->GetChannelUri() );
   
   // Expose an object for remote calls.
   RemotingConfiguration::RegisterWellKnownServiceType(
      RemoteObject::typeid, L"RemoteObject.rem", WellKnownObjectMode::Singleton );
   
   // Get the channel's sink chain.
   IServerChannelSink^ sinkChain = serverChannel->ChannelSinkChain;
   Console::WriteLine( L"The type of the server channel's sink chain is {0}.", sinkChain->GetType() );
   
   // See if the channel wants to listen.
   bool wantsToListen = serverChannel->WantsToListen;
   Console::WriteLine( L"The value of WantsToListen is {0}.", wantsToListen );
   
   // Parse the channel's URI.
   array<String^>^ urls = serverChannel->GetUrlsForUri( L"RemoteObject.rem" );
   if ( urls->Length > 0 )
   {
      String^ objectUrl = urls[ 0 ];
      String^ objectUri;
      String^ channelUri = serverChannel->Parse( objectUrl,  objectUri );
      Console::WriteLine( L"The object URI is {0}.", objectUri );
      Console::WriteLine( L"The channel URI is {0}.", channelUri );
      Console::WriteLine( L"The object URL is {0}.", objectUrl );
   }

   
   // Wait for the user prompt.
   Console::WriteLine( L"Press ENTER to exit the server." );
   Console::ReadLine();
   Console::WriteLine( L"The server is exiting." );
}

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;

public class Server
{
    public static void Main(string[] args)
    {
        // Create the server channel.
        HttpServerChannel serverChannel = new HttpServerChannel(9090);

        // Register the server channel.
        ChannelServices.RegisterChannel(serverChannel);

        // Display the channel's scheme.
        Console.WriteLine("The channel scheme is {0}.",
            serverChannel.ChannelScheme);

        // Display the channel's URI.
        Console.WriteLine("The channel URI is {0}.",
            serverChannel.GetChannelUri());

        // Expose an object for remote calls.
        RemotingConfiguration.RegisterWellKnownServiceType(
            typeof(RemoteObject), "RemoteObject.rem",
            WellKnownObjectMode.Singleton);

        // Get the channel's sink chain.
        IServerChannelSink sinkChain = serverChannel.ChannelSinkChain;
        Console.WriteLine(
            "The type of the server channel's sink chain is {0}.",
            sinkChain.GetType().ToString());

        // See if the channel wants to listen.
        bool wantsToListen = serverChannel.WantsToListen;
        Console.WriteLine(
            "The value of WantsToListen is {0}.",
            wantsToListen);

        // Parse the channel's URI.
        string[] urls = serverChannel.GetUrlsForUri("RemoteObject.rem");
        if (urls.Length > 0)
        {
            string objectUrl = urls[0];
            string objectUri;
            string channelUri =
                serverChannel.Parse(objectUrl, out objectUri);
            Console.WriteLine("The object URI is {0}.", objectUri);
            Console.WriteLine("The channel URI is {0}.", channelUri);
            Console.WriteLine("The object URL is {0}.", objectUrl);
        }

        // Wait for the user prompt.
        Console.WriteLine("Press ENTER to exit the server.");
        Console.ReadLine();
        Console.WriteLine("The server is exiting.");
    }
}

O exemplo de código a seguir mostra um cliente para este servidor.

#using <System.dll>
#using <System.Runtime.Remoting.dll>
#using "common.dll"
using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Http;

void main()
{
   // Create the channel.
   HttpClientChannel^ channel = gcnew HttpClientChannel;
   
   // Register the channel.
   ChannelServices::RegisterChannel( channel );
   
   // Register as client for remote object.
   WellKnownClientTypeEntry^ remoteType = gcnew WellKnownClientTypeEntry(
      RemoteObject::typeid,L"http://localhost:9090/RemoteObject.rem" );
   RemotingConfiguration::RegisterWellKnownClientType( remoteType );
   
   // Create an instance of the remote object.
   RemoteObject^ service = gcnew RemoteObject;
   
   // Invoke a method on the remote object.
   Console::WriteLine( L"The client is invoking the remote object." );
   Console::WriteLine( L"The remote object has been called {0} times.", service->GetCount() );
}

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;

public class Client
{
    public static void Main(string[] args)
    {
        // Create the channel.
        HttpClientChannel channel = new HttpClientChannel();

        // Register the channel.
        ChannelServices.RegisterChannel(channel);

        // Register as client for remote object.
        WellKnownClientTypeEntry remoteType = new WellKnownClientTypeEntry(
            typeof(RemoteObject),"http://localhost:9090/RemoteObject.rem");
        RemotingConfiguration.RegisterWellKnownClientType(remoteType);

        // Create an instance of the remote object.
        RemoteObject service = new RemoteObject();

        // Invoke a method on the remote object.
        Console.WriteLine("The client is invoking the remote object.");
        Console.WriteLine("The remote object has been called {0} times.",
            service.GetCount());
    }
}

O exemplo de código a seguir mostra o objeto remoto usado pelo servidor e pelo cliente.

using namespace System;
using namespace System::Runtime::Remoting;

// Remote object.
public ref class RemoteObject: public MarshalByRefObject
{
private:
   static int callCount = 0;

public:
   int GetCount()
   {
      callCount++;
      return (callCount);
   }

};

using System;
using System.Runtime.Remoting;

// Remote object.
public class RemoteObject : MarshalByRefObject
{
    private int callCount = 0;

    public int GetCount()
    {
        callCount++;
        return(callCount);
    }
}

Comentários

Canais transportam mensagens entre limites de comunicação remota (por exemplo, entre computadores em domínios de aplicativo). A HttpServerChannel classe transporta mensagens usando o protocolo HTTP.

Os canais são usados pela infraestrutura de comunicação remota .NET Framework para transportar chamadas remotas. Quando um cliente faz uma chamada para um objeto remoto, a chamada é serializada em uma mensagem enviada por um canal cliente e recebida por um canal de servidor. Em seguida, ele é desserializado e processado. Todos os valores retornados são transmitidos pelo canal do servidor e recebidos pelo canal cliente.

Para executar processamento adicional de mensagens no lado do servidor, você pode especificar uma implementação do por meio do IServerChannelSinkProvider qual todas as mensagens processadas pelo HttpServerChannel são passadas.

O HttpServerChannel aceita mensagens serializadas no formato binário ou SOAP.

Um HttpServerChannel objeto tem propriedades de configuração associadas que podem ser definidas em tempo de execução em um arquivo de configuração (invocando o método estático RemotingConfiguration.Configure ) ou programaticamente (passando uma IDictionary coleção para o HttpServerChannel construtor). Para obter uma lista dessas propriedades de configuração, consulte a documentação de HttpServerChannel.

Construtores

HttpServerChannel()	Inicializa uma nova instância da classe HttpServerChannel.
HttpServerChannel(IDictionary, IServerChannelSinkProvider)	Inicializa uma nova instância da classe HttpServerChannel com as propriedades de canal e os coletores especificados.
HttpServerChannel(Int32)	Inicializa uma nova instância da classe HttpServerChannel que escuta na porta especificada.
HttpServerChannel(String, Int32)	Inicializa uma nova instância da classe HttpServerChannel com o nome fornecido e que escuta na porta especificada.
HttpServerChannel(String, Int32, IServerChannelSinkProvider)	Inicializa uma nova instância da classe HttpServerChannel na porta especificada com o nome fornecido, que escuta na porta especificada e usa o coletor especificado.

Campos

SinksWithProperties

Indica que o coletor de canal superior na pilha de coletores de canal.

(Herdado de BaseChannelWithProperties)

Propriedades

ChannelData	Obtém dados específicos do canal.
ChannelName	Obtém o nome do canal atual.
ChannelPriority	Obtém a prioridade do canal atual.
ChannelScheme	Obtém o tipo de ouvinte ao qual conectar (por exemplo, "http").
ChannelSinkChain	Obtém a cadeia de coletor de canal que o canal atual está usando.
Count	Obtém o número de propriedades associadas ao objeto de canal. (Herdado de BaseChannelObjectWithProperties)
IsFixedSize	Obtém um valor que indica se o número de propriedades que podem ser inseridas no canal de objeto é fixo. (Herdado de BaseChannelObjectWithProperties)
IsReadOnly	Obtém um valor que indica se a coleção de propriedades no objeto de canal é somente leitura. (Herdado de BaseChannelObjectWithProperties)
IsSynchronized	Obtém um valor que indica se o dicionário de propriedades de objeto de canal é sincronizado. (Herdado de BaseChannelObjectWithProperties)
Item[Object]	Retorna a propriedade de canal especificada.
Keys	Obtém um ICollection de chaves ao qual as propriedades do canal estão associadas.
Properties	Obtém um IDictionary das propriedades de canal associadas ao objeto de canal atual. (Herdado de BaseChannelWithProperties)
SyncRoot	Obtém um objeto usado para sincronizar o acesso ao BaseChannelObjectWithProperties. (Herdado de BaseChannelObjectWithProperties)
Values	Obtém um ICollection dos valores das propriedades associadas ao objeto de canal. (Herdado de BaseChannelObjectWithProperties)
WantsToListen	Obtém um valor booliano que indica se IChannelReceiverHook quiser ser conectado o serviço ouvinte externo.

Métodos

Add(Object, Object)	Gera uma NotSupportedException. (Herdado de BaseChannelObjectWithProperties)
AddHookChannelUri(String)	Adiciona um URI no qual o gancho do canal escutará.
Clear()	Gera uma NotSupportedException. (Herdado de BaseChannelObjectWithProperties)
Contains(Object)	Retorna um valor que indica se o objeto de canal contém uma propriedade associada à chave especificada. (Herdado de BaseChannelObjectWithProperties)
CopyTo(Array, Int32)	Gera uma NotSupportedException. (Herdado de BaseChannelObjectWithProperties)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetChannelUri()	Retorna o URI do canal atual.
GetEnumerator()	Retorna um IDictionaryEnumerator que enumera em todas as propriedades associadas ao objeto de canal. (Herdado de BaseChannelObjectWithProperties)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetUrlsForUri(String)	Retorna uma matriz de todas as URLs de um objeto com o URI especificado, hospedado no HttpChannel atual.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Parse(String, String)	Extrai o URI do canal e o URI do objeto bem conhecido remoto da URL especificada.
Remove(Object)	Gera uma NotSupportedException. (Herdado de BaseChannelObjectWithProperties)
StartListening(Object)	Instrui o canal atual a iniciar a escuta de solicitações.
StopListening(Object)	Instrui o canal atual a parar de escutar solicitações.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Implantações explícitas de interface

IEnumerable.GetEnumerator()

Retorna um IEnumerator que enumera em todas as propriedades associadas ao objeto de canal.

(Herdado de BaseChannelObjectWithProperties)

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Aplica-se a

Confira também

Propriedades de configuração de canal e formatador

Partilhar via