HttpClientChannel Klasse

Definition

Namespace:

System.Runtime.Remoting.Channels.Http

Assembly:

System.Runtime.Remoting.dll

Implementiert einen Clientkanal für Remoteaufrufe, die das HTTP-Protokoll zum Übertragen von Nachrichten verwenden.

public ref class HttpClientChannel : System::Runtime::Remoting::Channels::BaseChannelWithProperties, System::Runtime::Remoting::Channels::IChannelSender, System::Runtime::Remoting::Channels::ISecurableChannel

public class HttpClientChannel : System.Runtime.Remoting.Channels.BaseChannelWithProperties, System.Runtime.Remoting.Channels.IChannelSender, System.Runtime.Remoting.Channels.ISecurableChannel

type HttpClientChannel = class
    inherit BaseChannelWithProperties
    interface IChannelSender
    interface IChannel
    interface ISecurableChannel

Public Class HttpClientChannel
Inherits BaseChannelWithProperties
Implements IChannelSender, ISecurableChannel

Vererbung

Object

BaseChannelObjectWithProperties

BaseChannelWithProperties

HttpClientChannel

Implementiert

IChannel IChannelSender ISecurableChannel

Beispiele

Das folgende Codebeispiel zeigt, wie sie einen HttpClientChannel Remotingserver und seinen Client einrichten. 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 dem 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

Von Bedeutung

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

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

Kanäle werden von der .NET Framework-Remotinginfrastruktur zum Transport von Remoteanrufen verwendet. Wenn ein Client einen Aufruf an ein Remoteobjekt sendet, 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 eine zusätzliche Verarbeitung von Nachrichten auf clientseitiger Seite durchzuführen, können Sie eine Implementierung der Implementierung angeben, über die IClientChannelSinkProvider alle nachrichten, die von der HttpClientChannel Nachricht verarbeitet werden, übergeben werden.

Standardmäßig verwendet der HttpServerChannel SOAP-Formatierer zum Serialisieren aller Nachrichten.

Ein HttpClientChannel 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 HttpClientChannel Konstruktor) festgelegt werden können.

Konstruktoren

Name	Beschreibung
HttpClientChannel()	Initialisiert eine neue Instanz der HttpClientChannel-Klasse.
HttpClientChannel(IDictionary, IClientChannelSinkProvider)	Initialisiert eine neue Instanz der HttpClientChannel Klasse mit den angegebenen Konfigurationseigenschaften und -senken.
HttpClientChannel(String, IClientChannelSinkProvider)	Initialisiert eine neue Instanz der HttpClientChannel Klasse mit dem angegebenen Namen und sink.

Felder

Name	Beschreibung
SinksWithProperties	Gibt die obere Kanalspüle im Kanal-Senkenstapel an. (Geerbt von BaseChannelWithProperties)

Eigenschaften

Name	Beschreibung
ChannelName	Ruft den Namen des aktuellen Kanals ab.
ChannelPriority	Ruft die Priorität des aktuellen Kanals ab.
Count	Ruft die Anzahl der Eigenschaften ab, die dem Kanalobjekt zugeordnet sind. (Geerbt von BaseChannelObjectWithProperties)
IsFixedSize	Ruft einen Wert ab, der angibt, ob die Anzahl der Eigenschaften, die in das Kanalobjekt eingegeben werden können, behoben ist. (Geerbt von BaseChannelObjectWithProperties)
IsReadOnly	Ruft einen Wert ab, der angibt, ob die Auflistung von Eigenschaften im Kanalobjekt schreibgeschützt ist. (Geerbt von BaseChannelObjectWithProperties)
IsSecured	Ruft ab oder legt fest, ob der Clientkanal gesichert ist.
IsSynchronized	Ruft einen Wert ab, der angibt, ob das Wörterbuch der Kanalobjekteigenschaften synchronisiert wird. (Geerbt von BaseChannelObjectWithProperties)
Item[Object]	Gibt die angegebene Kanaleigenschaft zurück.
Keys	Ruft einen ICollection Schlüssel ab, dem die Kanaleigenschaften zugeordnet sind.
Properties	Ruft eine IDictionary der Kanaleigenschaften ab, die dem aktuellen Kanalobjekt zugeordnet sind. (Geerbt von BaseChannelWithProperties)
SyncRoot	Ruft ein Objekt ab, das zum Synchronisieren des Zugriffs auf die BaseChannelObjectWithProperties. (Geerbt von BaseChannelObjectWithProperties)
Values	Ruft einen ICollection der Werte der Eigenschaften ab, die dem Kanalobjekt zugeordnet sind. (Geerbt von BaseChannelObjectWithProperties)

Methoden

Name	Beschreibung
Add(Object, Object)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
Clear()	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
Contains(Object)	Gibt einen Wert zurück, der angibt, ob das Kanalobjekt eine Eigenschaft enthält, die dem angegebenen Schlüssel zugeordnet ist. (Geerbt von BaseChannelObjectWithProperties)
CopyTo(Array, Int32)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
CreateMessageSink(String, Object, String)	Gibt eine Kanalnachrichtensenke zurück, die Nachrichten an das angegebene URL- oder Kanaldatenobjekt übermittelt.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetEnumerator()	Gibt einen IDictionaryEnumerator Wert zurück, der alle dem Kanalobjekt zugeordneten Eigenschaften aufzählt. (Geerbt von BaseChannelObjectWithProperties)
GetHashCode()	Dient als die Standard-Hashfunktion (Geerbt von Object)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
Parse(String, String)	Extrahiert den Kanal-URI und den bekannten Remoteobjekt-URI aus der angegebenen URL.
Remove(Object)	Löst eine NotSupportedException aus. (Geerbt von BaseChannelObjectWithProperties)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

Name	Beschreibung
IEnumerable.GetEnumerator()	Gibt einen IEnumerator Wert zurück, der alle Eigenschaften aufzählt, die dem Kanalobjekt zugeordnet sind. (Geerbt von BaseChannelObjectWithProperties)

Erweiterungsmethoden

Name	Beschreibung
AsParallel(IEnumerable)	Aktiviert die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Wandelt eine IEnumerable in eine IQueryableum.
Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um.
OfType<TResult>(IEnumerable)	Filtert die Elemente einer IEnumerable basierend auf einem angegebenen Typ.