СиШарп: Делегаты

Зачем нам нужны делегаты

Исторически Windows API часто использовал указатели функций в стиле C для создания функций обратного вызова. Используя обратный вызов, программисты могли настроить одну функцию для отправки отчета другой функции в приложении. Таким образом, целью использования обратного вызова является обработка действий, связанных с нажатием кнопки, выбором меню и перемещением мыши. Но проблема с этим традиционным подходом заключается в том, что функции обратного вызова не были типобезопасными. В среде .NET обратные вызовы по-прежнему возможны с использованием делегатов с более эффективным подходом. Делегаты сохраняют три важные части информации, как показано ниже:

Параметры метода.
Адрес вызываемого метода.
Тип возвращаемого значения метода.

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

Обзор делегатов

Делегат — это абстракция одного или нескольких указателей на функции (существующих в C++; объяснение этого выходит за рамки этой статьи). В .NET реализована концепция указателей функций в виде делегатов. С делегатами вы можете обращаться с функцией как с данными. Делегаты позволяют передавать функции в качестве параметров, возвращать из функции в виде значения и сохранять в массиве. Делегаты обладают следующими характеристиками:

Делегаты являются производными от класса System.MulticastDelegate.
У них есть подпись и возвращаемый тип. Функция, добавляемая к делегатам, должна быть совместима с этой сигнатурой.
Делегаты могут указывать на статические или экземплярные методы.
После создания объекта делегата он может динамически вызывать методы, на которые он указывает, во время выполнения.
Делегаты могут вызывать методы синхронно и асинхронно.

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

Определение делегата

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

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

Объявления делегатов выглядят почти так же, как объявления абстрактных методов, вы просто заменяете ключевое слово abstract на ключевое слово delegate. Ниже приведено допустимое объявление делегата:

public delegate int operation(int x, int y);   

Когда компилятор C# встречает эту строку, он определяет тип, производный от MulticastDelegate, который также реализует метод с именем Invoke, который имеет точно такую же сигнатуру, как метод, описанный в объявлении делегата. Для всех практических целей этот класс выглядит следующим образом:

public class operation : System.MulticastDelegate  
{  
    public double Invoke(int x, int y);  
    // Other code  
}  

Как вы можете видеть с помощью ILDASM.exe, сгенерированный компилятором класс операции определяет три общедоступных метода, как показано ниже:

Figure 1.1

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

Образец программы делегатов

Реализация делегата может вызвать большую путаницу при первом знакомстве. Таким образом, это отличная идея, чтобы понять, создав этот пример программы как:

using System;  
  
namespace Delegates  
{  
    // Delegate Definition  
    public delegate int operation(int x, int y);  
         
    class Program  
    {  
        // Method that is passes as an Argument  
        // It has same signature as Delegates   
        static int Addition(int a, int b)  
        {  
            return a + b;  
        }  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            operation obj = new operation(Program.Addition);  
   
            // output  
            Console.WriteLine("Addition is={0}",obj(23,27));   
            Console.ReadLine();    
        }  
    }  
}  

Здесь мы определяем делегат как тип делегата. Важно помнить, что подпись ссылки на функцию делегатом должна совпадать с подписью делегата как:

// Delegate Definition  
public delegate int operation(int x, int y);  

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

// Delegate instantiation  
operation obj = new operation(Program.Addition);  

На этом этапе вы можете вызвать член, на который указывает прямой вызов функции, как:

Console.WriteLine("Addition is={0}",obj(23,27));   

Наконец, когда делегат больше не требуется, установите для экземпляра делегата значение null.

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

Массив делегатов

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

using System;  
  
namespace Delegates  
{  
    public class Operation  
    {  
        public static void Add(int a, int b)  
        {  
            Console.WriteLine("Addition={0}",a + b);  
        }  
  
        public static void Multiple(int a, int b)  
        {  
            Console.WriteLine("Multiply={0}", a * b);  
        }  
    }   
  
    class Program  
    {  
        delegate void DelOp(int x, int y);  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            DelOp[] obj =   
           {  
               new DelOp(Operation.Add),  
               new DelOp(Operation.Multiple)  
           };  
   
            for (int i = 0; i < obj.Length; i++)  
            {  
                obj[i](2, 5);  
                obj[i](8, 5);  
                obj[i](4, 6);  
            }  
            Console.ReadLine();  
        }  
    }  
}  

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

Figure 1.2

Анонимные методы

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

