The Internet Communications Engine (Ice) 跨平台异构通讯方案 第二弹-Hello world！

 　　如果不知道ICE是什么的同学，请看上一篇的ICE简介：http://www.cnblogs.com/winds/p/3864677.html

 　　好了，HelloWorld，从中间语言讲起。

　　首先，我们新建一个控制台项目，添加一个txt文件，在其中写上中间语言代码：

#ifndef HELLO_ICE

#define HELLO_ICE



module Demo

{



interface Hello

{

    void sayHello(int delay);

    void shutdown();

};



};



#endif

这是一段很简单的代码，其中

#ifndef HELLO_ICE

#define HELLO_ICE



#endif

这是ICE的一个的规范而已，必须要加，否则接下来的编译器会通不过。这个语法和.Net的条件编译不一样，更多的像C中的代码风格。

module Demo

{

}

对应的是.net中的命名空间

interface Hello

{

    void sayHello(int delay);

    void shutdown();

};

这个是一个简单的接口。简单的介绍完后，接下来的我们把txt后缀改为.ice后缀。

接下来，右键项目：

 

将EnableBuilder勾上，接下来ICE会自动帮我们生成Hello.cs文件：

好了，这个Hello.cs文件有我们定义好的被编译为C#的接口，接下里我们开始让服务端实现接口：

public class HelloI : HelloDisp_

{

    public override void sayHello(int delay, Ice.Current current)

    {

        if(delay > 0)

        {

            System.Threading.Thread.Sleep(delay);

        }

        System.Console.Out.WriteLine("Hello World!");

    }

    

    public override void shutdown(Ice.Current current)

    {

        System.Console.Out.WriteLine("Shutting down...");

        current.adapter.getCommunicator().shutdown();

    }

}

 

其中HelloDisp_为Hello.cs文件中被编译为C#了的一个抽象类，我们实现接口，接下来，我们了解一下ICE的基本配置（好吧，又是配置），不过这个配置比起WCF简单多了：

Hello.Endpoints=tcp -p 10000:udp -p 10000

当然我们要新建一个配置文件，名字可以随便取。这里我取的名字为：config.server 放在项目的根目录下：

 

接下来，写服务端：

public class Server

{

    class App : Ice.Application

    {

        public override int run(string[] args)

        {

            if(args.Length > 0)

            {

                System.Console.Error.WriteLine(appName() + ": too many arguments");

                return 1;

            }



            Ice.ObjectAdapter adapter = communicator().createObjectAdapter("Hello");

            adapter.add(new HelloI(), communicator().stringToIdentity("hello"));

            adapter.activate();

            communicator().waitForShutdown();

            return 0;

        }

    }



    public static int Main(string[] args)

    {

        App app = new App();

        app.main(args, "config.server");return 1;

    }

}

OK了，服务端写完了，接下来写客户端：

public class Client

{

    public class App : Ice.Application

    {

        private static void menu()

        {

            Console.Write(

                "usage:\n" +

                "t: send greeting as twoway\n" +

                "o: send greeting as oneway\n" +

                "O: send greeting as batch oneway\n" +

                "d: send greeting as datagram\n" +

                "D: send greeting as batch datagram\n" +

                "f: flush all batch requests\n" +

                "T: set a timeout\n" +

                "P: set a server delay");

            if(_haveSSL)

            {

                Console.Write("\nS: switch secure mode on/off");

            }

            Console.WriteLine(

                "\ns: shutdown server\n" +

                "x: exit\n" +

                "?: help\n");

        }



        public override int run(string[] args)

