ActivatedClientTypeEntry Klasa

Definicja

Przestrzeń nazw:: System.Runtime.Remoting

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Przechowuje wartości typu obiektu zarejestrowanego na końcu klienta jako typ, który można aktywować na serwerze.

public ref class ActivatedClientTypeEntry : System::Runtime::Remoting::TypeEntry

public class ActivatedClientTypeEntry : System.Runtime.Remoting.TypeEntry

[System.Runtime.InteropServices.ComVisible(true)]
public class ActivatedClientTypeEntry : System.Runtime.Remoting.TypeEntry

type ActivatedClientTypeEntry = class
    inherit TypeEntry

[<System.Runtime.InteropServices.ComVisible(true)>]
type ActivatedClientTypeEntry = class
    inherit TypeEntry

Public Class ActivatedClientTypeEntry
Inherits TypeEntry

Dziedziczenie: Object

TypeEntry
ActivatedClientTypeEntry

Atrybuty: ComVisibleAttribute

Przykłady

W poniższym przykładzie kodu pokazano, jak użyć obiektu do ActivatedClientTypeEntry zarejestrowania obiektu zdalnego aktywowanego przez klienta. Przykład zawiera trzy części, klienta, serwera i obiektu zdalnego używanego przez klienta i serwer.

Poniższy przykład kodu przedstawia klienta:

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

using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Tcp;
static void main()
{
   // Register TCP Channel.
   ChannelServices::RegisterChannel( gcnew TcpChannel );
   
   // Create activated client type entry.
   ActivatedClientTypeEntry^ activatedClientTypeEntry = gcnew ActivatedClientTypeEntry( HelloServer::typeid, "tcp://localhost:8082" );
   
   // Register type on client to activate it on the server.
   RemotingConfiguration::RegisterActivatedClientType( activatedClientTypeEntry );
   
   // Activate a client activated object type.
   HelloServer^ helloServer = gcnew HelloServer( "ParameterString" );
   
   // Print the object type.
   Console::WriteLine( "Object type of client activated object: {0}", activatedClientTypeEntry->ObjectType->ToString() );
   
   // Print the application URL.
   Console::WriteLine( "Application url where the type is activated: {0}", activatedClientTypeEntry->ApplicationUrl->ToString() );
   
   // Print the string representation of the type entry.
   Console::WriteLine( "Type and assembly name and application URL of the remote object: {0}", activatedClientTypeEntry->ToString() );
   
   // Print a blank line.
   Console::WriteLine();
   
   // Check that server was located.
   if (  !helloServer )
   {
      Console::WriteLine( "Could not locate server" );
   }
   else
   {
      Console::WriteLine( "Calling remote object" );
      Console::WriteLine( helloServer->HelloMethod( "Bill" ) );
   }
}

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

public class MyClient
{
    public static void Main()
    {
        // Register TCP Channel.
        ChannelServices.RegisterChannel(new TcpChannel());

        // Create activated client type entry.
        ActivatedClientTypeEntry myActivatedClientTypeEntry =
            new ActivatedClientTypeEntry(typeof(HelloServer),
            "tcp://localhost:8082");

        // Register type on client to activate it on the server.
        RemotingConfiguration.RegisterActivatedClientType(
            myActivatedClientTypeEntry);

        // Activate a client activated object type.
        HelloServer myHelloServer = new HelloServer("ParameterString");

        // Print the object type.
        Console.WriteLine(
            "Object type of client activated object: " +
            myActivatedClientTypeEntry.ObjectType.ToString());

        // Print the application URL.
        Console.WriteLine(
            "Application url where the type is activated: " +
            myActivatedClientTypeEntry.ApplicationUrl);

        // Print the string representation of the type entry.
        Console.WriteLine(
            "Type name, assembly name and application URL " +
            "of the remote object: " +
            myActivatedClientTypeEntry.ToString());

        // Print a blank line.
        Console.WriteLine();

        // Check that server was located.
        if (myHelloServer == null)
        {
            Console.WriteLine("Could not locate server");
        }
        else
        {
            Console.WriteLine("Calling remote object");
            Console.WriteLine(myHelloServer.HelloMethod("Bill"));
        }
    }
}

Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels
Imports System.Runtime.Remoting.Channels.Tcp

Public Class MyClient
    
    Public Shared Sub Main()
        ' Register TCP Channel.
        ChannelServices.RegisterChannel(New TcpChannel())

        ' Create activated client type entry.
        Dim myActivatedClientTypeEntry As _
            New ActivatedClientTypeEntry(GetType(HelloServer), _
            "tcp://localhost:8082")

        ' Register type on client to activate it on the server.
        RemotingConfiguration.RegisterActivatedClientType( _
            myActivatedClientTypeEntry)

        ' Activate a client activated object type.
        Dim myHelloServer As New HelloServer("ParameterString")

        ' Print the object type.
        Console.WriteLine("Object type of client activated object: " + _
            myActivatedClientTypeEntry.ObjectType.ToString())

        ' Print the application URL.
        Console.WriteLine("Application url where the type is activated: " + _
            myActivatedClientTypeEntry.ApplicationUrl)

        ' Print the string representation of the type entry.
        Console.WriteLine( _
            "Type name, assembly name and application URL " + _
            "of the remote object: " + _
            myActivatedClientTypeEntry.ToString())

        ' Print a blank line.
        Console.WriteLine()

        ' Check that server was located.
        If myHelloServer Is Nothing Then
            Console.WriteLine("Could not locate server")
        Else
            Console.WriteLine("Calling remote object")
            Console.WriteLine(myHelloServer.HelloMethod("Bill"))
        End If
    End Sub
