Statements, Expressions, and Operators

This section contains information regarding the fundamental elements that make up a C# program. The C# code that comprises an application consists of statements comprising C# keywords, expressions and operators.

Statements

A statement is a procedural building-block from which all C# programs are constructed. A statement can declare a local variable or constant, call a method, create an object, or assign a value to a variable, property, or field. A control statement can create a loop, such as a for loop, or make a decision and branch to a new block of code, such as an if or switch statement. Statements are usually terminated by a semicolon.

A series of statements surrounded by curly braces form a block of code. A method body is one example of a code block. Code blocks often follow a control statement. Variables or constants declared within a code block are only available to statements within the same code block. For example, the following code shows a method block and a code block following a control statement:

bool IsPositive(int number) { if (number > 0) { return true; } else { return false; } }

Statements in C# often contain expressions. An expression in C# is a fragment of code containing a literal value, a simple name, or an operator and its operands. Most common expressions, when evaluated, yield a literal value, a variable, or an object property or object indexer access. Whenever a variable, object property or object indexer access is identified from an expression, the value of that item is used as the value of the expression. In C#, an expression can be placed anywhere that a value or object is required as long as the expression ultimately evaluates to the required type.

Some expressions evaluate to a namespace, a type, a method group, or an event access. These special-purpose expressions are only valid at certain times, usually as part of a larger expression, and will result in a compiler error when used improperly.

Операторы и выражения

В этом разделе содержатся сведения об основных элементах, из которых состоят программы на языке C#. Код приложений в C# состоит из операторов с ключевыми словами и выражениями.

Операторы

Оператор — это процедурный стандартный блок, из которых создаются все программы C#. С помощью оператора можно объявлять локальную переменную или константу, вызывать метод, создавать объект или назначать значение переменной, свойству или полю. С помощью оператора управления можно создать цикл, например цикл for, или создать решение и ответвление к новому блоку кода, например оператор ifили switch. Операторы обычно заканчиваются точкой с запятой.

Последовательность операторов, заключенная в фигурные скобки, представляет собой блок кода. Тело метода является одним из примеров блока кода. Блоки кода часто идут после оператора управления. Переменные или константы, объявленные в блоке кода, доступны только операторам в этом блоке кода. Например, в следующем коде показаны блок метода и блок кода, расположенные после оператора управления:

ß---

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

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

 

Expressions

An expression is a fragment of code that can be evaluated to a single value, object, method, or namespace. Expressions can contain a literal value, a method invocation, an operator and its operands, or a simple name. Simple names can be the name of a variable, type member, method parameter, namespace or type.

Expressions can use operators that in turn use other expressions as parameters, or method calls whose parameters are in turn other method calls, so expressions can range from simple to very complex.

Literals and Simple Names

The two simplest types of expressions are literals and simple names. A literal is a constant value that has no name. For example, in the following code example, both 5 and "Hello World" are literal values:

int i = 5; string s = "Hello World";

In the example above, both i and s are simple names identifying local variables. When those variables are used in an expression, the value of the variable is retrieved and used for the expression. For example, in the following code example, when DoWork is called, the method receives the value 5 by default and is not able to access the variable var:

int var = 5; DoWork(var);

Invocation Expressions

In the following code example, the call to DoWork is another kind of expression, called an invocation expression.

DoWork(var);

Specifically, calling a method is a method invocation expression. A method invocation requires the name of the method, either as a name as in the previous example, or as the result of another expression, followed by parenthesis and any method parameters. For more information, see Methods. A delegate invocation uses the name of a delegate and method parameters in parenthesis. For more information, see Delegates. Method invocations and delegate invocations evaluate to the return value of the method, if the method returns a value. Methods that return void cannot be used in place of a value in an expression.

Выражения

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

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

Литералы и простые имена

Двумя наиболее простыми типами выражений являются литералы и простые имена. Литерал представляет собой постоянное значение, у которого нет имени. Например, в следующем примере 5 и "Hello World" являются литералами.

int i = 5; string s = "Hello World";

В приведенном выше примере i и s являются простыми именами, которые определяют локальные переменные. При использовании таких переменных в выражениях для вычисления выражения используются значения этих переменных. Например, в следующем примере кода при вызове метода DoWork этот метод по умолчанию получает значение 5 и не может получить доступ к переменной var:

int var = 5; DoWork(var);

Выражения вызова

