public void CommandTest()
{
{
Command command = new CommandA();
var i = new Invoke(command);
i.ExecuteCommand();
}
{
// 创建银行帐号
var account = new Account();
// 创建一个存入500元的命令
var commandIn = new MoneyInCommand(account, 500);
// 创建一个调度者
var invoker = new Invoker();
// 执行存钱
invoker.ExecuteCommand(commandIn);
Console.WriteLine("当前余额 " + account.GetTotalAmount().ToString("N2"));
// 再次存入500
var commandIn2 = new MoneyInCommand(account, 500);
invoker.ExecuteCommand(commandIn2);
Console.WriteLine("当前余额 " + account.GetTotalAmount().ToString("N2"));
// 取出300
var commandOut = new MoneyOutCommand(account, 300);
invoker.ExecuteCommand(commandOut);
Console.WriteLine("当前余额 " + account.GetTotalAmount().ToString("N2"));
//重复
invoker.Redo();
Console.WriteLine("当前余额 " + account.GetTotalAmount().ToString("N2"));
}
}
public async Task TestCommandNull()
{
var command = new CommandA();
var self = new CommandAndValidator(command, null);
var result = await CommandValidationSteps.Validate(self);
result.ShouldBe(command);
}
public static void Main(string[] args)
{
using (var bus = new GsBus())
{
Console.WriteLine("Client started!");
while (true)
{
Console.Write("Press ENTER to send command or 'q' to quit: ");
var key = Console.ReadLine();
if ("q".Equals(key, StringComparison.OrdinalIgnoreCase))
{
return;
}
if (!bus.IsConnected)
{
bus.Connect();
}
var cmd = new CommandA {
StrProps = "Hello"
};
Console.WriteLine($"Sending command: {cmd.ToJsonString()}");
bus.Send(cmd);
}
}
}
public async Task TestCommandValid()
{
var command = new CommandA();
var self = new CommandAndValidator(command, _validValidator);
var result = await CommandValidationSteps.Validate(self);
await _validValidator.Received().ValidateAsync(command);
result.ShouldBe(command);
}
protected InControlWrapper(InputDevice _device, CommandA _myCommandA)
{
m_device = _device;
m_myCommandA = _myCommandA;
if (m_myCommandA is Axis)
{
m_myAxis = (m_myCommandA as Axis);
}
}
public void Handle(CommandA message)
{
Data.ReplyAddress = Bus.CurrentMessageContext.ReplyToAddress;
Data.Data = message.Data;
Bus.Send("Process2", new CommandB
{
Data = Data.Data
});
}
public void TestCommandNullIn()
{
var command = new CommandA();
var self = new CommandAndValidatorType(command, null);
var spy = Substitute.For<Func<Type, IValidator>>();
var result = CommandValidationSteps.CreateValidator(self, spy);
result.Command.ShouldBe(command);
result.Validator.ShouldBe(null);
spy.DidNotReceive().Invoke(Arg.Any<Type>());
}
public static void Main(string[] args)
{
IReceiver receiver = new Receiver();
ICommand commandA = new CommandA(receiver);
ICommand commandB = new CommandB(receiver);
commandA.Execute();
commandB.Execute();
}
public PageRendererTestPageViewModel(INavigationService navigationService, CoreModel coreModel) : base(navigationService)
{
KeyHistory = coreModel.ObserveProperty(x => x.KeyHistory).ToReadOnlyReactiveProperty();
KeyDownCommand = new ReactiveCommand <string>().WithSubscribe(x => coreModel.SetKeyHistory(x));
MethodHistory = coreModel.ObserveProperty(x => x.MethodHistory).ToReadOnlyReactiveProperty();
CommandA.Subscribe(_ => coreModel.MethodA());
CommandB.Subscribe(_ => coreModel.MethodB());
CommandC.Subscribe(_ => coreModel.MethodC());
}
public void TestCommandInvalid()
{
var command = new CommandA();
var self = new CommandAndValidator(command, _invalidValidator);
var result = Should.Throw<Qvc.Validation.ValidationException>(async () => await CommandValidationSteps.Validate(self));
_invalidValidator.Received().ValidateAsync(command);
result.Violations.Single().FieldName.ShouldBe("fieldCamelCase");
result.Violations.Single().Message.ShouldBe("error");
}
public async Task TestValidateCommand()
{
var commandA = new CommandA();
var result = await Validate.Command(commandA)
.ThenFindValidator(_validatorRepo.FindValidatorFor)
.ThenCreateValidator(t => Default.CreateHandler(t) as IValidator)
.ThenValidate();
result.ShouldBe(commandA);
}
public override bool AreSame(Command obj)
{
CommandA other = obj as CommandA;
if (other == null)
{
return(false);
}
return(other.Id == this.Id);
}
public override Command DeserializeCommand(BinaryReader str)
{
if (str == null)
{
throw new ArgumentNullException("str");
}
CommandA c = new CommandA();
c.Id = str.ReadInt32();
return(c);
}
public void Command_Test()
{
var command = new CommandA(new Receiver()); // Receiver contains the action
command.Parameter = "hola!!";
var invoker = new Invoker();
invoker.command = command;
var result = invoker.ExecuteCommand();
Assert.IsTrue(result.Contains(command.Parameter) && result.Length > command.Parameter.Length);
}
public void TestCommand()
{
var command = new CommandA();
var self = new CommandAndType(command);
var result = CommandValidationSteps.FindValidator(
self,
t =>
{
t.ShouldBe(self.Type);
return typeof(TestValidator<CommandA>);
});
result.ValidatorType.ShouldBe(typeof(TestValidator<CommandA>));
result.Command.ShouldBe(command);
}
public void TestCommandNullOut()
{
var command = new CommandA();
var self = new CommandAndValidatorType(command, typeof(TestValidator<CommandA>));
var result = CommandValidationSteps.CreateValidator(
self,
t =>
{
t.ShouldBe(typeof(TestValidator<CommandA>));
return null;
});
result.Command.ShouldBe(command);
result.Validator.ShouldBe(null);
}
public void Test_ExecuteCommand_Invokes_CommandHandlerFactory_Create_For_CommandType()
{
//Given
var command = new CommandA();
var mockCommandHandlerFactory = new Mock <ICommandHandlerFactory <CommandA> >();
_commandProcessor.RegisterHandlerFactory(mockCommandHandlerFactory.Object);
//When
var result = _commandProcessor.Execute(command);
//Then
mockCommandHandlerFactory.Verify(x => x.CreateHandler(), Times.Once);
}
public void TestCommandNull()
{
var command = new CommandA();
var self = new CommandAndType(command);
var result = CommandValidationSteps.FindValidator(
self,
t =>
{
t.ShouldBe(self.Type);
return null;
});
result.ValidatorType.ShouldBe(null);
result.Command.ShouldBe(command);
}
private void Start()
{
CommandManager cm = new CommandManager();
//建立一个Command重复使用
Command c = null;
c = new CommandA(new ReciverA(), "命令A1");
cm.AddCommand(c);
c = new CommandA(new ReciverA(), "命令A2");
cm.AddCommand(c);
c = new CommandB(new ReciverB(), "命令B1");
cm.AddCommand(c);
//执行
cm.ExecuateCommand();
}
public void Test_ExecuteCommand_Invokes_CommandHandler_Execute_with_Command()
{
//Given
var command = new CommandA();
var mockCommandHandlerFactory = new Mock <ICommandHandlerFactory <CommandA> >();
var mockCommandHandler = new Mock <ICommandHandler <CommandA> >();
mockCommandHandlerFactory.Setup(x => x.CreateHandler()).Returns(mockCommandHandler.Object);
_commandProcessor.RegisterHandlerFactory(mockCommandHandlerFactory.Object);
//When
var result = _commandProcessor.Execute(command);
//Then
mockCommandHandler.Verify(x => x.Execute(command), Times.Once);
}
public void Test_ExecuteCommand_Invokes_AmbiguousCommandHandler_Execute_with_Command()
{
//Given
var command = new CommandA();
var mockCommandHandlerA = new Mock <ICommandHandler <CommandA> >();
var mockCommandHandlerB = new Mock <ICommandHandler <CommandB> >();
var ambiguousCommandHandlerFactory = new AmbiguousCommandHandlerFactory(mockCommandHandlerA.Object, mockCommandHandlerB.Object);
_commandProcessor.RegisterHandlerFactory <CommandA>(ambiguousCommandHandlerFactory);
_commandProcessor.RegisterHandlerFactory <CommandB>(ambiguousCommandHandlerFactory);
//When
var result = _commandProcessor.Execute(command);
//Then
mockCommandHandlerA.Verify(x => x.Execute(command), Times.Once);
mockCommandHandlerB.Verify(x => x.Execute(It.IsAny <CommandB>()), Times.Never);
}
public override async Task Run()
{
var commandA = new CommandA();
var commandB = new CommandB();
var resulta1 = await _exampleCommandDispatcher.Dispatch <CommandA, Result1>(commandA);
var resulta2 = await _exampleCommandDispatcher.Dispatch <CommandA, Result2>(commandA);
var resultb1 = await _exampleCommandDispatcher.Dispatch <CommandB, Result1>(commandB);
var resultb2 = await _exampleCommandDispatcher.Dispatch <CommandB, Result2>(commandB);
Console.WriteLine(resulta1.GetType());
Console.WriteLine(resulta2.GetType());
Console.WriteLine(resultb1.GetType());
Console.WriteLine(resultb2.GetType());
Console.ReadLine();
}
private void RefreshCommands()
{
CommandA.RaiseCanExecuteChanged();
CommandB.RaiseCanExecuteChanged();
CommandC.RaiseCanExecuteChanged();
}
public ICYButton(InputDevice _device, CommandA _myCommandA) : base(_device, _myCommandA)
{
}
public ICLeftStickX(InputDevice _device, CommandA _myCommandA) : base(_device, _myCommandA)
{
}
public ICRightStickY(InputDevice _device, CommandA _myCommandA) : base(_device, _myCommandA)
{
}
public ICRightTrigger(InputDevice _device, CommandA _myCommandA) : base(_device, _myCommandA)
{
}
public ICLeftBumper(InputDevice _device, CommandA _myCommandA) : base(_device, _myCommandA)
{
}
public static void InputCommand()
{
CommandA[] CommandAList = new CommandA[] {
new CommandA("freeze", FreezeThreads),
new CommandA("resume", ResumeThreads),
new CommandA("threadterm", TerminateThreads),
new CommandA("procterm", TerminateProcess),
new CommandA("threadinfo", ThreadInfo),
new CommandA("memkill", SpecificProcKill),
new CommandA("shake", ShakeWindow)
};
CommandN[] CommandNList = new CommandN[] {
new CommandN("listproc", ListProcesses),
new CommandN("memkillrandom", RandomProcKill),
new CommandN("lasterror", PrintLastError),
new CommandN("exit", ExitFunction),
new CommandN("blockinput", BlockInputCmd),
new CommandN("swapbuttons", SwapButtonsCmd),
new CommandN("beep", Beeps),
new CommandN("beepswap", BeepSwapInit)
};
string input = Console.ReadLine();
bool cmdFound = false;
if (input == "cmds")
{
Console.WriteLine("Commands with args:");
foreach (CommandA com in CommandAList)
{
Console.WriteLine(com.Name);
}
Console.WriteLine();
Console.WriteLine("Commands without args:");
foreach (CommandN com in CommandNList)
{
Console.WriteLine(com.Name);
}
return;
}
if (input.IndexOf(' ') >= 0)
{
int spaceIndex = input.IndexOf(' ');
string inputName = (input.Substring(0, spaceIndex)).ToLower();
string inputArgs = input.Substring(spaceIndex + 1);
foreach (CommandA com in CommandAList)
{
if (com.Name == inputName)
{
com.CmdFunction(inputArgs);
return;
}
}
foreach (CommandN com in CommandNList)
{
if (com.Name == inputName)
{
Console.WriteLine(com.Name + " takes no arguments");
return;
}
}
}
else
{
foreach (CommandN com in CommandNList)
{
if (com.Name == input)
{
com.CmdFunction();
return;
}
}
foreach (CommandA com in CommandAList)
{
if (com.Name == input)
{
Console.WriteLine(com.Name + " takes arguments");
return;
}
}
}
if (cmdFound == false)
{
Console.WriteLine("Invalid command");
}
}
static void Main(string[] args)
{
CommandA comand = new CommandA();
// MenuA menu = new MenuA();
MenuA.Introdusing();
bool generalOptionCycle = true, cycleOption = true;
int choice = 0;
while (generalOptionCycle)
{
MenuA.ShowMenu();
choice = int.Parse(Console.ReadLine());
switch (choice)
{
case 1:
{
cycleOption = true;
do
{
MenuA.ShowTicketMenu();
char operation1;
operation1 = Convert.ToChar(Console.ReadLine());
if (operation1 == 'A')
{
comand.Write("Ticket");
}
else if (operation1 == 'B')
{
comand.ChangeTicket();
}
else if (operation1 == 'C')
{
comand.AddTicket();
}
else if (operation1 == 'D')
{
comand.Write("Ticket");
comand.RemoveByIndexTicket();
}
else if (operation1 == 'E')
{
comand.PopularMovie();
}
else
{
cycleOption = false;
}
}while (cycleOption);
}
break;
case 2:
{
cycleOption = true;
do
{
MenuA.ShowMenuHuman();
int operation2 = Convert.ToInt32(Console.ReadLine());
bool adminInput = true, adminInput2 = true;
if (operation2 == 1)
{
while (adminInput)
{
MenuA.ShowActorMenu();
char operation3A = Convert.ToChar(Console.ReadLine());
switch (operation3A)
{
case 'A':
comand.Write("Actor");
break;
case 'B':
{
comand.PopularActor();
}
break;
case 'C':
{
comand.AddActor();
}
break;
case 'D':
{
comand.Write("Actor");
comand.RemoveByIndexActor();
}
break;
case 'E':
{
adminInput = false;
Console.Clear();
}
break;
}
}
break;
}
if (operation2 == 2)
{
while (adminInput2)
{
MenuA.ShowClientMenu();
char operation3 = Convert.ToChar(Console.ReadLine());
switch (operation3)
{
case 'A':
{
comand.Write("Client");
}
break;
case 'B':
{
comand.PrintRespones();
}
break;
case 'C':
{
comand.Write("Client");
comand.RemoveByIndexClient();
}
break;
case 'E':
{
comand.ShowPopcorn();
}
break;
case 'D':
{
adminInput2 = false;
}
break;
}
}
}
else
{
cycleOption = false;
}
} while (cycleOption);
}
break;
case 3:
{
generalOptionCycle = false;
break;
}
default:
{
Console.WriteLine("Error! Try again");
}
break;
}
}
}
