355 500 произведений, 25 200 авторов.

Электронная библиотека книг » Герберт Шилдт » C# 4.0: полное руководство » Текст книги (страница 37)
C# 4.0: полное руководство
  • Текст добавлен: 6 апреля 2017, 04:00

Текст книги "C# 4.0: полное руководство"


Автор книги: Герберт Шилдт



сообщить о нарушении

Текущая страница: 37 (всего у книги 83 страниц)

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

Анонимный метод – один из способов создания безымянного блока кода, связанного с конкретным экземпляром делегата. Для создания анонимного метода достаточно указать кодовый блок после ключевого слова delegate. Покажем, как это делается, на конкретном примере. В приведенной ниже программе анонимный метод служит для подсчета от 0 до 5.

// Продемонстрировать применение анонимного метода.

using System;

// Объявить тип делегата,

delegate void CountIt();

class AnonMethDemo {

  static void Main() {

    // Далее следует код для подсчета чисел, передаваемый делегату

    // в качестве анонимного метода.

    CountIt count = delegate {

      // Этот кодовый блок передается делегату,

      for (int i=0; i <= 5; i++)

        Console.WriteLine(i) ;

    }; // обратите внимание на точку с запятой

    count();

  }

}

В данной программе сначала объявляется тип делегата CountIt без параметров и с возвращаемым типом void. Далее в методе Main() создается экземпляр count делегата CountIt, которому передается кодовый блок, следующий после ключевого слова delegate. Именно этот кодовый блок и является анонимным методом, который будет выполняться при обращении к делегату count. Обратите внимание на то, что после кодового блока следует точка с запятой, фактически завершающая оператор объявления. Ниже приведен результат выполнения данной программы.

0

1

2

3

4

5


Передача аргументов анонимному методу

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

// Продемонстрировать применение анонимного метода, принимающего аргумент,

using System;

// Обратите внимание на то, что теперь у делегата Countlt имеется параметр,

delegate void CountIt(int end);

class AnonMethDemo2 {

  static void Main() {

    // Здесь конечное значение для подсчета передается анонимному методу.

    CountIt count = delegate(int end) {

      for(int i=0; i <= end; i++)

        Console.WriteLine(i);

    };

    count(3);

    Console.WriteLine();

    count(5);

  }

}

В этом варианте программы делегат CountIt принимает целочисленный аргумент. Обратите внимание на то, что при создании анонимного метода список параметров указывается после ключевого слова delegate. Параметр end становится доступным для кода в анонимном методе таким же образом, как и при создании именованного метода. Ниже приведен результат выполнения данной программы.

0

1

2

3

0

1

2

3

4

5


Возврат значения из анонимного метода

Анонимный метод может возвращать значение. Для этой цели служит оператор return, действующий в анонимном методе таким же образом, как и в именованном методе. Как и следовало ожидать, тип возвращаемого значения должен быть совместим с возвращаемым типом, указываемым в объявлении делегата. В качестве примера ниже приведен код, выполняющий подсчет с суммированием и возвращающий результат.

// Продемонстрировать применение анонимного метода,

//возвращающего значение.

using System; 

// Этот делегат возвращает значение,

delegate int CountIt(int end);

class AnonMethDemo3 {

  static void Main() {

    int result;

    // Здесь конечное значение для подсчета передается анонимному методу.

    //А возвращается сумма подсчитанных чисел.

    CountIt count = delegate (int end) {

      int sum = 0;

      for(int i=0; i <= end; i++) {

        Console.WriteLine(i);

        sum += i;

      }

      return sum; // возвратить значение из анонимного метода

    };

    result = count(3);

    Console.WriteLine("Сумма 3 равна " + result);

    Console.WriteLine();

    result = count (5);

    Console.WriteLine("Сумма 5 равна " + result);

  }

}