В следующем примере кода вызов метода DoWork является выражением вызова.

DoWork();

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

 

Query Expressions

The same rules for expressions in general apply to query expressions.

Lambda Expressions

Lambda expressions represent "inline methods" that have no name but can have input parameters and multiple statements. They are used extensively in LINQ to pass arguments to methods. Lambda expressions are compiled to either delegates or expression trees depending on the context in which they are used. For more information, see Lambda Expressions.

Expression Trees

Expression trees enable expressions to be represented as data structures. They are used extensively by LINQ providers to translate query expressions into code that is meaningful in some other context, such as a SQL database.

Remarks

Whenever a variable, object property, or object indexer access is identified from an expression, the value of that item is used as the value of the expression. An expression can be placed anywhere in C# where a value or object is required, as long as the expression ultimately evaluates to the required type.

 

Выражения запроса

Аналогичные правила в общем случае относятся и к выражениям запроса.

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

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

Деревья выражений

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

Заметки

Если в выражении присутствует переменная, свойство объекта или индексатор объекта, для вычисления выражения используется значение этого элемента. В C# выражение можно использовать везде, где требуется значение или объект, если результат вычисления выражения соответствует требуемому типу.

 

Operators

In C#, an operator is a term or a symbol that takes one or more expressions, called operands, as input and returns a value. Operators that take one operand, such as the increment operator (++) or new, are called unary operators. Operators that take two operands, such as arithmetic operators (+, -, *, /) are called binary operators. One operator, the conditional operator (?:), takes three operands and is the sole tertiary operator in C#.

The following C# statement contains a single unary operator, and a single operand. The increment operator, ++, modifies the value of the operand y.:

y++;

The following C# statement contains two binary operators, each with two operands. The assignment operator, =, has the integer y, and the expression 2 + 3 as operands. The expression 2 + 3 itself contains the addition operator, and uses the integer values 2 and 3 as operands:

y = 2 + 3;

An operand can be a valid expression of any size, composed of any number of other operations.

Operators in an expression are evaluated in a specific order known as operator precedence. The following table divides the operators into categories based on the type of operation they perform. The categories are listed in order of precedence.

Primary	x.y, f(x), a[x], x++, x--, new, typeof, checked, unchecked
Unary	+, -,!, ~, ++x, --x, (T)x
Arithmetic — Multiplicative	*, /, %
Arithmetic — Additive	+, -
Shift	<<, >>
Relational and type testing	<, >, <=, >=, is, as
Equality	==,!=
Logical, in order of precedence	&, ^, |
Conditional, in order of precedence	&&, ||,?:
Assignment	=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, =>

Операторы

Оператор в C# — это термин или символ, получающий на вход одно или несколько выражений (операндов) и возвращающий значение. Операторы, получающие на вход только один операнд, например оператор приращения (++) или new, называются унарными операторами. Операторы, получающие на вход два операнда, например, арифметические операторы (+, -, *, /) называются бинарными. Один оператор — условный оператор (?:) получает на вход три операнда и является единственным третичным оператором в C#.

Следующая строка кода C# содержит один унарный оператор и один операнд. Оператор приращения ++ изменяет значение операнда y:

y++;

Следующая строка кода C# содержит два бинарных оператора, каждый с двумя операндами. Оператор присвоения = получает y и выражение 2 + 3 в качестве операндов. Выражение 2 + 3 само содержит оператор сложения и использует в качестве операндов целочисленные значения 2 и 3.

y = 2 + 3;

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

Категория	Выражение	Описание
Основная	x.y	Доступ к членам
	f(x)	Вызов метода и делегата
	a[x]	Доступ к массиву и индексатору
	x++	Постфиксное приращение
	x--	Постфиксное уменьшение
	new T(...)	Создание объекта и делегата

 

 

	new T(...){...}	Создание объекта с инициализатором. См. раздел Инициализаторы объектов и коллекций.
	new {...}	Анонимный инициализатор объекта. См. раздел Анонимные типы.
	new T[...]	Создание массива. См. раздел Массивы.
	typeof(T)	Получение объекта System.Type для T
	checked(x)	Вычисление выражения в проверенном контексте
	unchecked(x)	Вычисление выражения в непроверенном контексте
	default (T)	Получение значения по умолчания для типа T
	delegate {}	Анонимная функция (анонимный метод)
