This page shows how to create an Ice application with C#.
On this page:
We create two projects, one for the Server application and one for the Client application. These are regular Console projects with very little Ice-specific additions.
|
The next step is to add the Slice file (Printer.ice
) created earlier to each project, and then compile this Slice file.
800px
|
To implement our Printer
interface, we must create a servant class. By convention, a servant class uses the name of its interface with an I
-suffix, so our servant class is called PrinterI
and we will place it into the default C# source file Program.cs:
using System; namespace Server { public class PrinterI : Demo.PrinterDisp_ { public override void printString(string s, Ice.Current current) { Console.WriteLine(s); } } class Program { static void Main(string[] args) { } } } |
The PrinterI
class inherits from a base class called PrinterDisp_
, which is generated by the slice2cs
compiler. The base class is abstract and contains a printString
method that accepts a string for the printer to print and a parameter of type Ice.Current
. (For now we will ignore the Ice.Current
parameter.) Our implementation of the printString
method simply writes its argument to the terminal.
The remainder of the server code follows in Program.cs
and is shown in full here:
using System; namespace Server { public class PrinterI : Demo.PrinterDisp_ { public override void printString(string s, Ice.Current current) { Console.WriteLine(s); } } public class Program { public static int Main(string[] args) { try { using(Ice.Communicator communicator = Ice.Util.initialize(ref args)) { var adapter = communicator.createObjectAdapterWithEndpoints("SimplePrinterAdapter", "default -h localhost -p 10000"); adapter.add(new PrinterI(), Ice.Util.stringToIdentity("SimplePrinter")); adapter.activate(); communicator.waitForShutdown(); } } catch(Exception e) { Console.Error.WriteLine(e); return 1; } return 0; } } } |
The body of Main
contains a try
block in which we place all the server code, followed by a catch
block. The catch block catches all exceptions that may be thrown by the code; the intent is that, if the code encounters an unexpected run-time exception anywhere, the stack is unwound all the way back to Main
, which prints the exception and then returns failure to the operating system.
The Ice.Communicator
object implements IDisposable
, which allows us to use the using
statement for the initialization of the Ice.Communicator
object. This ensures the communicator destroy
method is called when the using
block goes out of scope. Doing this is essential in order to correctly finalize the Ice run time.
The body of our try
block contains the actual server code.
The code goes through the following steps:
Ice.Util.initialize
. (We pass args
to this call because the server may have command-line arguments that are of interest to the run time; for this example, the server does not require any command-line arguments.) The call to initialize
returns an Ice.Communicator
reference, which is the main object in the Ice run time.createObjectAdapterWithEndpoints
on the Communicator
instance. The arguments we pass are "SimplePrinterAdapter"
(which is the name of the adapter) and "default -p 10000"
, which instructs the adapter to listen for incoming requests using the default transport protocol (TCP/IP) at port number 10000.Printer
interface by instantiating a PrinterI
object.add
on the adapter; the arguments to add
are the servant we have just instantiated, plus an identifier. In this case, the string "SimplePrinter"
is the name of the Ice object. (If we had multiple printers, each would have a different name or, more correctly, a different object identity.)activate
method. (The adapter is initially created in a holding state; this is useful if we have many servants that share the same adapter and do not want requests to be processed until after all the servants have been instantiated.)waitForShutdown
. This call suspends the calling thread until the server implementation terminates, either by making a call to shut down the run time, or in response to a signal. (For now, we will simply interrupt the server on the command line when we no longer need it.)We can compile the server code as follows:
|
The client code, in Client/Program.cs
, looks very similar to the server.
Here it is in full:
using Demo; using System; namespace Client { public class Program { public static int Main(string[] args) { try { using(Ice.Communicator communicator = Ice.Util.initialize(ref args)) { var obj = communicator.stringToProxy("SimplePrinter:default -h localhost -p 10000"); var printer = PrinterPrxHelper.checkedCast(obj); if(printer == null) { throw new ApplicationException("Invalid proxy"); } printer.printString("Hello World!"); } } catch(Exception e) { Console.Error.WriteLine(e); return 1; } return 0; } } } |
Note that the overall code layout is the same as for the server: we use the same try
and catch
blocks to deal with errors. The code in the try
block does the following:
Ice.Util.initialize
within the using
statementstringToProxy
on the communicator, with the string "SimplePrinter:default -p 10000"
. Note that the string contains the object identity and the port number that were used by the server. (Obviously, hard-coding object identities and port numbers into our applications is a bad idea, but it will do for now; we will see more architecturally sound ways of doing this when we discuss IceGrid.stringToProxy
is of type Ice.ObjectPrx
, which is at the root of the inheritance tree for interfaces and classes. But to actually talk to our printer, we need a proxy for a Printer
interface, not an Object
interface. To do this, we need to do a down-cast by calling PrinterPrxHelper.checkedCast
. A checked cast sends a message to the server, effectively asking "is this a proxy for a Printer
interface?" If so, the call returns a proxy of type Demo::Printer
; otherwise, if the proxy denotes an interface of some other type, the call returns null.printString
method, passing it the time-honored "Hello World!"
string. The server prints that string on its terminal.The client's project is just like the server's project shown earlier.
|
To run client and server, we first start the server in a separate window:
|
At this point, we won't see anything because the server simply waits for a client to connect to it. We run the client in a different window:
|
The client runs and exits without producing any output; however, in the server window, we see the "Hello World!"
that is produced by the printer. To get rid of the server, we just interrupt it on the command line for now.
If anything goes wrong, the client will print an error message. For example, if we run the client without having first started the server, we get something like the following:
Ice.ConnectionRefusedException error = 0 |