HttpServerChannel Classe

Riferimento

Definizione

Spazio dei nomi:: System.Runtime.Remoting.Channels.Http

Assembly:: System.Runtime.Remoting.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Implementa un canale server per chiamate remote che utilizza il protocollo HTTP per la trasmissione dei messaggi.

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

Ereditarietà: Object

BaseChannelObjectWithProperties

BaseChannelWithProperties
HttpServerChannel

Implementazioni: IChannel IChannelReceiver IChannelReceiverHook

Esempio

Nell'esempio di codice seguente viene illustrato come usare un oggetto per configurare un HttpServerChannel server di comunicazione remota e il relativo client. L'esempio contiene tre parti:

Server
Un client
Oggetto remoto usato dal server e dal client

Nell'esempio di codice seguente viene illustrato un server.

#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.");
    }
}

Nell'esempio di codice seguente viene illustrato un client per questo server.

#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());
    }
}

Nell'esempio di codice seguente viene illustrato l'oggetto remoto usato dal server e dal client.

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);
    }
}

Commenti

I canali trasportano i messaggi tra limiti remoti, ad esempio tra computer nei domini dell'applicazione. La HttpServerChannel classe trasporta i messaggi usando il protocollo HTTP.

I canali vengono usati dall'infrastruttura remota di .NET Framework per il trasporto di chiamate remote. Quando un client effettua una chiamata a un oggetto remoto, la chiamata viene serializzata in un messaggio inviato da un canale client e ricevuto da un canale server. Viene quindi deserializzato ed elaborato. Tutti i valori restituiti vengono trasmessi dal canale del server e ricevuti dal canale client.

Per eseguire un'elaborazione aggiuntiva dei messaggi sul lato server, è possibile specificare un'implementazione dell'oggetto IServerChannelSinkProvider tramite cui vengono passati tutti i messaggi elaborati dall'oggetto HttpServerChannel .

Accetta HttpServerChannel messaggi serializzati in formato binario o SOAP.

Un HttpServerChannel oggetto ha associato proprietà di configurazione che possono essere impostate in fase di esecuzione in un file di configurazione (richiamando il metodo statico RemotingConfiguration.Configure ) o a livello di codice (passando una IDictionary raccolta al HttpServerChannel costruttore). Per un elenco di queste proprietà di configurazione, vedere la documentazione per HttpServerChannel.

Costruttori

HttpServerChannel()	Inizializza una nuova istanza della classe HttpServerChannel.
HttpServerChannel(IDictionary, IServerChannelSinkProvider)	Inizializza una nuova istanza della classe HttpServerChannel con il sink e le proprietà del canale specificati.
HttpServerChannel(Int32)	Inizializza una nuova istanza della classe HttpServerChannel che è in attesa sulla porta specificata.
HttpServerChannel(String, Int32)	Inizializza una nuova istanza della classe HttpServerChannel con il nome specificato e in attesa sulla porta specificata.
HttpServerChannel(String, Int32, IServerChannelSinkProvider)	Inizializza una nuova istanza della classe HttpServerChannel nella porta specificata con il nome indicato, che è in attesa sulla porta specificata e utilizza il sink specificato.

Campi

SinksWithProperties

Indica il sink di canale superiore nello stack di sink di canale.

(Ereditato da BaseChannelWithProperties)

Proprietà

ChannelData	Ottiene dati specifici del canale.
ChannelName	Ottiene il nome del canale corrente.
ChannelPriority	Ottiene la priorità del canale corrente.
ChannelScheme	Ottiene il tipo di listener con cui eseguire l'hook, ad esempio "http".
ChannelSinkChain	Ottiene la catena di sink del canale utilizzata dal canale corrente.
Count	Ottiene il numero delle proprietà associate all'oggetto canale. (Ereditato da BaseChannelObjectWithProperties)
IsFixedSize	Ottiene un valore che indica se il numero delle proprietà che è possibile immettere nell'oggetto canale corrente è fisso. (Ereditato da BaseChannelObjectWithProperties)
IsReadOnly	Ottiene un valore che indica se l'insieme delle proprietà nell'oggetto canale è in sola lettura. (Ereditato da BaseChannelObjectWithProperties)
IsSynchronized	Ottiene un valore che indica se il dizionario delle proprietà dell'oggetto canale è sincronizzato. (Ereditato da BaseChannelObjectWithProperties)
Item[Object]	Restituisce la proprietà del canale specificata.
Keys	Ottiene un insieme ICollection delle chiavi a cui sono associate le proprietà del canale.
Properties	Ottiene un'interfaccia IDictionary delle proprietà del canale associate all'oggetto canale corrente. (Ereditato da BaseChannelWithProperties)
SyncRoot	Ottiene un oggetto che è possibile utilizzare per sincronizzare l'accesso a BaseChannelObjectWithProperties. (Ereditato da BaseChannelObjectWithProperties)
Values	Ottiene un'interfaccia ICollection dei valori delle proprietà associate all'oggetto canale. (Ereditato da BaseChannelObjectWithProperties)
WantsToListen	Ottiene un valore booleano che indica se è necessario eseguire l'hook dell'interfaccia IChannelReceiverHook al servizio di listener esterno.

Metodi

Add(Object, Object)	Genera un oggetto NotSupportedException. (Ereditato da BaseChannelObjectWithProperties)
AddHookChannelUri(String)	Aggiunge un URI sul quale l'hook del canale deve restare in attesa.
Clear()	Genera un oggetto NotSupportedException. (Ereditato da BaseChannelObjectWithProperties)
Contains(Object)	Restituisce un valore che indica se l'oggetto canale contiene una proprietà associata alla chiave specificata. (Ereditato da BaseChannelObjectWithProperties)
CopyTo(Array, Int32)	Genera un oggetto NotSupportedException. (Ereditato da BaseChannelObjectWithProperties)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetChannelUri()	Restituisce l'URI del canale corrente.
GetEnumerator()	Restituisce un'interfaccia IDictionaryEnumerator che enumera tutte le proprietà associate all'oggetto canale. (Ereditato da BaseChannelObjectWithProperties)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
GetUrlsForUri(String)	Restituisce una matrice di tutti gli URL di un oggetto con l'URI specificato, ospitato nell'oggetto HttpChannel corrente.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Parse(String, String)	Estrae dall'URL specificato l'URI del canale e quello dell'oggetto remoto conosciuto.
Remove(Object)	Genera un oggetto NotSupportedException. (Ereditato da BaseChannelObjectWithProperties)
StartListening(Object)	Indica al canale corrente di mettersi in attesa di richieste.
StopListening(Object)	Indica al canale corrente di interrompere l'attesa di richieste.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IEnumerable.GetEnumerator()

Restituisce un'interfaccia IEnumerator che enumera tutte le proprietà associate all'oggetto canale.

(Ereditato da BaseChannelObjectWithProperties)

Metodi di estensione

Cast<TResult>(IEnumerable)	Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)	Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Vedi anche

Proprietà di configurazione di canali e formattatori