Export (0) Print
Expand All

Remoting Example: Asynchronous Remoting

The following sample application demonstrates asynchronous programming in a remoting scenario. The example first creates a synchronous delegate to a remote object and invokes it to illustrate the thread waiting on the return. It then uses asynchronous delegates and a ManualResetEvent object to invoke a remote object method and wait for the response.

This application runs on a single computer or across a network. If you want to run this application over a network, you must replace "localhost" in the client configuration with the name of the remote computer.

CAUTION   .NET remoting does not do authentication or encryption by default. Therefore, it is recommended that you take all necessary steps to make certain of the identity of clients or servers before interacting with them remotely. Because .NET remoting applications require FullTrust permissions to execute, if a unauthorized client were granted access on your server, the client could execute code as though it were fully trusted. Always authenticate your endpoints and encrypt the communication streams, either by hosting your remoted types in Internet Information Services (IIS) or by building a custom channel sink pair to do this work.

To compile this sample

  1. Type the following commands at the command prompt:

    csc /t:library /out:ServiceClass.dll ServiceClass.cs

    vbc -r:ServiceClass.dll RemoteAsyncVB.vb

    csc /r:ServiceClass.dll Server.cs

    csc /r:ServiceClass.dll RemoteAsync.cs

  2. Open two command prompts pointing to the same directory. In one, type server. In the other, type RemoteAsyncVB or RemoteAsync.

RemoteAsyncVB.vb

Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Messaging
Imports System.Threading
Imports Microsoft.VisualBasic

Public Class RemotingDelegates
   
   
   Public Shared e As ManualResetEvent
   
   ' Declares two delegates, each of which will represent 
   ' a function returning a string. The names are strictly 
   ' for clarity in the code – there is no difference between
   ' the two delegates. (In fact, the same delegate type 
   ' could be used for both synchronous and asynchronous 
   ' calls.)
   Delegate Function RemoteSyncDelegate() As String
   Delegate Function RemoteAsyncDelegate() As String
   
   <MTAThread()> _
   Public Shared Sub Main()
      
      e = New ManualResetEvent(False)
      
      Console.WriteLine("Remote synchronous and asynchronous delegates.")
      Console.WriteLine(New [String]("-"c, 80))
      Console.WriteLine()
      
      ' Configuration is required in a remoting scenario, for both
      ' synchronous and asynchronous programming. You can use either
      ' a configuration file, as shown here, or method calls.
      RemotingConfiguration.Configure("SyncAsync.exe.config")
      
      ' The remaining steps are identical to single-
      ' AppDomain programming. First, create the service class. In this 
      ' case, the object is actually created on the server, and only a 
      ' single instance is created. (See the server configuration file, 
      ' ServerVB.exe.config.)
      Dim obj As New ServiceClass()
      
      If RemotingServices.IsTransparentProxy(obj) Then
         Console.WriteLine("It's remote.")
      Else
         Console.WriteLine("Uh-oh. It's local.")
         Return
      End If
      
      ' This delegate is a remote synchronous delegate.
      Dim RemoteSyncDel As New RemoteSyncDelegate(AddressOf obj.VoidCall)

      ' When invoked, program execution waits until the method returns.
      ' The return value is displayed to the console.
      Console.WriteLine(RemoteSyncDel())

      
      ' Next, the remote asynchronous call.
      ' First, create an AsyncCallback delegate that represents  
      ' the method to be executed when the asynchronous method has finished 
      ' executing.
      Dim RemoteCallback As New AsyncCallback(AddressOf RemotingDelegates.OurRemoteAsyncCallBack)
      
      ' Second, create the delegate to the method that will be 
      ' executed asynchronously.
      Dim RemoteDel As New RemoteAsyncDelegate(AddressOf obj.TimeConsumingRemoteCall)
      
      ' Finally, begin the method invocation.
      ' Note that execution on this thread continues immediately without 
      ' waiting for the return of the method call.
      Dim RemAr As IAsyncResult = RemoteDel.BeginInvoke(RemoteCallback, Nothing)
      ' If you want to block on the return:
      '      RemAr.AsyncWaitHandle.WaitOne();
      '      RemoteCallback(RemAr);

      ' Provide some feedback to indicate continued processing prior to 
      ' the return of the asynchronous call.
      Dim count As Integer = 0
      While Not RemAr.IsCompleted
         Console.Write("Not completed -- " & count & vbCr)
         count += 1
         ' The callback is made on a low priority worker thread. Blocking 
         ' the foreground thread for a millisecond each time enables the
         ' callback to execute. 
         Thread.Sleep(New TimeSpan(TimeSpan.TicksPerMillisecond))
      End While
      Console.WriteLine(vbCrLf & "Completed.")

   End Sub 'Main
    
   
   ' This is the method that the server will call when asynchronous 
   ' execution is complete. The method is represented by an AsyncCallBack 
   ' delegate, which determines its signature.
   Public Shared Sub OurRemoteAsyncCallBack(ByVal iar As IAsyncResult)
      ' The following nested cast looks confusing, because of the nature 
      ' of the Visual Basic casting operator, CType. Note that you could 
      ' get the same result with two separate casts:
      '    Dim ar As AsyncResult = CType(iar, AsyncResult)
      '    Dim del As RemoteAsyncDelegate = CType(ar.AsyncDelegate,RemoteAsyncDelegate)
      ' The first line casts the interface to an AsyncResult object to 
      ' access the AsyncDelegate property (in the second 
      ' line). This property returns a reference to the original delegate, 
      ' which must be cast back to its own type.
      Dim del As RemoteAsyncDelegate = CType(CType(iar, AsyncResult).AsyncDelegate, RemoteAsyncDelegate)
      Console.WriteLine(vbCrLf & "Result of the remote AsyncCallBack: " & del.EndInvoke(iar))
      Return
   End Sub 'OurRemoteAsyncCallBack
    
