// ----------------------------------------------------------------------------
// To compile:
//   csc -debug+ -r:System.ServiceModel.dll AsyncMiddleSample.cs
//
// This sample is provided "AS IS" with no warranties, and confers no rights.
//
// Sample output:
//     C:\>AsyncMiddleSample
//     starting SleepMiddle.BeginSleep(A)
//     finished SleepMiddle.BeginSleep(A)
//     starting SleepServer.Sleep(A)
//     finished SleepServer.Sleep(A), returning "A was number 1"
//     starting SleepMiddle.EndSleep()
//     finished SleepMiddle.EndSleep(), returning "A was number 1"
//     A was number 1
//     starting SleepMiddle.BeginSleep(B)
//     finished SleepMiddle.BeginSleep(B)
//     starting SleepServer.Sleep(B)
//     finished SleepServer.Sleep(B), returning "B was number 2"
//     starting SleepMiddle.EndSleep()
//     finished SleepMiddle.EndSleep(), returning "B was number 2"
//     B was number 2
//     starting SleepMiddle.BeginSleep(C)
//     finished SleepMiddle.BeginSleep(C)
//     starting SleepServer.Sleep(C)
//     finished SleepServer.Sleep(C), returning "C was number 3"
//     starting SleepMiddle.EndSleep()
//     finished SleepMiddle.EndSleep(), returning "C was number 3"
//     C was number 3
//

using System;
using System.ServiceModel;
using System.Threading;

class App
{
    public static Uri MiddleUri = new Uri("net.tcp://localhost/AsyncMiddle");
    public static Uri ServerUri = new Uri("net.tcp://localhost/AsyncServer");
    public static Binding Binding = new NetProfileTcpBinding();

    public static void Main()
    {
        using (ServiceHost<SleepServer> server = new ServiceHost<SleepServer>())
        {
            server.AddEndpoint(typeof(IServerSleep), App.Binding, App.ServerUri);
            server.Open();

            using (ServiceHost<SleepMiddle> middle = new ServiceHost<SleepMiddle>())
            {
                middle.AddEndpoint(typeof(IMiddleSleep), App.Binding, App.MiddleUri);
                middle.Open();

                using (IClientSleepChannel channel = ChannelFactory.CreateChannel<IClientSleepChannel>(App.MiddleUri, App.Binding))
                {
                    Console.WriteLine("{0}", channel.Sleep("A"));
                    Console.WriteLine("{0}", channel.Sleep("B"));
                    Console.WriteLine("{0}", channel.Sleep("C"));

                    channel.Close();
                }
                middle.Close();
            }
            server.Close();
        }
    }
}

// ----------------------------------------------------------------------------
// Client

interface IClientSleepChannel : IClientSleep, IProxyChannel
{
}

[ServiceContract(Name="Sleep")]
interface IClientSleep
{
    [OperationContract]
    string Sleep(string greeting);
}

// ----------------------------------------------------------------------------
// Middle

interface IMiddleSleepChannel : IMiddleSleep, IProxyChannel
{
}

[ServiceContract(Name="Sleep")]
interface IMiddleSleep
{
    [OperationContract(AsyncPattern=true)]
    IAsyncResult BeginSleep(string greeting, AsyncCallback callback, object state);

    string EndSleep(IAsyncResult result);
}

[ServiceBehavior(ConcurrencyMode=ConcurrencyMode.Multiple, InstanceMode=InstanceMode.PrivateSession)]
class SleepMiddle : IMiddleSleep, IDisposable
{
    IMiddleSleepChannel channel;

    SleepMiddle()
    {
        this.channel = ChannelFactory.CreateChannel<IMiddleSleepChannel>(App.ServerUri, App.Binding);
    }

    public void Dispose()
    {
        this.channel.Close();
    }

    public IAsyncResult BeginSleep(string greeting, AsyncCallback callback, object state)
    {
        Console.WriteLine("starting SleepMiddle.BeginSleep({0})", greeting);
        IAsyncResult result = this.channel.BeginSleep(greeting, callback, state);
        Console.WriteLine("finished SleepMiddle.BeginSleep({0})", greeting);
        return result;
    }

    public string EndSleep(IAsyncResult result)
    {
        Console.WriteLine("starting SleepMiddle.EndSleep()");
        string returnValue = this.channel.EndSleep(result);
        Console.WriteLine("finished SleepMiddle.EndSleep(), returning \"{0}\"", returnValue);
        return returnValue;
    }
}

// ----------------------------------------------------------------------------
// Server

[ServiceContract(Name="Sleep")]
interface IServerSleep
{
    [OperationContract]
    string Sleep(string greeting);
}

[ServiceBehavior(ConcurrencyMode=ConcurrencyMode.Multiple)]
class SleepServer : IServerSleep
{
    static int id;

    public string Sleep(string greeting)
    {
        Console.WriteLine("starting SleepServer.Sleep({0})", greeting);

        Thread.Sleep(5000);
        string result = String.Format("{0} was number {1}", greeting, Interlocked.Increment(ref id));

        Console.WriteLine("finished SleepServer.Sleep({0}), returning \"{1}\"", greeting, result);

        return result;
    }
}