C# ICommand.ToString方法代码示例

        public void RouteToHandler(ICommand command)
        {
            //optype set in logger context information about the logical operation that the system is executing
            //is used to group log messages togheter and to correlate child log to a logical operation.
            _logger.SetOpType("command", command.GetType().FullName + " Id:" + command.Id);
            
            _logger.Info("[queue] processing command " + command.ToString());

            var commandType = command.GetType();
            
            //get the executor function from the catalog, and then simply execute the command.
            var commandinvoker = _commandHandlerCatalog.GetExecutorFor(commandType);
            try
            {
                commandinvoker.Invoke(command);
                _logger.Info("[queue] command handled " + command.ToString());
            }
            catch (System.Exception ex)
            {
                //TODO log or do something better instead of retrhowing exception
                _logger.Error("[queue] Command error " + ex.Message, ex);
                throw;
            }
            finally 
            {
                _logger.RemoveOpType();
            }
            
        }

 public ICommand ExecuteCommand(ICommand command)
 {
     Stack<ICommand> commandStack = GetCommandStack();
       command.Execute();
       SubscriptionService.SubscriptionService.NotifyAll(command.ToString());
       commandStack.Push(command);
       return command;
 }

        public void Dispatch(ICommand cmd)
        {
            if (cmd.Timestamp == DateTime.MinValue)
            {
                throw new ArgumentException("Command must have a timestamp: " + cmd.GetType());
            }

            if (this.services.ContainsKey(cmd.GetType()))
            {
                foreach (var handler in this.services[cmd.GetType()])
                {
                    lock (onecommand)
                    {
                        Logger.DebugFormat("Dispatching Command: {0}", cmd.ToString());
                        handler.Execute(cmd);                        
                    }
                }
            }
            else
            {
                throw new InvalidOperationException(string.Format("No service to execute command {0}", cmd));
            }
        }

        /// <summary>
        /// Sends a command over the network
        /// </summary>
        /// <param name="command">The command to be sent</param>
        /// <param name="process">Should the command data be processed?</param>
        public virtual void SendCommand(ICommand command, bool process = true)
        {
            lock (lockObject)
            {
                string commandString = command.ToString() + '\n';
                if (commandString.Length > 511)
                {
                    throw new CommandTooLongException();
                }
                if (socket == null)
                {
                    return;
                }
                OnSendRawData(commandString);

                byte[] data = ConnectionEncoding.GetBytes(commandString);
                SendData(data);

                if (process)
                {
                    OnReceive(commandString, true);
                }
            }
        }

 private void ExecuteCommand(ICommand command)
 {
     try
     {
         command.Execute();
     }
     catch (ThreadAbortException)
     {
         _logger.DebugFormat("Swallowed ThreadAbortException");
         //Swallow. A redirect has happened
     }
     catch (Exception ex)
     {
         _logger.WarnFormat(ex, "Failed to execute {0} command", command.ToString());
     }
 }

        static void DebugPrintCommand(string prefix, ICommand command)
        {
            System.Diagnostics.Debugger.Log(0, "CmdHistory",
                String.Format("{0}:{1}\n", prefix, command.ToString()));

            CommandCollection cq = command as CommandCollection;
            if (cq != null)
            {
                for (int i = 0; i < cq.Count; ++i)
                {
                    System.Diagnostics.Debugger.Log(0, "CmdHistory",
                        String.Format("    [{0}]:{1}\n", i, cq[i].ToString()));
                }
            }
        }

 protected override void SaveEventsOnEventStore(ICommand command, EntityId entityId, IEnumerable<IEvent> versionedEvents)
 {
     var aggregateRootId = command.AggregateRootId;
     var eventDescriptors = versionedEvents.Select(evnt => BuildEventDescriptor(command.CommandId, entityId, evnt));
     CommandDescriptorsFor(aggregateRootId).Add(new CommandDescriptor(command.CommandId, aggregateRootId, command.Created, AggregateRootType(aggregateRootId), CommandType(command), command.ToString()));
     EventDescriptorsForEntity(entityId).AddRange(eventDescriptors);
 }

 public override void UnregisterCommand(ICommand command)
 {
     StackFrame frame = new StackFrame(skipFrames);
     var method = frame.GetMethod();
     var type = method.DeclaringType;
     var name = method.Name;
     var c = command.ToString();
     var key = string.Format("{0}.{1} -> {2}", type.Name, name, Label);
     Registrations.remove(key);            
     base.UnregisterCommand(command);
 }

        void RunCommand(ICommand command)
        {
            _serviceClient.CommandClient.ExecuteCommand(command);
              _commandStack.Push(command);
              ToolStripMenuItem undoCommandMenuItem = new ToolStripMenuItem(command.ToString());
              undoToolStripMenuItem.DropDownItems.Add(undoCommandMenuItem);

              //undoToolStripMenuItem.Click += (s, e) =>
              //  {
              //    UndoCommand();
              //    undoToolStripMenuItem.DropDownItems.RemoveAt(undoToolStripMenuItem.DropDownItems.Count-1);
              //  };
        }