        {

            if(args.Length > 0)

            {

                Console.Error.WriteLine(appName() + ": too many arguments");

                return 1;

            }



            try

            {

                communicator().getPluginManager().getPlugin("IceSSL");

                _haveSSL = true;

            }

            catch(Ice.NotRegisteredException)

            {

            }



            HelloPrx twoway = HelloPrxHelper.checkedCast(

                communicator().propertyToProxy("Hello.Proxy").ice_twoway().ice_timeout(-1).ice_secure(false));

            if(twoway == null)

            {

                Console.Error.WriteLine("invalid proxy");

                return 1;

            }

            HelloPrx oneway = (HelloPrx)twoway.ice_oneway();

            HelloPrx batchOneway = (HelloPrx)twoway.ice_batchOneway();

            HelloPrx datagram = (HelloPrx)twoway.ice_datagram();

            HelloPrx batchDatagram =(HelloPrx)twoway.ice_batchDatagram();



            bool secure = false;

            int timeout = -1;

            int delay = 0;



            menu();



            string line = null;

            do 

            {

                try

                {

                    Console.Out.Write("==> ");

                    Console.Out.Flush();

                    line = Console.In.ReadLine();

                    if(line == null)

                    {

                        break;

                    }

                    if(line.Equals("t"))

                    {

                        twoway.sayHello(delay);

                    }

                    else if(line.Equals("o"))

                    {

                        oneway.sayHello(delay);

                    }

                    else if(line.Equals("O"))

                    {

                        batchOneway.sayHello(delay);

                    }

                    else if(line.Equals("d"))

                    {

                        if(secure)

                        {

                            Console.WriteLine("secure datagrams are not supported");

                        }

                        else

                        {

                            datagram.sayHello(delay);

                        }

                    }

                    else if(line.Equals("D"))

                    {

                        if(secure)

                        {

                            Console.WriteLine("secure datagrams are not supported");

                        }

                        else

                        {

                            batchDatagram.sayHello(delay);

                        }

                    }

                    else if(line.Equals("f"))

                    {

                        communicator().flushBatchRequests();

                    }

                    else if(line.Equals("T"))

                    {

                        if(timeout == -1)

                        {

                            timeout = 2000;

                        }

                        else

                        {

                            timeout = -1;

                        }

                        

                        twoway = (HelloPrx)twoway.ice_timeout(timeout);

                        oneway = (HelloPrx)oneway.ice_timeout(timeout);

                        batchOneway = (HelloPrx)batchOneway.ice_timeout(timeout);

                        

                        if(timeout == -1)

                        {

                            Console.WriteLine("timeout is now switched off");

                        }

                        else

                        {

                            Console.WriteLine("timeout is now set to 2000ms");

                        }

                    }

                    else if(line.Equals("P"))

                    {

                        if(delay == 0)

                        {

                            delay = 2500;

                        }

                        else

                        {

                            delay = 0;

                        }

                        

                        if(delay == 0)

                        {

                            Console.WriteLine("server delay is now deactivated");

                        }

                        else

                        {

                            Console.WriteLine("server delay is now set to 2500ms");

                        }

                    }

                    else if(_haveSSL && line.Equals("S"))

                    {

                        secure = !secure;



                        twoway = (HelloPrx)twoway.ice_secure(secure);

                        oneway = (HelloPrx)oneway.ice_secure(secure);

                        batchOneway = (HelloPrx)batchOneway.ice_secure(secure);

                        datagram = (HelloPrx)datagram.ice_secure(secure);

                        batchDatagram = (HelloPrx)batchDatagram.ice_secure(secure);



                        if(secure)

                        {

                            Console.WriteLine("secure mode is now on");

                        }

                        else

                        {

                            Console.WriteLine("secure mode is now off");

                        }

                    }

                    else if(line.Equals("s"))

                    {

                        twoway.shutdown();

                    }

                    else if(line.Equals("x"))

                    {

                        // Nothing to do

                    }

                    else if(line.Equals("?"))

                    {

                        menu();

                    }

                    else

                    {

                        Console.WriteLine("unknown command `" + line + "'");

                        menu();

                    }

                }

                catch(System.Exception ex)

                {

                    Console.Error.WriteLine(ex);

                }

            }

            while (!line.Equals("x"));

            

            return 0;

        }



        private static bool _haveSSL = false;

    }



    public static int Main(string[] args)

    {

        App app = new App();

        return app.main(args, "config.client");

    }

}

从这个客户端明眼人应该能看出不少东西，以后再依此介绍。当然客户端文件配置：

Hello.Proxy=hello:tcp -p 10000:udp -p 10000

Ice.Default.Host=192.168.1.103

好了，启动服务端和运行客户端，效果如下：

 

Hello world完成。源码奉上：http://files.cnblogs.com/winds/hello.zip