Унарные	+x	Идентификация
	-x	Отрицание
	!x	Логическое отрицание
	~x	Поразрядное отрицание
	++x	Префиксное приращение
	--x	Префиксное уменьшение
	(T)x	Явное преобразование x в тип T
Мультипликативные	*,,	Умножение
	/	Деление
	%	Остаток

 

 

Аддитивные	x + y	Сложение, объединение строк, объединение делегатов
	x - y	Вычитание, удаление делегатов
Сдвиг	x << y	Сдвиг влево
	x >> y	Сдвиг вправо
Относительные и тестирующие типы	x < y	Меньше
	x > y	Больше
	x <= y	Меньше или равно
	x >= y	Больше или равно
	x is T	Возвращает значение true, если x относится к типу T, в противном случае возвращает значение false
	x as T	Возвращает x типа T или нулевое значение, если x не относится к типу T
Операторы равенства	x == y	Равно
	x!= y	Не равно
Логическое AND	x & y	Целочисленное поразрядное AND, логическое AND
Логическое исключающее XOR	x ^ y	Целочисленное поразрядное исключающее XOR, логическое исключающее XOR
Логическое OR	x | y	Целочисленное поразрядное OR, логическое OR
Условное AND	x && y	Вычисляет y только если x имеет значение true

 

 

Условное OR	x || y	Вычисляет y только если x имеет значение false
Объединение нулей	X?? y	Равно y, если x — нулевое, в противном случае равно x
Условные	x?: y: z	Равно y, если x имеет значение true, z если x имеет значение false
Присвоение или анонимная функция	=,, =>	Операторы присвоения
	x op= y	Составные операторы присвоения: +=, -=, *=, /=, %=, &=, |=,!=, <<=, >>=
	(T x) => y	Анонимная функция (лямбда-выражение).

 

When two operators with the same precedence are present in an expression, they are evaluated based on associativity. Left-associative operators are evaluated in order from left to right. For example, x * y / z is evaluated as (x * y) / z. Right-associative operators are evaluated in order from right to left. The assignment operators and the tertiary operator (?:) are right-associative. All other binary operators are left-associative. However, C# standard does not specify when, in an expression, the "set" portion of an increment instruction is executed. For example, the output of the following example code is 6:

int num1 = 5; num1++; System.Console.WriteLine(num1);

However, the output of the following example code is undefined:

int num2 = 5; num2 = num2++; //not recommended System.Console.WriteLine(num2);

Therefore, the latter example is not recommended. Parentheses can be used to surround an expression and force that expression to be evaluated before any others. For example, 2 + 3 * 2 would normally become 8. This is because multiplicative operators take precedence over additive operators. Writing the expression as (2 + 3) * 2 results in 10, because it indicates to the C# compiler that the addition operator (+) must be evaluated before the multiplication operator (*).

You can change the behavior of operators for custom classes and structs. This process is called operator overloading. This process is called operator overloading. For more information, see Overloadable Operators.

 

Когда выражение содержит два оператора с одинаковым порядком применения, они вычисляются на основе ассоциативности. Запросы с левой ассоциативностью вычисляются слева направо. Например, x * y / z вычисляется как (x * y) / z. Запросы с правой ассоциативностью вычисляются справа налево. Операторы присвоения и третичный оператор (?:) имеют правую ассоциативность. Все прочие двоичные операторы имеют левую ассоциативность. Однако стандарт C# не указывает, когда в выражении выполняется часть "set" инструкции приращения. Например, результатом следующего примера кода является число 6:

int num1 = 5; num1++; System.Console.WriteLine(num1);

Результат следующего примера кода не определен:

int num2 = 5; num2 = num2++; //not recommended System.Console.WriteLine(num2);

Поэтому применять последний пример не рекомендуется. Можно заключать выражения в скобки для принудительного вычисления некоторых частей выражения раньше других. Например, выражение 2 + 3 * 2 в обычном случае будет иметь значение 8, поскольку операторы умножения выполняются раньше операторов сложения. Результатом выражения (2 + 3) * 2 будет число 10, поскольку компилятор C# получит данные о том, что оператор сложения (+) нужно вычислить до оператора умножения (*).

Поведение операторов для пользовательских классов и структур можно изменить. Такой процесс называется перегрузкой операторов. Дополнительные сведения см. в разделе Перегружаемые операторы.

 

Anonymous Functions

