.Net remoting, Webservice,WCF,Socket区别

传统上，我们把计算机后台程序（Daemon）提供的功能，称为"服务"（service）。比如，让一个杀毒软件在后台运行，它会自动监控系统，那么这种自动监控就是一个"服务"。

通俗地说，"服务"就是计算机可以提供的某一种功能。

  根据来源的不同，"服务"又可以分成两种：一种是"本地服务"（使用同一台机器提供的服务，不需要网络），另一种是"网络服务"（使用另一台计算机提供的服务，必须通过

网络才能完成）。"网络服务"（Web Service）的本质，就是通过网络调用其他网站的资源。举例来说，去年公开课的时候我在ArcGIS Engine中调用过一个天气预报的信息，并将信息和具体的位置关联起来。所以，Web service让你的网站可以使用其他网站的资源，比如在网页上显示天气、地图、twitter上的最新动态等等。

综上：WebService是两个计算机之间通讯（交谈）的技术。并且现在炒的很火的SOA、云计算在技术层面上都是WebService。

除了WebService 通讯外,系统间通讯有很多种技术，如像qq的这种Socket通讯在银行系统中广泛应用，.Net Remoting、DCom等通讯方式也应用很 多，

但是这些方式有如下缺点：

•        通讯数据格式不统一，同样一个"你好"这样的字符串在不同的协议中有不同的表示方法，异构系统集成很麻烦。一个系统一个模样。

•        采用Socket、 .Net Remoting、DCom需要打开很多端口，而企业网络安全的一个基本原则就是“尽可能少的打开端口”，很多企业网络甚至严格规定“只能打开80端口”，

因此需要一种“跨防火墙”的技术（跨防火墙就是走80端口进行通讯）

•        这些通讯方式的协议是不开放的，要想知道服务提供了哪些方法、如何调用，必须能够自描述

WSDL（Web Service Description Language）

你会怎样向别人介绍你的Web service有什么功能，以及每个函数调用时的参数呢？你可能会自己写一套文档，你甚至可能会口头上告诉需要使用你的Web service的人。

这些非正式的方法至少都有一个严重的问题：当程序员坐到电脑前，想要使用你的Web service的时候，他们的工具(如Visual Studio)无法给他们提供任何帮助，因为这些工具根本就不了解你的Web service。解决方法是：用机器能阅读的方式提供一个正式的描述文档。Web service描述语言(WSDL)就是这样一个基于XML的语言，用于描述Web service及其函数、参数和返回值。因为是基于XML的，所以WSDL既是机器可阅读的，又是人可阅读的，这将是一个很大的好处。一些最新的开发工具既能根据你的Web service生成WSDL文档，又能导入WSDL文档，生成调用相应Web service的代码

Web服务器描述语言是用XML文档来描述Web服务的标准，是Web服务的接口定义语言，由Ariba、Intel、IBM、MS等共同提出，通过WSDL，可描述Web服务的三个基本属性：

·服务做些什么——服务所提供的操作（方法）

·如何访问服务——和服务交互的数据格式以及必要协议

·服务位于何处——协议相关的地址，如URL

