Remotingbeispiel: Asynchrones Remoting
Dieses Thema bezieht sich auf eine veraltete Technologie, die zum Zwecke der Abwärtskompatibilität mit vorhandenen Anwendungen beibehalten wird und nicht für die neue Entwicklung empfohlen wird. Verteilte Anwendungen sollten jetzt mit Windows Communication Foundation (WCF) entwickelt werden.
Die folgende Beispielanwendung veranschaulicht die asynchrone Programmierung in einem Remoteszenario. Im Beispiel wird zuerst ein synchroner Delegat für ein Remoteobjekt erstellt, der anschließend aufgerufen wird, um den Thread zu demonstrieren, der auf die Rückgabe wartet. Anschließend werden ein asynchroner Delegat und ein ManualResetEvent-Objekt verwendet, um eine Remotemethode aufzurufen und auf die Antwort zu warten.
Diese Anwendung wird auf einem einzelnen Computer oder über ein Netzwerk ausgeführt. Wenn Sie diese Anwendung über ein Netzwerk ausführen möchten, müssen Sie "localhost" in der Clientkonfiguration durch den Namen des Remotecomputers ersetzen.
.gif "0sa925ka.Caution(de-de,VS.100).gif") Vorsicht: |
|---|
| .NET Framework-Remoting führt standardmäßig keine Authentifizierung oder Verschlüsselung durch. Daher empfiehlt es sich, vor der Remoteinteraktion mit Clients und Servern alle erforderlichen Schritte zu unternehmen, um die Identität der Clients oder Server sicherzustellen. Da .NET Framework-Remoteanwendungen FullTrust-Berechtigungen zur Ausführung benötigen, könnte ein nicht autorisierter Client Code so ausführen, als ob er voll vertrauenswürdig wäre, wenn dem Client Zugriff auf Ihren Server gewährt würde. Authentifizieren Sie Ihre Endpunkte, und verschlüsseln Sie die Kommunikationsstreams unbedingt, indem Sie Ihre Remotetypen in Internetinformationsdiensten (IIS) hosten oder ein benutzerdefiniertes Channelsenkenpaar erstellen, das diese Aufgabe übernimmt. |
So kompilieren Sie dieses Beispiel
Geben Sie an der Eingabeaufforderung folgende Befehle ein:
vbc /t:library ServiceClass.vb vbc /r:ServiceClass.dll Server.vb vbc /r:ServiceClass.dll Client.vbcsc /t:library ServiceClass.cs csc /r:ServiceClass.dll Server.cs csc /r:ServiceClass.dll Client.csÖffnen Sie zwei Eingabeaufforderungen, die auf das gleiche Verzeichnis zeigen. Geben Sie an der einen server ein. Geben Sie an der anderen client ein.
ServiceClass
Imports System
Imports System.Runtime.Remoting
Public Class ServiceClass
Inherits MarshalByRefObject
Public Sub New()
Console.WriteLine("ServiceClass created.")
End Sub
Public Function VoidCall() As String
Console.WriteLine("VoidCall called.")
Return "You are calling the void call on the ServiceClass."
End Function
Public Function GetServiceCode() As Integer
Return Me.GetHashCode()
End Function
Public Function TimeConsumingRemoteCall() As String
Console.WriteLine("TimeConsumingRemoteCall called.")
For i As Integer = 0 To 20000
Console.Write("Counting: " & i.ToString() & vbCr)
Next
Return "This is a time-consuming call."
End Function
End Class
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
Imports System
Imports System.Runtime.Remoting
Public Class Server
Public Shared Sub Main()
RemotingConfiguration.Configure("server.exe.config", False)
Console.WriteLine("Waiting...")
Console.ReadLine()
End Sub
End Class
using System;
using System.Runtime.Remoting;
public class Server
{
public static void Main(string[] args)
{
RemotingConfiguration.Configure("server.exe.config", false);
Console.WriteLine("Waiting...");
Console.ReadLine();
}
}
Server.exe.config
<?xml version="1.0" encoding="utf-8" ?>
<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>
Client
Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Messaging
Imports System.Threading
Public Class Client
Inherits MarshalByRefObject
Public Shared e As ManualResetEvent
' Declares two delegates, each of which represents
' a function that returns 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.)
Public Delegate Function RemoteSyncDelegate() As String
Public Delegate Function RemoteAsyncDelegate() As String
' This is the call that the AsyncCallback delegate references
<OneWay()> _
Public Sub OurRemoteAsyncCallback(ByVal ar As IAsyncResult)
Dim del As RemoteAsyncDelegate = CType(ar, AsyncResult).AsyncDelegate
Console.WriteLine(vbLf & "**SUCCESS**: Result of the remote AsyncCallBack: " + del.EndInvoke(ar))
' Signal the thread.
e.Set()
Return
End Sub
Public Shared Sub Main()
'IMPORTANT: .NET Framework remoting does not remote
'static members. This class must be an instance before
'the callback from the asynchronous invocation can reach this client.
Dim clientApp As Client = New Client()
clientApp.Run()
End Sub
Public Sub 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("Client.exe.config", False)
' The remaining steps are identical to single-
' AppDomain programming.
Dim obj As ServiceClass = New ServiceClass()
' This delegate is a remote synchronous delegate.
Dim Remotesyncdel As RemoteSyncDelegate = New RemoteSyncDelegate(AddressOf obj.VoidCall)
' When invoked, program execution waits until the method returns.
' This delegate can 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.
Dim RemoteCallback As AsyncCallback = New AsyncCallback(AddressOf OurRemoteAsyncCallback)
' Create the delegate to the remote method you want to use
' asynchronously.
Dim RemoteDel As RemoteAsyncDelegate = New RemoteAsyncDelegate(AddressOf obj.TimeConsumingRemoteCall)
' Start the method call. 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 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.
Dim count As Integer = 0
While Not RemAr.IsCompleted
Console.Write("Not completed: " & count & vbCr)
count = count + 1
' Make sure the callback thread can invoke callback.
Thread.Sleep(1)
End While
End Sub
End Class
using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Messaging;
using System.Threading;
using Shared;
public class Client : MarshalByRefObject
{
public static ManualResetEvent e;
// Declares two delegates, each of which represents
// a function that returns 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.
public delegate string RemoteSyncDelegate();
public delegate string RemoteAsyncDelegate();
// This is the call that the AsyncCallBack delegate references.
[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 Framework remoting does not remote
// static members. This class must be an instance before
// the callback from the asynchronous invocation can reach this client.
Client clientApp = new Client();
clientApp.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("Client.exe.config", false);
// 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 can 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);
}
}
}
Client.exe.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<client>
<wellknown
type="ServiceClass, ServiceClass"
url="https://localhost:8080/ServiceClass.rem"
/>
</client>
<channels>
<channel
ref="http"
port="0"
/>
</channels>
</application>
</system.runtime.remoting>
</configuration>