Определите анонимный метод с ключевым словом delegate и безымянным телом функции. Этот код назначает делегату анонимный метод. Анонимный метод не должен иметь подписи. Тип подписи и возвращаемого значения выводится из типа делегата. Например, если делегат имеет три параметра и возвращает тип double, то анонимный метод также будет иметь такую же сигнатуру.

using System;  
  
namespace Delegates  
{  
    class Program  
    {  
        // Delegate Definition  
        delegate void operation();  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            operation obj = delegate  
            {  
                Console.WriteLine("Anonymous method");  
            };  
            obj();  
   
            Console.ReadLine();  
        }  
    }  
}  

Анонимные методы уменьшают сложность кода, особенно если определено несколько событий. При анонимном методе код не работает быстрее. Компилятор по-прежнему неявно определяет методы.

Многоадресный делегат

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

Делегат многоадресной рассылки похож на виртуальный контейнер, в котором несколько функций ссылаются на сохраненный список вызовов. Он последовательно вызывает каждый метод в порядке FIFO (первым пришел, первым обслужен). Если вы хотите добавить несколько методов к объекту делегата, вы просто используете перегруженный оператор +=, а не прямое присваивание.

using System;  
  
namespace Delegates  
{  
    public class Operation  
    {  
        public static void Add(int a)  
        {  
            Console.WriteLine("Addition={0}", a + 10);  
        }  
        public static void Square(int a)  
        {  
            Console.WriteLine("Multiple={0}",a * a);  
        }  
    }  
    class Program  
    {  
        delegate void DelOp(int x);  
   
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            DelOp obj = Operation.Add;  
            obj += Operation.Square;  
   
            obj(2);  
            obj(8);  
   
            Console.ReadLine();  
        }  
    }  
}  

Многоадресный делегат

// Delegate instantiation  
DelOp obj = Operation.Add;  
obj -= Operation.Square;  

Приведенный выше код объединяет два делегата, которые содержат функции Add() и Square(). Здесь сначала выполняется метод Add(), а затем Square(). Это порядок, в котором указатели функций добавляются к многоадресным делегатам.

Чтобы удалить ссылки на функции из многоадресного делегата, используйте перегруженный оператор -=, который позволяет вызывающему объекту динамически удалять метод из списка вызовов объекта делегата.

using System;  
  
namespace Delegates  
{  
    public class Operation  
    {  
        public static void One()  
        {  
            Console.WriteLine("one display");  
            throw new Exception("Error");   
        }  
        public static void Two()  
        {  
            Console.WriteLine("Two display");  
        }  
    }  
  
    class Program  
    {  
        delegate void DelOp();  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            DelOp obj = Operation.One;  
            obj += Operation.Two;  
  
            Delegate[] del = obj.GetInvocationList();  
  
            foreach (DelOp d in del)  
            {  
                try  
                {  
                    d();  
                }  
                catch (Exception)  
                {  
                    Console.WriteLine("Error caught");  
                }  
            }  
            Console.ReadLine();  
        }  
    }  
}  

Когда вы запустите приложение, вы увидите, что итерация по-прежнему продолжается со следующим методом даже после перехвата исключения, как показано ниже.

Figure 1.3

События

Приложения и окна взаимодействуют с помощью предопределенных сообщений. Эти сообщения содержат различную информацию для определения действий как окна, так и приложения. .NET рассматривает эти сообщения как событие. Если вам нужно отреагировать на конкретное входящее сообщение, вы должны обработать соответствующее событие. Например, при нажатии кнопки в форме Windows отправляет сообщение WM_MOUSECLICK обработчику сообщения кнопки.

Вам не нужно создавать собственные методы для добавления или удаления методов в список вызовов делегатов. C# предоставляет ключевое слово event. Когда компилятор обрабатывает ключевое слово event, вы можете подписывать и отменять подписку на методы, а также любые необходимые переменные-члены для ваших типов делегатов. Синтаксис определения события должен быть следующим:

имя_делегата_события доступности имя_события;

Определение события — это двухэтапный процесс. Во-первых, вам нужно определить тип делегата, который будет содержать список методов, которые будут вызываться при запуске события. Затем вы объявляете событие, используя ключевое слово event. Чтобы проиллюстрировать событие, мы создаем консольное приложение. В этой итерации мы определим добавляемое событие, связанное с одним делегатом DelEventHandler.

using System;  
  
namespace Delegates  
{  
    public delegate void DelEventHandler();  
  
    class Program  
    {  
        public static event DelEventHandler add;  
   
