C windows forms delegate

Introduction

Delegates are one of the wonderful features of .Net Framework. Their primary use is focused on support event handling and callback mechanism. In this article, we will explore how to use delegate as callback support to make simple communication between different opened windows forms.

In this article, I assume that you know the definition of delegate and its primary use in .Net Framework.

Scenario overview

In many scenarios, a windows form is used to open some other windows forms as modal or non-modal. The newly opened form or the opener itself (the parent form) may need to send each other some notifications or values. For example, you select a value from a ComboBox on the newly opened form, and you want to send this value immediately on select to the opener parent form. Or you changed a parameter value in the opener form (parent) that the newly opened form depends on. Such scenarios can be implemented using delegates in form of callbacks.

Scenario in action

We are going to explore 2 scenarios:

• First Scenario: The main windows form (parent) that can open deferent instances of other windows forms (children).

  The parent form will contain a TextBox, when the text in this text box changes, all opened windows forms (children) should be notified with this change and display it.

• Second Scenario: The main windows form (parent) that contains a ListBox will open a dialog form that contains a TextBox with two buttons (Add Item) & (Close). Whenever the user click the Add Item button, the item should be added to the ListBox in the main form without closing the dialog. Close button should close the dialog.

Of course these scenarios can be done by exposing controls as public instances. But many would prefer to keep controls as private and start using delegates

The Rule

First of all, you need to decide what do you want to send to the other form cause this will lead you to decide what is parameter type you will use in your delegate.

In our case here, we need only to pass string, so we need to define delegate with string as parameter for example:

public delegate void SetParameterValueDelegate(string value);

Second, you need to decide who is the owner of the communication, in other words, which form will send the notification?! In our first scenario the main form (parent) will be the owner of the communication. But in the second scenario the dialog form will be the owner.

Once you decide the owner, you’ll need to declare an instance of your delegate type inside the owner class for example:

public SetParameterValueDelegate SetParameterValueCallback;

The other forms will be subscribers for the callback (delegate), only if you wish to send notification to them.

The First Scenario

The following screenshot shows the first scenario in action, just to note the simple user interface we are using to demonstrate the example:

Картинка с сайта: www.c-sharpcorner.com

You need to declare a delegate, should be outside any class for our example needs.

Listing 01-Declare a delegate:

public delegate void SetParameterValueDelegate(string value);

The following is the code written in the Main From «FrmMain Class»:

Listing 02-FrmMain Class:

//Declare delagete callback function, the owner of communication
public SetParameterValueDelegate SetParameterValueCallback;
private void btnOpenFrm1_Click(object sender, EventArgs e)
{
    FrmChild1 frm = new FrmChild1();
    //Subscribe frm for Callback
    this.SetParameterValueCallback += new SetParameterValueDelegate(frm.SetParamValueCallbackFn);
    frm.Show();
}
private void btnOpenFrm2_Click(object sender, EventArgs e)
{
    FrmChild2 frm = new FrmChild2();
    //Subscribe frm for Callback
    this.SetParameterValueCallback += new SetParameterValueDelegate(frm.SetParamValueCallbackFn);
    frm.Show();
}
private void txtParam_TextChanged(object sender, EventArgs e)
{
    //Send Notification to all subscribers
    SetParameterValueCallback(txtParam.Text);
}

Did you note the frm.SetParamValueCallbackFn?! Well this is method defined in both FrmChild1 & FrmChild2 forms, of course the method can have different names on each class.

What you should know and note, this method should have the same signature as the delegate, which means, the delegate is void, your method should be void, the delegate accepts only one string parameter, your method also should accept only one string parameter.

The following shows the definition of the SetParamValueCallbackFn method:

Listing 03-SetParamValueCallbackFn Method:

public void SetParamValueCallbackFn(string param)
{
    txtParam.Text = param;
}

The Second Scenario

You might guess what we should do in this scenario, first we will create a new delegate that takes a string parameter, we will call it AddItemDelegate. In the Dialog form (FrmDialog) we will declare a callback method of type AddItemDelegate. In main from (FrmMain) we will define the callback function.

Listing 04-AddItemDelegate:

public delegate void AddItemDelegate(string item);

Listing 05-FrmDialog Class:

