public static void Main(string[] args)
{
    Access Log#region Access Log
    COM.Handler.LogHandler.Tracking(
        "Access Method: " + ((object)MethodBase.GetCurrentMethod()).ToString() + " ;"
    );
    #endregion Access Log

    string optionalArgs = string.Empty;
    if (args.Length > 0)
    {
        optionalArgs = args[0];
    }
    args Handling#region args Handling
    if (!string.IsNullOrEmpty(optionalArgs))
    {
        if("/?".Equals(optionalArgs.ToLower()))
        {
            Console.WriteLine("Help Menu");
            Console.ReadLine();
            return;
        }
        else if("/local".Equals(optionalArgs.ToLower()))
        {
            Console.Title = "Indexus.Net Shared Cache - Server";
            Console.BackgroundColor = ConsoleColor.DarkBlue;
            Console.ForegroundColor = ConsoleColor.White;
            // running as cmd appliacation
            Indexus SrvIndexus = new Indexus();
            SrvIndexus.StartService();
            Console.ReadLine();
            SrvIndexus.StopService();
            return;
        }
        else if(@"/verbose".Equals(optionalArgs.ToLower()))
        {
            // Console.SetOut(this);
            // Console.SetIn(Console.Out);
            // Console.ReadLine();
            return;
        }
        TransactedInstaller ti = new TransactedInstaller();
        IndexusInstaller ii = new IndexusInstaller();
        ti.Installers.Add(ti);
        string path = string.Format("/assemblypath={0}", System.Reflection.Assembly.GetExecutingAssembly().Location);
        string[] cmd = { path };
        InstallContext context = new InstallContext(string.Empty, cmd);
        ti.Context = context;

        if ("/install".Equals(optionalArgs.ToLower()) || "/i".Equals(optionalArgs.ToLower()))
        {
            ti.Install(new Hashtable());
        }
        else if ("/uninstall".Equals(optionalArgs.ToLower()) || "/u".Equals(optionalArgs.ToLower()))
        {
            ti.Uninstall(null);
        }
        else
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(@"Your provided Argument is not available." + Environment.NewLine);
            sb.Append(@"Use one of the following once:" + Environment.NewLine);
            sb.AppendFormat(@"To Install the service '{0}': '/install' or '/i'" + Environment.NewLine, @"IndeXus.Net");
            sb.AppendFormat(@"To Un-Install the service'{0}': '/uninstall' or '/u'" + Environment.NewLine, @"IndeXus.Net");
            Console.WriteLine(sb.ToString());
        }
    }
    else
    {
        // nothing received as input argument
        ServiceBase[] servicesToRun;
        servicesToRun = new ServiceBase[] { new Indexus() };
        ServiceBase.Run(servicesToRun);
    }
    #endregion args Handling
}

/**//// <summary>
/// Inits this instance. This method used at startup to initialize
/// all required server components
/// </summary>
public void Init()
{
    Access Log#region Access Log
    COM.Handler.LogHandler.Tracking(
        "Access Method: " + this.GetType().ToString()+ "->" + ((object)MethodBase.GetCurrentMethod()).ToString() + " ;"
    );
    #endregion Access Log

    COM.Handler.LogHandler.Force("Initializing Settings" + COM.Enums.LogCategory.ServiceStart.ToString());
    Console.WriteLine(@"Welcome to indeXus.Net Shared Cache");
    Console.WriteLine();
    Console.WriteLine(COM.Handler.Config.DisplayAppSettings());
    COM.Handler.LogHandler.Info(COM.Handler.Config.DisplayAppSettings());
    // needs to be instantiated before TCP, it needs an instance of CachExpire
    cacheExpireInstance = new CacheExpire();
    // TCP needs an instance of CacheExpire
    tcpInstance = new TcpServer(cacheExpireInstance);

    COM.Handler.LogHandler.Force("Init and Start Thread Tcp");
    COM.Handler.LogHandler.Force("Init and Start Thread CacheExpire");
    // Init all extenders
    // an extender is a class which initializes its own logic around
    // specific issue within its own thread;
    /**////
    this.workerTcp = new Thread(this.tcpInstance.Init);
    this.workerTcp.Name = "TCP Handler";
    this.workerTcp.IsBackground = true;
    this.workerTcp.Priority = ThreadPriority.Normal;
    /**////
    this.workerCacheExpire = new Thread(this.cacheExpireInstance.Init);
    this.workerCacheExpire.Name = "Cache Expire Handler";
    this.workerCacheExpire.IsBackground = true;
    this.workerCacheExpire.Priority = ThreadPriority.Lowest;
    /**////
    this.workerCacheExpire.Start();
    this.workerTcp.Start();

    // enable the search of replicaiton servers
    if (this.enableServiceFamilyMode)
    {
        NetworkDistribution.Init();
    } 

    string msgThreadInfo = Environment.NewLine + 
        "Main Thread Id: " + Thread.CurrentThread.ManagedThreadId.ToString() + Environment.NewLine +
        "this.workerTcp: " + this.workerTcp.ManagedThreadId.ToString() + Environment.NewLine +
        /**//*"this.workerTimer: " + this.workerTimer.ManagedThreadId.ToString() + Environment.NewLine +*/
        "this.workerCacheExpire: " + this.workerCacheExpire.ManagedThreadId.ToString();

    Console.WriteLine(msgThreadInfo + Environment.NewLine);
    Console.WriteLine("+ + + + + + + + + + + + + + + + + + + + + + + + + + + + ");
    Console.WriteLine("server is ready to receive data.");

    COM.Handler.LogHandler.Force("IndeXus.Net Service Started " + COM.Enums.LogCategory.ServiceStart.ToString());
}

