//return a delegate public CalculateHandler GetMethod(CalcOperators.Operators operation) { CalculateHandler calcMethod = null; switch (operation) { case CalcOperators.Operators.Add: calcMethod = Calculator.Add; break; case CalcOperators.Operators.Substract: calcMethod = Calculator.Subtract; break; case CalcOperators.Operators.Multiply: calcMethod = Calculator.Multiply; break; case CalcOperators.Operators.Divide: calcMethod = Calculator.Divide; break; case CalcOperators.Operators.Power: calcMethod = Calculator.Power; break; } return(calcMethod); }
public static CalculateHandler GetMethod(Operations.AveilibleOperations chosenOerator) { CalculateHandler chosenMethod = null; switch (chosenOerator) { case Operations.AveilibleOperations.Add: chosenMethod = Calculator.Add; break; case Operations.AveilibleOperations.Subtract: chosenMethod = Calculator.Subtract; break; case Operations.AveilibleOperations.Multiply: chosenMethod = Calculator.Multiply; break; case Operations.AveilibleOperations.Divide: chosenMethod = Calculator.Divide; break; case Operations.AveilibleOperations.Power: chosenMethod = Calculator.Power; break; } return(chosenMethod); }
public void TestDelegateFactory() { IFactory <CalculateHandler> factory = new CalculateHandlerFactory(); CalculateHandler handler = factory.Create(); Assert.AreEqual <int>(1 + 2 + 3, handler(1, 2, 3)); }
// Starten der asynchronen Ausführung public IAsyncResult BeginCalculate(int intVar, AsyncCallback callback, object state) { del = new CalculateHandler(Calculate); // aufruf der Methode Calculate, die in einem eigenen // Thread ausgeführt wird return(del.BeginInvoke(intVar, callback, state)); }
public async Task <ActionResult> CalculateFeetToInches([FromForm] FeetInchesRequestModel body, Types type) { try { if (type == Types.Feet) { if (string.IsNullOrEmpty(body.Feet)) { return(BadRequest($"{nameof(body.Feet)} is required")); } } else { if (string.IsNullOrEmpty(body.Inches)) //Alternative: !ModelState.IsValid { return(BadRequest($"{nameof(body.Inches)} is required")); } } //Validation ObjectResult val = Validations(body); if (val.StatusCode.Equals(400)) { return(BadRequest(val.Value)); } try { if (type == Types.Feet) { //We convert double feet = GetDouble(body.Feet); double result = await CalculateHandler.CalculateFeetToInches(feet); return(Ok($"{result} feet")); } else { //We convert double inches = GetDouble(body.Inches); double result = await CalculateHandler.CalculateInchesToFeet(inches); return(Ok($"{result} inches")); } } catch (Exception e) { return(BadRequest($"We couldn't calculate with value of: {body.Feet}")); } } catch (Exception e) { return(BadRequest("Couldn't calculate")); } }
static void Main(string[] args) { CalculateHandler calculate; do { //Eingabe Console.Clear(); Console.WriteLine("erster Operand: "); double input1 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("zweiter Operand: "); double input2 = Convert.ToDouble(Console.ReadLine()); //Wahl der Operation Console.WriteLine("Operation: Addition (A) oder Subtraktion (S)"); string wahl = Console.ReadLine().ToUpper(); double result = 0; if (wahl == "A") { calculate = new CalculateHandler(Demo.Add); } else if (wahl == "S") { calculate = Demo.Subtract; } else if (wahl == "M") { calculate = delegate(double x, double y) { return(x * y); } } ; else if (wahl == "D") { calculate = (x, y) => { return(x / y); } } ; else { Console.WriteLine("Ungültige Eingabe"); Console.ReadLine(); return; } result = calculate(input1, input2); Console.WriteLine("Ergebnis: " + result); Console.WriteLine("Zum Beenden F12 drücken."); } while (Console.ReadKey(true).Key != ConsoleKey.F12); }
static void Main(string[] args) { // 2. Variable vom Typ des Delegaten CalculateHandler calculate; do { // ---- Eingabe der Operanden ---- Console.Clear(); Console.Write("Geben Sie den ersten Operanden ein: "); double input1 = Convert.ToDouble(Console.ReadLine()); Console.Write("Geben Sie den zweiten Operanden ein: "); double input2 = Convert.ToDouble(Console.ReadLine()); // ---- Wahl der Operation ---- Console.Write("Operation: Addition - (A) oeder Subtraktion - (S)? "); string wahl = Console.ReadLine().ToUpper(); // In Abhängigkeit von der Wahl des Anwenders wird die Variable 'calculate' // mit einem Zeiger auf die auszuführende Methode initialisiert // 3. Zeiger der Delegaten-Variablen auf statische Methoden // Allerdings wird die Methode, auf die der Delegat in Form eines Zeigers verweist, // noch nicht sofort ausgeführt, denn dazu bedarf es eines Anstoßes durch den // Aufruf des Delegates: // double result = calculate(input1, input2); (s.u.) if (wahl == "A") { calculate = new CalculateHandler(Demo.Add); } else if (wahl == "S") { calculate = new CalculateHandler(Demo.Sub); } else { Console.Write("Ungültgte Eingabe !"); Console.ReadLine(); return; } // Aufruf der Operation 'Add' oder 'Subtract' über den Delegaten // 4. Aufruf einer Operation über den DELEGATEN double result = calculate(input1, input2); Console.WriteLine("----------------------------------"); Console.WriteLine("Ergebnis = {0}\n\n", result); Console.WriteLine("Zum Beenden F12 drücken."); // (true) bedeutet: nicht in die Konsole schreiben } while (Console.ReadKey(true).Key != ConsoleKey.F12); // Console.ReadLine(); }
public List <long> Start() { _log.WriteDataToLog(DateTime.Now.ToString() + "------------------------"); _log.WriteDataToLog("Threads Time, ms "); List <long> data = new List <long>(); for (int i = 1; i <= _maxQThreads; i++)//цикл деления поля на потоки { InizializeField(); int p = _size / i;//количество строк в потоке Stopwatch stopWatch = new Stopwatch(); _countdown = new CountdownEvent(i); stopWatch.Start(); //List<Thread> myThrConteiner = new List<Thread>(); List <IAsyncResult> myDelConteiner = new List <IAsyncResult>(); for (int k = 0, j = 0; j < i; k = k + p, j++) { PartMatrix mypiece = new PartMatrix(); mypiece.begin = k; mypiece.end = k + p; CalculateHandler handler = new CalculateHandler(CalculateCells1); //IAsyncResult resultObj = handler.BeginInvoke(mypiece, handler.EndInvoke, null); //myDelConteiner.Add(resultObj); //Thread myThread = new Thread(new ParameterizedThreadStart(CalculateCells)); //myThrConteiner.Add(myThread); //myThread.Start(mypiece); } //_countdown.Wait(); // Blocks until Signal has been called "i" times //for (int n = 0; n < myThrConteiner.Count; n++) //{ // myThrConteiner[n].Join(); //} //for (int j = 0; j < myDelConteiner.Count; j++) //{ // myDelConteiner[j].EndInvoke(resultObj) //} stopWatch.Stop(); data.Add(stopWatch.ElapsedMilliseconds); _log.WriteDataToLog("" + stopWatch.ElapsedMilliseconds + "; " + CheckMatrix()); } MessageBox.Show("Вычисление матрицы завершено"); _log.Close(); return(data); }
/// <summary> /// Method that performs the required calculation by delegating the job to the /// delegate CalculateHandler /// </summary> /// /// <param name="value1"></param> /// <param name="value2"></param> /// <param name="operation"></param> /// <returns></returns> /// <remarks></remarks> public double DoCalculate(double value1, double value2, CalcOperators.Operators operation) { //what happens //CalculateHandler calcDelegate; //calcDelegate = new CalculateHandler ( Calculator.Add ); //calcDelegate += Calculator.Subtract; //calcDelegate += Calculator.Divide; //calcDelegate += Calculator.Multiply; //calcDelegate += Calculator.Power; //which function? don't know until runtime // declared but not created CalculateHandler calcDelegate = GetMethod(operation); return(calcDelegate(value1, value2)); }
static void Main(string[] args) { // Variable vom Typ des Delegaten CalculateHandler calculate; do { // Eingabe der Operanden Console.Clear(); Console.Write("Geben Sie den ersten Operanden ein: "); double input1 = Convert.ToDouble(Console.ReadLine()); Console.Write("Geben Sie den zweiten Operanden ein: "); double input2 = Convert.ToDouble(Console.ReadLine()); // Wahl der Operation Console.Write("Operation: Addition - (A) oeder Subtraktion - (S)? "); string wahl = Console.ReadLine().ToUpper(); // in Abhängigkeit von der Wahl des Anwenders wird die Variable // 'calculate' mit einem Zeiger auf die auszuführende Methode // initialisiert if (wahl == "A") { calculate = new CalculateHandler(Demo.Add); } else if (wahl == "S") { calculate = new CalculateHandler(Demo.Subtract); } else { Console.Write("Ungültige Eingabe"); Console.ReadLine(); return; } // Aufruf der Operation 'Addition' oder 'Subtraktion' über den Delegaten double result = calculate(input1, input2); Console.WriteLine("----------------------------------"); Console.WriteLine("Ergebnis = {0}\n\n", result); Console.WriteLine("Zum Beenden F12 drücken."); } while (Console.ReadKey(true).Key != ConsoleKey.F12); }
public double PerformCalculation(double x, double y, Operations.AveilibleOperations chosenOperator) { CalculateHandler calcMethod = GetMethod(chosenOperator); return(calcMethod(x, y)); }
public double PerformCalc(CalculateHandler method, double value1, double value2) { return(method(value1, value2)); }
static void Main(string[] args) { CalculateHandler calculate = null; CalculateHandler _add = new CalculateHandler(Add); CalculateHandler _sub = Subtract; CalculateHandler _mul = Multiplicate; CalculateHandler _div = Divide; CalculateHandler _mod = Module; try { Console.WriteLine(_div(10, 0)); } catch (DivideByZeroException e) { Console.WriteLine(e.Message); } Console.WriteLine(_add.Invoke(50, 10.2) + "\n"); Console.WriteLine(_mul.Invoke(80, 5) + "\n"); //and so on calculate = _add; //(CalculateHandler)Delegate.Combine(_add); calculate += _sub; //when i use + = the following happens,called Delegate.Combine like next calculate = (CalculateHandler)Delegate.Combine(calculate, _mul, _div, _mod); //use params calculate.Invoke(15, 5); double result = calculate(10.5, 6.3); // the return value is returned from the last method, all the other values is dropped Console.WriteLine(result + "\n"); //Alternatie versions Anonymous Metods and lambda expressions CalculateHandler add = null; CalculateHandler sub = null; CalculateHandler div = null; CalculateHandler mul = null; CalculateHandler mod = null; add = new CalculateHandler(delegate(double x, double y) { return(x + y); }); sub = delegate(double x, double y) { return(x - y); }; //Anonymous Metods C#2.0 div = (double x, double y) => { return(x / y); }; mul = (x, y) => x * y; //lambda expressions C# 3.0 mod = (double x, double y) => { return(x % y); }; Console.WriteLine(add.Invoke(10, 3)); Console.WriteLine(sub.Invoke(50, 12.3)); Console.WriteLine(div(30.15, 5)); //and so on CalculateHandler handler = null; handler = (CalculateHandler)Delegate.Combine(add, sub, div, mul, mod);//handler=add+sub+div+mul+mod // handler += add + sub + div + mul + mod;//10 Metod //to keep all the values that the methods returned Delegate[] arrayHnadler = handler.GetInvocationList(); double[] KepReturnValues = new double[arrayHnadler.Length]; for (int i = 0; i < KepReturnValues.Length; i++) { foreach (CalculateHandler item in arrayHnadler) { KepReturnValues[i] = item.Invoke(30, 15); } } }
public async void TestCalculateHandler_GetSum_OK1666583334() { Assert.Equal(1666583334, await CalculateHandler.GetSumMultipliers(100000, 4, 6)); }
public async void TestCalculateHandler_GetSum_OK23() { Assert.Equal(23, await CalculateHandler.GetSumMultipliers(10, 3, 5)); }
static void Main(string[] args) { #region DELAGATES /* * Delegate metodlarin adreslerini dolayi yolla methodu saxlayan , isaret * eden strukturdur. * * Methodlar ozleride RAM da yaranan ve RAM-da adresleri olan struktura sahibdir. * * Delegate reference type-dir, yeni olardan instance alina biler. * * public delegate void MyDelegateHandler(); * * Delegate-in temsil edeceyi method ile geri donus tipi ve parametr-leri eyni olmalidir. * * Delegate adlarinin sonuna adeten Handler elave edilir , mecburi deyil. * * Delegate eyni imzaya sahib methodlari saxlayir ve onlari sirasi ile ise salir. * * c# da olan delegate c, c++ da function pointer strukturuna benzeyir. * * * Niye istifade edilir ? * * Delegate umumilikde ram-da olan bir methodun bir hadiseye bagli ise salinmasi * ucun istifade edilmekdedir. * * WindowsFormApp de meselen bir buttona click olunan zaman bir methodun ise dusmesi, * db-dan bir datanin silinmesi zmaani her hansisa methodun ise dusmesi, bir file silinen * zaman her hansisa bir methodun ise dusmesi delegate vasitesi il edilir. * * form load olan zaman Form1.Designer.cs * this.Load += new System.EventHandler(this.Form1_Load); * * * */ #endregion #region use: examples #region 1 //DelegateHandler delegateHandler = new DelegateHandler(X); //DelegateHandler delegateHandler0 =X; //delegateHandler();==delegateHandler.Invoke(); //delegateHandler(); //delegateHandler.Invoke(); #endregion #region 2 CalculateHandler delegateHandler1 = new CalculateHandler(Sum); delegateHandler1 += Multiply; delegateHandler1 += Cixma; delegateHandler1(4, 5); //veya delegateHandler1.Invoke(2, 3); #region GetInvocationList //Delegate[] methods = delegateHandler.GetInvocationList(); //foreach (var item in methods) //{ // Console.WriteLine(item.Method.Name); //} #endregion #region runtime += -= #endregion #endregion #region anonymous method : run time PrintHandler printHandler1 = new PrintHandler(Print1); printHandler1.Invoke("name", "surname"); PrintHandler printHandler2 = new PrintHandler(delegate(string name, string surname) { Console.WriteLine($"{name} {surname}"); }); printHandler2("12121", "1212121212"); // lambda PrintHandler printHandler3 = (name, surname) => { Console.WriteLine($"{name} {surname}"); }; printHandler3("asasasa", "sasasasas"); #endregion #endregion Console.ReadLine(); }