//Declare delagete callback function, the owner of communication
public AddItemDelegate AddItemCallback;
private void btnAdd_Click(object sender, EventArgs e)
{
    //Notification subscribers
    AddItemCallback(txtItem.Text);
}

Listing 06-FrmMain Class:

private void btnScenario2_Click(object sender, EventArgs e)
{
    FrmDialog dlg = new FrmDialog();
    //Subscribe this form for callback
    dlg.AddItemCallback = new AddItemDelegate(this.AddItemCallbackFn);
    dlg.ShowDialog();
}
private void AddItemCallbackFn(string item)
{
    lstBx.Items.Add(item);
}

Картинка с сайта: www.c-sharpcorner.com

Conclusion

The way of using delegates to send information between windows forms is much more clear than exposing controls as public instances, well this is my opinion.

In the examples represented here, we could use on delegate instead of tow, but I represented this just for clarification. Hope you find it useful.

Делегаты и события

Делегаты являются типом, реализующим механизм динамического вызова функций с разными именами, но одинаковой сигнатурой и типом возвращаемого значения. Это еще один подход к полиморфизму в объектно-ориентированном программировании. Делегат аналогичен указателю на функцию в C / C++.

Делегат объявляется как тип в области видимости пространства имен с помощью ключевого слова delegate по следующему синтаксису

delegate тип_возврата имя_типа_делегата(список_параметров);

Внутри вызывающего кода создается экземпляр делегата, конструктору которого в качестве аргумента передается имя адресуемого метода с тождественной сигнатурой и типом возвращаемого значения

имя_типа_делегата объект = new конструктор_делегата(имя_метода);

После создания экземпляра делегата для конкретного метода вызовы метода можно выполнять через объект делегата

объект_делегата(список_параметров);

вместо

имя_метода(список_параметров);

Все делегаты представляют собой типы, которые неявным образом выводятся из класса System.Delegate, но напрямую так не объявляются.

Приведем поясняющий пример. Предположим, что нужно создать класс для выполнения операций сложения и вычитания двух целых чисел. Вот код этого класса

using System;
using System.Windows.Forms;
    
namespace MyApp
{
    // Объявление своего типа класса
    class MyClass
    {
        string str;
    
        public void Add(int x, int y)
        {
            str = String.Format("{0} + {1} = {2}", x, y, x + y);
            MessageBox.Show(str, "Сложение целых чисел");
        }
    
        public void Subtract(int x, int y)
        {
            str = String.Format("{0} - {1} = {2}", x, y, x - y);
            MessageBox.Show(str, "Вычитание целых чисел");
        }
    }
}

Теперь создадим вызывающую сторону кода класса, в которой предусмотрим

1. Вызов методов напрямую
2. Одиночные вызовы через экземпляры делегата
3. Организацию цепочки вызовов (многоадресный вызов) через объект делегата

Вот этот код

// Удалили сокращения пространств имен
// Все используемые типы находятся в проекте
namespace MyApp
{
    // Объявление своего типа делегата
    delegate void Arithmetics(int a, int b);
    
    class EntryPoint
    {
        static void Main()
        {
            // Объявляем ссылочную переменную типа делегата
            Arithmetics obDelegate;
            // Объявляем ссылочную переменную типа класса
            MyClass ob;
            // Создаем объект класса с методами
            ob = new MyClass();
    
            // Заготавливаем передаваемые методам аргументы
            int x = 5, y = 10;
    
            // Прямой вызов методов объекта класса
            ob.Add(x, y);
            ob.Subtract(x, y);
    
            // Косвенный (через делегата) вызов методов объекта класса
            // Адресуемся к первому методу объекта класса
            obDelegate = new Arithmetics(ob.Add);
            obDelegate(x, y);   // Вызываем метод через объект делегата
            // Адресуемся ко второму методу объекта класса
            obDelegate = new Arithmetics(ob.Subtract);
            obDelegate(x, y);   // Вызываем метод через объект делегата
    
            // Использование делегата для организации цепочки вызовов
            obDelegate = new Arithmetics(ob.Add);
            obDelegate += new Arithmetics(ob.Subtract);
            obDelegate(x, y);   // Вызов методов
        }
    }
}

