static void Main(String[] args) { Function f = new Function(); Console.WriteLine("请输入要操作的两个浮点数:"); double x = Convert.ToDouble(Console.ReadLine()); double y = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("积为{0}", f.twoNumMultiply(x, y)); Console.WriteLine("和为{0}", f.twoNumAdd(x, y)); intDelegate addDelegate = new intDelegate(f.twoNumAdd); intDelegate multiplyDelegate = new intDelegate(f.twoNumMultiply); int i = 0; while (i < 2) { Console.WriteLine("请输入要操作的两个整数:"); int a = Convert.ToByte(Console.ReadLine()); int b = Convert.ToByte(Console.ReadLine()); if (a < 10 && b < 10) { Console.WriteLine("两数都小于10,和为{0}", addDelegate(a, b)); } else { Console.WriteLine("两数不都小于10,积为{0}", multiplyDelegate(a, b)); } i++; } Console.ReadLine(); }
static void Main(string[] args) { intDelegate[] intDelegates = new intDelegate[] { intValueReturn, intValueReturn, intValueReturn, intValueReturn, intValueReturn }; arithmeticMean am = delegate(intDelegate[] delegates) { if (delegates.Length > 0) { int sum = 0; for (int i = 0; i < delegates.Length; i++) { sum = sum + delegates[0](); } decimal result = sum / delegates.Length; return(Math.Round(result, 2)); } else { return(0); } }; decimal result = am(intDelegates); Console.WriteLine($"Результат выполнения программы: {result}"); }
//Q4. Write a generic delegate which will point to method which will //return square , cube ,and factorial of a number. static void Main(string[] args) { intDelegate <int> square = new intDelegate <int>(Square); intDelegate <int> cube = new intDelegate <int>(Cube); intDelegate <int> factorial = new intDelegate <int>(Factorial); Console.WriteLine(square(5)); Console.WriteLine(cube(5)); Console.WriteLine(factorial(5)); }
private void UpdateProgress(int value) { if (statusProgress.ProgressBar.InvokeRequired) { intDelegate id = new intDelegate(UpdateProgress); this.Invoke(id, new object[] { value }); } else { statusProgress.ProgressBar.Value = value; } taskbar.SetProgressValue(value, 100); }
static void Main(string[] args) { // C# 3.0. A delegate can be initialized with // a lambda expression. The lambda also takes a string // as an input parameter (x). The type of x is inferred by the compiler. intDelegate cardI = (x) => { return(x); }; dblDelegate cardDbl = (x) => { return(x * 2); }; succDelegate cardSucc = (x) => { return(x + 1); }; // Invoke the delegates. Console.WriteLine(cardI(4)); Console.WriteLine(cardDbl(4)); Console.WriteLine(cardSucc(4)); Console.WriteLine(cardDbl(cardDbl(cardDbl(cardSucc(0))))); // Keep console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
/* edit_distn -- returns the edit distance between two strings, or -1 on * failure */ public static int edit_distn(byte[] from, int from_len, byte[] to, int to_len) { #if (!TRN_SPEEDUP) int ins, del, ch; /* local copies of edit costs */ #endif int row, col, index = 0; /* dynamic programming counters */ int radix; /* radix for modular indexing */ #if (TRN_SPEEDUP) int low; #endif int[] buffer; /* pointer to storage for one row * of the d.p. array */ var store = new int[THRESHOLD / sizeof(int)]; /* a small amount of static * storage, to be used when the * input strings are small enough */ /* Handle trivial cases when one string is empty */ if (from == null) { if (to == null) { return(0); } else { return(to_len * insert_cost); } } if (to == null) { return(from_len * delete_cost); } /* Initialize registers */ radix = 2 * from_len + 3; #if (TRN_SPEEDUP) var ins = 1; var del = 1; var ch = 3; var swap_cost = 5; #else ins = insert_cost; del = delete_cost; ch = change_cost; #endif /* Make from short enough to fit in the static storage, if it's at all possible */ if (from_len > to_len && from_len > STRLENTHRESHOLD) { swap_int(ref from_len, ref to_len); swap_char(ref from, ref to); #if (!TRN_SPEEDUP) swap_int(ref ins, ref del); #endif } /* if from_len > to_len */ /* Allocate the array storage (from the heap if necessary) */ buffer = from_len <= STRLENTHRESHOLD ? store : new int[radix]; /* Here's where the fun begins. We will find the minimum edit distance * using dynamic programming. We only need to store two rows of the matrix * at a time, since we always progress down the matrix. For example, * given the strings "one" and "two", and insert, delete and change costs * equal to 1: * * _ o n e * _ 0 1 2 3 * t 1 1 2 3 * w 2 2 2 3 * o 3 2 3 3 * * The dynamic programming recursion is defined as follows: * * ar(x,0) := x * insert_cost * ar(0,y) := y * delete_cost * ar(x,y) := min(a(x - 1, y - 1) + (from[x] == to[y] ? 0 : change), * a(x - 1, y) + insert_cost, * a(x, y - 1) + delete_cost, * a(x - 2, y - 2) + (from[x] == to[y-1] && * from[x-1] == to[y] ? swap_cost : * infinity)) * * Since this only looks at most two rows and three columns back, we need * only store the values for the two preceeding rows. In this * implementation, we do not explicitly store the zero column, so only 2 * * from_len + 2 words are needed. However, in the implementation of the * swap_cost check, the current matrix value is used as a buffer; we * can't overwrite the earlier value until the swap_cost check has * been performed. So we use 2 * from_len + 3 elements in the buffer. */ //#define ar(x,y,index) (((x) == 0) ? (y) * del : (((y) == 0) ? (x) * ins : // \ buffer[mod(index)])) //#define NW(x,y) ar(x, y, index + from_len + 2) //#define N(x,y) ar(x, y, index + from_len + 3) //#define W(x,y) ar(x, y, index + radix - 1) //#define NNWW(x,y) ar(x, y, index + 1) //#define mod(x) ((x) % radix) intDelegate mod = delegate(int x) { return(x % radix); }; arDelegate ar = delegate(int x, int y, int idx) { return(x == 0 ? y * del : y == 0 ? x * ins : buffer[mod(idx)]); }; doubleIntDelegate NW = delegate(int x, int y) { return(ar(x, y, index + from_len + 2)); }; doubleIntDelegate N = delegate(int x, int y) { return(ar(x, y, index + from_len + 3)); }; doubleIntDelegate W = delegate(int x, int y) { return(ar(x, y, index + radix - 1)); }; doubleIntDelegate NNWW = delegate(int x, int y) { return(ar(x, y, index + 1)); }; index = 0; #if (DEBUG_EDITDIST) Console.Write(" "); for (col = 0; col < from_len; col++) { Console.Write(" {0} ", from[col]); } Console.Write("\n "); for (col = 0; col <= from_len; col++) { Console.Write("{0}", col * del); } #endif /* Row 0 is handled implicitly; its value at a given column is col*del. * The loop below computes the values for Row 1. At this point we know the * strings are nonempty. We also don't need to consider swap costs in row * 1. * * COMMENT: the indicies row and col below point into the STRING, so * the corresponding MATRIX indicies are row+1 and col+1. */ buffer[index++] = min2(ins + del, from[0] == to[0] ? 0 : ch); #if (TRN_SPEEDUP) low = buffer[mod(index + radix - 1)]; #endif #if (DEBUG_EDITDIST) Console.Write("\n {0} {1} {2} ", to[0], ins, buffer[index - 1]); #endif for (col = 1; col < from_len; col++) { buffer[index] = min3( col * del + (from[col] == to[0] ? 0 : ch), (col + 1) * del + ins, buffer[index - 1] + del); #if (TRN_SPEEDUP) if (buffer[index] < low) { low = buffer[index]; } #endif index++; #if (DEBUG_EDITDIST) Console.Write("{0} ", buffer[index - 1]); #endif } /* for col = 1 */ #if (DEBUG_EDITDIST) Console.Write("\n {0} {1} ", to[1], 2 * ins); #endif /* Now handle the rest of the matrix */ for (row = 1; row < to_len; row++) { for (col = 0; col < from_len; col++) { buffer[index] = min3( NW(row, col) + (from[col] == to[row] ? 0 : ch), N(row, col + 1) + ins, W(row + 1, col) + del); if (from[col] == to[row - 1] && col > 0 && from[col - 1] == to[row]) { buffer[index] = min2(buffer[index], NNWW(row - 1, col - 1) + swap_cost); } #if (DEBUG_EDITDIST) Console.Write("{0} ", buffer[index]); #endif #if (TRN_SPEEDUP) if (buffer[index] < low || col == 0) { low = buffer[index]; } #endif index = mod(index + 1); } /* for col = 1 */ #if (DEBUG_EDITDIST) if (row < to_len - 1) { Console.Write("\n {0} {1} ", to[row + 1], (row + 2) * ins); } else { Console.Write("\n"); } #endif #if (TRN_SPEEDUP) if (low > MIN_DIST) { break; } #endif } /* for row = 1 */ row = buffer[mod(index + radix - 1)]; return(row); } /* edit_distn */
static void Main(string[] args) { //anonymous method (pre-Lambda) //anonymous method that returns square value of an int intDelegate intInstance = delegate(int input) { return(input * input); }; int value = 5; Console.WriteLine("Square value of 5: {0}", intInstance(value)); Console.WriteLine("---------------------------"); //anonymous method (pre-Lambda) //anonymous method that doesn't return any value but prints given value to console voidDelegate voidInstance = delegate(string text) { Console.WriteLine(text); }; voidInstance("Given text"); Console.WriteLine("---------------------------"); //delagate with Lambda expresion that returns int intDelegate intLambda = (int input) => input * input; value = 6; Console.WriteLine("Square value of 5: {0}", intLambda(value)); Console.WriteLine("---------------------------"); //delegate with extended Lambda expresion that returns int intDelegate intExtLambda = (int input) => { int buffer; buffer = input * input; buffer = (int)Math.PI * buffer; return(buffer); }; Console.WriteLine("Processed value of given input: {0}", intExtLambda(value)); Console.WriteLine("---------------------------"); //delgate with Lambda expression that returns nothing voidDelegate voidLambda = (string text) => Console.WriteLine(text); voidLambda("Given text"); Console.WriteLine("---------------------------"); //delegate with extended Lambda expression that return nothing voidDelegate voidExtLambda = (string text) => { Console.WriteLine("Given text: {0}", text); Console.WriteLine("Length: {0}", text.Length); Console.WriteLine("Capitalizad text: {0}", text.ToUpper()); }; voidExtLambda("input text_XXX"); }
private void UpdateProgress(int value) { if (statusProgress.ProgressBar.InvokeRequired) { intDelegate id = new intDelegate(UpdateProgress); this.Invoke(id, new object[] { value }); } else { statusProgress.ProgressBar.Value = value; } taskbar.SetProgressValue(value, 100); }