public CalculationResult Process(File file) { //file parser manager is responsible to parse file and return workable data var calculationItemsResult = FileParserExecutionManager.Process(file); var applyNumber = calculationItemsResult.InitialNumber; //validated ready to use instructions foreach (var calculationItem in calculationItemsResult.Instructions) { // although there are simple math operations, it is good practice to separate operations // rather then doing it with in if else statements // this will help a lot if we need to extend operations or/and change something var operationManager = OperationFactory.Create(calculationItem.InstructionType); applyNumber = operationManager.Calculate(applyNumber, calculationItem.Number); } var result = new CalculationResult { Result = applyNumber }; return(result); }
public void ExecuteOperation1InTest1() { var operationFactory = new OperationFactory(); var testFactory = new TestFactory(operationFactory); Test testExample1 = null; Order order = null; "Given an order" .x(() => order = new Order(testFactory)); "that is added a biochemistry test" .x(() => testExample1 = order.AddTest("testExample1")); "And operation OperationExample1 is added to testExample1" .x(() => testExample1.AddOperation("operationExample1")); "And the order is executed" .x(() => order.ExecuteOperations()); "Then the test must be positive with a value of cofidence 0.95 (both common test properties) and a biochemistryProperty of 0.32" .x(() => { testExample1.Result.Should().Be(Result.Positive); testExample1.Confidence.Should().Be(0.95f); (testExample1 as BiochemistryTest).PropA.Should().Be(0.32f); }); }
public void ExecuteOperation1InImmunologyTest() { var operationFactory = new OperationFactory(); var testFactory = new TestFactory(operationFactory); Test testExample2 = null; Order order = null; "Given an order" .x(() => order = new Order(testFactory)); "that is added a immunology test" .x(() => testExample2 = order.AddTest("testExample2")); "And operation OperationExample1 is added" .x(() => testExample2.AddOperation("operationExample1")); "And the order is executed" .x(() => order.ExecuteOperations()); "Then the test must be negative" .x(() => { testExample2.Result.Should().Be(Result.Negative); testExample2.Confidence.Should().Be(1.0f); }); }
public void ExecuteOperation1And2InTest1() { var operationFactory = new OperationFactory(); var testFactory = new TestFactory(operationFactory); Test testExample1 = null; Order order = null; "Given an order" .x(() => order = new Order(testFactory)); "that is added a biochemistry test" .x(() => testExample1 = order.AddTest("testExample1")); "And operation OperationExample1 and OperationExample2 is added to testExample1" .x(() => { testExample1.AddOperation("operationExample1"); testExample1.AddOperation("operationExample2"); }); "And the order is executed" .x(() => order.ExecuteOperations()); "Then the test must be negative" .x(() => { testExample1.Result.Should().Be(Result.Negative); testExample1.Confidence.Should().Be(1f); (testExample1 as BiochemistryTest).PropA.Should().Be(0.0f); }); }
protected static void Execute(string operationType, string[] args) { var factory = OperationFactory.Create(); var operation = factory.GetOperation(operationType); operation.Execute(Console, args); }
public double SimpleFactory(OperationRequestEntity requestEntity) { var operationFactory = new OperationFactory(); var operation = operationFactory.CreateOperation(requestEntity.OperationType); return(operation.GetResult(requestEntity.num1, requestEntity.num2)); }
public static int Operation(int firtsOperand, int secondOperand, EnumTypeOperation operation) { var operationFactory = new OperationFactory(); var opera = operationFactory.Fabricate(operation); return(opera != null?opera.Calculate(firtsOperand, secondOperand) : 0); }
private void FindAlteredSequences(IEnumerable <Tuple <ISequence, ISequence> > sequencePairs) { _operations.AddRange( sequencePairs .Where(pair => !EquivalentSequences(pair.Item1, pair.Item2)) .Select(pair => OperationFactory.AlterSequenceOperation(pair.Item1, pair.Item2))); }
private void FindCreatedSequences(IEnumerable <Tuple <ISequence, ISequence> > sequencePairs, IEnumerable <ISequence> targetSequences) { _operations.AddRange( targetSequences .Except(sequencePairs.Select(p => p.Item2), (x, y) => MatchSequenceNames(x, y) && MatchSequenceSchemas(x, y)) .Select(s => OperationFactory.CreateSequenceOperation(s))); }
private void FindDroppedSequences(IEnumerable <Tuple <ISequence, ISequence> > sequencePairs, IEnumerable <ISequence> sourceSequences) { _operations.AddRange( sourceSequences .Except(sequencePairs.Select(p => p.Item1), (x, y) => MatchSequenceNames(x, y) && MatchSequenceSchemas(x, y)) .Select(s => OperationFactory.DropSequenceOperation(s))); }
/// <summary> /// コンストラクタ /// </summary> /// <param name="node">対象Node</param> /// <param name="semanticModel">対象ソースのsemanticModel</param> /// <param name="parent">親IAnalyzeItem</param> /// <param name="container">イベントコンテナ</param> public ItemSwitchCase(SwitchSectionSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container) { ItemType = ItemTypes.MethodStatement; var operation = semanticModel.GetOperation(node) as ISwitchCaseOperation; // Caseラベル設定 foreach (var item in operation.Clauses.Where(item => !(item is IDefaultCaseClauseOperation))) { Labels.Add(OperationFactory.GetExpressionList(item.Children.First(), container)); } // defaultラベル設定 foreach (var item in operation.Clauses.Where(item => item is IDefaultCaseClauseOperation)) { Labels.Add(OperationFactory.GetExpressionList(item, container)); } // 内部処理設定 foreach (var statement in node.Statements) { var item = ItemFactory.Create(statement, semanticModel, container, this); if (!(item is null)) { Members.Add(ItemFactory.Create(statement, semanticModel, container, this)); } } }
private void FindRenamedSequences(IEnumerable <Tuple <ISequence, ISequence> > sequencePairs) { _operations.AddRange( sequencePairs .Where(pair => !MatchSequenceNames(pair.Item1, pair.Item2)) .Select(pair => OperationFactory.RenameSequenceOperation(pair.Item1, pair.Item2))); }
static void Main(string[] args) { double numberOne = 0; double numberTwo = 0; string operate = ""; try { Console.WriteLine("Please enter the first number!"); numberOne = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Please enter the second number!"); numberTwo = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Please enter an operator!"); operate = Console.ReadLine(); } catch (Exception ex) { Console.WriteLine("There is a problem with the number you entered!"); Console.WriteLine(ex.Message); } IOperation operation = OperationFactory.CreateOperation(operate); double result = operation.GetResult(numberOne, numberTwo); Console.WriteLine("The Result is " + result); Console.ReadKey(); }
public void SimpleFactoryTestMethod() { Operation oper = null; double numA = 99; double numB = 9.9; oper = OperationFactory.CreateOperate(OperationType.ADD); oper.NumberA = numA; oper.NumberB = numB; Assert.AreEqual(typeof(OperationAdd), oper.GetType()); Assert.AreEqual(numA + numB, oper.GetResult()); oper = OperationFactory.CreateOperate(OperationType.SUB); oper.NumberA = numA; oper.NumberB = numB; Assert.AreEqual(typeof(OperationSub), oper.GetType()); Assert.AreEqual(numA - numB, oper.GetResult()); oper = OperationFactory.CreateOperate(OperationType.MUL); oper.NumberA = numA; oper.NumberB = numB; Assert.AreEqual(typeof(OperationMul), oper.GetType()); Assert.AreEqual(numA * numB, oper.GetResult()); oper = OperationFactory.CreateOperate(OperationType.DIV); oper.NumberA = numA; oper.NumberB = numB; Assert.AreEqual(typeof(OperationDiv), oper.GetType()); Assert.AreEqual(numA / numB, oper.GetResult()); }
public FactoryReturnClass FactoryCalculate([FromBody] JsonFactoryParameter param) { FactoryReturnClass rtn = new FactoryReturnClass(); Operation oper = OperationFactory.CreateOperation(param.oper); if (oper != null) { oper.NumberX = param.NumberX; oper.NumberY = param.NumberY; try{ rtn.Message = "Calculated successfully by factoryPattern!"; rtn.result = oper.CalculateResult(); rtn.ReturnValue = 0; } catch (Exception ex) { rtn.Message = "error:" + ex.Message; rtn.ReturnValue = 100; } finally { } } else { rtn.Message = "Operator is invalid."; rtn.ReturnValue = 101; } return(rtn); }
private static void Main() { while (true) { Console.WriteLine("Enter expression:"); var expression = Console.ReadLine(); if (string.IsNullOrEmpty(expression)) { continue; } if (expression.Equals("exit", StringComparison.OrdinalIgnoreCase)) { break; } try { using var reader = new StringReader(expression); var tokenizer = new Tokenizer(reader); var operationFactory = new OperationFactory(); var engine = new MathExpressionEngine(operationFactory); var result = engine.ParseExpression(tokenizer).Eval(); Console.WriteLine($"Your result: {result}"); } catch (ExpressionParseException ex) { Console.WriteLine(ex.Message); } } }
/// <summary> /// コンストラクタ /// </summary> /// <param name="node">対象Node</param> /// <param name="semanticModel">対象ソースのsemanticModel</param> /// <param name="parent">親IAnalyzeItem</param> /// <param name="container">イベントコンテナ</param> public ItemIf(IfStatementSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container) { ItemType = ItemTypes.MethodStatement; var condition = semanticModel.GetOperation(node.Condition); Conditions.AddRange(OperationFactory.GetExpressionList(condition, container)); TrueBlock.AddRange(GetBlock(node.Statement, semanticModel)); FalseBlocks.AddRange(GetElseBlock(node.Else)); List <IAnalyzeItem> GetElseBlock(ElseClauseSyntax elseNode) { var result = new List <IAnalyzeItem>(); if (elseNode is null) { return(result); } result.Add(ItemFactory.Create(elseNode, semanticModel, container, parent)); // else ifの場合はさらに続ける if (elseNode.Statement is IfStatementSyntax ifNode) { result.AddRange(GetElseBlock(ifNode.Else)); } return(result); } }
public void SimpleFactory_Success_Test() { Operation oper; oper = OperationFactory.CreateOperate("+"); oper.NumberA = 1; oper.NumberB = 2; var addResult = oper.GetResult(); Assert.AreEqual(addResult, 1 + 2); oper = OperationFactory.CreateOperate("-"); oper.NumberA = 1; oper.NumberB = 2; var subResult = oper.GetResult(); Assert.AreEqual(subResult, 1 - 2); oper = OperationFactory.CreateOperate("*"); oper.NumberA = 1; oper.NumberB = 2; var mulResult = oper.GetResult(); Assert.AreEqual(mulResult, 1 * 2); oper = OperationFactory.CreateOperate("/"); oper.NumberA = 1; oper.NumberB = 2; var divResult = oper.GetResult(); Assert.AreEqual(divResult, 1.00 / 2.00); }
public override AssetBundleLoading LoadAssetBundle(string name) { string url = _assetBundlePathPrefix + name; return(OperationFactory.CreateAssetBundleLoadingFromFile(name, url, AssetBundle.LoadFromFileAsync(url))); }
public async Task <Stat.Types.State> ProcessJob(string opName) { // process operations //GetPipeline().ForEach(opName => //{ var newOp = opName; if (opName.Substring(0, 2).ToLower() == "up") { var isNumeric = int.TryParse(opName.Substring(2), out int n); if (isNumeric) { // filter the following number after "up" newOp = "up"; _tk.CurSending = _tk.CurSending + Convert.ToUInt64(opName.Substring(2)); } } var tuple = OperationFactory.CreateOp(newOp, _tk); var obj = tuple.Item1; var type = tuple.Item2; dynamic op = Convert.ChangeType(obj, type); await op.Do(_tk); //}); return(_tk.State); }
static void Main(string[] args) { int result; InputHandler inputHandler = new InputHandler(); OperationFactory operationFactory = new OperationFactory(); List <ICalculate> operaters; while (true) { try { inputHandler.execute(); operaters = operationFactory.createOperations(inputHandler.result); Calculator.Calculator calculator = new Calculator.Calculator(inputHandler.result, operaters); result = calculator.execute(); Console.WriteLine(string.Format("Answer: {0}", result)); inputHandler.result.Clear(); } catch (Exception e) { Console.WriteLine(string.Format("Something went wrong \n{0}", e.Message)); Main(null); } } }
static void Main(string[] args) { try { Console.Write("请输入数字A:"); string strNumberA = Console.ReadLine(); Console.Write("请选择运算符号(+、-、*、/):"); string strOperate = Console.ReadLine(); Console.Write("请输入数字B:"); string strNumberB = Console.ReadLine(); string strResult = ""; Operation oper; oper = OperationFactory.createOperate(strOperate); oper.NumberA = Convert.ToDouble(strNumberA); oper.NumberB = Convert.ToDouble(strNumberB); strResult = oper.GetResult().ToString(); Console.WriteLine("结果是:" + strResult); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine("您的输入有错:" + ex.Message); } }
public OperationFactoryTests() { var logger = Substitute.For <ILogger <OperationFactory> >(); var bus = Substitute.For <IOperationBus>(); _factory = new OperationFactory(logger, new[] { new DummyOperationInitializer() }, bus); }
protected override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters) { switch (operationRequest.OperationCode) { // Echo case 0: { var request = OperationFactory.GetRequest(operationRequest.OperationCode, operationRequest.Parameters) as EchoRequest; EchoResponse response = new EchoResponse(request.Message); SendOperationResponse(new OperationResponse(response.OperationCode, response.Parameters), sendParameters); } break; // Delay Echo case 1: { var request = OperationFactory.GetRequest(operationRequest.OperationCode, operationRequest.Parameters) as DelayRequest; int sleepTime = request.DelayMilliSeconds; Thread.Sleep(sleepTime); DelayResponse response = new DelayResponse(request.DelayMilliSeconds, request.Message); SendOperationResponse(new OperationResponse(response.OperationCode, response.Parameters), sendParameters); } break; } }
static void Main(string[] args) { Console.Title = "计算器"; try { double numberA = 0; double numberB = 0; var opStr = string.Empty; Operation op = null; double result = 0; Console.Write("请输入第一个操作数:"); numberA = double.Parse(Console.ReadLine()); Console.Write("请输入第二个操作数:"); numberB = double.Parse(Console.ReadLine()); Console.Write("请输入运算符(+,/):"); opStr = Console.ReadLine(); op = OperationFactory.CreateOpertion(opStr); op.NumberA = numberA; op.NumberB = numberB; result = op.GetResult(); Console.WriteLine("\n"); Console.WriteLine("******************"); Console.WriteLine("运算结果为:" + result); Console.WriteLine("******************"); } catch (Exception ex) { Console.WriteLine($"发生错误,原因:{ex.Message}"); } Console.ReadKey(); }
/// <summary> /// コンストラクタ /// </summary> /// <param name="node">対象Node</param> /// <param name="semanticModel">対象ソースのsemanticModel</param> /// <param name="parent">親IAnalyzeItem</param> /// <param name="container">イベントコンテナ</param> public ItemForEach(ForEachStatementSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container) { ItemType = ItemTypes.MethodStatement; var oparetion = semanticModel.GetOperation(node) as IForEachLoopOperation; var localSymbol = oparetion.Locals.First(); // ローカルの型設定 IsVar = node.Type.IsVar; LocalTypes.AddRange(GetTypes(localSymbol.Type, semanticModel, node)); // ローカル設定 Local.Add(new Expression(localSymbol.Name, Expression.GetSymbolTypeName(localSymbol))); // コレクションの型設定 var conversionOperation = oparetion.Collection as IConversionOperation; if (!(conversionOperation is null)) { CollectionTypes.AddRange(GetTypes(conversionOperation.Operand.Type, semanticModel, node)); } //コレクション Collection.AddRange(OperationFactory.GetExpressionList(oparetion.Collection.Children.First(), container)); // 内部処理設定 var block = node.Statement as BlockSyntax; foreach (var statement in block.Statements) { Members.Add(ItemFactory.Create(statement, semanticModel, container, this)); } }
private double getResult(double AnumbleA, double AnumbleB, string Aopt, MyOperation Aoper) { Aoper = OperationFactory.createOperate(Aopt); Aoper.NumberA = AnumbleA; Aoper.NumberB = AnumbleB; return(Aoper.GetResult());; }
public ResultAssociation Schedule(ModelAssociation currentModelAssoscation, MachineEnvironment currentMachineEnvironment, List <Constraint> currentConstraints, OptimisationObjective currentOptimisationObjective, DateTime startingWholeProcessingDate) { // Sort all operations on nearest Due Date first List <Operation> AllOperations = SchedulingUtlis.GetAllOperations(currentModelAssoscation.AllBatches); AllOperations.Sort((operation1, operation2) => operation1.CurrentBatch.DueDate.CompareTo(operation2.CurrentBatch.DueDate)); List <OperationMachineAssignment> CurrentOperationMachineAssociations = new List <OperationMachineAssignment>(); foreach (Operation CurrentOperation in AllOperations) { // Find next available machine for the processing of current operation List <Machine> CapableMachines = CurrentOperation.CapableMachinesWithProcessingTime.Keys.ToList(); CapableMachines.Sort((machine1, machine2) => machine1.NextAvailableStartProcessingDate.CompareTo(machine2.NextAvailableStartProcessingDate)); Machine ChosenMachine = CapableMachines.First(); DateTime StartProcessingDate = ChosenMachine.NextAvailableStartProcessingDate; // if it isn't the first process on the machine in the scheduling => we have to include setup time if (!startingWholeProcessingDate.Equals(StartProcessingDate)) { SetupForBatch CurrentSetupForBatch = CurrentOperation.SetupTimes .Find(setup => setup.CurrentMachine.Equals(ChosenMachine) && setup.PreviousOperation.Index.Equals(ChosenMachine.CurrentlyProcessedOperation.Index)); StartProcessingDate = StartProcessingDate.AddSeconds(CurrentSetupForBatch.SetupTime); } // Calculate processing time int NeededProcessingTime = CurrentOperation.CapableMachinesWithProcessingTime[ChosenMachine] * CurrentOperation.CurrentBatch.NumberOfJobs; // Include maintenance DateTime FinishProcessingDate = StartProcessingDate; while (NeededProcessingTime > ChosenMachine.TimeLeftTillMaintenance) { // Operation before maintenance FinishProcessingDate = FinishProcessingDate.AddSeconds(ChosenMachine.TimeLeftTillMaintenance); CurrentOperationMachineAssociations.Add (new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate)); NeededProcessingTime -= ChosenMachine.TimeLeftTillMaintenance; StartProcessingDate = FinishProcessingDate; // Maintenance FinishProcessingDate = StartProcessingDate.AddSeconds(ChosenMachine.TimeOfMaintenance); CurrentOperationMachineAssociations.Add (new OperationMachineAssignment(OperationFactory.generateMaintenance(), ChosenMachine, StartProcessingDate, FinishProcessingDate)); ChosenMachine.TimeLeftTillMaintenance = RandomGenerator.MachineTimeLeftTillMaintenanceForSmallScaleProduction(); StartProcessingDate = FinishProcessingDate; } // Operation FinishProcessingDate = FinishProcessingDate.AddSeconds(NeededProcessingTime); CurrentOperationMachineAssociations.Add(new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate)); ChosenMachine.TimeLeftTillMaintenance -= NeededProcessingTime; // Update dates for the machine ChosenMachine.NextAvailableStartProcessingDate = FinishProcessingDate; ChosenMachine.CurrentlyProcessedOperation = CurrentOperation; } return(new ResultAssociation(CurrentOperationMachineAssociations, null, null)); }
public void FailIfTestDoesntExists() { var factory = new OperationFactory(); Action act = () => factory.CreateOperation("XXXXX"); act.Should().Throw <OperationNotFoundException>(); }
private static void TestSimpleFactory() { var oper = OperationFactory.CreateOperation(OperationFactory.OperationType.SUB); oper.NumberA = 10; oper.NumberB = 6.6; Console.WriteLine($"result:{oper.GetResult()}"); }