End Class 'RemotingDelegates

RemoteAsync.cs

using System;
using System.Reflection;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Channels;
using System.Threading;

public class RemotingDelegates : MarshalByRefObject{


    public static ManualResetEvent e;

    public delegate string RemoteSyncDelegate();
    public delegate string RemoteAsyncDelegate();

    // This is the call that the AsyncCallBack delegate will reference.
    [OneWayAttribute]
   public void OurRemoteAsyncCallBack(IAsyncResult ar){
      RemoteAsyncDelegate del = (RemoteAsyncDelegate)((AsyncResult)ar).AsyncDelegate;
      Console.WriteLine("\r\n**SUCCESS**: Result of the remote AsyncCallBack: "  + del.EndInvoke(ar) );
      
        // Signal the thread.
        e.Set();
        return;
   }

    public static void Main(string[] Args){

        // IMPORTANT: .NET remoting does not remote
        // static members. This class must be an instance before
        // the callback from the asynchronous invocation can reach this client.
        RemotingDelegates HandlerInstance = new RemotingDelegates();
        HandlerInstance.Run();        
 
    }

    public void Run(){
        // Enable this and the e.WaitOne call at the bottom if you 
        // are going to make more than one asynchronous call.
        e = new ManualResetEvent(false);

        Console.WriteLine("Remote synchronous and asynchronous delegates.");
        Console.WriteLine(new String('-',80));
        Console.WriteLine();

        // This is the only thing you must do in a remoting scenario
        // for either synchronous or asynchronous programming 
        // configuration.
        RemotingConfiguration.Configure("SyncAsync.exe.config");

        // The remaining steps are identical to single-
        // AppDomain programming.
        ServiceClass obj = new ServiceClass();
        
        // This delegate is a remote synchronous delegate.
        RemoteSyncDelegate Remotesyncdel = new RemoteSyncDelegate(obj.VoidCall);
        
        // When invoked, program execution waits until the method returns.
        // This delegate could be passed to another application domain
        // to be used as a callback to the obj.VoidCall method.
        Console.WriteLine(Remotesyncdel());

        // This delegate is an asynchronous delegate. Two delegates must 
        // be created. The first is the system-defined AsyncCallback 
        // delegate, which references the method that the remote type calls 
        // back when the remote method is done.

        AsyncCallback RemoteCallback = new AsyncCallback(this.OurRemoteAsyncCallBack);

        // Create the delegate to the remote method you want to use 
        // asynchronously.
        RemoteAsyncDelegate RemoteDel = new RemoteAsyncDelegate(obj.TimeConsumingRemoteCall);
        
        // Start the method call. Note that execution on this 
        // thread continues immediately without waiting for the return of 
        // the method call. 
        IAsyncResult RemAr = RemoteDel.BeginInvoke(RemoteCallback, null);

        // If you want to stop execution on this thread to 
        // wait for the return from this specific call, retrieve the 
        // IAsyncResult returned from the BeginIvoke call, obtain its 
        // WaitHandle, and pause the thread, such as the next line:
        // RemAr.AsyncWaitHandle.WaitOne();

        // To wait in general, if, for example, many asynchronous calls 
        // have been made and you want notification of any of them, or, 
        // like this example, because the application domain can be 
        // recycled before the callback can print the result to the 
        // console.
        //e.WaitOne();

   // This simulates some other work going on in this thread while the 
   // async call has not returned. 
   int count = 0;
   while(!RemAr.IsCompleted){
      Console.Write("\rNot completed: " + (++count).ToString());
      // Make sure the callback thread can invoke callback.
      Thread.Sleep(1);
   }
    }
}

Server.cs

using System;
using System.Runtime.Remoting;

public class Server{

   public static void Main(){
      RemotingConfiguration.Configure("server.exe.config");
      Console.WriteLine("Waiting...");
      Console.ReadLine();
   }
}

ServiceClass.cs

using System;
using System.Runtime.Remoting;

public class ServiceClass : MarshalByRefObject{

   public ServiceClass() {
      Console.WriteLine("ServiceClass created.");
   }

   public string VoidCall(){
      Console.WriteLine("VoidCall called.");
      return "You are calling the void call on the ServiceClass.";
   }

   public int GetServiceCode(){
      return this.GetHashCode();
   }

   public string TimeConsumingRemoteCall(){
      Console.WriteLine("TimeConsumingRemoteCall called.");
   
      for(int i = 0; i < 20000; i++){
         Console.Write("Counting: " + i.ToString());
         Console.Write("\r");
      }
      return "This is a time-consuming call.";
   }
}

Server.exe.config

<configuration>
   <system.runtime.remoting>
      <application>
         <service>
            <wellknown 
               type="ServiceClass, ServiceClass"
               mode="Singleton"
               objectUri="ServiceClass.rem"
            />
         </service>
         <channels>
            <channel 
               ref="http" 
               port="8080"
            />
         </channels>
      </application>
   </system.runtime.remoting>
</configuration>

SyncAsync.exe.config

<configuration>
   <system.runtime.remoting>
      <application>
         <client>
            <wellknown 
               type="ServiceClass, ServiceClass"
               url="http://localhost:8080/ServiceClass.rem"
            />
         </client>
         <channels>
            <channel 
               ref="http" 
               port="0"
            />
         </channels>
      </application>
   </system.runtime.remoting>
</configuration>

See Also

Remoting Examples | Asynchronous Remoting

Show:
© 2014 Microsoft