public IndexViewModel()
        {
            ConsentValidFromStart = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            ConsentValidFromEnd = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            ConsentValidToStart = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            ConsentValidToEnd = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            NotificationReceivedStart = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            NotificationReceivedEnd = new OptionalDateInputViewModel(allowPastDates: true, showLabels: false);
            NotificationTypes = new SelectList(EnumHelper.GetValues(typeof(NotificationType)), dataTextField: "Value", dataValueField: "Key");
            TradeDirections = new SelectList(EnumHelper.GetValues(typeof(TradeDirection)), dataTextField: "Value", dataValueField: "Key");
            InterimStatus = new SelectList(new[]
            {
                new SelectListItem
                {
                    Text = "Interim",
                    Value = "true"
                },
                new SelectListItem
                {
                    Text = "Non-interim",
                    Value = "false"
                }
            }, dataTextField: "Text", dataValueField: "Value");
            OperationCodes = new MultiSelectList(EnumHelper.GetValues(typeof(OperationCode)), dataTextField: "Value", dataValueField: "Key");

            NotificationStatuses = new SelectList(GetCombinedNotificationStatuses(), dataTextField: "Name", dataValueField: "StatusId", dataGroupField: "TradeDirection", selectedValue: null);

            SelectedOperationCodes = new OperationCode[] { };
        }

 public void RegisterController(OperationCode opCode,ControllerBase controll)
 {
     if (!controllers.ContainsKey((byte)opCode))
     {
         controllers.Add((byte)opCode, controll);
     }
 }

 //用于注册Controller的方法
 public void RegisterController(OperationCode opCode, ControllerBase controller)
 {
     controllers.Add((byte) opCode, controller);
     //if (!controllers.ContainsKey((byte) opCode))
     //{
     //    controllers.Add((byte) opCode, controller);
     //}
 }

        public void Operation_Code_Is_Correctly_Deserialized(byte[] flagBytes, OperationCode expectedValue)
        {
            var bytes = _headerBytes.WithFlagBytes(flagBytes).ToArray();

            var message = _serializer.DeserializeFromBytes(bytes);

            Assert.That(message.OperationCode, Is.EqualTo(expectedValue));
        }

        public static OperationCode[] GetOperationCodes()
        {
            var values = Enum.GetValues(typeof(OperationCode));
            var result = new OperationCode[values.Length - BUILTIN_OPCODES_INDEX];
            for (int i = BUILTIN_OPCODES_INDEX, j = 0; i < values.Length; i++, j++)
            {
                result[j] = (OperationCode)values.GetValue(i);
            }

            return result;
        }

        public static ParameterDefinition[] ParametersInfo(OperationCode funcOpcode)
        {
            ParameterDefinition[] info;
            if(!_paramInfoCache.TryGetValue(funcOpcode, out info))
            {
                info = _paramInfoGenerators[funcOpcode]();
                _paramInfoCache.Add(funcOpcode, info);
            }

            return info;
        }

 public static string GetName(OperationCode OperationEnum)
 {
     switch (OperationEnum)
     {
         case OperationCode.BootRequest:
             return "BootRequest";
         case OperationCode.BootReply:
             return "BootReply";
         default:
             return "Unknown";
     }
 }

        public OperationRequest(DataPhaseInfo dpi, OperationCode ope, UInt32 tid, 
			UInt32 param1 = 0, UInt32 param2 = 0, UInt32 param3 = 0, UInt32 param4 = 0, UInt32 param5 = 0)
        {
            DataPhaseInfo = dpi;
            OperationCode = ope;
            TransactionID = tid;
            Parameter1 = param1;
            Parameter2 = param2;
            Parameter3 = param3;
            Parameter4 = param4;
            Parameter5 = param5;
            PacketType = PacketType.OperationRequest;
        }

        public OperationResponse operationRequest(
            DataPhaseInfo dpi, OperationCode code, UInt32 tid,
            UInt32 param1 = 0, UInt32 param2 = 0, UInt32 param3 = 0, UInt32 param4 = 0, UInt32 param5 = 0)
        {
            OperationRequest request = new OperationRequest(
                dpi, code, tid, param1, param2, param3, param4, param5);
            request.send(cmdStream);

            OperationResponse response = new OperationResponse();
            response.recv(cmdStream);

            return response;
        }

        //用来转发请求
        public static void TransmitRequest(ClientPeer peer, OperationRequest request,OperationCode opCode)
        {
            foreach (ClientPeer temp in peer.Team.clientPeers)
            {
                if (temp != peer)
                {
                    EventData data = new EventData();
                    data.Parameters = request.Parameters;
                    ParameterTool.AddOperationcodeSubcodeRoleID(data.Parameters, opCode, peer.LoginRole.ID);
                    temp.SendEvent(data, new SendParameters());
                }

            }
        }

        public static NotificationType GetCodeType(OperationCode operationCode)
        {
            var attribute = typeof(OperationCode).GetField(operationCode.ToString())
                .GetCustomAttribute<OperationCodeTypeAttribute>(false);
            
            if (attribute == null)
            {
                throw new InvalidOperationException("Operation Code " 
                    + operationCode 
                    + " does not provide a Operation Code type attribute.");
            }

            return attribute.OperationType;
        }

 public void ProcessOperationRequest(OperationCode code, IDictionary<byte, object> parameters)
 {
     if (code == OperationCode.HandleOperation)
     {
         _service.HandleOperation(_reader.ReadOperation(parameters));
     }
     else if (code == OperationCode.HandleOperationWithResponse)
     {
         _service.HandleOperationWithResponse(_reader.ReadOperation(parameters), _reader.ReadPromiseId(parameters));
     }
     else if (code == OperationCode.HandleResponse)
     {
         _service.HandleResponse(_reader.ReadResponse(parameters));
     }
 }

        public async Task<int> LogOperationAsync(int cardId, decimal amount, OperationCode code, DateTime date)
        {
            var operation = new Operation
                            {
                                CardId = cardId,
                                Amount = amount,
                                Code = code,
                                Date = date
                            };

            _context.Operations.Add(operation);

            await _context.SaveChangesAsync();

            return operation.Id;
        }

        public ResponseCode operationRequest(
            DataPhaseInfo dpi, OperationCode code, UInt32 tid,
            UInt32 param1 = 0, UInt32 param2 = 0, UInt32 param3 = 0, UInt32 param4 = 0, UInt32 param5 = 0)
        {
            // OperationRequestを送信
            byte[] data = operationRequestData(dpi, code, tid, param1, param2, param3, param4, param5);
            stream.Write(data, 0, data.Length);

            // データフェーズがあれば送信（未実装）
            if (dpi == DataPhaseInfo.DataOutPhase)
            {
                sendDataPhase(tid);
            }

            // データを受信
            data = recvAllData();
            UInt32 length = BitConverter.ToUInt32(data, 0);
            PacketType pt = (PacketType)BitConverter.ToUInt32(data, 4);

            // データフェーズがあれば受信する
            if (pt == PacketType.StartData)
            {
                // 全データサイズ
                UInt64 tlen = BitConverter.ToUInt64(data, 12);
                recvData = new byte[tlen];
                int recvDataCount = 0;
                do
                {
                    data = recvAllData();
                    length = BitConverter.ToUInt32(data, 0);
                    pt = (PacketType)BitConverter.ToUInt32(data, 4);
                    Array.Copy(data, 12, recvData, recvDataCount, length - 12);
                    recvDataCount += (int)length - 12;
                }
                while (pt != PacketType.EndData);

                data = recvAllData();
                length = BitConverter.ToUInt32(data, 0);
                pt = (PacketType)BitConverter.ToUInt32(data, 4);
            }

            return (ResponseCode)BitConverter.ToUInt16(data, 8);
        }

 private Expression ParseBinaryOperation(OperationCode currentOpcode)
 {
     switch (currentOpcode) {
     default:
       Debug.Assert(false);
       goto case OperationCode.Xor;
     case OperationCode.Add:
     case OperationCode.Add_Ovf:
     case OperationCode.Add_Ovf_Un:
       return this.ParseAddition(currentOpcode);
     case OperationCode.And:
       return this.ParseBinaryOperation(new BitwiseAnd());
     case OperationCode.Ceq:
       return this.ParseBinaryOperation(new Equality());
     case OperationCode.Cgt:
       return this.ParseBinaryOperation(new GreaterThan());
     case OperationCode.Cgt_Un:
       return this.ParseBinaryOperation(new GreaterThan() { IsUnsignedOrUnordered = true });
     case OperationCode.Clt:
       return this.ParseBinaryOperation(new LessThan());
     case OperationCode.Clt_Un:
       return this.ParseBinaryOperation(new LessThan() { IsUnsignedOrUnordered = true });
     case OperationCode.Div:
       return this.ParseBinaryOperation(new Division());
     case OperationCode.Div_Un:
       return this.ParseUnsignedBinaryOperation(new Division() { TreatOperandsAsUnsignedIntegers = true });
     case OperationCode.Mul:
     case OperationCode.Mul_Ovf:
     case OperationCode.Mul_Ovf_Un:
       return this.ParseMultiplication(currentOpcode);
     case OperationCode.Or:
       return this.ParseBinaryOperation(new BitwiseOr());
     case OperationCode.Rem:
       return this.ParseBinaryOperation(new Modulus());
     case OperationCode.Rem_Un:
       return this.ParseUnsignedBinaryOperation(new Modulus() { TreatOperandsAsUnsignedIntegers = true });
     case OperationCode.Shl:
       return this.ParseBinaryOperation(new LeftShift());
     case OperationCode.Shr:
       return this.ParseBinaryOperation(new RightShift());
     case OperationCode.Shr_Un:
       RightShift shrun = new RightShift();
       shrun.RightOperand = this.PopOperandStack();
       shrun.LeftOperand = this.PopOperandStackAsUnsigned();
       return shrun;
     case OperationCode.Sub:
     case OperationCode.Sub_Ovf:
     case OperationCode.Sub_Ovf_Un:
       return this.ParseSubtraction(currentOpcode);
     case OperationCode.Xor:
       return this.ParseBinaryOperation(new ExclusiveOr());
       }
 }

 private Expression ParseAddition(OperationCode currentOpcode)
 {
     Addition addition = new Addition();
       addition.CheckOverflow = currentOpcode != OperationCode.Add;
       if (currentOpcode == OperationCode.Add_Ovf_Un) {
     addition.TreatOperandsAsUnsignedIntegers = true; //force use of unsigned addition, even for cases where the operands are expressions that result in signed values
     return this.ParseUnsignedBinaryOperation(addition);
       } else
     return this.ParseBinaryOperation(addition);
 }

 private Expression ParseSubtraction(OperationCode currentOpcode)
 {
     Subtraction subtraction = new Subtraction();
       subtraction.CheckOverflow = currentOpcode != OperationCode.Sub;
       if (currentOpcode == OperationCode.Sub_Ovf_Un) {
     subtraction.TreatOperandsAsUnsignedIntegers = true;
     return this.ParseUnsignedBinaryOperation(subtraction);
       } else
     return this.ParseBinaryOperation(subtraction);
 }

 private Expression ParseMultiplication(OperationCode currentOpcode)
 {
     Multiplication multiplication = new Multiplication();
       multiplication.CheckOverflow = currentOpcode != OperationCode.Mul;
       if (currentOpcode == OperationCode.Mul_Ovf_Un) {
     multiplication.TreatOperandsAsUnsignedIntegers = true;
     return this.ParseUnsignedBinaryOperation(multiplication);
       } else
     return this.ParseBinaryOperation(multiplication);
 }

 private static uint SizeOfOperationCode(OperationCode opcode)
 {
     if (((int)opcode) > 0xff && (opcode < OperationCode.Array_Create)) return 2;
       return 1;
 }

 public WasteOperationCode(OperationCode operationCode)
 {
     OperationCode = operationCode;
 }