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