.net remoting 接口 异步调用 回调 tcp 编码配置

参考了<<.net 分布式编程——C# 篇>>
和微软的WebCast，还有其它资料。

只要把远程对象的接口给客户端，不必把远程对象的实现给客户端。
远程对象的实现放在服务器端。

服务器端规定了回调函数的接口，客户端可以实现这个接口，
在异步调用远程对象结束后，调用回调函数，而不是在客户端线程调用回调函数。

=================================================================================

我们先来写一个接口，将这个接口编译成 ClientCallbackInterface.dll

namespace ClientCallbackInterface
{
public interface IClientCallback
{
int ResultCallback(int result);
}
}

服务器端远程对象将使用这个接口来执行回调函数。

=================================================================================

下面写一个类，实现上面的接口，编译成 ClientCallbackLibrary.dll
[先添加对ClientCallbackInterface.dll的引用]

using System.Threading;
using ClientCallbackInterface;
namespace ClientCallbackLibrary
{
[Serializable]//因为这个类要传到远程对象，所以要能序列化的。
public class ClientCallbackSink : MarshalByRefObject, IClientCallback
{
public int ResultCallback(int result)
{
Console.WriteLine("--->>>ResultCallback executing on thread {0}",
Thread.CurrentThread.GetHashCode());
Console.WriteLine("Add result is {0}", result);
Thread.Sleep(3000);//模拟复杂运算
return result * result;//返回一个平方
}
}
}

这个ClientCallbackLibrary.dll只在客户端添加
而服务器端只添加对ClientCallbackInterface.dll的引用

=================================================================================

下面我们来写远程对象的接口，然后编译成: CustomerInterface.dll
先添加对ClientCallbackInterface.dll的引用

using ClientCallbackInterface;
namespace CustomerInterface
{
public interface ICustomerService
{
//int Test();
//ICustomer CreateCustomer(string name);
int Add(int a, int b);
void AsyncAdd(int n1, int n2, IClientCallback callback);
}
}

=================================================================================

现在开始写远程对象了。编译成CustomerLibrary.dll
引用：ClientCallbackInterface.dll 和 CustomerInterface.dll

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Runtime.Remoting.Messaging;
using System.IO;
using CustomerLibrary;
using System.Runtime.Remoting;
using ClientCallbackInterface;
using CustomerInterface;
namespace CustomerLibrary
{
public class CustomerService : MarshalByRefObject, ICustomerService
{
delegate int BinaryOperatorDelegate(int n1, int n2);

public int Add(int a, int b)
{
Console.WriteLine("CustomerService.Add() = " + (a + b));
Thread.Sleep(3000);
return a + b;
}

public void AsyncAdd(int n1, int n2, IClientCallback callback)
{
Console.WriteLine("CustomerLibrary.AsyncAdd() executing on thread {0}",
Thread.CurrentThread.GetHashCode());

BinaryOperatorDelegate binOp;
binOp = new BinaryOperatorDelegate(Add);
binOp.BeginInvoke(n1, n2, new AsyncCallback(DoClientCallback), callback);
}

private void DoClientCallback(IAsyncResult ar)
{
Console.WriteLine("DoClientCallback executing on thread {0}",
Thread.CurrentThread.GetHashCode());

AsyncResult asyncResult = (AsyncResult)ar;

BinaryOperatorDelegate binOp;
binOp = (BinaryOperatorDelegate)asyncResult.AsyncDelegate;

int result = binOp.EndInvoke(ar);

IClientCallback callback = ar.AsyncState as IClientCallback;

if (callback != null)
{
try
{
int tmp = callback.ResultCallback(result);
}
catch (RemotingException e)
{
Console.WriteLine(e.ToString());
}
catch (IOException e)
{
Console.WriteLine(e.ToString());
}
finally
{
}
}
}

public override object InitializeLifetimeService()
{
return null;
}
}
}

=================================================================================

