private void PreviewReceive(object sender, CommunicationReceiveEventArgs e)
 {
     if (e.Head == null || e.Head.Length != 17)
     {
         e.Handled = true;
         return;
     }
 }
 private void Receive(object sender, CommunicationReceiveEventArgs e)
 {
     if (e.Head[0] < 3)
     {
         var id = new Guid(e.Head.Skip(1).Take(16).ToArray());
         IOManager.SetMessage(id, e.Data);
         return;
     }
     Receive_3_InvokeMethod(e);
 }
        private void Execute_0_ChannelExist(CommunicationReceiveEventArgs e)
        {
            string channelName = MessageFormatter.ToChannelExist(e.Data);

            if (ChannelManager.Exist(channelName))
            {
                e.Communication.Send(new byte[] { 1 }, e.Head);
            }
            else
            {
                e.Communication.Send(new byte[] { 0 }, e.Head);
            }
        }
        private void Execute_1_CreateChannel(CommunicationReceiveEventArgs e)
        {
            string channelName = MessageFormatter.ToChannelExist(e.Data);

            if (ChannelManager.Exist(channelName))
            {
                ServiceUser user = (ServiceUser)e.Communication["user"];
                InstanceManager.GetInstance(ChannelManager[channelName], InvokeMethod, user);
                e.Communication.Send(new byte[] { 1 }, e.Head);
            }
            else
            {
                e.Communication.Send(new byte[] { 0 }, e.Head);
            }
        }
        private void Receive(object sender, CommunicationReceiveEventArgs e)
        {
            switch (e.Head[0])
            {
            case 0:
                Execute_0_ChannelExist(e);
                break;

            case 1:
                Execute_1_CreateChannel(e);
                break;

            case 2:
                Execute_2_MethodInvoke(e);
                break;

            case 3:
                var id = new Guid(e.Head.Skip(1).Take(16).ToArray());
                IOManager.SetMessage(id, e.Data);
                break;
            }
        }
        private void Execute_2_MethodInvoke(CommunicationReceiveEventArgs e)
        {
            ServiceChannel channel;
            int            methodIndex;

            object[] args;
            MessageFormatter.ToChannelMethodInvoke(e.Data, ChannelManager, out channel, out methodIndex, out args);

            ServiceUser user = (ServiceUser)e.Communication["user"];

            byte[] data;
            if (channel == null)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "ChannelNotExist");
                e.Communication.Send(data, e.Head);
                return;
            }

            if (methodIndex >= channel.Provider.ServerOperations.Count)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodNotExist");
                e.Communication.Send(data, e.Head);
                return;
            }
            var method = channel.Provider.ServerOperations[methodIndex];

            var instance = InstanceManager.GetInstance(channel, InvokeMethod, user);

            ServiceContext.Context = user.GetContext(channel);

            if (instance == null)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "InstanceCreateFailed");
                e.Communication.Send(data, e.Head);
                return;
            }
            object result;

            if (args.Length == 0)
            {
                args = null;
            }
            try
            {
                result = method.Invoke(instance, args);
            }
            catch (ArgumentException ex)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodParametersError");
                e.Communication.Send(data, e.Head);
                return;
            }
            catch (Exception ex)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodRuntimeError");
                e.Communication.Send(data, e.Head);
                return;
            }
            data = MessageFormatter.FromChannelMethodResult(result, null);
            e.Communication.Send(data, e.Head);
        }
        internal void Receive_3_InvokeMethod(CommunicationReceiveEventArgs e)
        {
            byte[]         data;
            ServiceChannel channel;
            int            methodIndex;

            object[]         args;
            BinaryDataReader reader = new BinaryDataReader(e.Data);
            var channelName         = reader.ReadString().ToLower().Trim();

            channel = ChannelBuffer.Keys.SingleOrDefault(t => t.Name.ToLower().Trim() == channelName);
            if (channel == null)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "ChannelNotExist");
                Client.Send(data, e.Head);
                return;
            }
            methodIndex = reader.ReadInt32();
            if (methodIndex >= channel.Provider.ClientOperations.Count)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodNotExist");
                Client.Send(data, e.Head);
                return;
            }
            var method    = channel.Provider.ClientOperations[methodIndex];
            var parameter = method.GetParameters();

            args = new object[reader.ReadByte()];
            for (int i = 0; i < args.Length; i++)
            {
                if (channel.Formatter != null)
                {
                    args[i] = channel.Formatter.Deserialize(parameter[i].ParameterType, reader.ReadBytes());
                }
                else
                {
                    args[i] = DataFormatter.Deserialize(parameter[i].ParameterType, reader.ReadBytes());
                }
            }

            var instance = ChannelBuffer[channel].GetType().GetMethod("GetChannel").Invoke(ChannelBuffer[channel], null);

            if (instance == null)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "InstanceCreateFailed");
                Client.Send(data, e.Head);
                return;
            }
            object result;

            try
            {
                result = method.Invoke(instance, args);
            }
            catch (ArgumentException)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodParametersError");
                Client.Send(data, e.Head);
                return;
            }
            catch (Exception)
            {
                data = MessageFormatter.FromChannelMethodResult(null, "MethodRuntimeError");
                Client.Send(data, e.Head);
                return;
            }
            data = MessageFormatter.FromChannelMethodResult(result, null);
            Client.Send(data, e.Head);
        }