HttpServerChannel Klasse

Referenz

Definition

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

Assembly:: System.Runtime.Remoting.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Implementiert einen Serverchannel für Remoteaufrufe, der das HTTP-Protokoll zum Übertragen von Meldungen verwendet.

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

Vererbung: Object

BaseChannelObjectWithProperties

BaseChannelWithProperties
HttpServerChannel

Implementiert: IChannel IChannelReceiver IChannelReceiverHook

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Sie ein HttpServerChannel -Objekt verwenden, um einen Remotingserver und seinen Client einzurichten. Das Beispiel enthält drei Teile:

Ein Server
Ein Client
Ein Remoteobjekt, das vom Server und dem Client verwendet wird

Das folgende Codebeispiel zeigt einen 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.");
    }
}

Das folgende Codebeispiel zeigt einen Client für diesen 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());
    }
}

Das folgende Codebeispiel zeigt das vom Server und dem Client verwendete Remoteobjekt.

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

Hinweise

Kanäle transportieren Nachrichten über Remotinggrenzen hinweg (z. B. zwischen Computern in Anwendungsdomänen). Die HttpServerChannel -Klasse transportiert Nachrichten mithilfe des HTTP-Protokolls.

Kanäle werden von der .NET Framework Remotinginfrastruktur verwendet, um Remoteanrufe zu transportieren. Wenn ein Client ein Remoteobjekt aufruft, wird der Aufruf in eine Nachricht serialisiert, die von einem Clientkanal gesendet und von einem Serverkanal empfangen wird. Es wird dann deserialisiert und verarbeitet. Alle zurückgegebenen Werte werden vom Serverkanal übertragen und vom Clientkanal empfangen.

Um zusätzliche Verarbeitung von Nachrichten auf serverseitiger Seite durchzuführen, können Sie eine Implementierung von angeben, über die IServerChannelSinkProvider alle von verarbeiteten HttpServerChannel Nachrichten übergeben werden.

Die HttpServerChannel akzeptiert Nachrichten, die entweder im Binär- oder SOAP-Format serialisiert sind.

Ein HttpServerChannel Objekt verfügt über zugeordnete Konfigurationseigenschaften, die zur Laufzeit entweder in einer Konfigurationsdatei (durch Aufrufen der statischen RemotingConfiguration.Configure Methode) oder programmgesteuert (durch Übergeben einer IDictionary Auflistung an den HttpServerChannel Konstruktor) festgelegt werden können. Eine Liste dieser Konfigurationseigenschaften finden Sie in der Dokumentation zu HttpServerChannel.

Konstruktoren

HttpServerChannel()	Initialisiert eine neue Instanz der HttpServerChannel-Klasse.
HttpServerChannel(IDictionary, IServerChannelSinkProvider)	Initialisiert eine neue Instanz der HttpServerChannel-Klasse mit den angegebenen Channeleigenschaften und der angegebenen Channelsenke.
HttpServerChannel(Int32)	Initialisiert eine neue Instanz der HttpServerChannel-Klasse, die den angegebenen Anschluss überwacht.
HttpServerChannel(String, Int32)	Initialisiert eine neue Instanz der HttpServerChannel-Klasse mit dem angegebenen Namen, die den angegebenen Anschluss überwacht.
HttpServerChannel(String, Int32, IServerChannelSinkProvider)	Initialisiert eine neue Instanz der HttpServerChannel-Klasse am angegebenen Anschluss mit dem angegebenen Namen, die den angegebenen Anschluss überwacht und die angegebene Senke verwendet.

Felder

SinksWithProperties

Gibt die oberste Channelsenke im Channelsenkenstapel an.

(Geerbt von BaseChannelWithProperties)

Eigenschaften

ChannelData	Ruft channelspezifische Daten ab.
ChannelName	Ruft den Namen des aktuellen Channels ab.
ChannelPriority	Ruft die Priorität des aktuellen Channels ab.
ChannelScheme	Ruft den Typ des Listeners ab, dem ein Hook hinzugefügt werden soll, z. B. "http".
ChannelSinkChain	Ruft die vom aktuellen Channel verwendete Channelsenkenkette ab.
Count	Ruft die Anzahl der Eigenschaften ab, die dem Channelobjekt zugeordnet sind. (Geerbt von BaseChannelObjectWithProperties)
IsFixedSize	Ruft einen Wert ab, der angibt, ob die Anzahl der Eigenschaften, die in das Channelobjekt eingegeben werden können, festgelegt ist. (Geerbt von BaseChannelObjectWithProperties)
IsReadOnly	Ruft einen Wert ab, der angibt, ob die Auflistung von Eigenschaften im Channelobjekt schreibgeschützt ist. (Geerbt von BaseChannelObjectWithProperties)
IsSynchronized	Ruft einen Wert ab, der angibt, ob das Wörterbuch von Channelobjekteigenschaften synchronisiert ist. (Geerbt von BaseChannelObjectWithProperties)
Item[Object]	Gibt die angegebene Channeleigenschaft zurück.
Keys	Ruft eine ICollection von Schlüsseln ab, denen die Channeleigenschaften zugeordnet sind.
Properties	Ruft ein IDictionary von Channeleigenschaften ab, die dem aktuellen Channelobjekt zugeordnet sind. (Geerbt von BaseChannelWithProperties)
SyncRoot	Ruft ein Objekt ab, mit dem der Zugriff auf das BaseChannelObjectWithProperties synchronisiert wird. (Geerbt von BaseChannelObjectWithProperties)
Values	Ruft eine ICollection der Werte der Eigenschaften ab, die dem Channelobjekt zugeordnet sind. (Geerbt von BaseChannelObjectWithProperties)
WantsToListen	Ruft einen booleschen Wert ab, der angibt, ob IChannelReceiverHook dem externen Listenerdienst als Hook hinzugefügt werden soll.

Methoden

Add(Object, Object)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
AddHookChannelUri(String)	Fügt einen URI hinzu, an dem der Channelhook überwachen muss.
Clear()	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
Contains(Object)	Gibt einen Wert zurück, der angibt, ob das Channelobjekt eine dem angegebenen Schlüssel zugeordnete Eigenschaft enthält. (Geerbt von BaseChannelObjectWithProperties)
CopyTo(Array, Int32)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetChannelUri()	Gibt den URI des aktuellen Channels zurück.
GetEnumerator()	Gibt einen IDictionaryEnumerator zurück, der alle dem Channelobjekt zugeordneten Eigenschaften auflistet. (Geerbt von BaseChannelObjectWithProperties)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetUrlsForUri(String)	Gibt ein Array sämtlicher URLs für ein Objekt mit dem angegebenen URI zurück, für das der aktuelle HttpChannel als Host fungiert.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Parse(String, String)	Extrahiert aus der angegebenen URL den Channel-URI und den URI des bekannten Remoteobjekts.
Remove(Object)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
StartListening(Object)	Weist den aktuellen Channel an, mit der Überwachung von Anforderungen zu beginnen.
StopListening(Object)	Weist den aktuellen Channel an, die Überwachung von Anforderungen zu beenden.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IEnumerable.GetEnumerator()

Gibt einen IEnumerator zurück, der alle dem Channelobjekt zugeordneten Eigenschaften auflistet.

(Geerbt von BaseChannelObjectWithProperties)

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Gilt für:

Weitere Informationen

Kanal- und Formatierungskonfigurationseigenschaften

Teilen über