Freigeben über


HttpClientChannel Klasse

Definition

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

public ref class HttpClientChannel : System::Runtime::Remoting::Channels::BaseChannelWithProperties, System::Runtime::Remoting::Channels::IChannelSender
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
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
type HttpClientChannel = class
    inherit BaseChannelWithProperties
    interface IChannelSender
    interface IChannel
    interface ISecurableChannel
Public Class HttpClientChannel
Inherits BaseChannelWithProperties
Implements IChannelSender
Public Class HttpClientChannel
Inherits BaseChannelWithProperties
Implements IChannelSender, ISecurableChannel
Vererbung
Implementiert

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie sie einen HttpClientChannel 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;

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 vom Server und dem Client verwendete Remoteobjekt.

#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 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 verwendet, um Remoteanrufe zu übertragen. 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 eine zusätzliche Verarbeitung von Nachrichten auf der Clientseite durchzuführen, können Sie eine Implementierung von angeben, über die IClientChannelSinkProvider alle von verarbeiteten HttpClientChannel Nachrichten übergeben werden.

Standardmäßig wird ein HttpServerChannel SOAP-Formatierer verwendet, um alle Nachrichten zu serialisieren.

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. Eine Liste dieser Konfigurationseigenschaften finden Sie unter Konfigurationseigenschaften für Kanal und Formatierer.

Konstruktoren

HttpClientChannel()

Initialisiert eine neue Instanz der HttpClientChannel-Klasse.

HttpClientChannel(IDictionary, IClientChannelSinkProvider)

Initialisiert eine neue Instanz der HttpClientChannel-Klasse mit den angegebenen Konfigurationseigenschaften und Konfigurationssenken.

HttpClientChannel(String, IClientChannelSinkProvider)

Initialisiert eine neue Instanz der HttpClientChannel-Klasse mit dem angegebenen Namen und der angegebenen Senke.

Felder

SinksWithProperties

Gibt die oberste Channelsenke im Channelsenkenstapel an.

(Geerbt von BaseChannelWithProperties)

Eigenschaften

ChannelName

Ruft den Namen des aktuellen Channels ab.

ChannelPriority

Ruft die Priorität des aktuellen Channels 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 ab oder legt fest, ob der Clientchannel gesichert ist.

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)

Methoden

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 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)
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)
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: