WSHCommon/Common/CommonNetwork_ICE/Ice_gen/Slice/send.cs

// **********************************************************************
//
// Copyright (c) 2003-2013 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
//
// Ice version 3.5.1
//
// <auto-generated>
//
// Generated from file `send.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//


using _System = global::System;
using _Microsoft = global::Microsoft;

#pragma warning disable 1591

namespace IceCompactId
{
}

namespace Slice
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial class TransMessage : Ice.ObjectImpl
    {
        #region Slice data members

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public int type;

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public long serial;

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public int length;

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public byte[] data;

        #endregion

        #region Constructors

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public TransMessage()
        {
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public TransMessage(int type, long serial, int length, byte[] data)
        {
            this.type = type;
            this.serial = serial;
            this.length = length;
            this.data = data;
        }

        #endregion

        #region Slice type-related members

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public static new readonly string[] ids__ = 
        {
            "::Ice::Object",
            "::Slice::TransMessage"
        };

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override string[] ice_ids()
        {
            return ids__;
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override string ice_id()
        {
            return ids__[1];
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public override string ice_id(Ice.Current current__)
        {
            return ids__[1];
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        public static new string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Operation dispatch

        #endregion

        #region Marshaling support

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.writeInt(type);
            os__.writeLong(serial);
            os__.writeInt(length);
            Slice.ByteDataHelper.write(os__, data);
            os__.endWriteSlice();
        }

        [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            type = is__.readInt();
            serial = is__.readLong();
            length = is__.readInt();
            data = Slice.ByteDataHelper.read(is__);
            is__.endReadSlice();
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial interface Sender : Ice.Object, SenderOperations_, SenderOperationsNC_
    {
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial interface ServerCallback : Ice.Object, ServerCallbackOperations_, ServerCallbackOperationsNC_
    {
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial interface ICombatSession : Ice.Object, ICombatSessionOperations_, ICombatSessionOperationsNC_, Glacier2.Session
    {
    }
}

namespace Slice
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_SendData();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_SendAck();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_Connect();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_ConnectAck();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_Close();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_Sender_CloseAck();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_ServerCallback_ServerToClient();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_ICombatSession_SetCallback();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public delegate void Callback_ICombatSession_ClientToServer();
}

namespace Slice
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface TransMessagePrx : Ice.ObjectPrx
    {
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface SenderPrx : Ice.ObjectPrx
    {
        void SendData(int recvPort, Slice.TransMessage message);
        void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_SendData> begin_SendData(int recvPort, Slice.TransMessage message);
        Ice.AsyncResult<Slice.Callback_Sender_SendData> begin_SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_SendData(int recvPort, Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_SendData(Ice.AsyncResult r__);

        void SendAck(int recvPort, long serial);
        void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_SendAck> begin_SendAck(int recvPort, long serial);
        Ice.AsyncResult<Slice.Callback_Sender_SendAck> begin_SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_SendAck(int recvPort, long serial, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_SendAck(Ice.AsyncResult r__);

        void Connect(int recvPort);
        void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_Connect> begin_Connect(int recvPort);
        Ice.AsyncResult<Slice.Callback_Sender_Connect> begin_Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_Connect(int recvPort, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_Connect(Ice.AsyncResult r__);

        void ConnectAck();
        void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_ConnectAck> begin_ConnectAck();
        Ice.AsyncResult<Slice.Callback_Sender_ConnectAck> begin_ConnectAck(_System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_ConnectAck(Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_ConnectAck(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_ConnectAck(Ice.AsyncResult r__);

        void Close(int recvPort);
        void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_Close> begin_Close(int recvPort);
        Ice.AsyncResult<Slice.Callback_Sender_Close> begin_Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_Close(int recvPort, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_Close(Ice.AsyncResult r__);

        void CloseAck(int recvPort);
        void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_Sender_CloseAck> begin_CloseAck(int recvPort);
        Ice.AsyncResult<Slice.Callback_Sender_CloseAck> begin_CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_CloseAck(int recvPort, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_CloseAck(Ice.AsyncResult r__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ServerCallbackPrx : Ice.ObjectPrx
    {
        void ServerToClient(Slice.TransMessage message);
        void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_ServerCallback_ServerToClient> begin_ServerToClient(Slice.TransMessage message);
        Ice.AsyncResult<Slice.Callback_ServerCallback_ServerToClient> begin_ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_ServerToClient(Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_ServerToClient(Ice.AsyncResult r__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ICombatSessionPrx : Glacier2.SessionPrx
    {
        void SetCallback(Slice.ServerCallbackPrx callback);
        void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_ICombatSession_SetCallback> begin_SetCallback(Slice.ServerCallbackPrx callback);
        Ice.AsyncResult<Slice.Callback_ICombatSession_SetCallback> begin_SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_SetCallback(Slice.ServerCallbackPrx callback, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_SetCallback(Ice.AsyncResult r__);

        void ClientToServer(Slice.TransMessage message);
        void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__);

        Ice.AsyncResult<Slice.Callback_ICombatSession_ClientToServer> begin_ClientToServer(Slice.TransMessage message);
        Ice.AsyncResult<Slice.Callback_ICombatSession_ClientToServer> begin_ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_ClientToServer(Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__);
        Ice.AsyncResult begin_ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_ClientToServer(Ice.AsyncResult r__);
    }
}

namespace Slice
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface SenderOperations_
    {
        void SendData(int recvPort, Slice.TransMessage message, Ice.Current current__);

        void SendAck(int recvPort, long serial, Ice.Current current__);

        void Connect(int recvPort, Ice.Current current__);

        void ConnectAck(Ice.Current current__);

        void Close(int recvPort, Ice.Current current__);

        void CloseAck(int recvPort, Ice.Current current__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface SenderOperationsNC_
    {
        void SendData(int recvPort, Slice.TransMessage message);

        void SendAck(int recvPort, long serial);

        void Connect(int recvPort);

        void ConnectAck();

        void Close(int recvPort);

        void CloseAck(int recvPort);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ServerCallbackOperations_
    {
        void ServerToClient(Slice.TransMessage message, Ice.Current current__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ServerCallbackOperationsNC_
    {
        void ServerToClient(Slice.TransMessage message);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ICombatSessionOperations_ : Glacier2.SessionOperations_
    {
        void SetCallback(Slice.ServerCallbackPrx callback, Ice.Current current__);

        void ClientToServer(Slice.TransMessage message, Ice.Current current__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ICombatSessionOperationsNC_ : Glacier2.SessionOperationsNC_
    {
        void SetCallback(Slice.ServerCallbackPrx callback);

        void ClientToServer(Slice.TransMessage message);
    }
}

namespace Slice
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ByteDataHelper
    {
        public static void write(IceInternal.BasicStream os__, byte[] v__)
        {
            os__.writeByteSeq(v__);
        }

        public static byte[] read(IceInternal.BasicStream is__)
        {
            byte[] v__;
            v__ = is__.readByteSeq();
            return v__;
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class TransMessagePrxHelper : Ice.ObjectPrxHelperBase, TransMessagePrx
    {
        #region Asynchronous operations

        #endregion

        #region Checked and unchecked cast operations

        public static TransMessagePrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            TransMessagePrx r = b as TransMessagePrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                TransMessagePrxHelper h = new TransMessagePrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static TransMessagePrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            TransMessagePrx r = b as TransMessagePrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                TransMessagePrxHelper h = new TransMessagePrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static TransMessagePrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    TransMessagePrxHelper h = new TransMessagePrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static TransMessagePrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    TransMessagePrxHelper h = new TransMessagePrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static TransMessagePrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            TransMessagePrx r = b as TransMessagePrx;
            if(r == null)
            {
                TransMessagePrxHelper h = new TransMessagePrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static TransMessagePrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            TransMessagePrxHelper h = new TransMessagePrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::Ice::Object",
            "::Slice::TransMessage"
        };

        public static string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Marshaling support

        protected override Ice.ObjectDelM_ createDelegateM__()
        {
            return new TransMessageDelM_();
        }

        protected override Ice.ObjectDelD_ createDelegateD__()
        {
            return new TransMessageDelD_();
        }

        public static void write__(IceInternal.BasicStream os__, TransMessagePrx v__)
        {
            os__.writeProxy(v__);
        }

        public static TransMessagePrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                TransMessagePrxHelper result = new TransMessagePrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class SenderPrxHelper : Ice.ObjectPrxHelperBase, SenderPrx
    {
        #region Synchronous operations

        public void Close(int recvPort)
        {
            Close(recvPort, null, false);
        }

        public void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            Close(recvPort, context__, true);
        }

        private void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __Close_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.Close(recvPort, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void CloseAck(int recvPort)
        {
            CloseAck(recvPort, null, false);
        }

        public void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            CloseAck(recvPort, context__, true);
        }

        private void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __CloseAck_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.CloseAck(recvPort, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void Connect(int recvPort)
        {
            Connect(recvPort, null, false);
        }

        public void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            Connect(recvPort, context__, true);
        }

        private void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __Connect_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.Connect(recvPort, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void ConnectAck()
        {
            ConnectAck(null, false);
        }

        public void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__)
        {
            ConnectAck(context__, true);
        }

        private void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __ConnectAck_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.ConnectAck(context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void SendAck(int recvPort, long serial)
        {
            SendAck(recvPort, serial, null, false);
        }

        public void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            SendAck(recvPort, serial, context__, true);
        }

        private void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __SendAck_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.SendAck(recvPort, serial, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void SendData(int recvPort, Slice.TransMessage message)
        {
            SendData(recvPort, message, null, false);
        }

        public void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            SendData(recvPort, message, context__, true);
        }

        private void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __SendData_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        SenderDel_ del__ = (SenderDel_)delBase__;
                        del__.SendData(recvPort, message, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        #endregion

        #region Asynchronous operations

        public Ice.AsyncResult<Slice.Callback_Sender_Close> begin_Close(int recvPort)
        {
            return begin_Close(recvPort, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_Close> begin_Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_Close(recvPort, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_Close(int recvPort, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_Close(recvPort, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_Close(recvPort, ctx__, true, cb__, cookie__);
        }

        private const string __Close_name = "Close";

        public void end_Close(Ice.AsyncResult r__)
        {
            end__(r__, __Close_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_Close> begin_Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_Close> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_Close>(this, __Close_name, Close_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__Close_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeInt(recvPort);
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void Close_completed__(Slice.Callback_Sender_Close cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_Sender_CloseAck> begin_CloseAck(int recvPort)
        {
            return begin_CloseAck(recvPort, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_CloseAck> begin_CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_CloseAck(recvPort, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_CloseAck(int recvPort, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_CloseAck(recvPort, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_CloseAck(recvPort, ctx__, true, cb__, cookie__);
        }

        private const string __CloseAck_name = "CloseAck";

        public void end_CloseAck(Ice.AsyncResult r__)
        {
            end__(r__, __CloseAck_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_CloseAck> begin_CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_CloseAck> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_CloseAck>(this, __CloseAck_name, CloseAck_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__CloseAck_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeInt(recvPort);
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void CloseAck_completed__(Slice.Callback_Sender_CloseAck cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_Sender_Connect> begin_Connect(int recvPort)
        {
            return begin_Connect(recvPort, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_Connect> begin_Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_Connect(recvPort, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_Connect(int recvPort, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_Connect(recvPort, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_Connect(recvPort, ctx__, true, cb__, cookie__);
        }

        private const string __Connect_name = "Connect";

        public void end_Connect(Ice.AsyncResult r__)
        {
            end__(r__, __Connect_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_Connect> begin_Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_Connect> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_Connect>(this, __Connect_name, Connect_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__Connect_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeInt(recvPort);
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void Connect_completed__(Slice.Callback_Sender_Connect cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_Sender_ConnectAck> begin_ConnectAck()
        {
            return begin_ConnectAck(null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_ConnectAck> begin_ConnectAck(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_ConnectAck(ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_ConnectAck(Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ConnectAck(null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_ConnectAck(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ConnectAck(ctx__, true, cb__, cookie__);
        }

        private const string __ConnectAck_name = "ConnectAck";

        public void end_ConnectAck(Ice.AsyncResult r__)
        {
            end__(r__, __ConnectAck_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_ConnectAck> begin_ConnectAck(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_ConnectAck> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_ConnectAck>(this, __ConnectAck_name, ConnectAck_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__ConnectAck_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                result__.writeEmptyParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void ConnectAck_completed__(Slice.Callback_Sender_ConnectAck cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_Sender_SendAck> begin_SendAck(int recvPort, long serial)
        {
            return begin_SendAck(recvPort, serial, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_SendAck> begin_SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_SendAck(recvPort, serial, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_SendAck(int recvPort, long serial, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SendAck(recvPort, serial, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SendAck(recvPort, serial, ctx__, true, cb__, cookie__);
        }

        private const string __SendAck_name = "SendAck";

        public void end_SendAck(Ice.AsyncResult r__)
        {
            end__(r__, __SendAck_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_SendAck> begin_SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_SendAck> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_SendAck>(this, __SendAck_name, SendAck_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__SendAck_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeInt(recvPort);
                os__.writeLong(serial);
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void SendAck_completed__(Slice.Callback_Sender_SendAck cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_Sender_SendData> begin_SendData(int recvPort, Slice.TransMessage message)
        {
            return begin_SendData(recvPort, message, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_Sender_SendData> begin_SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_SendData(recvPort, message, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_SendData(int recvPort, Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SendData(recvPort, message, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SendData(recvPort, message, ctx__, true, cb__, cookie__);
        }

        private const string __SendData_name = "SendData";

        public void end_SendData(Ice.AsyncResult r__)
        {
            end__(r__, __SendData_name);
        }

        private Ice.AsyncResult<Slice.Callback_Sender_SendData> begin_SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_SendData> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_Sender_SendData>(this, __SendData_name, SendData_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__SendData_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeInt(recvPort);
                os__.writeObject(message);
                os__.writePendingObjects();
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void SendData_completed__(Slice.Callback_Sender_SendData cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        #endregion

        #region Checked and unchecked cast operations

        public static SenderPrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            SenderPrx r = b as SenderPrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                SenderPrxHelper h = new SenderPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static SenderPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            SenderPrx r = b as SenderPrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                SenderPrxHelper h = new SenderPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static SenderPrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    SenderPrxHelper h = new SenderPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static SenderPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    SenderPrxHelper h = new SenderPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static SenderPrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            SenderPrx r = b as SenderPrx;
            if(r == null)
            {
                SenderPrxHelper h = new SenderPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static SenderPrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            SenderPrxHelper h = new SenderPrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::Ice::Object",
            "::Slice::Sender"
        };

        public static string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Marshaling support

        protected override Ice.ObjectDelM_ createDelegateM__()
        {
            return new SenderDelM_();
        }

        protected override Ice.ObjectDelD_ createDelegateD__()
        {
            return new SenderDelD_();
        }

        public static void write__(IceInternal.BasicStream os__, SenderPrx v__)
        {
            os__.writeProxy(v__);
        }

        public static SenderPrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                SenderPrxHelper result = new SenderPrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ServerCallbackPrxHelper : Ice.ObjectPrxHelperBase, ServerCallbackPrx
    {
        #region Synchronous operations

        public void ServerToClient(Slice.TransMessage message)
        {
            ServerToClient(message, null, false);
        }

        public void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            ServerToClient(message, context__, true);
        }

        private void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __ServerToClient_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        ServerCallbackDel_ del__ = (ServerCallbackDel_)delBase__;
                        del__.ServerToClient(message, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        #endregion

        #region Asynchronous operations

        public Ice.AsyncResult<Slice.Callback_ServerCallback_ServerToClient> begin_ServerToClient(Slice.TransMessage message)
        {
            return begin_ServerToClient(message, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_ServerCallback_ServerToClient> begin_ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_ServerToClient(message, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_ServerToClient(Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ServerToClient(message, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ServerToClient(message, ctx__, true, cb__, cookie__);
        }

        private const string __ServerToClient_name = "ServerToClient";

        public void end_ServerToClient(Ice.AsyncResult r__)
        {
            end__(r__, __ServerToClient_name);
        }

        private Ice.AsyncResult<Slice.Callback_ServerCallback_ServerToClient> begin_ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_ServerCallback_ServerToClient> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_ServerCallback_ServerToClient>(this, __ServerToClient_name, ServerToClient_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__ServerToClient_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeObject(message);
                os__.writePendingObjects();
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void ServerToClient_completed__(Slice.Callback_ServerCallback_ServerToClient cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        #endregion

        #region Checked and unchecked cast operations

        public static ServerCallbackPrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ServerCallbackPrx r = b as ServerCallbackPrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ServerCallbackPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            ServerCallbackPrx r = b as ServerCallbackPrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ServerCallbackPrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ServerCallbackPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ServerCallbackPrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ServerCallbackPrx r = b as ServerCallbackPrx;
            if(r == null)
            {
                ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ServerCallbackPrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            ServerCallbackPrxHelper h = new ServerCallbackPrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::Ice::Object",
            "::Slice::ServerCallback"
        };

        public static string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Marshaling support

        protected override Ice.ObjectDelM_ createDelegateM__()
        {
            return new ServerCallbackDelM_();
        }

        protected override Ice.ObjectDelD_ createDelegateD__()
        {
            return new ServerCallbackDelD_();
        }

        public static void write__(IceInternal.BasicStream os__, ServerCallbackPrx v__)
        {
            os__.writeProxy(v__);
        }

        public static ServerCallbackPrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                ServerCallbackPrxHelper result = new ServerCallbackPrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ICombatSessionPrxHelper : Ice.ObjectPrxHelperBase, ICombatSessionPrx
    {
        #region Synchronous operations

        /// <summary>
        /// Destroy the session.
        /// This is called automatically when the
        /// Router is destroyed.
        /// </summary>
        
        public void destroy()
        {
            destroy(null, false);
        }

        /// <summary>
        /// Destroy the session.
        /// This is called automatically when the
        /// Router is destroyed.
        /// </summary>
        /// <param name="context__">The Context map to send with the invocation.</param>
        
        public void destroy(_System.Collections.Generic.Dictionary<string, string> context__)
        {
            destroy(context__, true);
        }

        private void destroy(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __destroy_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        ICombatSessionDel_ del__ = (ICombatSessionDel_)delBase__;
                        del__.destroy(context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void ClientToServer(Slice.TransMessage message)
        {
            ClientToServer(message, null, false);
        }

        public void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            ClientToServer(message, context__, true);
        }

        private void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __ClientToServer_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        ICombatSessionDel_ del__ = (ICombatSessionDel_)delBase__;
                        del__.ClientToServer(message, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        public void SetCallback(Slice.ServerCallbackPrx callback)
        {
            SetCallback(callback, null, false);
        }

        public void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__)
        {
            SetCallback(callback, context__, true);
        }

        private void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
        {
            if(explicitContext__ && context__ == null)
            {
                context__ = emptyContext_;
            }
            Ice.Instrumentation.InvocationObserver observer__ = IceInternal.ObserverHelper.get(this, __SetCallback_name, context__);
            int cnt__ = 0;
            try
            {
                while(true)
                {
                    Ice.ObjectDel_ delBase__ = null;
                    try
                    {
                        delBase__ = getDelegate__(false);
                        ICombatSessionDel_ del__ = (ICombatSessionDel_)delBase__;
                        del__.SetCallback(callback, context__, observer__);
                        return;
                    }
                    catch(IceInternal.LocalExceptionWrapper ex__)
                    {
                        handleExceptionWrapper__(delBase__, ex__, observer__);
                    }
                    catch(Ice.LocalException ex__)
                    {
                        handleException__(delBase__, ex__, true, ref cnt__, observer__);
                    }
                }
            }
            finally
            {
                if(observer__ != null)
                {
                    observer__.detach();
                }
            }
        }

        #endregion

        #region Asynchronous operations

        public Ice.AsyncResult<Glacier2.Callback_Session_destroy> begin_destroy()
        {
            return begin_destroy(null, false, null, null);
        }

        /// <summary>
        /// Destroy the session.
        /// This is called automatically when the
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        public Ice.AsyncResult<Glacier2.Callback_Session_destroy> begin_destroy(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_destroy(ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_destroy(Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_destroy(null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_destroy(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_destroy(ctx__, true, cb__, cookie__);
        }

        private const string __destroy_name = "destroy";

        public void end_destroy(Ice.AsyncResult r__)
        {
            end__(r__, __destroy_name);
        }

        private Ice.AsyncResult<Glacier2.Callback_Session_destroy> begin_destroy(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Glacier2.Callback_Session_destroy> result__ = new IceInternal.OnewayOutgoingAsync<Glacier2.Callback_Session_destroy>(this, __destroy_name, destroy_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__destroy_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                result__.writeEmptyParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void destroy_completed__(Glacier2.Callback_Session_destroy cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_ICombatSession_ClientToServer> begin_ClientToServer(Slice.TransMessage message)
        {
            return begin_ClientToServer(message, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_ICombatSession_ClientToServer> begin_ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_ClientToServer(message, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_ClientToServer(Slice.TransMessage message, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ClientToServer(message, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_ClientToServer(message, ctx__, true, cb__, cookie__);
        }

        private const string __ClientToServer_name = "ClientToServer";

        public void end_ClientToServer(Ice.AsyncResult r__)
        {
            end__(r__, __ClientToServer_name);
        }

        private Ice.AsyncResult<Slice.Callback_ICombatSession_ClientToServer> begin_ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_ICombatSession_ClientToServer> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_ICombatSession_ClientToServer>(this, __ClientToServer_name, ClientToServer_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__ClientToServer_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                os__.writeObject(message);
                os__.writePendingObjects();
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void ClientToServer_completed__(Slice.Callback_ICombatSession_ClientToServer cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<Slice.Callback_ICombatSession_SetCallback> begin_SetCallback(Slice.ServerCallbackPrx callback)
        {
            return begin_SetCallback(callback, null, false, null, null);
        }

        public Ice.AsyncResult<Slice.Callback_ICombatSession_SetCallback> begin_SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_SetCallback(callback, ctx__, true, null, null);
        }

        public Ice.AsyncResult begin_SetCallback(Slice.ServerCallbackPrx callback, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SetCallback(callback, null, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_SetCallback(callback, ctx__, true, cb__, cookie__);
        }

        private const string __SetCallback_name = "SetCallback";

        public void end_SetCallback(Ice.AsyncResult r__)
        {
            end__(r__, __SetCallback_name);
        }

        private Ice.AsyncResult<Slice.Callback_ICombatSession_SetCallback> begin_SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Slice.Callback_ICombatSession_SetCallback> result__ = new IceInternal.OnewayOutgoingAsync<Slice.Callback_ICombatSession_SetCallback>(this, __SetCallback_name, SetCallback_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare__(__SetCallback_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
                IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
                Slice.ServerCallbackPrxHelper.write__(os__, callback);
                result__.endWriteParams__();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }

        private void SetCallback_completed__(Slice.Callback_ICombatSession_SetCallback cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        #endregion

        #region Checked and unchecked cast operations

        public static ICombatSessionPrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ICombatSessionPrx r = b as ICombatSessionPrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ICombatSessionPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            ICombatSessionPrx r = b as ICombatSessionPrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ICombatSessionPrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ICombatSessionPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ICombatSessionPrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ICombatSessionPrx r = b as ICombatSessionPrx;
            if(r == null)
            {
                ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ICombatSessionPrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            ICombatSessionPrxHelper h = new ICombatSessionPrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::Glacier2::Session",
            "::Ice::Object",
            "::Slice::ICombatSession"
        };

        public static string ice_staticId()
        {
            return ids__[2];
        }

        #endregion

        #region Marshaling support

        protected override Ice.ObjectDelM_ createDelegateM__()
        {
            return new ICombatSessionDelM_();
        }

        protected override Ice.ObjectDelD_ createDelegateD__()
        {
            return new ICombatSessionDelD_();
        }

        public static void write__(IceInternal.BasicStream os__, ICombatSessionPrx v__)
        {
            os__.writeProxy(v__);
        }

        public static ICombatSessionPrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                ICombatSessionPrxHelper result = new ICombatSessionPrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }
}

namespace Slice
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface TransMessageDel_ : Ice.ObjectDel_
    {
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface SenderDel_ : Ice.ObjectDel_
    {
        void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ServerCallbackDel_ : Ice.ObjectDel_
    {
        void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public interface ICombatSessionDel_ : Glacier2.SessionDel_
    {
        void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);

        void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__);
    }
}

namespace Slice
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class TransMessageDelM_ : Ice.ObjectDelM_, TransMessageDel_
    {
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class SenderDelM_ : Ice.ObjectDelM_, SenderDel_
    {
        public void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("Close", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeInt(recvPort);
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("CloseAck", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeInt(recvPort);
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("Connect", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeInt(recvPort);
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("ConnectAck", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                og__.writeEmptyParams();
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("SendAck", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeInt(recvPort);
                    os__.writeLong(serial);
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("SendData", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeInt(recvPort);
                    os__.writeObject(message);
                    os__.writePendingObjects();
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ServerCallbackDelM_ : Ice.ObjectDelM_, ServerCallbackDel_
    {
        public void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("ServerToClient", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeObject(message);
                    os__.writePendingObjects();
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ICombatSessionDelM_ : Ice.ObjectDelM_, ICombatSessionDel_
    {
        public void destroy(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("destroy", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                og__.writeEmptyParams();
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("ClientToServer", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    os__.writeObject(message);
                    os__.writePendingObjects();
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }

        public void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            IceInternal.Outgoing og__ = handler__.getOutgoing("SetCallback", Ice.OperationMode.Normal, context__, observer__);
            try
            {
                try
                {
                    IceInternal.BasicStream os__ = og__.startWriteParams(Ice.FormatType.DefaultFormat);
                    Slice.ServerCallbackPrxHelper.write__(os__, callback);
                    og__.endWriteParams();
                }
                catch(Ice.LocalException ex__)
                {
                    og__.abort(ex__);
                }
                bool ok__ = og__.invoke();
                if(og__.hasResponse())
                {
                    try
                    {
                        if(!ok__)
                        {
                            try
                            {
                                og__.throwUserException();
                            }
                            catch(Ice.UserException ex__)
                            {
                                throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                            }
                        }
                        og__.readEmptyParams();
                    }
                    catch(Ice.LocalException ex__)
                    {
                        throw new IceInternal.LocalExceptionWrapper(ex__, false);
                    }
                }
            }
            finally
            {
                handler__.reclaimOutgoing(og__);
            }
        }
    }
}

namespace Slice
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class TransMessageDelD_ : Ice.ObjectDelD_, TransMessageDel_
    {
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class SenderDelD_ : Ice.ObjectDelD_, SenderDel_
    {
        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void Close(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "Close", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.Close(recvPort, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void CloseAck(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "CloseAck", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.CloseAck(recvPort, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void Connect(int recvPort, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "Connect", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.Connect(recvPort, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void ConnectAck(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "ConnectAck", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.ConnectAck(current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void SendAck(int recvPort, long serial, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "SendAck", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.SendAck(recvPort, serial, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void SendData(int recvPort, Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "SendData", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                Sender servant__ = null;
                try
                {
                    servant__ = (Sender)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.SendData(recvPort, message, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ServerCallbackDelD_ : Ice.ObjectDelD_, ServerCallbackDel_
    {
        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void ServerToClient(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "ServerToClient", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                ServerCallback servant__ = null;
                try
                {
                    servant__ = (ServerCallback)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.ServerToClient(message, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public sealed class ICombatSessionDelD_ : Ice.ObjectDelD_, ICombatSessionDel_
    {
        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void destroy(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "destroy", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                ICombatSession servant__ = null;
                try
                {
                    servant__ = (ICombatSession)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.destroy(current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void ClientToServer(Slice.TransMessage message, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "ClientToServer", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                ICombatSession servant__ = null;
                try
                {
                    servant__ = (ICombatSession)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.ClientToServer(message, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031")]
        public void SetCallback(Slice.ServerCallbackPrx callback, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
        {
            Ice.Current current__ = new Ice.Current();
            initCurrent__(ref current__, "SetCallback", Ice.OperationMode.Normal, context__);
            IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
            {
                ICombatSession servant__ = null;
                try
                {
                    servant__ = (ICombatSession)obj__;
                }
                catch(_System.InvalidCastException)
                {
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }
                servant__.SetCallback(callback, current__);
                return Ice.DispatchStatus.DispatchOK;
            };
            IceInternal.Direct direct__ = null;
            try
            {
                direct__ = new IceInternal.Direct(current__, run__);
                try
                {
                    Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
                    _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                }
                finally
                {
                    direct__.destroy();
                }
            }
            catch(Ice.SystemException)
            {
                throw;
            }
            catch(_System.Exception ex__)
            {
                IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
            }
        }
    }
}

namespace Slice
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public abstract class SenderDisp_ : Ice.ObjectImpl, Sender
    {
        #region Slice operations

        public void SendData(int recvPort, Slice.TransMessage message)
        {
            SendData(recvPort, message, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void SendData(int recvPort, Slice.TransMessage message, Ice.Current current__);

        public void SendAck(int recvPort, long serial)
        {
            SendAck(recvPort, serial, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void SendAck(int recvPort, long serial, Ice.Current current__);

        public void Connect(int recvPort)
        {
            Connect(recvPort, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void Connect(int recvPort, Ice.Current current__);

        public void ConnectAck()
        {
            ConnectAck(Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void ConnectAck(Ice.Current current__);

        public void Close(int recvPort)
        {
            Close(recvPort, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void Close(int recvPort, Ice.Current current__);

        public void CloseAck(int recvPort)
        {
            CloseAck(recvPort, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void CloseAck(int recvPort, Ice.Current current__);

        #endregion

        #region Slice type-related members

        public static new readonly string[] ids__ = 
        {
            "::Ice::Object",
            "::Slice::Sender"
        };

        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override string[] ice_ids()
        {
            return ids__;
        }

        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        public override string ice_id()
        {
            return ids__[1];
        }

        public override string ice_id(Ice.Current current__)
        {
            return ids__[1];
        }

        public static new string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Operation dispatch

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus SendData___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int recvPort;
            recvPort = is__.readInt();
            IceInternal.ParamPatcher<Slice.TransMessage> message__PP = new IceInternal.ParamPatcher<Slice.TransMessage>(Slice.TransMessage.ice_staticId());
            is__.readObject(message__PP);
            is__.readPendingObjects();
            inS__.endReadParams();
            obj__.SendData(recvPort, message__PP.value, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus SendAck___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int recvPort;
            long serial;
            recvPort = is__.readInt();
            serial = is__.readLong();
            inS__.endReadParams();
            obj__.SendAck(recvPort, serial, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus Connect___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int recvPort;
            recvPort = is__.readInt();
            inS__.endReadParams();
            obj__.Connect(recvPort, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus ConnectAck___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            inS__.readEmptyParams();
            obj__.ConnectAck(current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus Close___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int recvPort;
            recvPort = is__.readInt();
            inS__.endReadParams();
            obj__.Close(recvPort, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus CloseAck___(Sender obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int recvPort;
            recvPort = is__.readInt();
            inS__.endReadParams();
            obj__.CloseAck(recvPort, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        private static string[] all__ =
        {
            "Close",
            "CloseAck",
            "Connect",
            "ConnectAck",
            "SendAck",
            "SendData",
            "ice_id",
            "ice_ids",
            "ice_isA",
            "ice_ping"
        };

        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
        {
            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
            if(pos < 0)
            {
                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
            }

            switch(pos)
            {
                case 0:
                {
                    return Close___(this, inS__, current__);
                }
                case 1:
                {
                    return CloseAck___(this, inS__, current__);
                }
                case 2:
                {
                    return Connect___(this, inS__, current__);
                }
                case 3:
                {
                    return ConnectAck___(this, inS__, current__);
                }
                case 4:
                {
                    return SendAck___(this, inS__, current__);
                }
                case 5:
                {
                    return SendData___(this, inS__, current__);
                }
                case 6:
                {
                    return ice_id___(this, inS__, current__);
                }
                case 7:
                {
                    return ice_ids___(this, inS__, current__);
                }
                case 8:
                {
                    return ice_isA___(this, inS__, current__);
                }
                case 9:
                {
                    return ice_ping___(this, inS__, current__);
                }
            }

            _System.Diagnostics.Debug.Assert(false);
            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
        }

        #endregion

        #region Marshaling support

        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.endWriteSlice();
        }

        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            is__.endReadSlice();
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public abstract class ServerCallbackDisp_ : Ice.ObjectImpl, ServerCallback
    {
        #region Slice operations

        public void ServerToClient(Slice.TransMessage message)
        {
            ServerToClient(message, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void ServerToClient(Slice.TransMessage message, Ice.Current current__);

        #endregion

        #region Slice type-related members

        public static new readonly string[] ids__ = 
        {
            "::Ice::Object",
            "::Slice::ServerCallback"
        };

        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override string[] ice_ids()
        {
            return ids__;
        }

        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        public override string ice_id()
        {
            return ids__[1];
        }

        public override string ice_id(Ice.Current current__)
        {
            return ids__[1];
        }

        public static new string ice_staticId()
        {
            return ids__[1];
        }

        #endregion

        #region Operation dispatch

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus ServerToClient___(ServerCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            IceInternal.ParamPatcher<Slice.TransMessage> message__PP = new IceInternal.ParamPatcher<Slice.TransMessage>(Slice.TransMessage.ice_staticId());
            is__.readObject(message__PP);
            is__.readPendingObjects();
            inS__.endReadParams();
            obj__.ServerToClient(message__PP.value, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        private static string[] all__ =
        {
            "ServerToClient",
            "ice_id",
            "ice_ids",
            "ice_isA",
            "ice_ping"
        };

        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
        {
            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
            if(pos < 0)
            {
                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
            }

            switch(pos)
            {
                case 0:
                {
                    return ServerToClient___(this, inS__, current__);
                }
                case 1:
                {
                    return ice_id___(this, inS__, current__);
                }
                case 2:
                {
                    return ice_ids___(this, inS__, current__);
                }
                case 3:
                {
                    return ice_isA___(this, inS__, current__);
                }
                case 4:
                {
                    return ice_ping___(this, inS__, current__);
                }
            }

            _System.Diagnostics.Debug.Assert(false);
            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
        }

        #endregion

        #region Marshaling support

        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.endWriteSlice();
        }

        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            is__.endReadSlice();
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.5.1")]
    public abstract class ICombatSessionDisp_ : Ice.ObjectImpl, ICombatSession
    {
        #region Slice operations

        public void SetCallback(Slice.ServerCallbackPrx callback)
        {
            SetCallback(callback, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void SetCallback(Slice.ServerCallbackPrx callback, Ice.Current current__);

        public void ClientToServer(Slice.TransMessage message)
        {
            ClientToServer(message, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void ClientToServer(Slice.TransMessage message, Ice.Current current__);

        #endregion

        #region Inherited Slice operations

        public void destroy()
        {
            destroy(Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void destroy(Ice.Current current__);

        #endregion

        #region Slice type-related members

        public static new readonly string[] ids__ = 
        {
            "::Glacier2::Session",
            "::Ice::Object",
            "::Slice::ICombatSession"
        };

        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override string[] ice_ids()
        {
            return ids__;
        }

        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        public override string ice_id()
        {
            return ids__[2];
        }

        public override string ice_id(Ice.Current current__)
        {
            return ids__[2];
        }

        public static new string ice_staticId()
        {
            return ids__[2];
        }

        #endregion

        #region Operation dispatch

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus SetCallback___(ICombatSession obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            Slice.ServerCallbackPrx callback;
            callback = Slice.ServerCallbackPrxHelper.read__(is__);
            inS__.endReadParams();
            obj__.SetCallback(callback, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus ClientToServer___(ICombatSession obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            IceInternal.ParamPatcher<Slice.TransMessage> message__PP = new IceInternal.ParamPatcher<Slice.TransMessage>(Slice.TransMessage.ice_staticId());
            is__.readObject(message__PP);
            is__.readPendingObjects();
            inS__.endReadParams();
            obj__.ClientToServer(message__PP.value, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        private static string[] all__ =
        {
            "ClientToServer",
            "SetCallback",
            "destroy",
            "ice_id",
            "ice_ids",
            "ice_isA",
            "ice_ping"
        };

        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
        {
            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
            if(pos < 0)
            {
                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
            }

            switch(pos)
            {
                case 0:
                {
                    return ClientToServer___(this, inS__, current__);
                }
                case 1:
                {
                    return SetCallback___(this, inS__, current__);
                }
                case 2:
                {
                    return Glacier2.SessionDisp_.destroy___(this, inS__, current__);
                }
                case 3:
                {
                    return ice_id___(this, inS__, current__);
                }
                case 4:
                {
                    return ice_ids___(this, inS__, current__);
                }
                case 5:
                {
                    return ice_isA___(this, inS__, current__);
                }
                case 6:
                {
                    return ice_ping___(this, inS__, current__);
                }
            }

            _System.Diagnostics.Debug.Assert(false);
            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
        }

        #endregion

        #region Marshaling support

        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.endWriteSlice();
        }

        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            is__.endReadSlice();
        }

        #endregion
    }
}