RemotingConfiguration.RegisterWellKnownServiceType Método

  • Referência

Definição

Namespace:
System.Runtime.Remoting
Assembly:
mscorlib.dll

Registra um Type de objeto no lado do serviço como um tipo conhecido (chamada única ou singleton).

Sobrecargas

RegisterWellKnownServiceType(WellKnownServiceTypeEntry)

Registra um objeto Type registrado no WellKnownServiceTypeEntry fornecido na extremidade do serviço como um tipo conhecido.
RegisterWellKnownServiceType(Type, String, WellKnownObjectMode)

Registra um Type de objeto no lado do serviço como um tipo conhecido, usando os parâmetros fornecidos para inicializar uma nova instância de WellKnownServiceTypeEntry.

RegisterWellKnownServiceType(WellKnownServiceTypeEntry)

Registra um objeto Type registrado no WellKnownServiceTypeEntry fornecido na extremidade do serviço como um tipo conhecido.

public:
 static void RegisterWellKnownServiceType(System::Runtime::Remoting::WellKnownServiceTypeEntry ^ entry);
public static void RegisterWellKnownServiceType (System.Runtime.Remoting.WellKnownServiceTypeEntry entry);
static member RegisterWellKnownServiceType : System.Runtime.Remoting.WellKnownServiceTypeEntry -> unit
Public Shared Sub RegisterWellKnownServiceType (entry As WellKnownServiceTypeEntry)

Parâmetros

entry
WellKnownServiceTypeEntry

Definições de configuração para o tipo conhecido.

Exceções

SecurityException

Pelo menos um dos chamadores no topo da pilha de chamadas não tem permissão para configurar canais e tipos de comunicação remota.

Exemplos

#using <system.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::Http;
using namespace System::Runtime::Remoting::Messaging;
using namespace System::Runtime::Serialization;

public ref class RemoteObject: public MarshalByRefObject
{
public:
   void Method1( LocalObject^ param )
   {
      Console::WriteLine( "Invoked: Method1( {0})", param );
   }
};

int main()
{
   ChannelServices::RegisterChannel( gcnew HttpChannel( 8090 ) );
   WellKnownServiceTypeEntry^ wkste = gcnew WellKnownServiceTypeEntry( RemoteObject::typeid,"RemoteObject",WellKnownObjectMode::Singleton );
   RemotingConfiguration::RegisterWellKnownServiceType( wkste );
   RemoteObject^ RObj = dynamic_cast<RemoteObject^>(Activator::GetObject( RemoteObject::typeid, "http://localhost:8090/RemoteObject" ));
   LocalObject^ LObj = gcnew LocalObject;
   RObj->Method1( LObj );
   Console::WriteLine( "Press Return to exit..." );
   Console::ReadLine();
}

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Serialization;
using System.Security.Permissions;

public class ObjRefExample {

   public static void Main() {

      ChannelServices.RegisterChannel(new HttpChannel(8090));

      WellKnownServiceTypeEntry wkste =
         new WellKnownServiceTypeEntry(typeof(RemoteObject),
                                       "RemoteObject",
                                       WellKnownObjectMode.Singleton);

      RemotingConfiguration.RegisterWellKnownServiceType( wkste );

      RemoteObject RObj =
         (RemoteObject)Activator.GetObject(typeof(RemoteObject),
                                           "http://localhost:8090/RemoteObject");

      LocalObject LObj = new LocalObject();

      RObj.Method1( LObj );

      Console.WriteLine("Press Return to exit...");
      Console.ReadLine();
   }
}

public class RemoteObject : MarshalByRefObject {

   public void Method1(LocalObject param) {
      Console.WriteLine("Invoked: Method1({0})", param);
   }
}

Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels
Imports System.Runtime.Remoting.Channels.Http
Imports System.Runtime.Remoting.Messaging
Imports System.Runtime.Serialization
Imports System.Security.Permissions

' code that drives the example
Public Class ObjRefExample

   <PermissionSet(SecurityAction.LinkDemand)> _
   Public Overloads Shared Sub Main()
      ChannelServices.RegisterChannel(New HttpChannel(8090))

      RemotingConfiguration.RegisterWellKnownServiceType(New WellKnownServiceTypeEntry(GetType(RemoteObject), "RemoteObject", WellKnownObjectMode.Singleton))

      Dim RObj As RemoteObject = CType(Activator.GetObject(GetType(RemoteObject), "http://localhost:8090/RemoteObject"), RemoteObject)
      Dim LObj As New LocalObject()

      RObj.Method1(LObj)

      Console.WriteLine("Press Return to exit...")

      Console.ReadLine()
   End Sub

