Writing your first IceRPC + Slice client in C#

dotnet new icerpc-slice-client -o MySliceClient

This command creates a new IceRPC client application in directory MySliceClient.

Let's examine each file:

slice/Greeter.slice - the contract

This file is (and must be) identical or almost identical to the Greeter.slice we used for the server:

[cs::namespace("MySliceClient")]
module VisitorCenter

/// Represents a simple greeter.
interface Greeter {
    /// Creates a personalized greeting.
    /// @param name: The name of the person to greet.
    /// @returns: The greeting.
    greet(name: string) -> string
}

The only difference with our server's Greeter.slice is the cs::namespace attribute. That's fine: attributes don't change the contract. Here, the Slice compiler generates the C# code in namespace MySliceClient and contract-wise, it doesn't matter that the server uses a different namespace.

Program.cs - the client

The main program starts by creating a connection to the server:

// Create a simple console logger factory and configure the log level for category IceRpc.
using ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
    builder
        .AddSimpleConsole()
        .AddFilter("IceRpc", LogLevel.Information));

// Path to the root CA certificate.
using var rootCA = X509CertificateLoader.LoadCertificateFromFile("certs/cacert.der");

// Create Client authentication options with custom certificate validation.
var clientAuthenticationOptions = new SslClientAuthenticationOptions
{
    RemoteCertificateValidationCallback = (sender, certificate, chain, errors) =>
    {
        if (certificate is X509Certificate2 peerCertificate)
        {
            using var customChain = new X509Chain();
            customChain.ChainPolicy.RevocationMode = X509RevocationMode.NoCheck;
            customChain.ChainPolicy.DisableCertificateDownloads = true;
            customChain.ChainPolicy.TrustMode = X509ChainTrustMode.CustomRootTrust;
            customChain.ChainPolicy.CustomTrustStore.Add(rootCA);
            return customChain.Build(peerCertificate);
        }
        else
        {
            return false;
        }
    }
};

await using var connection = new ClientConnection(
    new Uri("icerpc://localhost"),
    clientAuthenticationOptions,
    logger: loggerFactory.CreateLogger<ClientConnection>());

This connection naturally matches our server configuration:

• the server address is icerpc://localhost, meaning we connect with the icerpc protocol to localhost on the default port for icerpc (4062)
• we don't specify a transport so we use the default multiplexed transport (tcp)
• Setting the clientAuthenticationOptions means we'll establish a secure SSL connection

Then, the client program creates an invocation pipeline that flows into the connection:

Pipeline pipeline = new Pipeline()
    .UseLogger(loggerFactory)
    .UseDeadline(defaultTimeout: TimeSpan.FromSeconds(10))
    .Into(connection);

When we send a request, the request goes through the Logger interceptor and the Deadline interceptor before being sent over the connection. The Deadline interceptor we install here ensures the request times out after 10 seconds without a response.

Next, the client program creates a Greeter proxy with this invocation pipeline:

var greeterProxy = new GreeterProxy(pipeline);

GreeterProxy is a struct that the Slice compiler generated from Slice interface Greeter. This struct allows us to send requests to a remote service that implements Greeter.

With this code, the address of the target service (or service address) is the default for Greeter, namely icerpc:/VisitorCenter.Greeter. It matches the route we created in the server. We could also create the same proxy with an explicit service address:

var greeterProxy = new GreeterProxy(pipeline, new Uri("icerpc:/VisitorCenter.Greeter"));

Finally, the client sends a greet request, awaits the response (the greeting), prints the greeting and shuts down the connection gracefully:

string greeting = await greeterProxy.GreetAsync(Environment.UserName);

Console.WriteLine(greeting);
await connection.ShutdownAsync();

When we call greeterProxy.GreetAsync, the connection to the server is not yet established: it's the GreetAsync call that triggers the connection establishment.

MySliceClient.csproj - the project file

The project file is identical to the server's project file, with references to 4 separate IceRpc NuGet packages:

• IceRpc.Slice - the IceRPC + Slice integration package
• IceRpc.Slice.Tools - the package that compiles Greeter.slice into generated/Greeter.cs
• IceRpc.Deadline and IceRpc.Logger - the packages with the two interceptors we installed in our invocation pipeline

Start the server

cd MySliceServer
dotnet run

The server is now listening for new connections from clients.

Start the client

cd MySliceClient
dotnet run

The client sends a single greet request to the service hosted by our server:

info: IceRpc.Logger.LoggerInterceptor[0]
      Sent request greet to icerpc:/VisitorCenter.Greeter over [::1]:59522<->[::1]:4062 and received a response with status code Ok
Hello, jose!

Shutdown the server

Press Ctrl+C on the server console to shut it down.