В этом варианте кода суммарное значение возвращается кодовым блоком, связанным с экземпляром делегата count. Обратите внимание на то, что оператор return применяется в анонимном методе таким же образом, как и в именованном методе. Ниже приведен результат выполнения данного кода.

0

1

2

3

Сумма 3 равна 6

0

1

2

3

4

5

Сумма 5 равна 15


Применение внешних переменных в анонимных методах

Локальная переменная, в область действия которой входит анонимный метод, называется внешней переменной. Такие переменные доступны для использования в анонимном методе. И в этом случае внешняя переменная считается захваченной. Захваченная переменная существует до тех пор, пока захвативший ее делегат не будет собран в «мусор». Поэтому если локальная переменная, которая обычно прекращает свое существование после выхода из кодового блока, используется в анонимном методе, то она продолжает существовать до тех пор, пока не будет уничтожен делегат, ссылающийся на этот метод.

Захват локальной переменной может привести к неожиданным результатам. В качестве примера рассмотрим еще один вариант программы подсчета с суммированием чисел. В данном варианте объект CountIt конструируется и возвращается статическим методом Counter(). Этот объект использует переменную sum, объявленную в охватывающей области действия метода Counter(), а не самого анонимного метода. Поэтому переменная sum захватывается анонимным методом. Метод Counter() вызывается в методе Main() для получения объекта CountIt, а следовательно, переменная sum не уничтожается до самого конца программы.

// Продемонстрировать применение захваченной переменной,

using System;

// Этот делегат возвращает значение типа int

// и принимает аргумент типа int.

delegate int CountIt(int end);

class VarCapture {

  static CountIt Counter() {

    int sum = 0;

    // Здесь подсчитанная сумма сохраняется в переменной sum.

    CountIt ctObj = delegate (int end) {

      for(int i=0; i <= end; i++) {

        Console.WriteLine(i);

        sum += i;

      }

      return sum;

    };

    return ctObj;

  }

  static void Main() {

    // Получить результат подсчета.

    CountIt count = Counter();

    int result;

    result = count(3);

    Console.WriteLine("Сумма 3 равна " + result);

    Console.WriteLine();

    result = count(5);

    Console.WriteLine("Сумма 5 равна " + result);

  }

}

Ниже приведен результат выполнения этой программы. Обратите особое внимание на суммарное значение.

0

1

2

3

Сумма 3 равна 6

0

1

2

3

4

5

Сумма 5 равна 21

Как видите, подсчет по-прежнему выполняется как обычно. Но обратите внимание на то, что сумма 5 теперь равна 21, а не 15! Дело в том, что переменная sum захватывается объектом ctObj при его создании в методе Counter(). Это означает, что она продолжает существовать вплоть до уничтожения делегата count при «сборке мусора» в самом конце программы. Следовательно, ее значение не уничтожается после возврата из метода Counter() или при каждом вызове анонимного метода, когда происходит обращение к делегату count в методе Main().

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


Лямбда-выражения

Несмотря на всю ценность анонимных методов, им на смену пришел более совершенный подход: лямбда-выражение. Не будет преувеличением сказать, что лямбда-выражение относится к одним из самых важных нововведений в С#, начиная с выпуска исходной версии 1.0 этого языка программирования. Лямбда-выражение основывается на совершенно новом синтаксическом элементе и служит более эффективной альтернативой анонимному методу. И хотя лямбда-выражения находят применение главным образом в работе с LINQ (подробнее об этом – в главе 19), они часто используются и вместе с делегатами и событиями. Именно об этом применении лямбда-выражений и пойдет речь в данном разделе.

Лямбда-выражение – это другой собой создания анонимной функции. (Первый ее способ, анонимный метод, был рассмотрен в предыдущем разделе.) Следовательно, лямбда-выражение может быть присвоено делегату. А поскольку лямбда-выражение считается более эффективным, чем эквивалентный ему анонимный метод, то в большинстве случаев рекомендуется отдавать предпочтение именно ему.


Лямбда-оператор

