Partager via


TcpServerChannel Classe

Définition

Implémente pour les appels distants un canal serveur qui utilise le protocole TCP pour transmettre des messages.

public ref class TcpServerChannel : System::Runtime::Remoting::Channels::IChannelReceiver
public ref class TcpServerChannel : System::Runtime::Remoting::Channels::IChannelReceiver, System::Runtime::Remoting::Channels::ISecurableChannel
public class TcpServerChannel : System.Runtime.Remoting.Channels.IChannelReceiver
public class TcpServerChannel : System.Runtime.Remoting.Channels.IChannelReceiver, System.Runtime.Remoting.Channels.ISecurableChannel
type TcpServerChannel = class
    interface IChannelReceiver
    interface IChannel
type TcpServerChannel = class
    interface IChannelReceiver
    interface IChannel
    interface ISecurableChannel
Public Class TcpServerChannel
Implements IChannelReceiver
Public Class TcpServerChannel
Implements IChannelReceiver, ISecurableChannel
Héritage
TcpServerChannel
Implémente

Exemples

L’exemple de code suivant montre l’utilisation d’un type accessible à distance.

using namespace System;
using namespace System::Runtime::Remoting;

public ref class Remotable: public MarshalByRefObject
{
private:
   int callCount;

public:
   Remotable()
      : callCount( 0 )
   {}

   int GetCount()
   {
      callCount++;
      return (callCount);
   }
};
using System;
using System.Runtime.Remoting;

public class Remotable : MarshalByRefObject
{

    private int callCount = 0;

    public int GetCount()
    {
        callCount++;
        return(callCount);
    }
}

L’exemple de code suivant montre l’utilisation de la TcpServerChannel classe pour exposer un type accessible à distance.

#using <System.Runtime.Remoting.dll>
#using <System.dll>
#using <Remotable.dll>

using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Tcp;

int main()
{
   // Set up a server channel.
   TcpServerChannel^ serverChannel = gcnew TcpServerChannel( 9090 );
   ChannelServices::RegisterChannel( serverChannel );

   // Expose an object for remote calls.
   RemotingConfiguration::RegisterWellKnownServiceType( Remotable::typeid, "Remotable.rem", WellKnownObjectMode::Singleton );

   // Show the name and priority of the channel.
   Console::WriteLine( "Channel Name: {0}", serverChannel->ChannelName );
   Console::WriteLine( "Channel Priority: {0}", serverChannel->ChannelPriority );

   // Show the URIs associated with the channel.
   ChannelDataStore^ data = dynamic_cast<ChannelDataStore^>(serverChannel->ChannelData);
   System::Collections::IEnumerator^ myEnum = data->ChannelUris->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ uri = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( uri );
   }

   // Wait for method calls.
   Console::WriteLine( "Listening..." );
   Console::ReadLine();
}
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

public class Server
{
    public static void Main()
    {

        // Set up a server channel.
        TcpServerChannel serverChannel = new TcpServerChannel(9090);
        ChannelServices.RegisterChannel(serverChannel);

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

        // Show the name and priority of the channel.
        Console.WriteLine("Channel Name: {0}", serverChannel.ChannelName);
        Console.WriteLine("Channel Priority: {0}", serverChannel.ChannelPriority);

        // Show the URIs associated with the channel.
        ChannelDataStore data = (ChannelDataStore) serverChannel.ChannelData;
        foreach (string uri in data.ChannelUris)
        {
            Console.WriteLine(uri);
        }

        // Wait for method calls.
        Console.WriteLine("Listening...");
        Console.ReadLine();
    }
}

Remarques

Important

L’appel de méthodes de cette classe avec des données non approuvées est un risque de sécurité. Appelez les méthodes de cette classe avec des données approuvées uniquement. Pour plus d’informations, consultez Valider toutes les entrées.

Les canaux transportent les messages au-delà des limites de communication à distance (par exemple, les ordinateurs ou les domaines d’application). La TcpServerChannel classe transporte les messages à l’aide du protocole TCP.

Les canaux sont utilisés par l’infrastructure de communication à distance .NET Framework pour transporter les appels distants. Lorsqu’un client effectue un appel à un objet distant, l’appel est sérialisé dans un message envoyé par un canal client et reçu par un canal serveur. Il est ensuite désérialisé et traité. Toutes les valeurs retournées sont transmises par le canal serveur et reçues par le canal client.

Pour effectuer un traitement supplémentaire des messages côté serveur, vous pouvez spécifier une implémentation de l’interface IServerChannelSinkProvider via laquelle tous les messages traités par l’instance TcpServerChannel sont passés.

L’instance TcpServerChannel accepte les messages sérialisés au format binaire ou SOAP.

Un TcpServerChannel objet a des propriétés de configuration associées qui peuvent être définies au moment de l’exécution dans un fichier de configuration (en appelant la méthode statique RemotingConfiguration.Configure ) ou par programmation (en passant une IDictionary collection au TcpServerChannel constructeur). Pour obtenir la liste de ces propriétés de configuration, consultez Propriétés de configuration du canal et du formateur.

Constructeurs

TcpServerChannel(IDictionary, IServerChannelSinkProvider)

Initialise une nouvelle instance de la classe TcpServerChannel avec les propriétés de canal et le récepteur spécifiés.

TcpServerChannel(IDictionary, IServerChannelSinkProvider, IAuthorizeRemotingConnection)

Initialise une nouvelle instance de la classe TcpServerChannel avec les propriétés de canal, le récepteur et le fournisseur d'autorisation spécifiés.

TcpServerChannel(Int32)

Initialise une nouvelle instance de la classe TcpServerChannel qui écoute sur le port spécifié.

TcpServerChannel(String, Int32)

Initialise une nouvelle instance de la classe TcpServerChannel portant le nom indiqué et à l'écoute sur le port spécifié.

TcpServerChannel(String, Int32, IServerChannelSinkProvider)

Initialise une nouvelle instance de la classe TcpServerChannel avec le nom donné, qui écoute sur le port spécifié et utilise le récepteur spécifié.

Propriétés

ChannelData

Obtient les données spécifiques au canal.

ChannelName

Obtient le nom du canal en cours.

ChannelPriority

Obtient la priorité du canal actuel.

IsSecured

Obtient ou définit une valeur Boolean qui indique si le canal actuel est sécurisé.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetChannelUri()

Retourne l'URI du canal en cours.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
GetUrlsForUri(String)

Retourne un tableau de toutes les URL d'un objet doté de l'URI spécifié qui sont hébergées sur l'instance de TcpChannel en cours.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
Parse(String, String)

Extrait l'URI du canal et de l'objet connu distant à partir de l'URL spécifiée.

StartListening(Object)

Indique au canal actuel de commencer à écouter sur un canal après que la méthode StopListening(Object) a été appelée pour arrêter d’écouter sur le canal.

StopListening(Object)

Commande au canal en cours d'arrêter l'écoute des demandes.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à