As described elsewhere, a delegate is a type that wraps a method call. A delegate instance can be passed between methods just like a type, and it can be invoked like a method. An anonymous function is an "inline" statement or expression that can be used wherever a delegate type is expected. You can use it to initialize a named delegate or pass it instead of a named delegate type as a method parameter.

There are two kinds of anonymous functions, which are discussed individually in the following topics:

· Lambda Expressions.

· Anonymous Methods

 

Note:

Lambda expressions can be bound to expression trees and also to delegates.

The Evolution of Delegates in C#

In C# 1.0, you created an instance of a delegate by explicitly initializing it with a method that was defined elsewhere in the code. C# 2.0 introduced the concept of anonymous methods as a way to write unnamed inline statement blocks that can be executed in a delegate invocation. C# 3.0 introduces lambda expressions, which are similar in concept to anonymous methods but more expressive and concise. These two features are known collectively as anonymous functions. In general, applications that target version 3.5 and later of the.NET Framework should use lambda expressions.

The following example demonstrates the evolution of delegate creation from C# 1.0 to C# 3.0:

 

Анонимные функции

Как описано в других разделах, делегат — это тип, создающий оболочку вызова метода. Экземпляр делегата можно подставлять между методами как тип и вызывать как метод. Анонимная функция – это оператор или выражение "inline", которое можно использовать каждый раз, когда ожидается тип делегата. Ее можно использовать для инициализации именованного делегата или подставить вместо типа именованного делегата в качестве параметра метода.

Существует два типа анонимных функций, каждый из которых по отдельности рассматривается в следующих разделах:

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

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

Примечание.

Лямбда-выражения можно привязать к деревьям выражений и к делегатам.

Эволюция делегатов в C#

В языке C# 1.0 разработчик создавал экземпляр делегата путем его явной инициализации с методом, определенным в каком-либо месте кода. В C# версии 2.0 представлена концепция анонимных методов, которые позволяют писать блоки неименованных встраиваемых выражений, которые можно выполнять в вызове делегата. В языке C# версии 3.0 представлены лямбда-выражения, концепция которых соответствует анонимным методам, но которые являются более выразительными и лаконичными. Две эти возможности вместе называются анонимными функциями. В общем, в приложениях для среды.NET Framework версии 3.5 и более новой версии должны использоваться лямбда-выражения.

В приведенном ниже примере демонстрируется эволюция создания делегата в языке C# с версии 1.0 до версии 3.0.

 

class Test