При запуске приведенного кода трижды повторяется результат сложения и вычитания двух целых чисел, который инициируется вызовами методов напрямую, одиночными вызовами через делегата и множественным вызовом через делегата. Множественная адресации возможна только для функций, возвращающих тип void, одиночная адресация возможна для любого возвращаемого типа.

Способность делегатов к множественной адресации однотипных функций (одинаковой сигнатуры) является наиболее ценным их качеством. Но рассмотренный способ применения делегатов используется не очень часто. Большее распространение получило применение делегатов для создания событий. События являются современным механизмом общения классов и объектов приложения между собой. Один объект может сгенерировать событие и передать вместе с ним требуемые значения аргументов. Другие объекты, которые подписались на это событие и ждут его появления, реагируют на него вызовом соответствующих обработчиков.

Сгенерированное объектом событие помещается в канал сообщений, созданный для приложения операционной системой, и предлагается для обработки всем подписавшимся на него объектам. Подписка объекта на событие означает существование в объекте обработчика этого события. Хотя может быть и такое, что обработчик как метод создан в объекте, но не подключен на прослушивание соответствующего события, т.е. не зарегистрирован в канале сообщений.

Поскольку событие представляет собой косвенный вызов методов (обработчиков) всех подписавшихся на него объектов и может передавать из сгенерировавшего его объекта фактические значения аргументов, то обработчики всех подписавшихся объектов должны иметь одинаковую сигнатуру. Вот здесь-то и нашли широкое применение делегаты, с помощью которых и определяется как сигнатура самого события, так и сигнатура подписавшихся на него обработчиков.

В отличие от делегатов, которые являются типами и объявляются непосредственно в пространстве имен, события являются членами классов и объявляются внутри классов как экземпляры делегатов с ключевым словом event. Чтобы событие было видно в других классах, оно должно быть общедоступным ( public ) или защищенным ( protected ). События как члены класса могут наследоваться другими классами точно также, как и другие доступные члены класса (методы, свойства, поля).

Приведем пример. Пусть гаишник стоит на дороге, измеряет скорость, оценивает водителя и по рации передает свое решение на пост писарю и кассиру. Писарь заполняет протокол на штраф или премию, а кассир берет или выдает деньги. Каждый из них самостоятельно определяет, кому что делать, в зависимости от поступившего сообщения. Бедному водителю остается только бодро рапортовать.

Вот код примера

using System;
using System.Windows.Forms;
using System.Drawing;
    
namespace MyApp
{
    // Объявление с помощью делегата прототипов событий и обработчиков
    delegate void Premium(Driver driver, int speed);
    delegate void Penalty(Driver driver, int speed);
    
    // Гаишник
    class Gai
    {
        // Объявление событий и критерия оценки
        public static event Premium premium;
        public static event Penalty penalty;
        const int SPEED_BORDER = 60;    // Критерий оценки
    
        // Измерить скорость и сгенерировать событие
        public static void MeasureSpeed(Driver driver, int speed)
        {
            // Критерий выполнен и обработчик существует
            if (speed <= SPEED_BORDER && premium != null)
                premium(driver, speed);
            else if(penalty != null)
                penalty(driver, speed);
        }
    }
    
    // Писарь
    //class Писарь
    class Clerk
    {
        // Вспомогательное поле
        string message;
    
        // Конструктор для автоматической подписки
        //public Писарь()
        public Clerk()
        {
            // Пописка на события
            Gai.penalty += new Penalty(Gai_penalty);
            Gai.premium += new Premium(Gai_premium);
        }
    
        void Gai_penalty(Driver driver, int speed)
        {
            message = "Оштрафовать водителя ";
            message += driver.Name + "а за скорость ";
            message += speed + " км/час";
            MessageBox.Show(message, "Писарь");
        }
    
        void Gai_premium(Driver driver, int speed)
        {
            message = "Поощрить водителя ";
            message += driver.Name + "а за скорость ";
            message += speed + " км/час";
            MessageBox.Show(message, "Писарь");
        }
    }
    
    // Кассир
    class Cashier
    {
        // Вспомогательное поле
        string message;
    
        // Конструктор для автоматической подписки
        public Cashier()
        {
            Gai.penalty += new Penalty(Gai_penalty);
            Gai.premium += new Premium(Gai_premium);
        }
    
