[.net] .NET Bidirectional Remoting

///
// Method used to open the server connection (when player is host)
///
private void btn_Go_Click(object sender, System.EventArgs e)
{
  //start the server
  OvServer.StartConnection();
  
  //start the client
  //if the player is hosting, server and client are on the same machine
  //so we can use localhost as url
  OvClient.TryConnection(portNo, "localhost");

  // subscribe to the event which is fired when a new client connects
  Overlapped.ClientConnected += new EmptyDelegate(OnClientConnected);

  // host always has the Player-ID 1
  mMainForm.PlayerInstance.PlayerID = 1;
  
  // tell the server that a client connected (host instance itself connects)
  OvClient.Server.ClientConnected(mMainForm.PlayerInstance);

  // Init refresh timer to check for updates
  mRefreshTimer.AutoReset = true;
  mRefreshTimer.Start();
  mRefreshTimer.Elapsed += new System.Timers.ElapsedEventHandler(mRefreshTimer_Elapsed);

  // subsribe to the event that is triggered if any of the clients changed
  // its team selection
  OvClient.Server.ConnectionStatusChanged +=new EmptyDelegate(Server_ConnectionStatusChanged);	

  // subscribe to the event that is triggered if any of the clients changed
  // its ready-state
  OvClient.Server.ReadyStateChanged += new EmptyDelegate(Server_ReadyStateChanged);

  // show the host user that connection has been opened
  this.lbl_ConnectionStatus.Text = "Waiting for Players";
  this.lbl_ConnectionStatus.BackColor = Color.YellowGreen;
}

using System;
using System.Collections;
using System.Windows.Forms;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;

using Overlapped.IniFile;

namespace Overlapped.Server
{
  /// <summary>
  /// The game server, singleton class
  /// </summary>
  public class OvServer
  {
    private static int mPortNo;
    private OvIniHandler mIniFile;
    private static OvServer mInstance = new OvServer();

    private OvServer()
    {
      mIniFile = new OvIniHandler(Application.StartupPath + @"\ServerSettings.ini");
      mPortNo = mIniFile.GetInt("Connection", "ServerPort", 8050);
    }

    // Starting the server connection / enabling the remote object
    public static void StartConnection()
    {
      // create my own sinks because type filter level has to be set to full
      BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
      BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
	
      // Set TypeFilterLevel to full (needed so send remote events)
      serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

      // Initialize the server channel
      IDictionary props = new Hashtable();
      props["port"] = mPortNo;
      props["typeFilterLevel"] = TypeFilterLevel.Full;
      HttpChannel chan = new HttpChannel(props,clientProvider,serverProvider);

      // Register server channel
      ChannelServices.RegisterChannel(chan);

//enable remote object
      RemotingConfiguration.RegisterWellKnownServiceType(typeof(OvRemoteObject),"Overlapped",WellKnownObjectMode.Singleton);
    }

    // get singleton-instance
    public static OvServer GetInstance()
    {
      return mInstance;
    }

  }
}

using System;
using System.Collections;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Serialization.Formatters;

using Overlapped.Server;

namespace Overlapped.Client
{
  /// <summary>
  /// Client Class
  /// </summary>
  public class OvClient
  {
    /// <summary>
    /// Singleton instance of this client
    /// </summary>
    private static OvClient mInstance = new OvClient();
    private static OvRemoteObject mServer;

    private OvClient()
    {
      mServer = null;
    }

    public static OvClient GetInstance()
    {
      return mInstance;
    }

    //Connect to the server
    public static void TryConnection(int port, string url)
    {
      BinaryClientFormatterSinkProvider clientProvider = new inaryClientFormatterSinkProvider();
      BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
      serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
	
      //init client channel		                
      IDictionary props = new Hashtable();
      props["port"] = 0;
      //create unique client name
      string s = System.Guid.NewGuid().ToString();
      props["name"] = s;

      props["typeFilterLevel"] = TypeFilterLevel.Full;
      HttpChannel chan = new HttpChannel(props,clientProvider,serverProvider);
      ChannelServices.RegisterChannel(chan);

      Type typeofRO = typeof(OvRemoteObject);
 
      //Activate RemoteObject
      mServer = (OvRemoteObject)Activator.GetObject(typeofRO,	"http://"+url+":"+port+"/Overlapped");
    }

    public static OvRemoteObject Server
    {
      get {return mServer;}
    }

    public static Hashtable GetPlayerConnections()
    {
      return mServer.GetPlayerSelections();
    }
  }
}

using System;
using System.Collections;
using System.Windows.Forms;
using System.Runtime.Remoting;

using Overlapped.TypeDefs;
using Overlapped.Core;

namespace Overlapped.Server
{
  [Serializable]
  public class OvRemoteObject : MarshalByRefObject
  {
    private Hashtable mPlayerConnectionStatus;
    private OvGameState mGameState;

    public OvRemoteObject()
    {
      mPlayerConnectionStatus = new Hashtable();
      mGameState = new OvGameState();
    }

    public static event InitDelegate NewClient;
    public event EmptyDelegate ConnectionStatusChanged;
    public event EmptyDelegate ReadyStateChanged;

    // a new client connected to the server
    public int ClientConnected(OvPlayer playerInstance)
    {
      // assign player-ID to the new player instance
      playerInstance.PlayerID = mPlayerConnectionStatus.Count + 1;

      // save player instance
      mPlayerConnectionStatus.Add(playerInstance.PlayerID, playerInstance);

      // notify all other clients that a new client connected 
      // (exclude server, because it has been notified already)
      if(playerInstance.PlayerName
!=((OvPlayer)mPlayerConnectionStatus[1]).PlayerName)
      
***   // use method in the client instance for notification (only works in LAN)
***   playerInstance.NewClient(playerInstance);
      
***   // use event to notify clients (only works in LAN)
***   //NewClient(playerInstance); 

***   // set new connection status in all clients (only works in LAN)
***   if(ConnectionStatusChanged != null)
***	ConnectionStatusChanged();

      // return last Player-ID
      return mPlayerConnectionStatus.Count;
    }

   //works
   public Hashtable GetPlayerConnectionStatus()
   {
     return (Hashtable)(mPlayerConnectionStatus.Clone());
   }

   //works
   public Hashtable GetPlayerSelections()
   {
     return mPlayerConnectionStatus;
   }

   public OvGameState GameState
   {
     get { return mGameState; }
     set { mGameState = value; }
   }

   // Notify clients if connection state changed
   public void UpdateConnectionStatus(int playerNo, string playerSelection)
   {
     ((OvPlayer)mPlayerConnectionStatus[playerNo]).Team = playerSelection;
***  if(ConnectionStatusChanged != null)	
***    ConnectionStatusChanged(); // Only works via LAN
   }

   // Notify clients if ready-state changed
   public void UpdateReadyStatus(int playerNo, bool readyState)
   {
     ((OvPlayer)mPlayerConnectionStatus[playerNo]).ReadyState = readyState;

***  if(ReadyStateChanged != null)
***    ReadyStateChanged(); // Only works via LAN
   }

   public Hashtable PlayerConnectionStatus
   { 
     get { return mPlayerConnectionStatus; }
     set { mPlayerConnectionStatus = value; }
   }

   public void AddPlayerToGameState(int pID, OvPlayer player)
   {
     GameState.AddPlayer(pID, player);
   }

   // ... (cut off the rest)
   // ...

  }
}