public void Init()
{
   

    IPEndPoint endpoint = COM.Handler.Network.GetServerAnyIPEndPoint(this.cacheIpPort);

    serverSocket = new Socket(endpoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(endpoint);
    serverSocket.Listen((int)SocketOptionName.MaxConnections);

   

    // setup listener issues
    acceptThread = new Thread(AcceptConnections);
    acceptThread.IsBackground = true;
    acceptThread.Priority = ThreadPriority.Normal;
    acceptThread.Start();

   

}

private void AcceptConnections()
{
   

    while (true)
    {
        // Accept a connection
        Socket socket = serverSocket.Accept();
        ConnectionInfo connection = new ConnectionInfo();
        connection.Socket = socket;

        // Modified:06-01-2008 Merge System GmbH, rschuetz : for more information checkout the following link> http://netrsc.blogspot.com/2007/02/another-extract-from-scalenet-threading.html
        ThreadPool.QueueUserWorkItem(this.ProcessConnection, connection);

        // Store the socket in the open connections
        lock (this.connections)
        {
            this.connections.Add(connection);
        } 

    }
}

private void ProcessConnection(object stats)
{
     

    ConnectionInfo connection = (ConnectionInfo)stats;

    try
    {
       

        // read data from Socket and convert it to an IndeXusMessage
        COM.IndexusMessage msg = new COM.Handler.NetworkMessage().ProcessNetworkMessage(connection.Socket);

        if (msg != null)
        {
            this.ProcessMessage(msg, connection);
        }
        else
        {
            Console.WriteLine("Error appears due processing network message!");
            COM.Handler.LogHandler.Error("Error appears due processing network message!");
        }
    }
    catch (OutOfMemoryException ex)
    {
       
    }
    catch (Exception ex)
    {
       

    }
    finally
    {
        connection.Socket.Close();
        lock (this.connections)
            this.connections.Remove(connection);
    }
}

private void ProcessMessage(COM.IndexusMessage msg, ConnectionInfo connection)
{
   

    // check status first [Request || Response]
    switch (msg.Status)
    {
        case COM.IndexusMessage.StatusValue.Request:
            {
                request case#region request case
                COM.IndexusMessage replicationMessage = null;

                if (ServiceLogic.NetworkDistribution.ReplicationEnabled)
                {
                    // create a new object of received msg. to broadcast on servers.
                    replicationMessage = new COM.IndexusMessage(new Random().Next(), msg.Action, COM.IndexusMessage.StatusValue.Request,new KeyValuePair<string,byte[]>(msg.Key, msg.Payload));
                } 

               
                // switch over cache actions
                switch (msg.Action)
                {
                    case COM.IndexusMessage.ActionValue.Ping:
                        {
                           
                        }
                    case COM.IndexusMessage.ActionValue.Add:
                        {
                           
                        }
                    case COM.IndexusMessage.ActionValue.Get:
                        {
                          
                        }
                    case COM.IndexusMessage.ActionValue.Remove:
                        {
                           
                        }
                    case COM.IndexusMessage.ActionValue.RemoveAll:
                        {
                           
                        }
                    case COM.IndexusMessage.ActionValue.GetAllKeys:
                        {
                           
                        }
                    case COM.IndexusMessage.ActionValue.Statistic:
                        {
                           
                        }
                }
                break;
                #endregion request case
            }
        case COM.IndexusMessage.StatusValue.Response:
            {
               
            }
    } 

}

case COM.IndexusMessage.ActionValue.Add:
    {
        Add Case#region Add Case
        if (writeStats)
            Console.WriteLine("Message Action: {0}", msg.Action.ToString());

        Console.WriteLine(@"Adding new Item with Key: {0}", msg.Key);
        lock (bulkObject)
        {
            LocalCache.Add(new KeyValuePair<string, byte[]>(msg.Key, msg.Payload));
            // if the given msg expires is not MaxValue
            // it will be listed sub-process which clean
            // up in iterations the cache.
            // QuickFix
            if (msg.Expires != DateTime.MaxValue)
            {
                if (this.expire != null)
                {
                    this.expire.Expire.DumpCacheItemAt(msg.Key, msg.Expires);
                }                                           
            }
            // update cleanup list with new object
            CacheCleanup.Update(msg);
        } 

        msg.Action = COM.IndexusMessage.ActionValue.Successful;

        rschuetz: MODIFIED: 21-07-2007: distribute object over wire to other installations#region rschuetz: MODIFIED: 21-07-2007: distribute object over wire to other installations
        // Question is if the client needs to wait until this happens,
        // or should the client first get an answer and just then it
        // will distribute it.
        if (ServiceLogic.NetworkDistribution.ReplicationEnabled)
        {
            ServiceLogic.NetworkDistribution.Replicate(replicationMessage);
        }
        #endregion 

        // send object back throug the connection
        connection.Socket.Send(msg.GetBytes());

        // handle max size and purge issues
        //DateTime startTime = DateTime.Now;
        if (this.cacheAmountOfObjects != -1 && this.cacheAmountOfObjects <= LocalCache.CalculatedCacheSize && !CacheCleanup.PurgeIsRunning)
        {
            Console.WriteLine(@"Current Size of Cache: {0} ; {1} ", LocalCache.CalculatedCacheSize, LocalCache.CalculatedCacheSize <= 0 ? 0 : LocalCache.CalculatedCacheSize / (1024 * 1024));
            List<string> remove = CacheCleanup.Purge(LocalCache.CalculatedCacheSize);
            if (remove != null)
            {
                lock (bulkObject)
                {
                    foreach (string s in remove)
                    {
                        LocalCache.Remove(s);
                    }
                }
            }
        }
        break;
        #endregion Add Case
    }