        void Gai_penalty(Driver driver, int speed)
        {
            message = "Взымаю штраф с водителя ";
            message += driver.Name + "а за скорость ";
            message += speed + " км/час";
            MessageBox.Show(message, "Кассир");
        }
    
        void Gai_premium(Driver driver, int speed)
        {
            message = "Выдаю премию водителю ";
            message += driver.Name + "у за скорость ";
            message += speed + " км/час";
            MessageBox.Show(message, "Кассир");
        }
    }
    
    // Водитель
    class Driver
    {
        public string Name;
    
        public Driver(string Name)
        {
            Gai.penalty += new Penalty(Gai_penalty);
            Gai.premium += new Premium(Gai_premium);
            this.Name = Name;
        }
    
        void Gai_penalty(Driver driver, int speed)
        {
            if (driver == this)
                MessageBox.Show("Признателен за штраф!!!", "Водитель " + Name);
        }
    
        void Gai_premium(Driver driver, int speed)
        {
            if (driver == this)
                MessageBox.Show("Благодарю за премию!!!", "Водитель " + Name);
        }
    }
    
    // Для запуска
    class ExecuteClass
    {
        public ExecuteClass()
        {
            // Создаем объекты
            //Писарь писарь = new Писарь();
            // Если событие принимают сразу несколько объектов,
            // то порядок обработки событий определяется
            // порядком создания принимающих объектов!!!
            Clerk clerk = new Clerk();
            Cashier cashier = new Cashier();
            Driver driver1 = new Driver("Иванов");
            Driver driver2 = new Driver("Петров");
            Driver driver3 = new Driver("Сидоров");
    
            // Измерить скорость и передать объектам
            // готовое решение с дополнительной информацией
            Gai.MeasureSpeed(driver1, 50);
            Gai.MeasureSpeed(driver2, 70);
            Gai.MeasureSpeed(driver3, 90);
        }
    }
}

// Удалили сокращения пространств имен
// Все используемые типы находятся в проекте
namespace MyApp
{
    class EntryPoint
    {
        static void Main()
        {
            new ExecuteClass();
        }
    }
}

Обратите внимание на закомментированное имя типа «Писарь» и ссылку «писарь». Их можно вполне использовать как идентификаторы переменных и пользовательских типов. Visual Studio 2005 это позволяет, но сообщество программистов не приветствует — непрофессионально!

В приведенном коде использован распространенный способ вызова методов разных объектов с помощью событий. Объект, сгенерировавший событие, не заботится о том, будет ли оно обработано другими объектами. Он просто констатирует возникшую ситуацию выбросом сообщения. Если другой объект заинтересован в получении этого сообщения, он должен на него подписаться с регистрацией обработчика. Простая, но очень эффективная схема взаимодействия объектов.

Здесь есть одно обстоятельство. Если объект сгенерировал событие, но к нему не было присоединено ни одного обработчика, то будет сгенерировано исключение. Поэтому мы сделали предварительную проверку ссылки события на нулевое значения.

• Download demo project — 51.01 KB

Картинка с сайта: www.codeproject.com

Passing Data Between Forms

Introduction

Some of you would have faced a scenario where you wanted to pass data from one form to another in WinForms. Honestly, I too had a similar problem (that’s why I am writing this article!).

There are so many methods (How many? I don’t know) to pass data between forms in Windows application. In this article, let me take four important (easiest) ways of accomplishing this:

1. Using constructor
2. Using objects
3. Using properties
4. Using delegates

Let us see all the above methods in detail in the following sections.

For data to be passed between forms using any of the above methods, we need two forms and some controls. Let us start by following the steps given below.

Step 1

Create a new project and select Windows application. This will create a default form as “Form1”. We can use this form for sending data.

Step 2

Add a textbox and a button to the form.

Step 3

Add another Windows Form for receiving the data and to display it. Right click the project and select Add->Add Windows Form. Enter a name or use the default name “Form2.cs” and click ok button.

Step 4

Add a label to the second form to display the text from form1.

The Constructor Approach

This could be the easiest method of all. A method is invoked whenever you instantiate an object. This method is called a constructor. Code a constructor for form2 class with one string parameter. In the constructor, assign the text to the label’s text property. Instantiate form2 class in form1’s button click event handler using the constructor with one string parameter and pass the textbox’s text to the constructor.