XML和XSD 
可扩展的标记语言(XML)是Web service平台中表示数据的基本格式。除了易于建立和易于分析外，XML主要的优点在于它既是平台无关的，又是厂商无关的。无关性是比技术优越性更重要的：软件厂商是不会选择一个由竞争对手所发明的技术的。 
XML解决了数据表示的问题，但它没有定义一套标准的数据类型，更没有说怎么去扩展这套数据类型。例如，整形数到底代表什么？16位，32位，还是64位？这些细节对实现互操作性都是很重要的。W3C制定的XML Schema(XSD)就是专门解决这个问题的一套标准。它定义了一套标准的数据类型，并给出了一种语言来扩展这套数据类型。Web service平台就是用XSD来作为其数据类型系统的。当你用某种语言(如VB.NET或C#)来构造一个Web service时，为了符合Web service标准，所有你使用的数据类型都必须被转换为XSD类型。你用的工具可能已经自动帮你完成了这个转换，但你很可能会根据你的需要修改一下转换过程。在第二章中，我们将深入XSD，学习怎样转换自定义的数据类型(例如类)到XSD的类型。

SOAP 
Web service建好以后，你或者其他人就会去调用它。简单对象访问协议(SOAP)提供了标准的RPC方法来调用Web service。实际上，SOAP在这里有点用词不当：它意味着下面的Web service是以对象的方式表示的，但事实并不一定如此：你完全可以把你的Web service写成一系列的C函数，并仍然使用SOAP进行调用。SOAP规范定义了SOAP消息的格式，以及怎样通过HTTP协议来使用SOAP。SOAP也是基于XML和XSD的，XML是SOAP的数据编码方式。第三章我们会讨论SOAP，并结识SOAP消息的各种元素。

综上我们还可以得出以下结论：

请求、返回的XML数据格式（有哪些节点、节点的名字等等）WebService 用SOAP协议进行规定，方法描述信息XML用WSDL协议规定。WebService技术是与语言、平台无关，因此.net可以访问java编写的WebService、java也可以访问.net编写的webservice，php、python等各种语言也几乎都支持webservice，因此可以说webservice可以实现跨语言方法调用。

但是如果自己构建请求、返回xml，解析xml请求，自己负责方法描述信息更新是很麻烦的，.net就提供了简化开发WebService。

WebService的创建和使用

WebService的使用过程包括服务器端代码的编写和客户端代码的调用，服务器端的代码比较容易，只是在使用的时候需要添加一些[WebService]和[WebMethod]这样的标记

1、  服务器端（ServerWeb）：就想写普通方法一样，不需要处理请求、响应。服务器端新建“Web服务”（asmx），在远端可以调用的方法上标注[WebMethod]。

using System;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml.Linq;
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
// 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消对下行的注释。
// [System.Web.Script.Services.ScriptService]
public class Service : System.Web.Services.WebService
{
    public Service () {
        //如果使用设计的组件，请取消注释以下行
        //InitializeComponent();
    }
    //[WebMethod]
    //public string HelloWorld()
    //{
    //    return "Hello World";
    //}
    [WebMethod(Description = "求和的方法")]
    public double addition(double i, double j)
    {
        return i + j;
    }
    [WebMethod(Description = "求差的方法")]
    public double subtract(double i, double j)
    {
        return i - j;
    }
    [WebMethod(Description = "求积的方法")]
    public double multiplication(double i, double j)
    {
        return i * j;
    }
    [WebMethod(Description = "求商的方法")]
    public double division(double i, double j)
    {
        if (j != )
            return i / j;
        else
            return ;
    }
}  

2、客户端添加对asmx的“服务器引用”，然后就可以调用***SoapClient类中的方法。就“好像”直接调用了服务端的方法（因为VS2010中有两种添加服务的方法，一种是早期的针对net2.0的，如果是2.0的话，会生成一个跟服务端同类名的类）。

添加服务引用的时候工具读取asmx的WSDL自动生成了ServiceReference1中的类，这些类帮我们来拼Http请求，并且把Http返回值拆成函数的返回。

客户端“添加服务引用”，填写asmx的地址。然后就可以调用Service References下自动生成的***SoapClient类了。

用WebService的时候如果服务端的接口定义发生变化，则需要重新添加对服务端的引用，因为Service References中的类是工具读取WSDL定义自动生成的。在服务引用上点击右键，选择“更新服务引用”。如果只是修改了WebService内部实现，而接口没变，则不需要“更新服务引用”，因为WSDL没变，Soap没变。

 static void Main(string[] args)
        {
            ServiceTest.ServiceSoapClient stsoap = new ServiceTest.ServiceSoapClient();

           double c= stsoap.addition(, );
           Console.WriteLine(c.ToString());

            // vs 2010中两种方式
            ServiceTest.Service st = new ServiceTest.Service();

            double a = st.addition(, );

            Console.WriteLine(a.ToString());

            Console.ReadKey();
        }

.Net remoting

Net remoting 是简化网络通讯的技术，底层仍然是TCP等东西。

remoting要添加对System.Runtime.Remoting的引用

编写服务接口类库项目，正常写法！WebService中WSDL相当于对服务端方法的描述；.net Remoting中走的是二进制数据，因此必须一个描述服务端方法的接口类库。这个类库里面往往是一个接口，定义了服务器端实现方法的方法名，客户端和服务器端都需要引进用这个接口。

服务端实现服务接口，继承自MarshalByRefObject，然后运行备注中的代码注册服务。

客户端代码在备注中

Remoting和WebService的区别：Remoting效率高，走的是普通TCP， WebService则是Http协议，需要IIS、ASP.Net、XML解析等，效率低。Remoting适合于内网通讯， WebService适合于外网通讯。

除非项目要求，否则以后尽量用WCF。.Net Remoting是微软私有协议，因此如果要跨平台调用还是普通Socket或者WebService。

用法说明:

1、新建接口项目，定义服务接口。

注意：remoting要添加对System.Runtime.Remoting的引用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NETRemotiongInterface
{
    public interface IRemotingTest
    {
        double add(double a,double b);
    }
}

2、新建服务器端项目（控制台的，或者WinForm，或者Windows服务等）

定义实现服务接口的类，还要继承继承自MarshalByRefObject类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NETRemotiongInterface;

namespace RemotingServer
{
    class TestServiceImp : MarshalByRefObject,IRemotingTest

{ #region IRemotingTest 成员 public double add(double a, double b) { return a + b; } #endregion } }

3，服务器启动时调用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;

namespace RemotingServer
{
    class Program
    {
        static void Main(string[] args)
        {

             TcpChannel tcpChannel = new TcpChannel();

            ChannelServices.RegisterChannel(tcpChannel);

            //注册服务：第一个参数为服务的实现类，第二个参数为服务的名字。

            RemotingConfiguration.RegisterWellKnownServiceType(typeof(TestServiceImp),

                "test", WellKnownObjectMode.Singleton);

   //注册服务。如果控制台程序，控制不要让程序退出，

            //主要目的是不要让服务器退出

            while (true)

            {

                string s = Console.ReadLine();

                if (s == "quit")

                {

                    return;

                }

            }
        }
    }
}

 

,4、客户端：新建客户端项目，引用服务接口

namespace RemotingClient
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpChannel tcpChannel = new TcpChannel();

            ChannelServices.RegisterChannel(tcpChannel, false);

            IRemotingTest test =
                (IRemotingTest)Activator.GetObject(typeof(IRemotingTest), "tcp://127.0.0.1:9999/test");//第一个参数为服务实现的接口，第二个参数为服务的地址：最后一部分是服务在服务器端RegisterWellKnownServiceType时第二个参数的名字然后就可以调用服务端方法了。
            double a = test.add(, );
            Console.WriteLine(a.ToString());
            Console.ReadKey();

        }
    }
}