End Class

Poniższy przykład kodu przedstawia serwer dla tego klienta:

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

using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Tcp;
void main()
{
   ChannelServices::RegisterChannel( gcnew TcpChannel( 8082 ) );
   RemotingConfiguration::RegisterActivatedServiceType( HelloServer::typeid );
   Console::WriteLine( "Press enter to stop this process" );
   Console::ReadLine();
}

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

public class MyServer
{
    public static void Main()
    {
        ChannelServices.RegisterChannel(new TcpChannel(8082));
        RemotingConfiguration.RegisterActivatedServiceType(typeof(HelloServer));
        Console.WriteLine("Press enter to stop this process");
        Console.ReadLine();
   }
}

Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels
Imports System.Runtime.Remoting.Channels.Tcp

Public Class MyServer
    
    Public Shared Sub Main()
        ChannelServices.RegisterChannel(New TcpChannel(8082))
        RemotingConfiguration.RegisterActivatedServiceType(GetType(HelloServer))
        Console.WriteLine("Press enter to stop this process")
        Console.ReadLine()
    End Sub

End Class

Poniższy przykład kodu zawiera obiekt zdalny używany przez klienta i serwer:

using namespace System;
public ref class HelloServer: public MarshalByRefObject
{
public:
   HelloServer( String^ myString )
   {
      Console::WriteLine( "HelloServer activated" );
      Console::WriteLine( "Paramater passed to the constructor is {0}", myString );
   }

   String^ HelloMethod( String^ myName )
   {
      Console::WriteLine( "HelloMethod : {0}", myName );
      return String::Format( "Hi there {0}", myName );
   }

};

using System;
public class HelloServer : MarshalByRefObject
{
    public HelloServer(String myString)
    {
        Console.WriteLine("HelloServer activated");
        Console.WriteLine("Parameter passed to the constructor is "+myString);
    }
    public String HelloMethod(String myName)
    {
        Console.WriteLine("HelloMethod : {0}",myName);
        return "Hi there " + myName;
    }
}

Public Class HelloServer
    Inherits MarshalByRefObject
    
    Public Sub New(myString As String)
        Console.WriteLine("HelloServer activated")
        Console.WriteLine("Parameter passed to the constructor is " + myString)
    End Sub
    
    Public Function HelloMethod(myName As String) As String
        Console.WriteLine("HelloMethod : {0}", myName)
        Return "Hi there " + myName
    End Function 'HelloMethod
End Class

Uwagi

Aby utworzyć wystąpienie obiektu aktywowanego przez klienta na kliencie, musisz go znać Type i musi zostać zarejestrowany na kliencie przy użyciu RegisterActivatedClientType metody . Aby uzyskać serwer proxy dla nowego wystąpienia obiektu aktywowanego przez klienta, klient musi najpierw zarejestrować kanał za ChannelServices pomocą polecenia , a następnie aktywować obiekt przez wywołanie metody new.

Aby aktywować typ obiektu aktywowanego przez klienta za new pomocą słowa kluczowego, należy najpierw zarejestrować typ obiektu na kliencie przy użyciu RegisterActivatedClientType metody . Wywołając polecenie RegisterActivatedClientType , udostępniasz infrastrukturę komunikacji zdalnej lokalizację aplikacji zdalnej, w której new próbuje ją utworzyć. Jeśli z drugiej strony użyjesz Activator.CreateInstance metody w celu utworzenia nowego wystąpienia obiektu aktywowanego przez klienta, musisz podać adres URL aplikacji zdalnej jako parametr, więc nie jest wymagana wcześniejsza rejestracja na końcu klienta. Aby podać metodę Activator.CreateInstance z adresem URL serwera, na którym chcesz utworzyć obiekt, należy hermetyzować adres URL w wystąpieniu UrlAttribute klasy.

Konstruktory

Nazwa	Opis
ActivatedClientTypeEntry(String, String, String)	Inicjuje nowe wystąpienie ActivatedClientTypeEntry klasy o podanej nazwie typu, nazwie zestawu i adresie URL aplikacji.
ActivatedClientTypeEntry(Type, String)	Inicjuje nowe wystąpienie ActivatedClientTypeEntry klasy przy użyciu podanego Type adresu URL aplikacji i .

Właściwości

Nazwa	Opis
ApplicationUrl	Pobiera adres URL aplikacji w celu aktywowania typu .
AssemblyName	Pobiera nazwę zestawu typu obiektu skonfigurowanego jako typ aktywowany zdalnie. (Odziedziczone po TypeEntry)
ContextAttributes	Pobiera lub ustawia atrybuty kontekstu dla typu aktywowanego przez klienta.
ObjectType	Type Pobiera typ aktywowany przez klienta.
TypeName	Pobiera pełną nazwę typu obiektu skonfigurowanego jako typ aktywowany zdalnie. (Odziedziczone po TypeEntry)

Metody

Nazwa	Opis
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
ToString()	Zwraca nazwę typu, nazwę zestawu i adres URL aplikacji typu aktywowanego przez klienta jako String.

Dotyczy

Zobacz też

RegisterActivatedClientType(Type, String)

Opinia

Czy ta strona była pomocna?