End Class


' a simple remote object
<PermissionSet(SecurityAction.Demand, Name:="FullTrust")> _
Public Class RemoteObject
   Inherits MarshalByRefObject

   Public Sub Method1(ByVal param As LocalObject)
       Console.WriteLine("Invoked: Method1({0})", param)
   End Sub

End Class

Comentários

Qualquer cliente que conheça o URI de um objeto conhecido registrado pode obter um proxy para o objeto registrando o canal que ele prefere com ChannelServicese ativando o objeto chamando new ou o Activator.GetObject método . Para ativar um objeto conhecido com new, primeiro você deve registrar o tipo de objeto conhecido no cliente usando o RegisterWellKnownClientType método . Chamar o RegisterWellKnownClientType método fornece à infraestrutura de comunicação remota o local do objeto remoto, o que permite que o new palavra-chave criá-lo. Se, por outro lado, você usar o Activator.GetObject método para ativar o objeto conhecido, deverá fornecê-lo com a URL do objeto como um argumento, portanto, nenhum registro anterior na extremidade do cliente será necessário.

Quando a chamada chega ao servidor, o .NET Framework extrai o URI da mensagem, examina as tabelas de comunicação remota para localizar a referência do objeto que corresponde ao URI e, em seguida, instancia o objeto, se necessário, encaminhando a chamada de método para o objeto. Se o objeto for registrado como SingleCall, ele será destruído após a conclusão da chamada de método. Uma nova instância do objeto é criada para cada método chamado. A única diferença entre Activator.GetObject e new é que o primeiro permite que você especifique uma URL como um parâmetro e o último obtém a URL da configuração.

O objeto remoto em si não é instanciado pelo processo de registro. Isso só acontece quando um cliente tenta chamar um método no objeto ou ativa o objeto do lado do cliente.

Para obter uma descrição detalhada de objetos conhecidos, consulte Ativação do servidor.

Confira também

Aplica-se a

RegisterWellKnownServiceType(Type, String, WellKnownObjectMode)

Registra um Type de objeto no lado do serviço como um tipo conhecido, usando os parâmetros fornecidos para inicializar uma nova instância de WellKnownServiceTypeEntry.

public:
 static void RegisterWellKnownServiceType(Type ^ type, System::String ^ objectUri, System::Runtime::Remoting::WellKnownObjectMode mode);
public static void RegisterWellKnownServiceType (Type type, string objectUri, System.Runtime.Remoting.WellKnownObjectMode mode);
static member RegisterWellKnownServiceType : Type * string * System.Runtime.Remoting.WellKnownObjectMode -> unit
Public Shared Sub RegisterWellKnownServiceType (type As Type, objectUri As String, mode As WellKnownObjectMode)

Parâmetros

type
Type

O objeto Type.

objectUri
String

O URI do objeto.

mode
WellKnownObjectMode

O modo de ativação do tipo de objeto conhecido que está sendo registrado. (Consulte WellKnownObjectMode.)

Exceções

SecurityException

Pelo menos um dos chamadores no topo da pilha de chamadas não tem permissão para configurar canais e tipos de comunicação remota.

Exemplos

O exemplo de código a seguir demonstra o registro de um tipo de objeto no servidor como um tipo de objeto conhecido. Para o código do cliente que corresponde ao código do servidor apresentado, consulte o exemplo do RegisterWellKnownClientType método .

#using <system.dll>
#using <system.runtime.remoting.dll>
#using "service.dll"