Во всех лямбда-выражениях применяется новый лямбда-оператор =>, который разделяет лямбда-выражение на две части. В левой его части указывается входной параметр (или несколько параметров), а в правой части – тело лямбда-выражения. Оператор => иногда описывается такими словами, как «переходит» или «становится».

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


Одиночные лямбда-выражения

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

Ниже приведена общая форма одиночного лямбда-выражения, принимающего единственный параметр.

параметр => выражение

Если же требуется указать несколько параметров, то используется следующая форма.

(список_параметров) => выражение

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

Ниже приведен простой пример одиночного лямбда-выражения.

count => count + 2

В этом выражении count служит параметром, на который воздействует выражение count + 2. В итоге значение параметра count увеличивается на 2. А вот еще один пример одиночного лямбда-выражения.

n => n % 2 == 0

В данном случае выражение возвращает логическое значение true, если числовое значение параметра n оказывается четным, а иначе – логическое значение false.

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

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

// Применить два одиночных лямбда-выражения.

using System;

// Объявить делегат, принимающий аргумент типа int и

// возвращающий результат типа int.

delegate int Incr(int v);

// Объявить делегат, принимающий аргумент типа int и

// возвращающий результат типа bool,

delegate bool IsEven(int v);

class SimpleLambdaDemo {

  static void Main() {

    // Создать делегат Incr, ссылающийся на лямбда-выражение,

    // увеличивающее свой параметр на 2.

    Incr incr = count => count + 2;

    // А теперь использовать лямбда-выражение incr.

    Console.WriteLine("Использование лямбда-выражения incr: ");

    int x = -10;

    while(x <= 0) {

      Console.Write(x + " ");

      x = incr(x); // увеличить значение x на 2

    }

    Console.WriteLine («n»);

    // Создать экземпляр делегата IsEven, ссылающийся на лямбда-выражение,

    // возвращающее логическое значение true, если его параметр имеет четное

    // значение, а иначе – логическое значение false.

    IsEven isEven = n => n % 2 == 0;

    // А теперь использовать лямбда-выражение isEven.

    Console.WriteLine("Использование лямбда-выражения isEven: ");

    for (int i=1; i <= 10; i++)

      if(isEven (i)) Console.WriteLine(i + « четное.»);

  }

}

Вот к какому результату приводит выполнение этой программы.

Использование лямбда-выражения incr:

-10 -8 -6 -4 -2 0

Использование лямбда-выражения isEven:

2 четное.

4 четное.

6 четное.

8 четное.

10 четное.

Обратите в данной программе особое внимание на следующие строки объявлений.

Incr incr = count => count +2;

IsEven isEven = n => n % 2 == 0;

В первой строке объявления экземпляру делегата incr присваивается одиночное лямбда-выражение, возвращающее результат увеличения на 2 значения параметра count. Это выражение может быть присвоено делегату Incr, поскольку оно совместимо с объявлением данного делегата. Аргумент, указываемый при обращении к экземпляру делегата incr, передается параметру count, который и возвращает результат вычисления лямбда-выражения. Во второй строке объявления делегату isEven присваивается выражение, возвращающее логическое значение true, если передаваемый ему аргумент оказывается четным, а иначе – логическое значение false. Следовательно, это лямбда-выражение совместимо с объявлением делегата IsEven.

В связи со всем изложенным выше возникает резонный вопрос: каким образом компилятору становится известно о типе данных, используемых в лямбда-выражении, например, о типе int параметра count в лямбда-выражении, присваиваемом экземпляру делегата incr? Ответить на этот вопрос можно так: компилятор делает заключение о типе параметра и типе результата вычисления выражения по типу делегата. Следовательно, параметры и возвращаемое значение лямбда-выражения должны быть совместимы по типу с параметрами и возвращаемым значением делегата.