{

delegate void TestDelegate(string s);

static void M(string s)

{

Console.WriteLine(s);

}

 

static void Main(string[] args)

{

// Original delegate syntax required

// initialization with a named method.

TestDelegate testdelA = new TestDelegate(M);

 

// C# 2.0: A delegate can be initialized with

// inline code, called an "anonymous method." This

// method takes a string as an input parameter.

TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

 

// C# 3.0. A delegate can be initialized with

// a lambda expression. The lambda also takes a string

// as an input parameter (x). The type of x is inferred by the compiler.

TestDelegate testDelC = (x) => { Console.WriteLine(x); };

 

// Invoke the delegates.

testdelA("Hello. My name is M and I write lines.");

testDelB("That's nothing. I'm anonymous and ");

testDelC("I'm a famous author.");

 

// Keep console window open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

}

/* Output:

Hello. My name is M and I write lines.

That's nothing. I'm anonymous and

I'm a famous author.

Press any key to exit.

*/

ß------ Пример

Lambda Expressions

A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types.

All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters (if any) and the right side holds the expression or statement block. The lambda expression x => x * x is read "x goes to x times x." This expression can be assigned to a delegate type as follows:

delegate int del(int i); del myDelegate = x => x * x; int j = myDelegate(5); //j = 25

To create an expression tree type:

using System.Linq.Expressions; //... Expression<del> = x => x * x;

The => operator has the same precedence as assignment (=) and is right-associative.

Lambdas are used in method-based LINQ queries as arguments to standard query operator methods such as Where and Where(IQueryable, String, array<Object>[]()[]).

When you use method-based syntax to call the Where method in the Enumerable class (as you do in LINQ to Objects and LINQ to XML) the parameter is a delegate type Func<(Of <(T, TResult>)>). A lambda expression is the most convenient way to create that delegate. When you call the same method in, for example, the Queryable class (as you do in LINQ to SQL) then the parameter type is an Expression<Func> where Func is any Func delegates with up to five input parameters. Again, a lambda expression is just a very concise way to construct that expression tree. The lambdas allow the Where calls to look similar although in fact the type of object created from the lambda is different.

In the previous example, notice that the delegate signature has one implicitly-typed input parameter of type int, and returns an int. The lambda expression can be converted to a delegate of that type because it also has one input parameter (x) and a return value that the compiler can implicitly convert to type int. (Type inference is discussed in more detail in the following sections.) When the delegate is invoked by using an input parameter of 5, it returns a result of 25.

Lambdas are not allowed on the left side of the is or as operator.

All restrictions that apply to anonymous methods also apply to lambda expressions. For more information, see Anonymous Methods.

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

Лямбда-выражение — это анонимная функция, которая содержит выражения и операторы и может использоваться для создания делегатов или типов дерева выражений.

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

ß---

Создание типа дерева выражений

ß---

Оператор => имеет тот же приоритет, что и оператор присваивания (=) и является правоассоциативным.

Лямбда-операторы используются в запросах LINQ на основе методов в качестве аргументов стандартных методов операторов запроса, таких как Where и Where(IQueryable, String, array<Object>[]()[]).

При использовании синтаксиса на основе методов для вызова метода Where в классе Enumerable (как это делается в LINQ на объекты и LINQ to XML) параметром является тип делегата System..::.Func<(Of <(T, TResult>)>). Лямбда-выражение — это наиболее удобный способ создания делегата. При вызове такого же метода, к примеру, в классе System.Linq..::.Queryable (как это делается в LINQ to SQL) типом параметра будет System.Linq.Expressions..::.Expression<Func>, где Func — это любые делегаты Func с числом параметров ввода не более пяти. Опять же, лямбда-выражения представляют собой самый быстрый способ построения дерева выражений. Лямбда-операторы позволяют вызовам Where выглядеть одинаково, хотя на самом деле объект, созданный из лямбда-выражения, имеет другой тип.

Обратите внимание: в приведенном выше примере подпись делегата имеет один неявный параметр ввода типа int и возвращает значение типа int. Лямбда-выражение можно преобразовать в делегат соответствующего типа, поскольку он также имеет один параметр ввода (x) и возвращает значение, которое компилятор может неявно преобразовать в тип int. (Вывод типа более подробно рассматривается в следующих разделах.) Делегат, вызываемый посредством параметра ввода 5, возвращает результат 25.

Лямбда-операторы не разрешены с левой стороны оператора is или as.

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

Expression Lambdas

A lambda expression with an expression on the right side is called an expression lambda. Expression lambdas are used extensively in the construction of Expression Trees. An expression lambda returns the result of the expression and takes the following basic form:

(input parameters) => expression

The parentheses are optional only if the lambda has one input parameter; otherwise they are required. Two or more input parameters are separated by commas enclosed in parentheses:

(x, y) => x == y

Sometimes it is difficult or impossible for the compiler to infer the input types. When this occurs, you can specify the types explicitly as shown in the following example:

(int x, string s) => s.Length > x

Specify zero input parameters with empty parentheses:

() => SomeMethod()

Note in the previous example that the body of an expression lambda can consist of a method call. However, if you are creating expression trees that will be consumed in another domain, such as SQL Server, you should not use method calls in lambda expressions. The methods will have no meaning outside the context of the.NET common language runtime.

 

Выражения-лямбды

Лямбда-выражение с выражением с правой стороны называется выражением-лямбдой. Выражения-лямбды широко используются при конструировании Деревья выражений. Выражения-лямбды возвращают результат выражения и принимают следующую основную форму.

(input parameters) => expression

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

(x, y) => x == y

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

(int x, string s) => s.Length > x

Нулевые параметры ввода указываются пустыми скобками.

() => SomeMethod()

Обратите внимание: в примере выше основная часть выражения-лямбды может состоять из вызова метода. Однако при создании деревьев выражений, которые будут использоваться в другом домене, например SQL Server, в лямбда-выражениях не следует использовать вызовы методов. Эти методы не имеют смыслового значения вне контекста среды выполнения.NET.

 

Statement Lambdas

A statement lambda resembles an expression lambda except that the statement(s) is enclosed in braces:

(input parameters) => {statement;}

The body of a statement lambda can consist of any number of statements; however, in practice there are typically no more than two or three.

delegate void TestDelegate(string s); … TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); }; myDel("Hello");

Statement lambdas, like anonymous methods, cannot be used to create expression trees.