ITrackingHandler Interfaccia

Definizione

Spazio dei nomi:

System.Runtime.Remoting.Services

Assembly:

mscorlib.dll

Indica che all'oggetto che esegue l'implementazione deve essere notificato dall'infrastruttura remota il marshalling, l'unmarshalling, e la disconnessione di oggetti e proxy.

public interface class ITrackingHandler

[System.Runtime.InteropServices.ComVisible(true)]
public interface ITrackingHandler

[<System.Runtime.InteropServices.ComVisible(true)>]
type ITrackingHandler = interface

Public Interface ITrackingHandler

Attributi

ComVisibleAttribute

Esempio

Nell'esempio di codice seguente viene illustrato come implementare i metodi dell'interfaccia ITrackingHandler per ricevere notifiche dall'infrastruttura remota.

Nell'esempio di codice seguente viene illustrato come implementare questa interfaccia.

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Services;

// Intercept marshal, unmarshal, and disconnect events for an object.
public class TrackingHandler : ITrackingHandler
{
    // Called when the tracked object is marshaled.

    public void MarshaledObject(Object obj, ObjRef objRef)
    {
        // Notify the user of the marshal event.
        Console.WriteLine("Tracking: An instance of {0} was marshaled.", 
            obj.ToString());

        // Print the channel information.
        if (objRef.ChannelInfo != null)
        {
            // Iterate over ChannelData.
            foreach(object data in objRef.ChannelInfo.ChannelData)
            {
                if (data is ChannelDataStore)
                {
                    // Print the URIs from the ChannelDataStore objects.
                    string[] uris = ((ChannelDataStore)data).ChannelUris;
                    foreach(string uri in uris)
                        Console.WriteLine("ChannelUri: " + uri);
                }
            }
        }

        // Print the envoy information.
        if (objRef.EnvoyInfo != null)
            Console.WriteLine("EnvoyInfo: " + objRef.EnvoyInfo.ToString());

        // Print the type information.
        if (objRef.TypeInfo != null)
        {
            Console.WriteLine("TypeInfo: " + objRef.TypeInfo.ToString());
            Console.WriteLine("TypeName: " + objRef.TypeInfo.TypeName);
        }

        // Print the URI.
        if (objRef.URI != null)
            Console.WriteLine("URI: " + objRef.URI.ToString());
    }

    // Called when the tracked object is unmarshaled.
    public void UnmarshaledObject(Object obj, ObjRef objRef)
    {
        Console.WriteLine("Tracking: An instance of {0} was unmarshaled.", 
            obj.ToString());
    }

    // Called when the tracked object is disconnected.
    public void DisconnectedObject(Object obj)
    {
        Console.WriteLine("Tracking: An instance of {0} was disconnected.", 
            obj.ToString());
    }
}

Nell'esempio di codice seguente viene illustrato come implementare questa interfaccia in un server.

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

public class Server
{
    public static void Main(string[] args)
    {
        // Register the TCP channel.
        TcpChannel channel = new TcpChannel(1234);
        ChannelServices.RegisterChannel(channel);

        // Register a tracking handler.
        ITrackingHandler handler1 = new TrackingHandler();
        TrackingServices.RegisterTrackingHandler(handler1);

        // Register a second handler.
        ITrackingHandler handler2 = new TrackingHandler();
        TrackingServices.RegisterTrackingHandler(handler2);

        // Get the number of currently registered handlers.
        Console.WriteLine("Registered tracking handlers: " + 
            TrackingServices.RegisteredHandlers.Length);

        // Remove the tracking handler from the registered handlers.
        TrackingServices.UnregisterTrackingHandler(handler2);
        Console.WriteLine("Registered tracking handlers: " + 
            TrackingServices.RegisteredHandlers.Length);

        // Create and marshal an object for remote invocation.
        RemoteService service = new RemoteService();
        ObjRef obj = RemotingServices.Marshal(service, "TcpService");

        // Wait for the user prompt.
        Console.WriteLine("\r\nPress ENTER to unmarshal the object.");
        Console.ReadLine();

        // Unmarshal the object.
        RemotingServices.Unmarshal(obj);

        // Wait for the user prompt.
        Console.WriteLine("Press ENTER to disconnect the object.");
        Console.ReadLine();

        // Disconnect the object.
        RemotingServices.Disconnect(service);
    }
}

Nell'esempio di codice seguente viene illustrato come implementare questa interfaccia in un client per il server nell'esempio di codice precedente.

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

public class Client
{
    public static void Main(string[] args)
    {
        // Register the TCP channel.
        ChannelServices.RegisterChannel(new TcpChannel());

        // Register the client for the remote object.
        WellKnownClientTypeEntry remoteType = new WellKnownClientTypeEntry(
            typeof(RemoteService),"tcp://localhost:1234/TcpService");
        RemotingConfiguration.RegisterWellKnownClientType(remoteType);

        // Create an instance of the remote object.
        RemoteService service = new RemoteService(); 

        // Invoke a method on the remote object.
        service.Hello("world");
        Console.WriteLine("Hello invoked on server.");
    }
}

Nell'esempio di codice seguente viene illustrato l'oggetto remoto utilizzato dal server e dal client.

using System;

// Remote object.
public class RemoteService : MarshalByRefObject
{
    private DateTime startTime;

    public RemoteService()
    {
        // Notify the user that the constructor was invoked.
        Console.WriteLine("Constructor invoked.");
        startTime = DateTime.Now;
    }

    ~RemoteService()
    {
        // Notify the user that the finalizer was invoked.
        TimeSpan elapsedTime = 
            new TimeSpan(DateTime.Now.Ticks - startTime.Ticks);
        Console.WriteLine("Finalizer invoked after " + 
            elapsedTime.ToString() + " seconds.");
    }

    public void Hello(string name)
    {
        // Print a simple message.
        Console.WriteLine("Hello, " + name);
    }
}

Commenti

Ogni oggetto registrato con viene chiamato dalla comunicazione remota quando un oggetto o un proxy nell'oggetto corrente viene sottoposto a marshalling, non sincronizzato o disconnesso.Every object that is registered with TrackingServices is called by remoting when an object or proxy in the current AppDomain is marshaled, unmarshaled, or disconnected.

Si noti che solo gli oggetti possono essere disconnessi. Viene generata un'eccezione quando viene chiamata la disconnessione in un proxy.

Nota

Questa interfaccia rende una richiesta di collegamento. Viene generata un'eccezione SecurityException se il chiamante immediato effettua la chiamata tramite un riferimento all'interfaccia e non dispone dell'autorizzazione dell'infrastruttura. Per altre informazioni, vedere Richieste di collegamento .

Metodi

DisconnectedObject(Object)	Notifica all'istanza corrente che un oggetto è stato disconnesso dal relativo proxy.
MarshaledObject(Object, ObjRef)	Notifica all'istanza corrente che è stato effettuato il marshalling di un oggetto.
UnmarshaledObject(Object, ObjRef)	Notifica all'istanza corrente che è stato effettuato l'unmarshalling di un oggetto.