Несмотря на всю полезность логического заключения о типе данных, в некоторых случаях приходится явно указывать тип параметра лямбда-выражения. Для этого достаточно ввести конкретное название типа данных. В качестве примера ниже приведен другой способ объявления экземпляра делегата incr.

Incr incr = (int count) => count + 2;

Как видите, count теперь явно объявлен как параметр типа int. Обратите также внимание на использование скобок. Теперь они необходимы. (Скобки могут быть опущены только в том случае, если задается лишь один параметр, а его тип явно не указывается.)

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

(low, high, val) => val >= low && val <= high;

А вот как объявляется тип делегата, совместимого с этим лямбда-выражением.

delegate bool InRange(int lower, int upper, int v);

Следовательно, экземпляр делегата InRange может быть создан следующим образом.

InRange rangeOK = (low, high, val) => val >= low && val <= high;

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

if(rangeOK(1, 5, 3)) Console.WriteLine(

            «Число 3 находится в пределах от 1 до 5.»);

И последнее замечание: внешние переменные могут использоваться и захватываться в лямбда-выражениях таким же образом, как и в анонимных методах.


Блочные лямбда-выражения

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

Ниже приведен пример использования блочного лямбда-выражения для вычисления и возврата факториала целого значения.

// Продемонстрировать применение блочного лямбда-выражения,

using System;

// Делегат IntOp принимает один аргумент типа int

// и возвращает результат типа int.

delegate int IntOp(int end);

class StatementLambdaDemo {

  static void Main() {

    // Блочное лямбда-выражение возвращает факториал

    // передаваемого ему значения.

    IntOp fact = n => {

      int r = 1;

      for (int i=1; i <= n; i++)

        r = i * r;

      return r;

    };

    Console.WriteLine("Факториал 3 равен " + fact(3));

    Console.WriteLine("Факториал 5 равен " + fact(5));

  }

}

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

Факториал 3 равен 6

Факториал 5 равен 120

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

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

// Первый пример применения делегатов, переделанный с

// целью использовать блочные лямбда-выражения.

using System;

// Объявить тип делегата,

delegate string StrMod(string s);

class UseStatementLambdas {

  static void Main() {

    // Создать делегаты, ссылающиеся на лямбда– выражения,

    // выполняющие различные операции с символьными строками.

    // Заменить пробелы дефисами.

    StrMod ReplaceSpaces = s => {

      Console.WriteLine(«Замена пробелов дефисами.»);

      return s.Replace(' ', '-');

    };

    // Удалить пробелы.

    StrMod RemoveSpaces = s => {

      string temp = "";

      int i;

      Console.WriteLine(«Удаление пробелов.»);

      for(i=0; i < s.Length; i++)

        if(s[i] != ' ') temp += s[i];

      return temp;

    };

    // Обратить строку.

    StrMod Reverse = s => {

      string temp = ""; int i, j;

      Console.WriteLine(«Обращение строки.»);

      for(j=0, i=s.Length-1; i >= 0; i–, j++) temp += s[i];

      return temp;

    };

    string str;

    // Обратиться к лямбда-выражениям с помощью делегатов.

    StrMod strOp = ReplaceSpaces;

    str = strOp(«Это простой тест.»);

    Console.WriteLine("Результирующая строка: " + str);

    Console.WriteLine() ;

    strOp = RemoveSpaces;

    str = strOp(«Это простой тест.»);

    Console.WriteLine("Результирующая строка: " + str);

    Console.WriteLine();

    strOp = Reverse;

    str = strOp(«Это простой тест.»);

    Console.WriteLine("Результирующая строка: " + str);

  }

}

Результат выполнения кода этого примера оказывается таким же, как и в первом примере применения делегатов.

Замена пробелов дефисами.

Результирующая строка: Это-простой-тест.

Удаление пробелов.

Результирующая строка: Этопростойтест.

Обращение строки.

Результирующая строка: .тсет йотсорп отЭ


    Ваша оценка произведения:

Популярные книги за неделю