从WebService和NetRemoting来看客户端都要知道服务器端暴露的功能，这个是必须的，要不然客户端怎么调用，WS是通过一个地址，而NetRemoting是通过一个接口类库，当然这也只是表面现象。

   WCF

WCF（Windows Communication foundation）是微软的统一网络通讯开发的技术，无论底层用.Net Remoting还是WebService还是Restful还是MSMQ等，只要修改配置文件即可。所以WCF并不是新技术。

WCF和.Net Remoting、WebService等技术的关系就像ADO.Net和SQLServer、Oracle驱动的关系一样。通过VS的“WCF服务配置编辑器”简化配置，修改不同的协议。

一开始内网运行就行，后来想运行到公网，那么如果一开始用.net remoting写后来改成WebService还是有工作量的，因为写法不一样，但是用WCF就不一样了。

新建“WCF服务库”，WCF服务库可以Host在IIS上、单独的WinForm程序等。

WCF、.Net Remoting和WebService的关系： .Net Remoting是普通的TCP通讯，适合于局域网，效率高； WebService是基于Http协议，适合于广域网，效率低；WCF是对.Net Remoting、 WebService等的简化、统一，可以通过配置来切换不同的底层实现，代码几乎不用动。

关于WCF的例子，我也懒得写了，给出一篇博文，大家可以自行研究：http://www.cnblogs.com/oec2003/archive/2010/07/15/1778013.html

Socket的例子我们可能见得比较多，这里就不罗嗦了，啰嗦了，直接上代码：

服务器端

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class SynchronousSocketClient {

    public static void StartClient() {
        // Data buffer for incoming data.
        byte[] bytes = new byte[];

        // Connect to a remote device.
        try {
            // Establish the remote endpoint for the socket.
            // This example uses port 11000 on the local computer.
            IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName())
            IPAddress ipAddress = ipHostInfo.AddressList[];
            IPEndPoint remoteEP = new IPEndPoint(ipAddress,);

            // Create a TCP/IP  socket.
            Socket sender = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp );

            // Connect the socket to the remote endpoint. Catch any errors.
            try {
                sender.Connect(remoteEP);

                Console.WriteLine("Socket connected to {0}",
                    sender.RemoteEndPoint.ToString());

                // Encode the data string into a byte array.
                byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");

                // Send the data through the socket.
                int bytesSent = sender.Send(msg);

                // Receive the response from the remote device.
                int bytesRec = sender.Receive(bytes);
                Console.WriteLine("Echoed test = {0}",
                    Encoding.ASCII.GetString(bytes,,bytesRec));

                // Release the socket.
                sender.Shutdown(SocketShutdown.Both);
                sender.Close();

            } catch (ArgumentNullException ane) {
                Console.WriteLine("ArgumentNullException : {0}",ane.ToString());
            } catch (SocketException se) {
                Console.WriteLine("SocketException : {0}",se.ToString());
            } catch (Exception e) {
                Console.WriteLine("Unexpected exception : {0}", e.ToString());
            }

        } catch (Exception e) {
            Console.WriteLine( e.ToString());
        }
    }

    public static int Main(String[] args) {
        StartClient();
        return ;
    }
}

