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()}");
}