下面写服务器端，引用了ClientCallbackInterface.dll
CustomerInterface.dll
CustomerLibrary.dll
System.Runtime.Remoting.dll

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
using CustomerLibrary;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Serialization.Formatters;
using System.Collections;

namespace CustomerServer
{
class CustomerServerMain
{
static void Main(string[] args)
{
Console.WriteLine("Customer Server initializing...");

BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary tcpProps = new Hashtable();
tcpProps["port"] = 13101;
tcpProps["name"] = "server";
TcpChannel channel = new TcpChannel(tcpProps, clientProvider, serverProvider);
ChannelServices.RegisterChannel(channel, true);
ObjRef serverObjRef = RemotingServices.Marshal(new CustomerService(), "ServerObject");//这样就发布了远程对象，是Singleton模式的

Console.WriteLine("Application: " + RemotingConfiguration.ApplicationName);

Console.WriteLine("Waiting for clients. Press 'q' to quit");
string input;
do//服务器端需要一直执行。
{
input = Console.ReadLine();
} while (input != "q");

UnregistrationChannel("server");
}

static private void UnregistrationChannel(string channelName)
{
//获得当前已注册的通道；
IChannel[] channels = ChannelServices.RegisteredChannels;
//关闭指定名为channelName的通道；
foreach (IChannel channel in channels)
{
if (channel.ChannelName == channelName)
{
TcpChannel tcpChannel = (TcpChannel)channel;
//关闭监听
tcpChannel.StopListening(null);
//注销通道
ChannelServices.UnregisterChannel(tcpChannel);
}
}
}
}
}

=================================================================================

最后是客户端了：引用：ClientCallbackInterface.dll
ClientCallbackLibrary.dll
CustomerInterface.dll
System.Runtime.Remoting.dll

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Threading;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Remoting.Channels;
using System.Runtime.Serialization;
using CustomerInterface;
using ClientCallbackLibrary;
using System.Runtime.Serialization.Formatters;
using System.Collections;

namespace CustomerClient
{
class CustomerClientMain
{
delegate int BinaryOperatorDelegate(int n1, int n2);

static void Main(string[] args)
{
Console.WriteLine("Main executing on thread {0}",
Thread.CurrentThread.GetHashCode());

BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = 0;
props["name"] = "client";
TcpChannel chan = new TcpChannel(props, clientProvider, serverProvider);
ChannelServices.RegisterChannel(chan, true);

ICustomerService custSvc = Activator.GetObject(
typeof(CustomerInterface.ICustomerService),
"tcp://localhost:13101/ServerObject"
) as ICustomerService;

ClientCallbackSink callback = new ClientCallbackSink();
try
{
custSvc.AsyncAdd(15, 2, callback);
}
catch (SerializationException e)
{
Console.WriteLine(e.ToString());
}
finally
{
UnregistrationChannel("client");
}
Console.ReadLine();//服务器端没有异常处理，这里要停留一下。不然在服务器端会出现异常。因为回调函数还没有结束。连接暂时不能断开。
UnregistrationChannel("client");
}

static private void UnregistrationChannel(string channelName)
{
//获得当前已注册的通道；
IChannel[] channels = ChannelServices.RegisteredChannels;
//关闭指定名为channelName的通道；
foreach (IChannel channel in channels)
{
if (channel.ChannelName == channelName)
{
TcpChannel tcpChannel = (TcpChannel)channel;
//关闭监听
tcpChannel.StopListening(null);
//注销通道
ChannelServices.UnregisterChannel(tcpChannel);
}
}
}
}
}

最后，我们先运行服务器，再运行客户端就可以测试了。

服务器端运行：

Customer Server initializing...
Application:
Waiting for clients. Press 'q' to quit
CustomerLibrary.AsyncAdd() executing on thread 4
CustomerService.Add() = 17
DoClientCallback executing on thread 5

客户端运行：

Main executing on thread 1
--->>>ResultCallback executing on thread 5
Add result is 17