Delegates. Part 5. Examples of passing arrays, structures, classes to an anonymous method
Contents
- Question/Answer
- 1. An example of calling an anonymous method that gets an array of integers as input parameter
- 2. An example of calling an anonymous method that receives a structure as input parameter
- 3. An example of an anonymous method that receives as input parameter an array of structures
- 4. An example of an anonymous method that receives an object of an instance of the class
- 5. An example of an anonymous method that gets an array of object instances of the class
- Related topics
Search other websites:
1. An example of calling an anonymous method that gets an array of integers as input parameter
Declaring a delegate type named ProcessArray that receives an array of numbers as input and does not return a value
// declaration of the type of the delegate that receives the array of numbers as a parameter delegate void ProcessArray(ref int[] A);
Demonstration of delegates like ProcessArray with two anonymous methods. The first method zeroes all items of the array. The second method increments the value of array items by 10.
The source code that demonstrates the work of anonymous methods:
// Passing arguments to an anonymous method // A ProcessArray delegate is declared // Delegate PA1 zeroes the array ProcessArray PA1 = delegate (ref int[] A) { // zeroing an array of integers int i; for (i = 0; i < A.Length; i++) A[i] = 0; }; // Delegate PA2 increases the value of array elements by 10 ProcessArray PA2 = delegate(ref int[] A) { int i; for (i = 0; i < A.Length; i++) A[i] = A[i] + 10; }; // Demonstration of the work of delegates // Declaring an array of 5 integers int[] B = new int[5]; // calling the delegate PA1 - zeroing the array PA1(ref B); // B = [0, 0, 0, 0, 0] // calling the delegate PA2 - increasing the array elements by 10 PA2(ref B); // B = [10, 10, 10, 10, 10]
⇑
2. An example of calling an anonymous method that receives a structure as input parameter
Let the class description have a structure of the type Student:
// Declaring a structure of type Student struct Student { public string Name; public string Address; public int Age; };
To demonstrate the use of an anonymous method in the body of the structure, you must first declare the type of the delegate. The delegate type is declared in the same class as the structure type. The delegate declaration, for example, may be as follows:
// Declaring the delegate type delegate void ShowInfo(Student st);
Below is the code that demonstrates how to use the delegate type ShowInfo:
// Demonstrating the use of an anonymous method that receives a structure as a parameter // 1. Declaring an anonymous method ShowInfo SI; SI = delegate(Student st) { label1.Text = st.Name; label2.Text = st.Address; label3.Text = st.Age.ToString(); }; // 2. Declaring and filling the Stud variable Student Stud; Stud.Name = "Ivanov I.I."; Stud.Address = "The address of Ivanov I.I."; Stud.Age = 118; // 3. Calling an anonymous method using a delegate SI(Stud);
⇑
3. An example of an anonymous method that receives as input parameter an array of structures
In the example, an array of structures of type Student is passed to an anonymous method.
The structure of the type Student is declared in a certain class and has the form:
// Declaring a structure of type Student struct Student { public string Name; public string Address; public int Age; public void Set(string name, string address, int age) { Name = name; Address = address; Age = age; } };
The delegate type declaration is described in the same class as the Student structure.
// Declaring the delegate type delegate void ShowInfoIndex(Student[] st, int index);
Demonstration of passing of an array of structures to an anonymous method
// Passing an array of structures to a method // 1. Declaring a variable st of type "array of structures" Student[] st = new Student[3]; // 2. Filling an array of structures st st[0].Set("Ivanov I.I.", "Minsk", 32); st[1].Set("Johnson J.J.", "Kiev", 45); st[2].Set("Kameroon J.", "Las-Vegas", 23); // 3. Declaring a delegate variable with the SI name and the code of the anonymous method ShowInfoIndex SI; SI = delegate(Student[] ST, int index) { label1.Text = ST[index].Name; label2.Text = ST[index].Address; label3.Text = ST[index].Age.ToString(); }; // 4. Calling an anonymous method using a delegate SI(st, 0); // Will be displayed: {"Ivanov I.I.", "Minsk", 32} SI(st, 1); // Will be displayed: {"Johnson J.J.", "Kiev", 45}
⇑
4. An example of an anonymous method that receives an object of an instance of the class
Let the description of the class that is placed in a separate module (for example “MyClass1.cs”) be given. The class code is the following
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TrainDelegates07 { // Declaring a class in the module "MyClass1.cs" class MyClass1 { private int x; private double R; public int GetX() { return x; } public double GetR() { return R; } public void SetX(int nx) { x = nx; } public void SetR(double nR) { R = nR; } } }
The class implements two internal variables (x, R) and four methods that read and change the values of these internal variables. In another class (module), the delegate type is declared as follows:
// declaration of the delegate type that gets the class MyClass1 delegate void ProcessMyClass(MyClass1 mc);
In a method that demonstrates the operation of anonymous methods (for example, an event handler), you need to execute approximately the following code
// Demonstration of the use of the class // 1. Declare a class object MyClass1 MC1 = new MyClass1(); // allocate memory for MC1 // 2. Fill class fields with values MC1.SetX(5); MC1.SetR(10.5); // 3. Declare a delegate of type ProcessMyClass ProcessMyClass PC; // The delegate refers to an anonymous method that gets the class PC = delegate (MyClass1 mc) { int x; double R; // output on the form the values x, R x = mc.GetX(); R = mc.GetR(); label1.Text = x.ToString(); label2.Text = R.ToString(); }; // 4. Calling an anonymous method using a delegate PC(MC1);
⇑
5. An example of an anonymous method that gets an array of object instances of the class
The task
It is given a class that is described in a separate module “MyClass1.cs”. The code of module is as follows:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TrainDelegates08 { // class declaration MyClass1 class MyClass1 { private int x; private double R; public int GetX() { return x; } public double GetR() { return R; } public void SetX(int nx) { x = nx; } public void SetR(double nR) { R = nR; } } }
It is needed to declare an anonymous method that takes an array of classes of type MyClass1 as the input parameter. It is needed to realize the demonstration of the use of an anonymous method in the Form1 class.
Solution
Program code of the Form1.cs module is as follows:
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace TrainDelegates08 { public partial class Form1 : Form { // declaration of the delegate type, which receives an array of classes of the type MyClass1 delegate void ProcessMyClass(MyClass1[] mc, int index); public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { // Demonstration of passing an array of classes to an anonymous method // 1. Declare an object named MC of the type "array of 10 classes" MyClass1[] MC; // 2. Memory allocation // 2.1. Allocate memory for an array of classes as a whole MC = new MyClass1[10]; // 2.2. Allocate the memory for each element of the array (for the class) for (int i = 0; i < 10; i++) MC[i] = new MyClass1(); // 3. Fill the fields of a class array with values for (int i=0; i<10; i++) { MC[i].SetX(i + 1); MC[i].SetR(10 * i + 1); } // 4. Declare the delegate of ProcessMyClass type ProcessMyClass PC; // 5. Describe the program code of an anonymous method that receives an array of classes PC = delegate (MyClass1[] mc, int index) { // displaying on the form of a class instance values with the number 'index' int x; double R; x = mc[index].GetX(); R = mc[index].GetR(); label1.Text = x.ToString(); label2.Text = R.ToString(); }; // 6. Calling an anonymous method using the PC delegate PC(MC, 5); } } }
Let’s explain some fragments of the code.
In the Form1 class, the delegate type is declared, which receives a class array as an input parameter. The code snippet is as follows:
// declaration of the type of the delegate, that receive an array of classes of the type MyClass1 delegate void ProcessMyClass(MyClass1[] mc, int index);
The button1_Click () event handler demonstrates the use of an anonymous method that receives a class array as a parameter. Also is demonstrated the allocation of memory for an array of 10 instances of class objects.
⇑
Related topics
- The concept of delegate. Declaration of delegate type. Using a delegate in the program. Group transformation of methods
- Anonymous functions. Anonymous methods. Returning the value. Passing parameters
- Delegates. Group addressing. Creating a chain of methods calling
- An example of using a delegate to call an anonymous method. The development of the program for finding the area of a triangle using the Heron’s formula