Почему пытается понять, что делегаты чувствуют, что пытаются понять природу Вселенной?

Ответ 1

Делегаты - это просто способ передать функцию в переменной.

Вы передаете делегированную функцию для выполнения обратного вызова. Например, при выполнении асинхронного ввода-вывода вы передаете делегированную функцию (функцию, которую вы написали с параметром делегирования), которая будет вызываться, когда данные были считаны с диска.

Ответ 2

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

Bullet
    DamageBullet
    HealBullet
    PoisonBullet
    DoSomethingElseBullet
    PoisonAndThenHealBullet
    FooAndBarBullet
    ....

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

new Bullet(DamageDelegate)

Это, очевидно, намного лучший способ сделать что-то.

В функциональных языках вы склонны видеть гораздо больше такого рода вещей.

Ответ 3

Делегат - это простой контейнер, который знает, где находится в памяти компьютера определенный метод.

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

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

Я думаю, вы знакомы с событиями, и вы регулярно используете их. Поле event на самом деле является списком таких делегатов (также называемым делегатом с несколькими листами). Может быть, все станет понятнее, когда мы посмотрим, как мы могли бы "имитировать" события на С#, если у него не было ключевого слова event, но только (не многоадресные) делегаты:

public class Button : Rectangle
{
    private List<Delegate> _delegatesToNotifyForClick = new List<Delegate>();

    public void PleaseNotifyMeWhenClicked(Delegate d)
    {
        this._delegatesToNotifyForClick.Add(d);
    }

    // ...

    protected void GuiEngineToldMeSomeoneClickedMouseButtonInsideOfMyRectangle()
    {
        foreach (Delegate d in this._delegatesToNotifyForClick)
        {
            d.Invoke(this, this._someArgument);
        }
    }
}

// Then use that button in your form

public class MyForm : Form
{
    public MyForm()
    {
        Button myButton = new Button();
        myButton.PleaseNotifyMeWhenClicked(new Delegate(this.ShowMessage));
    }

    private void ShowMessage()
    {
        MessageBox.Show("I know that the button was clicked! :))))");
    }
 }

Надеюсь, что смогу немного помочь.; -)

Ответ 4

Эта статья от Chris Sells может помочь:

. NET-делегаты: С# Bedtime Story

Ответ 5

Возможно, это помогает:

• Делегат - это тип (определяющий подпись метода)
• Экземпляр делегата - это ссылка на метод (указатель функции AKA)
• Обратный вызов - это параметр типа делегата
• Событие - это (вид) свойства типа делегата

Цель делегатов состоит в том, что вы можете иметь переменные/поля/параметры/свойства (события), которые "удерживают" функцию. Это позволяет вам сохранять/передавать определенную функцию, выбранную во время выполнения. Без него каждый вызов функции должен быть исправлен во время компиляции.

Синтаксис с участием делегатов (или событий) может сначала быть немного сложным, это имеет две причины:

• простые указатели на такие функции, как в C/С++, не были бы безопасными для типов, в .NET компилятор действительно генерирует класс вокруг него, а затем пытается скрыть это как можно больше.

• делегаты являются краеугольным камнем LINQ, и существует крутая эволюция от описания-все в С# 1 с помощью анонимных методов (С# 2) до lambdas (С# 3).

Просто познакомьтесь с 1 или 2 стандартными шаблонами.

Ответ 6

Давай, ребята! Все вы успешно усложнили DELEGATES:)!

Я постараюсь оставить подсказку здесь: я понял делегатов, как только я понял, что jquery ajax вызывает в Javascript. для ex: ajax.send(url, data, successcallback, failcallback) является сигнатурой функции. как вы знаете, он отправляет данные на URL-адрес сервера, как ответ, может быть 200OK или некоторая другая ошибка. В случае любого такого события (успех/сбой) вы хотите выполнить функцию. Таким образом, это действует как заполнитель функции, чтобы иметь возможность упоминать либо успех, либо неудачу. Этот заполнитель может быть не очень общим - он может принимать набор параметров и может/не возвращать значение. Это объявление такого Заполнителя, если сделано в С# IS CALLED DELEGATE! Поскольку функции javascript не являются строгими с количеством аргументов, вы просто видите их как GENERIC-заполнители... но у С# есть некоторые объявления STRICT... это сводится к объявлениям DELEGATE!!

Надеюсь, это поможет!

Ответ 7

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

Пример: как его использовать

class program {
 public static void Main) {
  List<Employee> empList = new List<Employee> () {
   new Employee () {Name = "Test1", Experience = 6 },
   new Employee () {Name = "Test2", Experience = 2 },
  }

// delegate point to the actual function
IsPromotable isEligibleToPromote = new IsPromotable(IsEligibleToPromoteEmployee)
Employee emp = new Employee();

// pass the delegate to a method where the delegate will be invoked.
emp.PromoteEmployee(empList, isEligibleToPromote);

// same can be achieved using lambda empression no need to declare delegate 
emp.PromoteEmployee (empList, emply =>emply.Experience > 2);

   // this condition can change at calling end 
   public static bool IsEligibleToPromoteEmployee (emp){
      if (emp.Experience > 5)
       return true;
      else
      return false;
    }
  }
}


public delegate bool IsPromotable(Employee emp);

public class Employee  {
  public string Name {get; set;}
  public int Experience {get; set;}

  // conditions changes it can 5, 6 years to promote
  public void PromoteEmployee (List<Employee> employees, IsPromotable isEligibleToPromote) {
  foreach (var employee in employees) {
    // invoke actual function
    if (isEligibleToPromote(employee)){
       Console.WriteLine("Promoted");   
    }
  }
}

Ответ 8

Я не думаю, что кто-то упомянул об этом, но раздел о делегатах Джона Скита в его книге " С# in depth", вероятно, лучшее, что я когда-либо встречал. Точно так же, как ОП, я боролся с делегатами. У меня была проблема с настройкой делегатов.

Книга "Джон Скит" отлично подходит для объяснения делегатов, потому что она разбивает делегат "настроена", дает разъяснения между типом делегирования и экземпляром делегирования (вам нужно будет понять, что книга, чтобы понять это, иначе я возможно, откроет себя для нарушения авторских прав, так как я не мог объяснить это лучше, чем Джон). Лучше всего он дает небольшой, но ясный пример.

Я никоим образом не связан с Джоном Скитом или Маннинг, но это стоит прочитать, а не только для раздела о делегатах.