        static void Main(string[] args)  
        {  
            add += new DelEventHandler(USA);  
            add += new DelEventHandler(India);  
            add += new DelEventHandler(England);  
            add.Invoke();  
   
            Console.ReadLine();  
        }  
        static void USA()  
        {  
            Console.WriteLine("USA");    
        }  
   
        static void India()  
        {  
            Console.WriteLine("India");  
        }  
   
        static void England()  
        {  
            Console.WriteLine("England");  
        }  
    }  
}  

В основном методе мы связываем событие с соответствующим обработчиком событий со ссылкой на функцию. Здесь мы также заполняем списки вызовов делегатов парой определенных методов, также используя оператор +=. Наконец, мы вызываем событие с помощью метода Invoke.

Примечание. Обработчики событий не могут возвращать значение. Они всегда пусты.

Давайте воспользуемся другим примером, чтобы лучше понять события. Здесь мы определяем имя события как xyz и делегат EventHandler со строковой подписью аргумента в классе операции. Мы помещаем реализацию в метод действия, чтобы подтвердить, запущено событие или нет.

using System;  
  
namespace Delegates  
{  
    public delegate void EventHandler(string a);  
  
    public class Operation  
    {  
        public event EventHandler xyz;  
  
        public void Action(string a)  
        {  
            if (xyz != null)  
            {  
                xyz(a);  
                Console.WriteLine(a);   
            }  
            else  
            {  
                Console.WriteLine("Not Registered");   
            }  
        }  
    }  
   
    class Program  
    {  
        public static void CatchEvent(string s)  
        {  
            Console.WriteLine("Method Calling");  
        }  
  
        static void Main(string[] args)  
        {  
            Operation o = new Operation();  
              
            o.Action("Event Calling");   
            o.xyz += new EventHandler(CatchEvent);  
             
            Console.ReadLine();  
        }  
    }  
}  

Позже в классе Program мы определяем метод CatchEvent, на который будет ссылаться список вызовов делегатов. Наконец, в основном методе мы создали экземпляр класса операции и добавили реализацию запуска события.

Наконец, мы развиваем события на реалистичном примере создания пользовательского элемента управления «Кнопка» над формой Windows, который будет вызываться из консольного приложения. Во-первых, мы наследуем класс программы от класса Form и определяем связанное с ним пространство имен вверху. После этого в конструкторе класса программы мы создаем пользовательское управление кнопкой.

using System;  
using System.Drawing;  
using System.Windows.Forms;  
  
namespace Delegates  
{  
    //custom delegate  
    public delegate void DelEventHandler();  
  
    class Program :Form   
    {  
        //custom event  
        public event DelEventHandler add;  
  
        public Program()  
        {  
            // desing a button over form  
            Button btn = new Button();  
            btn.Parent = this;  
            btn.Text = "Hit Me";  
            btn.Location = new Point(100,100);  
  
            //Event handler is assigned to  
            // the button click event  
            btn.Click += new EventHandler(onClcik);  
            add += new DelEventHandler(Initiate);  
  
            //invoke the event  
            add();  
        }  
        //call when event is fired  
        public void Initiate()  
        {  
            Console.WriteLine("Event Initiated");  
        }  
   
        //call when button clicked  
        public void onClcik(object sender, EventArgs e)  
        {  
            MessageBox.Show("You clicked me");    
        }  
        static void Main(string[] args)  
        {  
            Application.Run(new Program());  
   
            Console.ReadLine();  
        }  
    }  
  
}  

Мы вызываем форму Windows, используя метод Run класса Application. Наконец, когда пользователь запускает это приложение, сначала на экране будет отображаться сообщение «Событие запущено» и форма Windows с пользовательским элементом управления «Кнопка». При нажатии кнопки появится окно сообщения, как показано ниже;

Figure 1.4

Summary

Резюме

В этой статье мы узнали о делегатах и событиях в C# и .NET.

СиШарп

пятница, 7 января 2022 г.

Делегаты

Зачем нам нужны делегаты

Обзор делегатов

Определение делегата

Образец программы делегатов

Массив делегатов

Анонимные методы

Многоадресный делегат

Многоадресный делегат

События

Комментариев нет:

Отправить комментарий

Паттерн 'Репозиторий' в ASP.NET

пятница, 7 января 2022 г.

Делегаты

Зачем нам нужны делегаты

Обзор делегатов

Определение делегата

Образец программы делегатов

Массив делегатов

Анонимные методы

Многоадресный делегат

Многоадресный делегат

События

Комментариев нет:

Отправить комментарий

Паттерн 'Репозиторий' в ASP.NET

пятница, 7 января 2022 г.