客户端

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class SynchronousSocketListener {

    // Incoming data from the client.
    public static string data = null;

    public static void StartListening() {
        // Data buffer for incoming data.
        byte[] bytes = new Byte[];

        // Establish the local endpoint for the socket.
        // Dns.GetHostName returns the name of the
        // host running the application.
        IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[];
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, );

        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp );

        // Bind the socket to the local endpoint and
        // listen for incoming connections.
        try {
            listener.Bind(localEndPoint);
            listener.Listen();

            // Start listening for connections.
            while (true) {
                Console.WriteLine("Waiting for a connection");
                // Program is suspended while waiting for an incoming connection.
                Socket handler = listener.Accept();
                data = null;

                // An incoming connection needs to be processed.
                while (true) {
                    bytes = new byte[];
                    int bytesRec = handler.Receive(bytes);
                    data += Encoding.ASCII.GetString(bytes,,bytesRec);
                    if (data.IndexOf("<EOF>") > -) {
                        break;
                    }
                }

                // Show the data on the console.
                Console.WriteLine( "Text received : {0}", data);

                // Echo the data back to the client.
                byte[] msg = Encoding.ASCII.GetBytes(data);

                handler.Send(msg);
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }

        } catch (Exception e) {
            Console.WriteLine(e.ToString());
        }

        Console.WriteLine("\nPress ENTER to continue");
        Console.Read();

    }

    public static int Main(String[] args) {
        StartListening();
        return ;
    }
}

来点这四个的总结的话。

1：socket VS remoting

使用socket无疑是效率最高的。但是，在复杂的接口环境下，socket的开发效率也是最低的。故在兼顾开发效率的情况下，可以使用remoting来代替socket开发。并且：
    1、Tcp通道的Remoting速度非常快。
    你可以通过端口查看工具，发现remoting比直接socket传输的内容，应该是属于同一个数量级的。我的另一个担心是，大客户端数量的情况下，remoting传输效率会不会很低，结果经过现场测试，同时对300个客户端进行数据通信，不存在信息丢失情况。
    2、虽然是远程的，但是非常接近于本地调用对象。
    也就是完全符合面向对象思想。
    3、可以做到保持对象的状态
    直接使用socket传输机制，我们必须花大量的精力来处理异常、断网、死机等现象，使用remoting，这些工作会大大简化。

2：remoting vs webservice 
    1、webservice在framework2.0状态下只能寄宿于IIS等应用服务器中。微软直到3.0才提供了servicehost来寄宿 webservice，这就极大地限制了webservice在使用中的灵活性。在framework2.0环境下，如果你有一个应用要脱离IIS而存 在，就不得不抛弃webservice。（除非你想代码实现一个WEB应用服务器）
    2、remoting可寄宿在你自己的代码中，也可寄宿在windows服务及IIS中。最大程度的提供了开发和部署的灵活性。
    3、remoting在使用http通道的时候，也如webservice一样支持穿透路由。
    4、remoting与websercie相比，提供双向通信。哪怕是将remoting寄宿在IIS中，也支持。
    5、webservice客户端自动生成的代理类比较复杂。而remoting一般来说，都是手动编写客户端代码。
    6、当然，webservice最主要优势是，它是一个行业标准，而remoting只是微软自己内部的标准，如果你的应用要脱离微软的平台，就只能使用webservice了。

7，NetRemoting的优点是用户既可以使用TCP信道方式进行二进制流方式通信，也可以使用HTTP信道进行SOAP格式的性通信，而WebService只能使用HTTP通道

8, NetRemotiong效率相对WebService要高不少；

    9, Netremoting可以用于有状态的情况，而WebService只能使用无状态的情况。

3：remoting vs wcf
    与wcf的比较，更多的是从平台的普及度上来说。在当前环境下，2.0的普及度还是最高的。如果哪一天3.0甚至4.0普及了，当然WCF是最好的。

参考：http://evencode.iteye.com/blog/1453046

http://www.cnblogs.com/oec2003/archive/2010/07/15/1778013.html

http://blog.csdn.net/zhoufoxcn/article/details/1649776

http://blog.csdn.net/huangxinfeng/article/details/4967629