using namespace System;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Channels;
using namespace System::Runtime::Remoting::Channels::Tcp;
int main()
{

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

public class ServerClass {

    public static void Main()  {

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


Public Class ServerClass
   
   Public Shared Sub Main()

ChannelServices::RegisterChannel( gcnew TcpChannel( 8082 ) );
RemotingConfiguration::ApplicationName = "HelloServiceApplication";
RemotingConfiguration::RegisterWellKnownServiceType( HelloService::typeid,
                                                     "MyUri",
                                                     WellKnownObjectMode::SingleCall );

ChannelServices.RegisterChannel(new TcpChannel(8082));

RemotingConfiguration.ApplicationName = "HelloServiceApplication";

RemotingConfiguration.RegisterWellKnownServiceType( typeof(HelloService),
                                                    "MyUri",
                                                    WellKnownObjectMode.SingleCall
                                                  );

ChannelServices.RegisterChannel(New TcpChannel(8082))

RemotingConfiguration.ApplicationName = "HelloServiceApplication"

RemotingConfiguration.RegisterWellKnownServiceType(GetType(HelloService), "MyUri", WellKnownObjectMode.SingleCall)

   Console::WriteLine( "Press enter to stop this process." );
   Console::ReadLine();
   return 0;
}


        Console.WriteLine("Press enter to stop this process.");
        Console.ReadLine();
    }
}


      Console.WriteLine("Press enter to stop this process.")
      Console.ReadLine()

   End Sub

End Class

O exemplo de código a seguir mostra o objeto de serviço registrado no código de exemplo acima.

#using <system.dll>

using namespace System;
public ref class HelloService: public MarshalByRefObject
{
private:
   static int n_instances;

public:
   HelloService()
   {
      n_instances++;
      Console::WriteLine( "" );
      Console::WriteLine( "HelloService activated - instance # {0}.", n_instances );
   }

   ~HelloService()
   {
      Console::WriteLine( "HelloService instance {0} destroyed.", n_instances );
      n_instances--;
   }

   String^ HelloMethod( String^ name )
   {
      Console::WriteLine( "HelloMethod called on HelloService instance {0}.", n_instances );
      return String::Format( "Hi there {0}.", name );
   }

};

using System;

public class HelloService : MarshalByRefObject {

    static int n_instances;

    public HelloService() {
        n_instances++;
        Console.WriteLine("");
        Console.WriteLine("HelloService activated - instance # {0}.", n_instances);
    }

    ~HelloService()  {
        Console.WriteLine("HelloService instance {0} destroyed.", n_instances);
        n_instances--;
    }

    public String HelloMethod(String name)  {

        Console.WriteLine("HelloMethod called on HelloService instance {0}.", n_instances);
        return "Hi there " + name + ".";
    }
}

Public Class HelloService
   Inherits MarshalByRefObject
   
   Private Shared n_instances As Integer
     
   Public Sub New()
      n_instances += 1
      Console.WriteLine("")
      Console.WriteLine("HelloService activated - instance # {0}.", n_instances)
   End Sub
   
   
   Protected Overrides Sub Finalize()
      Console.WriteLine("HelloService instance {0} destroyed.", n_instances)
      n_instances -= 1
      MyBase.Finalize()
   End Sub
   
   
   Public Function HelloMethod(name As [String]) As [String]
      Console.WriteLine("HelloMethod called on HelloService instance {0}.", n_instances)
      Return "Hi there " + name + "."
   End Function 'HelloMethod

End Class

Comentários

Qualquer cliente que conheça o URI de um objeto conhecido registrado pode obter um proxy para o objeto registrando o canal que ele prefere com ChannelServicese ativando o objeto chamando new ou o Activator.GetObject método . Para ativar um objeto conhecido com new, primeiro você deve registrar o tipo de objeto conhecido no cliente usando o RegisterWellKnownClientType método . Chamar o RegisterWellKnownClientType método fornece à infraestrutura de comunicação remota o local do objeto remoto, o que permite que o new palavra-chave criá-lo. Se, por outro lado, você usar o Activator.GetObject método para ativar o objeto conhecido, deverá fornecê-lo com a URL do objeto como um argumento, portanto, nenhum registro anterior na extremidade do cliente será necessário.

Quando a chamada chega ao servidor, o .NET Framework extrai o URI da mensagem, examina as tabelas de comunicação remota para localizar a referência do objeto que corresponde ao URI e, em seguida, instancia o objeto, se necessário, encaminhando a chamada de método para o objeto. Se o objeto for registrado como SingleCall, ele será destruído após a conclusão da chamada de método. Uma nova instância do objeto é criada para cada método chamado. A única diferença entre Activator.GetObject e new é que o primeiro permite que você especifique uma URL como um parâmetro e o último obtém a URL da configuração.

O objeto remoto em si não é instanciado pelo processo de registro. Isso só acontece quando um cliente tenta chamar um método no objeto ou ativa o objeto do lado do cliente.

Para obter uma descrição detalhada de objetos conhecidos, consulte Ativação do servidor.

Confira também

Aplica-se a