BeWoPlaner/BeWoChatServer/Server.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;

using BS.Shared;

namespace BeWoChatServer
{
    public class Server
    {
        private static object _Lock = string.Empty;

        private static readonly Dictionary<Socket, long> clientList = new Dictionary<Socket, long>();
        protected static Socket serverSocket;

        private static AsyncCallback asyncCallback;

        private static int clientCount;

        static Packet dataPacketsdf;

        public static void Main(string[] args)
        {
            try
            {
                // Benutzt den DefaultHibernateSessionManager
                DefaultHibernateSessionManager.CurrentTenant = "demo";
                DefaultHibernateSessionManager.OpenSession();
                var test = DAOFactory.GenericDAO.LoadByID<ChatMessage>(1);

                serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                var server = new IPEndPoint(IPAddress.Any, 5000);

                serverSocket.Bind(server);
                serverSocket.Listen(4);

                serverSocket.BeginAccept(OnClientConnected, null);

                while (true) { }
            }
            catch (Exception e)
            {
                Debug.WriteLine("ChatServerException: " + e.Message);
            }
        }

        //TODO: Datenbankverbindung herstellen

        public static void OnClientConnected(IAsyncResult asyncResult)
        {
            try
            {
                var workerSocket = serverSocket.EndAccept(asyncResult);

                Interlocked.Increment(ref clientCount);

                clientList.Add(workerSocket, 0);

                WaitForClientData(workerSocket, clientCount, "LEER", 0, 0);

                serverSocket.BeginAccept(OnClientConnected, null);
            }
            catch (SocketException e)
            {
                Debug.WriteLine("ChatServerException: " + e.Message);
            }
        }

        public static void WaitForClientData(Socket socket, int clientNumber, string clientName, long oid, long recipientPersonOid)
        {
            try
            {
                if (asyncCallback == null)
                {
                    asyncCallback = OnReceiveData;
                }

                var packet = new Packet(socket, clientNumber, clientName, oid, recipientPersonOid);

                socket.BeginReceive(packet.DataBuffer, 0, packet.DataBuffer.Length, SocketFlags.None, asyncCallback, packet);
            }
            catch (Exception e)
            {
                Debug.WriteLine("ChatServerException: " + e.Message);
            }
        }

        public static void OnReceiveData(IAsyncResult asyncResult)
        {
            var dataPacket = (Packet) asyncResult.AsyncState;

            try
            {
                var responseByteCount = dataPacket.Socket.EndReceive(asyncResult);

                var chars = new char[responseByteCount];

                var decoder = Encoding.UTF8.GetDecoder();
                decoder.GetChars(dataPacket.DataBuffer, 0, responseByteCount, chars, 0);

                if(chars.Count(f => f.Equals(';')) >= 4)
                {
                    var message = new string(chars);

                    dataPacket.GetData(message);
                }

                // Nur bei DataIdentifier.Login
                //TODO: SenderOid im Dictionary speichern
                switch(dataPacket.DataIdentifier) { case DataIdentifier.Login:
                        var endPoint = dataPacket.Socket.RemoteEndPoint;

                        var endPointCollection = clientList.Select(s => s.Key.RemoteEndPoint).ToList();

                        var istEnthalten = endPointCollection.Contains(endPoint);
                        if(istEnthalten)
                        {
                            clientList[dataPacket.Socket] = dataPacket.SenderPersonOid;
                        }
                        break;
                    case DataIdentifier.Message:
                        if(responseByteCount == 0)
                        {
                            clientList.Remove(dataPacket.Socket);
                            return;
                        }
                        else
                        {

                            try
                            {
                                Monitor.Enter(_Lock);

                                DefaultHibernateSessionManager.CurrentTenant = "demo";
                                
                            }
                            finally
                            {
                                Monitor.Exit(_Lock);
                            }
                            

                            // in DB speichern und an evtl. an den Empfänger schicken, sofern dieser in der clientList enthalten ist
                        }

                        break;
                    case DataIdentifier.Logout:
                        break;
                }

                WaitForClientData(dataPacket.Socket, dataPacket.ClientNumber, dataPacket.ClientName, dataPacket.SenderPersonOid, dataPacket.RecipientPersonOid);
            }
            catch (Exception e)
            {
                Debug.WriteLine("ChatServerException: " + e.Message);
            }
        }
    }
}