Follow the steps given below:

Step 1

Code a constructor for form2 class as below:

public Form2(string strTextBox)
{
  InitializeComponent(); 
  label1.Text=strTextBox;
}

Step 2

Instantiate form2 class in form1’s button click event handler as below:

private void button1_Click(object sender, System.EventArgs e)
{
    Form2 frm=new Form2(textBox1.Text);
    frm.Show();
}

The Object Approach

Objects are reference types, and are created on the heap, using the keyword new. Here we are going to pass data using objects. The approach is simple; in form2 we are going to instantiate form1 class.

Then instantiate form2 in the button click event handler of form1. After this we are going to pass form1 object to the form2 using form2’s form1 object. The last step is to invoke the form2 window by calling the form2’s show method.

Follow the below steps:

Step 1

Change the access modifier for textbox in form1 to public:

public class Form1 : System.Windows.Forms.Form
{  
 public System.Windows.Forms.TextBox textBox1;

Step 2

In the button click event-handler, add the following code:

private void btnSend_Click(object sender, System.EventArgs e)
{
    Form2 frm= new Form2();
    frm.frm1=this;
    frm.Show();
}

Step 3

In form2.cs, instantiate form1 class:

public class Form2 : System.Windows.Forms.Form
{
     private System.Windows.Forms.Label label1;
     public Form1 frm1;

Step 4

In Form2’s Load method, type cast the object (frm1) of form1 to Form1 and access form1’s textbox and assign its text to label’s text.

private void Form2_Load(object sender, System.EventArgs e)
{
    label1.Text=((Form1)frm1).textBox1.Text;
}

The Properties Approach

Properties allow clients to access class state as if they were accessing member fields directly, while actually implementing that access through a class method. In this method, we are going to add one property to each form. In form1 we are going to use one property for retrieving value from the textbox and in form2, one property to set the label’s text property. Then, in form1’s button click event handler, we are going to instantiate form2 and use the form2’s property to set the label’s text.

Follow the below steps:

Step 1

Add a property in form1 to retrieve value from textbox:

public string _textBox1
{
    get{return textBox1.Text;}
}

Step 2

Add a property in form2 to set the labels’ text:

public string _textBox
{
   set{label1.Text=value;}
}

Step 3

In form1’s button click event handler, add the following code:

private void button1_Click(object sender, System.EventArgs e)
{
     Form2 frm=new Form2();
     frm._textBox=_textBox1;
     frm.Show();
}

The Delegates Approach

Technically, a delegate is a reference type used to encapsulate a method with a specific signature and return type. You can encapsulate any matching method in that delegate. Here we are going to create a delegate with some signature and assign a function to the delegate to assign the text from textbox to label.

Follow the below steps:

Step 1

Add a delegate signature to form1 as below:

public delegate void delPassData(TextBox text);

Step 2

In form1’s button click event handler, instantiate form2 class and delegate. Assign a function in form2 to the delegate and call the delegate as below:

private void btnSend_Click(object sender, System.EventArgs e)
{
    Form2 frm= new Form2();
    delPassData del=new delPassData(frm.funData);
    del(this.textBox1);
    frm.Show();
}

Step 3

In form2, add a function to which the delegate should point to. This function will assign textbox’s text to the label:

public void funData(TextBox txtForm1)
{
    label1.Text = txtForm1.Text;
}

Conclusion

These four approaches are very simple in implementing data passing between forms. There are also other methods available in accomplishing the same. Source code for the methods I stated above is given at the top for download. It is time for you to put on your thinking cap and find other ways of doing this. Happy coding!!!

History

• 16^th May, 2006: Initial post

The interface of the demo form is as follows:

Open A and B forms in MainForm, input text data in MainForm, click send message, and the corresponding data will be displayed in text boxes of A and B;

Картинка с сайта: www.fatalerrors.org

All the principles are interlinked. What we do is not creative work. All the problems have been solved by predecessors, so we are more fearless. What’s more, we not only have bookstores, but also have the Internet. We can find the information we need with our hands and feet. We just need to study it carefully. So when you encounter difficulties, please calm down and study slowly, because as long as you are attentive, there is nothing you can’t learn.

Add:

This paper is reproduced from: https://www.cnblogs.com/codeToUp/p/5371062.html