HttpChannel Klasse

Definition

Namespace:

System.Runtime.Remoting.Channels.Http

Assembly:

System.Runtime.Remoting.dll

Implementiert für Remoteaufrufe einen Clientchannel, der Meldungen mithilfe von HTTP überträgt.

public ref class HttpChannel : System::Runtime::Remoting::Channels::BaseChannelWithProperties, System::Runtime::Remoting::Channels::IChannelReceiver, System::Runtime::Remoting::Channels::IChannelReceiverHook, System::Runtime::Remoting::Channels::IChannelSender, System::Runtime::Remoting::Channels::ISecurableChannel

public class HttpChannel : System.Runtime.Remoting.Channels.BaseChannelWithProperties, System.Runtime.Remoting.Channels.IChannelReceiver, System.Runtime.Remoting.Channels.IChannelReceiverHook, System.Runtime.Remoting.Channels.IChannelSender, System.Runtime.Remoting.Channels.ISecurableChannel

type HttpChannel = class
    inherit BaseChannelWithProperties
    interface IChannelReceiver
    interface IChannel
    interface IChannelSender
    interface IChannelReceiverHook
    interface ISecurableChannel

Public Class HttpChannel
Inherits BaseChannelWithProperties
Implements IChannelReceiver, IChannelReceiverHook, IChannelSender, ISecurableChannel

Vererbung

Object

BaseChannelObjectWithProperties

BaseChannelWithProperties

HttpChannel

Implementiert

IChannel IChannelReceiver IChannelReceiverHook IChannelSender ISecurableChannel

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie einen HttpClientChannel verwenden, um einen Remotingserver und dessen 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;

void main()
{
   // Create the server channel.
   HttpServerChannel^ serverChannel = gcnew HttpServerChannel( 9090 );
   
   // Register the server channel.
   ChannelServices::RegisterChannel( serverChannel );
   
   // Expose an object for remote calls.
   RemotingConfiguration::RegisterWellKnownServiceType( RemoteObject::typeid, L"RemoteObject.rem", WellKnownObjectMode::Singleton );
   
   // 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);

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

        // 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^ clientChannel = gcnew HttpClientChannel;

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

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

   // Create a message sink.
   String^ objectUri;
   System::Runtime::Remoting::Messaging::IMessageSink^ messageSink = clientChannel->CreateMessageSink( L"http://localhost:9090/RemoteObject.rem", nullptr,  objectUri );
   Console::WriteLine( L"The URI of the message sink is {0}.", objectUri );
   if ( messageSink != nullptr )
   {
      Console::WriteLine( L"The type of the message sink is {0}.", messageSink->GetType() );
   }

   // Display the channel's properties using Keys and Item.
   for each(String^ key in clientChannel->Keys)
   {
       Console::WriteLine("clientChannel[{0}] = <{1}>", key, clientChannel[key]);
   }

   // Parse the channel's URI.
   String^ objectUrl = L"http://localhost:9090/RemoteObject.rem";
   String^ channelUri = clientChannel->Parse( objectUrl,  objectUri );
   Console::WriteLine( L"The object URL is {0}.", objectUrl );
   Console::WriteLine( L"The object URI is {0}.", objectUri );
   Console::WriteLine( L"The channel URI is {0}.", channelUri );

   // 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 clientChannel = new HttpClientChannel();

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

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

        // Create a message sink.
        string objectUri;
        System.Runtime.Remoting.Messaging.IMessageSink messageSink =
            clientChannel.CreateMessageSink(
            "http://localhost:9090/RemoteObject.rem",
            null, out objectUri);
        Console.WriteLine(
            "The URI of the message sink is {0}.",
            objectUri);
        if (messageSink != null)
        {
            Console.WriteLine("The type of the message sink is {0}.",
                messageSink.GetType().ToString());
        }

        // Display the channel's properties using Keys and Item.
        foreach(string key in clientChannel.Keys)
        {
            Console.WriteLine(
                "clientChannel[{0}] = <{1}>",
                key, clientChannel[key]);
        }

        // Parse the channel's URI.
        string objectUrl = "http://localhost:9090/RemoteObject.rem";
        string channelUri = clientChannel.Parse(objectUrl, out objectUri);
        Console.WriteLine("The object URL is {0}.", objectUrl);
        Console.WriteLine("The object URI is {0}.", objectUri);
        Console.WriteLine("The channel URI is {0}.", channelUri);

        // 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 Remoteobjekt, das vom Server und client verwendet wird.

#using <System.dll>
using namespace System;
using namespace System::Runtime::Remoting;

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

public:
   int GetCount()
   {
      Console::WriteLine( L"GetCount was called." );
      callCount++;
      return (callCount);
   }

};

using System;
using System.Runtime.Remoting;

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

    public int GetCount()
    {
        Console.WriteLine("GetCount was called.");
        callCount++;
        return(callCount);
    }
}

Hinweise

Wichtig

Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten stellt ein Sicherheitsrisiko dar. Rufen Sie die Methoden aus dieser Klasse nur mit vertrauenswürdigen Daten auf. Weitere Informationen finden Sie unter Überprüfen aller Eingaben.

Kanäle von Transportnachrichten über Remotinggrenzen hinweg (z. B. zwischen Computern oder Anwendungsdomänen). Die HttpChannel -Klasse transportiert Nachrichten mithilfe des HTTP-Protokolls.

Kanäle werden von der .NET Framework-Remotinginfrastruktur zum Transport von Remoteaufrufen verwendet. 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.

Ein HttpChannel 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 HttpChannel Konstruktor) festgelegt werden können. Eine Liste dieser Konfigurationseigenschaften finden Sie unter Kanal- und Formatiererkonfigurationseigenschaften.

Konstruktoren

HttpChannel()	Initialisiert eine neue Instanz der HttpChannel-Klasse.
HttpChannel(IDictionary, IClientChannelSinkProvider, IServerChannelSinkProvider)	Initialisiert eine neue Instanz der HttpChannel-Klasse mit den angegebenen Konfigurationseigenschaften und Konfigurationssenken.
HttpChannel(Int32)	Initialisiert eine neue Instanz der HttpChannel-Klasse mit einem Serverchannel, die den angegebenen Anschluss überwacht.

Felder

SinksWithProperties

Gibt die oberste Channelsenke im Channelsenkenstapel an. (Geerbt von BaseChannelWithProperties)

Eigenschaften

ChannelData	Ruft die channelspezifischen 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)
IsSecured	Ruft einen booleschen Wert ab, der angibt, ob der aktuelle Channel sicher ist, oder legt diesen fest.
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 der dem aktuellen Channel zugeordneten Channeleigenschaften ab.
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 die aktuelle Instanz in den externen Listenerdienst eingebunden 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 überwacht werden soll.
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)
CreateMessageSink(String, Object, String)	Gibt eine Channelnachrichtensenke zurück, die Meldungen an die angegebene URL oder das angegebene Channeldatenobjekt übermittelt.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
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.

Weitere Informationen

• Kanal- und Formatierungskonfigurationseigenschaften