Методы в C#
Метод — это блок кода, содержащий ряд инструкций. Программа инициирует выполнение инструкций, вызывая метод и указывая все аргументы, необходимые для этого метода. В C# все инструкции выполняются в контексте метода. Метод Main является точкой входа для каждого приложения C# и вызывается общеязыковой средой выполнения (CLR) при запуске программы.
Примечание.
В этом разделе рассматриваются названные методы. Дополнительные сведения об анонимных функциях см. в статье Лямбда-выражения.
Сигнатуры методов
Методы объявляются с помощью ограничений class, record или struct, для которых указываются следующие данные.
- Уровень доступа (необязательно), например
publicилиprivate. Значение по умолчанию —private. - Необязательные модификаторы, например
abstractилиsealed. - Возвращаемое значение или
void, если у метода его нет. - Имя метода.
- Любые параметры методов. Параметры метода заключаются в скобки и разделяются запятыми. Пустые скобки указывают, что параметры методу не требуются.
Вместе все эти части формируют сигнатуру метода.
Внимание
Тип возврата метода не является частью сигнатуры метода в целях перегрузки метода. Однако он является частью сигнатуры метода при определении совместимости между делегатом и методом, который он указывает.
В следующем примере определяется класс с именем Motorcycle, содержащий пять методов:
namespace MotorCycleExample
{
abstract class Motorcycle
{
// Anyone can call this.
public void StartEngine() {/* Method statements here */ }
// Only derived classes can call this.
protected void AddGas(int gallons) { /* Method statements here */ }
// Derived classes can override the base class implementation.
public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }
// Derived classes can override the base class implementation.
public virtual int Drive(TimeSpan time, int speed) { /* Method statements here */ return 0; }
// Derived classes must implement this.
public abstract double GetTopSpeed();
}
Класс Motorcycle включает перегруженный метод. Drive Оба метода называются одинаково, но различаются по типам параметров.
Вызов метода
Можно использовать метод instance или static. Для того чтобы вызвать метод instance, необходимо создать экземпляр объекта и вызвать для него метод; метод instance будет применен к этому экземпляру и его данным. Вы вызываете статический метод, ссылаясь на имя типа, к которому принадлежит метод; статические методы не работают с данными экземпляра. При попытке вызвать статический метод с помощью экземпляра объекта возникает ошибка компилятора.
Вызов метода аналогичен доступу к полю. После имени объекта (при вызове метода экземпляра) или имени типа (если вы вызываете static метод), добавьте период, имя метода и круглые скобки. Аргументы перечисляются в этих скобках и разделяются запятыми.
Определение метода задает имена и типы всех необходимых параметров. Когда вызывающий код вызывает метод, он предоставляет конкретные значения, называемые аргументами, для каждого параметра. Аргументы должны быть совместимы с типом параметра, но имя аргумента, если он используется в вызывающем коде, не должен совпадать с параметром, указанным в методе. В следующем примере метод Square имеет один параметр типа int с именем i. Первый вызов метода передает методу Square переменную типа int с именем num; второй — числовую константу, а третий — выражение.
public static class SquareExample
{
public static void Main()
{
// Call with an int variable.
int num = 4;
int productA = Square(num);
// Call with an integer literal.
int productB = Square(12);
// Call with an expression that evaluates to int.
int productC = Square(productA * 3);
}
static int Square(int i)
{
// Store input argument in a local variable.
int input = i;
return input * input;
}
}
В наиболее распространенной форме вызова методов используются позиционные аргументы; они передаются в том же порядке, что и параметры метода. Таким образом, методы класса Motorcycle могут вызываться, как показано в следующем примере. Например, вызов метода Drive включает два аргумента, которые соответствуют двум параметрам в синтаксисе метода. Первый становится значением параметра miles, а второй — значением параметра speed.
class TestMotorcycle : Motorcycle
{
public override double GetTopSpeed() => 108.4;
static void Main()
{
var moto = new TestMotorcycle();
moto.StartEngine();
moto.AddGas(15);
_ = moto.Drive(5, 20);
double speed = moto.GetTopSpeed();
Console.WriteLine("My top speed is {0}", speed);
}
}
При вызове метода вместо позиционных аргументов можно также использовать именованные аргументы. При использовании именованных аргументов необходимо указать имя параметра, двоеточие (":"), а затем аргумент. Аргументы для метода могут отображаться в любом порядке, при условии, что все обязательные аргументы присутствуют. В следующем примере для вызова метода TestMotorcycle.Drive используются именованные аргументы. В этом примере именованные аргументы передаются из списка параметров метода в обратном порядке.
namespace NamedMotorCycle;
class TestMotorcycle : Motorcycle
{
public override int Drive(int miles, int speed) =>
(int)Math.Round((double)miles / speed, 0);
public override double GetTopSpeed() => 108.4;
static void Main()
{
var moto = new TestMotorcycle();
moto.StartEngine();
moto.AddGas(15);
int travelTime = moto.Drive(miles: 170, speed: 60);
Console.WriteLine("Travel time: approx. {0} hours", travelTime);
}
}
// The example displays the following output:
// Travel time: approx. 3 hours
Метод можно вызывать, используя и позиционные, и именованные аргументы. Однако позиционные аргументы могут следовать за именованными аргументами, только если именованные аргументы находятся в правильных позициях. В следующем примере метод TestMotorcycle.Drive из предыдущего примера вызывается с использованием одного позиционного и одного именованного аргумента.
int travelTime = moto.Drive(170, speed: 55);
Унаследованные и переопределенные методы
Помимо членов, определенных в нем явно, тип наследует члены, определенные в его базовых классах. Так как все типы в системе управляемых типов напрямую или косвенно наследуются из класса Object, все типы наследуют его члены, такие как Equals(Object), GetType() и ToString(). В следующем примере определяется класс Person, который создает экземпляры двух объектов Person и вызывает метод Person.Equals, чтобы определить, равны ли эти объекты. Однако Equals метод не определен в Person классе; он наследуется от Object.
public class Person
{
public string FirstName = default!;
}
public static class ClassTypeExample
{
public static void Main()
{
Person p1 = new() { FirstName = "John" };
Person p2 = new() { FirstName = "John" };
Console.WriteLine("p1 = p2: {0}", p1.Equals(p2));
}
}
// The example displays the following output:
// p1 = p2: False
Типы могут переопределять унаследованные члены, используя ключевое слово override и обеспечивая реализацию переопределенного метода. Сигнатура метода должна быть такой же, как у переопределенного метода. Следующий пример аналогичен предыдущему за тем исключением, что переопределяет метод Equals(Object). (Он также переопределяет метод GetHashCode(), поскольку оба эти метода предназначены для получения согласованных результатов.)
namespace methods;
public class Person
{
public string FirstName = default!;
public override bool Equals(object? obj) =>
obj is Person p2 &&
FirstName.Equals(p2.FirstName);
public override int GetHashCode() => FirstName.GetHashCode();
}
public static class Example
{
public static void Main()
{
Person p1 = new() { FirstName = "John" };
Person p2 = new() { FirstName = "John" };
Console.WriteLine("p1 = p2: {0}", p1.Equals(p2));
}
}
// The example displays the following output:
// p1 = p2: True
Передача параметров
Типы в C# делятся на типы значений и ссылочные типы. Список встроенных типов значений см. в разделе Типы. По умолчанию и типы значений, и ссылочные типы передаются в метод по значению.
Передача параметров по значению
При передаче типа значения в метод по значению вместо самого объекта передается его копия. Это значит, что изменения объекта в вызываемом методе не отражаются на исходном объекте, когда управление возвращается вызывающему объекту.
Код в следующем примере передает тип значения в метод по значению, а вызываемый метод пытается изменить значение типа значения. Он определяет переменную типа int, который является типом значения, присваивает ему значение 20 и передает его в метод с именем ModifyValue, который изменяет значение переменной на 30. Однако, когда метод возвращается, значение переменной остается неизменным.
public static class ByValueExample
{
public static void Main()
{
var value = 20;
Console.WriteLine("In Main, value = {0}", value);
ModifyValue(value);
Console.WriteLine("Back in Main, value = {0}", value);
}
static void ModifyValue(int i)
{
i = 30;
Console.WriteLine("In ModifyValue, parameter value = {0}", i);
return;
}
}
// The example displays the following output:
// In Main, value = 20
// In ModifyValue, parameter value = 30
// Back in Main, value = 20
Если объект ссылочного типа передается в метод по значению, ссылка на этот объект передается по значению. Это значит, что метод получает не сам объект, а аргумент, который указывает расположение объекта. Если с помощью этой ссылки в член объекта вносится изменение, это изменение отражается в объекте, даже если управление возвращается вызывающему объекту. При этом изменения в объекте, переданном в метод, не отражаются на исходном объекте, когда управление возвращается вызывающему объекту.
В следующем примере определяется класс (ссылочного типа) с именем SampleRefType. Он создает экземпляр объекта SampleRefType, задает в его поле value значение 44 и передает объект в метод ModifyObject. Этот пример по сути совпадает с предыдущим примером. Он передает аргумент по значению методу. Однако поскольку здесь используется ссылочный тип, результат будет другим. В данном случае в методе ModifyObject изменено поле obj.value, при этом поле value аргумента rt в методе Main также изменяется на 33, как видно из результатов в предыдущем примере.
public class SampleRefType
{
public int value;
}
public static class ByRefTypeExample
{
public static void Main()
{
var rt = new SampleRefType { value = 44 };
ModifyObject(rt);
Console.WriteLine(rt.value);
}
static void ModifyObject(SampleRefType obj) => obj.value = 33;
}
Передача параметров по ссылке
Параметр передается по ссылке, когда нужно изменить значение аргумента в методе и сохранить это изменение после того, как управление вернется вызывающему методу. Для передачи параметра по ссылке используйте ключевое слово ref или out. Можно также передать значение по ссылке, чтобы предотвратить копирование, и при этом запретить внесение изменений с помощью ключевого слова in.
Следующий пример идентичен предыдущему за тем исключением, что значение передается в метод ModifyValue по ссылке. Если значение параметра в методе ModifyValue будет изменено, при возвращении управления вызывающему объекту это изменение не сохранится.
public static class ByRefExample
{
public static void Main()
{
var value = 20;
Console.WriteLine("In Main, value = {0}", value);
ModifyValue(ref value);
Console.WriteLine("Back in Main, value = {0}", value);
}
private static void ModifyValue(ref int i)
{
i = 30;
Console.WriteLine("In ModifyValue, parameter value = {0}", i);
return;
}
}
// The example displays the following output:
// In Main, value = 20
// In ModifyValue, parameter value = 30
// Back in Main, value = 30
Общий шаблон, в котором используются параметры по ссылке, включает замену значений переменных. Когда две переменные передаются в метод по ссылке, он меняет их содержимое местами. В следующем примере меняются местами целочисленные значения.
public static class RefSwapExample
{
static void Main()
{
int i = 2, j = 3;
Console.WriteLine("i = {0} j = {1}", i, j);
Swap(ref i, ref j);
Console.WriteLine("i = {0} j = {1}", i, j);
}
static void Swap(ref int x, ref int y) =>
(y, x) = (x, y);
}
// The example displays the following output:
// i = 2 j = 3
// i = 3 j = 2
Передача параметров ссылочного типа позволяет изменить значение самой ссылки, а не отдельных ее элементов или полей.
Массивы параметров
В некоторых случаях требование об указании точного числа аргументов для метода является строгим. Если параметр в массиве параметров указывается с помощью ключевого слова params, метод можно вызывать с переменным числом аргументов. Параметр, помеченный ключевым словом params, должен быть типом массива и занимать последнюю позицию в списке параметров метода.
После этого вызывающий объект можно вызвать одним из четырех способов:
- передавая массив соответствующего типа, содержащий требуемое число элементов;
- передавая в метод список отдельных аргументов соответствующего типа, разделенный запятыми;
- Путем передачи
null. - не передавая никакие аргументы в массив параметров.
В следующем примере определяется метод с именем GetVowels, возвращающий все гласные из массива параметров. Метод Main демонстрирует все четыре способа вызова метода. Вызывающие элементы не требуются для предоставления аргументов для параметров, включающих params модификатор. В этом случае параметр является пустым массивом.
static class ParamsExample
{
static void Main()
{
string fromArray = GetVowels(["apple", "banana", "pear"]);
Console.WriteLine($"Vowels from array: '{fromArray}'");
string fromMultipleArguments = GetVowels("apple", "banana", "pear");
Console.WriteLine($"Vowels from multiple arguments: '{fromMultipleArguments}'");
string fromNull = GetVowels(null);
Console.WriteLine($"Vowels from null: '{fromNull}'");
string fromNoValue = GetVowels();
Console.WriteLine($"Vowels from no value: '{fromNoValue}'");
}
static string GetVowels(params string[]? input)
{
if (input == null || input.Length == 0)
{
return string.Empty;
}
char[] vowels = ['A', 'E', 'I', 'O', 'U'];
return string.Concat(
input.SelectMany(
word => word.Where(letter => vowels.Contains(char.ToUpper(letter)))));
}
}
// The example displays the following output:
// Vowels from array: 'aeaaaea'
// Vowels from multiple arguments: 'aeaaaea'
// Vowels from null: ''
// Vowels from no value: ''
Необязательные параметры и аргументы
Определение метода может указать, что его параметры являются обязательными или являются необязательными. По умолчанию параметры обязательны. Для определения необязательных параметров значения параметра по умолчанию включаются в определение метода. Если при вызове метода никакие аргументы для необязательного параметры не указываются, вместо них используется значение по умолчанию.
Значение параметра по умолчанию должно быть назначено одним из следующих видов выражений:
Константа, например, строковый литерал или число.
Выражение, имеющее вид
default(SomeType), гдеSomeTypeможет быть либо типом значения, либо ссылочным типом. Использование ссылочного типа практически эквивалентно указаниюnull. Вы можете использоватьdefaultлитерал, так как компилятор может вывести тип из объявления параметра.Выражение в форме
new ValType(), гдеValType— это тип значения. Это вызывает неявный конструктор типа значения без параметров, который не является фактическим членом типа.Примечание.
В C# 10 и более поздних версиях, когда выражение формы
new ValType()вызывает явно определенный конструктор без параметров типа значения, компилятор выдает ошибку, так как значение параметра по умолчанию должно быть константой времени компиляции. Используйте выражениеdefault(ValType)или литералdefaultдля предоставления значения параметра по умолчанию. Дополнительные сведения о конструкторах без параметров см. в разделе "Инициализация структуры и значения по умолчанию" статьи "Типы структур".
Если метод содержит как обязательные, так и необязательные параметры, необязательные параметры определяются в конце списка параметров после всех обязательных параметров.
В следующем примере определяется метод ExampleMethod, который имеет один обязательный и два необязательных параметра.
public class Options
{
public void ExampleMethod(int required, int optionalInt = default,
string? description = default)
{
var msg = $"{description ?? "N/A"}: {required} + {optionalInt} = {required + optionalInt}";
Console.WriteLine(msg);
}
}
Если для вызова метода с несколькими необязательными аргументами используются позиционные аргументы, вызывающий объект должен предоставить аргумент для всех необязательных параметров, для которых предоставлен аргумент, от первого до последнего. Например, если вызывающий ExampleMethod объект предоставляет аргумент для description параметра, он также должен указать один для optionalInt параметра. opt.ExampleMethod(2, 2, "Addition of 2 and 2"); — допустимый вызов метода; opt.ExampleMethod(2, , "Addition of 2 and 0"); вызывает ошибку компилятора "Аргумент отсутствует".
Если метод вызывается с помощью именованных аргументов или комбинации позиционных и именованных аргументов, вызывающий объект может опустить любые аргументы, следующие за последним позиционным аргументом в вызове метода.
В следующем примере метод ExampleMethod вызывается трижды. В первых двух вызовах метода используются позиционные аргументы. В первом пропускаются оба необязательных аргумента, а во втором — последний. Третий вызов метода предоставляет позиционный аргумент для обязательного параметра, но использует именованный аргумент для передачи значения в параметр description, в то время как аргумент optionalInt опускается.
public static class OptionsExample
{
public static void Main()
{
var opt = new Options();
opt.ExampleMethod(10);
opt.ExampleMethod(10, 2);
opt.ExampleMethod(12, description: "Addition with zero:");
}
}
// The example displays the following output:
// N/A: 10 + 0 = 10
// N/A: 10 + 2 = 12
// Addition with zero:: 12 + 0 = 12
Использование необязательных параметров влияет на разрешение перегрузки или на способ, с помощью которого компилятор C# определяет, какая именно перегрузка должна вызываться при вызове метода, следующим образом:
- Метод, индексатор или конструктор является кандидатом на выполнение, если каждый из его параметров необязателен либо по имени или позиции соответствует одному и тому же аргументу в операторе вызова, и этот аргумент можно преобразовать в тип параметра.
- Если найдено более одного кандидата, правила разрешения перегрузки для предпочтительных преобразований применяются к аргументам, указанным явно. Опущенные аргументы для необязательных параметров игнорируются.
- Если два кандидата определяются как равно подходящие, предпочтение отдается кандидату без необязательных параметров, аргументы которых в вызове были опущены. Это — последовательность определения приоритетов в разрешении перегрузки для кандидатов с меньшим числом параметров.
Возвращаемые значения
Методы могут возвращать значение вызывающему объекту. Если возвращаемый тип (тип, указанный перед именем метода), не voidявляется, метод может вернуть значение с помощью return ключевое слово. Инструкция с ключевым словом return, за которым следует переменная, константа или выражение, соответствующие типу возврата, будут возвращать это значение объекту, вызвавшему метод. Методы с типом возврата, отличным от void, должны использовать ключевое слово return для возврата значения. Ключевое слове return также останавливает выполнение метода.
Если тип возврата — void, инструкцию return без значения по-прежнему можно использовать для завершения выполнения метода. Без ключевого слова return этот метод будет останавливать выполнение при достижении конца блока кода.
Например, в следующих двух методах ключевое слово return используется для возврата целочисленных значений.
class SimpleMath
{
public int AddTwoNumbers(int number1, int number2) =>
number1 + number2;
public int SquareANumber(int number) =>
number * number;
}
Чтобы использовать значение, возвращаемое из метода, вызывающий метод может применять сам вызов метода везде, где будет достаточно значения того же типа. Можно также назначить возвращаемое значение переменной. Например, следующие два примера кода достигают одной и той же цели.
int result = obj.AddTwoNumbers(1, 2);
result = obj.SquareANumber(result);
// The result is 9.
Console.WriteLine(result);
result = obj.SquareANumber(obj.AddTwoNumbers(1, 2));
// The result is 9.
Console.WriteLine(result);
Использование локальной переменной, в данном случае result, для сохранения значения является необязательным. Это может улучшить читаемость кода или может оказаться необходимым, если нужно сохранить исходное значение аргумента для всей области метода.
В некоторых случаях нужно, чтобы метод возвращал больше одного значения. Это можно сделать с помощью типов кортежей и кортежей. Тип кортежа определяет типы данных для элементов кортежа. Литералы кортежей предоставляют фактические значения возвращаемого кортежа. В следующем примере (string, string, string, int) определяет тип кортежа, возвращаемый методом GetPersonalInfo. Выражение (per.FirstName, per.MiddleName, per.LastName, per.Age) представляет собой литерал кортежа; метод возвращает имя, отчество и фамилию, а также возраст объекта PersonInfo.
public (string, string, string, int) GetPersonalInfo(string id)
{
PersonInfo per = PersonInfo.RetrieveInfoById(id);
return (per.FirstName, per.MiddleName, per.LastName, per.Age);
}
После этого вызывающий объект может использовать возвращенный кортеж в коде следующего вида:
var person = GetPersonalInfo("111111111");
Console.WriteLine($"{person.Item1} {person.Item3}: age = {person.Item4}");
Имена могут также назначаться элементам кортежа в определении типа кортежа. В следующих примерах демонстрируется альтернативная версия метода GetPersonalInfo, в котором используются именованные элементы:
public (string FName, string MName, string LName, int Age) GetPersonalInfo(string id)
{
PersonInfo per = PersonInfo.RetrieveInfoById(id);
return (per.FirstName, per.MiddleName, per.LastName, per.Age);
}
После этого предыдущий вызов метода GetPersonalInfo можно изменить следующим образом:
var person = GetPersonalInfo("111111111");
Console.WriteLine($"{person.FName} {person.LName}: age = {person.Age}");
Если метод передает массив в качестве аргумента и изменяет значение отдельных элементов, метод не нужен для возврата массива, хотя вы можете сделать это для хорошего стиля или функционального потока значений. Это связано с тем, что C# передает все ссылочные типы по значению, а значением ссылки на массив является указатель на массив. В следующем примере изменения в содержимом массива values, сделанные в методе DoubleValues, может отслеживать любой код, имеющий ссылку на этот массив.
public static class ArrayValueExample
{
static void Main()
{
int[] values = [2, 4, 6, 8];
DoubleValues(values);
foreach (var value in values)
{
Console.Write("{0} ", value);
}
}
public static void DoubleValues(int[] arr)
{
for (var ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
{
arr[ctr] *= 2;
}
}
}
// The example displays the following output:
// 4 8 12 16
Методы расширения
Как правило, добавлять методы в существующий тип можно двумя способами:
- Изменение исходного кода для этого типа. Конечно, это невозможно сделать, если вы не владеете исходным кодом типа. Если при этом в поддержку метода также добавляются поля закрытых данных, это изменение становится критическим.
- Определение нового метода в производном классе. Метод нельзя добавить таким образом с помощью наследования для других типов, таких как структуры и перечисления. Кроме того, оно не позволяет "добавить" метод в запечатанный класс.
Методы расширения позволяют "добавить" метод в существующий тип, не меняя сам тип и не реализуя новый метод в наследуемом типе. Метод расширения также не должен находиться в той же сборке, что и тип, который он расширяет. Вызовите метод расширения, как будто он является определенным членом типа.
Дополнительные сведения см. в статье Методы расширения.
Асинхронные методы
С помощью функции async можно вызывать асинхронные методы, не прибегая к использованию явных обратных вызовов или ручному разделению кода между несколькими методами или лямбда-выражениями.
Если пометить метод с помощью модификатора async, можно использовать в этом методе инструкцию await. Когда элемент управления достигает await выражения в асинхронном методе, элемент управления возвращается вызывающему объекту, если ожидаемая задача не завершена, и ход выполнения метода с await помощью ключевое слово будет приостановлен до тех пор, пока ожидающая задача не завершится. После завершения задачи выполнение в методе может быть возобновлено.
Примечание.
Асинхронный метод возвращается в вызывающий объект, когда он встречает первый ожидаемый объект, выполнение которого еще не завершено, или когда выполнение асинхронного метода доходит до конца — в зависимости от того, что происходит раньше.
Асинхронный метод обычно имеет тип возвращаемого значения Task<TResult>, Task, IAsyncEnumerable<T> или void. Тип возвращаемого значения void в основном используется для определения обработчиков событий, где требуется возвращать тип void. Асинхронный метод, который возвращает тип void, не может быть ожидающим. Вызывающий объект метода, возвращающего значение типа void, не может перехватывать исключения, которые выдает этот метод. Асинхронный метод может иметь любой тип возвращаемой задачи.
В следующем примере DelayAsync представляет собой асинхронный метод с оператором return, который возвращает целое число. Так как это асинхронный метод, его объявление метода должно иметь возвращаемый тип Task<int>. Поскольку тип возврата — Task<int>, вычисление выражения await в DoSomethingAsync создает целое число, как показывает следующий оператор: int result = await delayTask.
class Program
{
static Task Main() => DoSomethingAsync();
static async Task DoSomethingAsync()
{
Task<int> delayTask = DelayAsync();
int result = await delayTask;
// The previous two statements may be combined into
// the following statement.
//int result = await DelayAsync();
Console.WriteLine($"Result: {result}");
}
static async Task<int> DelayAsync()
{
await Task.Delay(100);
return 5;
}
}
// Example output:
// Result: 5
Асинхронный метод не может объявлять параметры in, ref или out, но может вызывать методы, имеющие такие параметры.
Дополнительные сведения об асинхронных методах см. в разделах Асинхронное программирование с использованием ключевых слов async и await (C#) и Типы возвращаемых значений асинхронных операций.
Элементы, воплощающие выражение
Обычно используются определения методов, которые просто возвращаются немедленно с результатом выражения или имеют одну инструкцию в качестве текста метода. Существует сочетание синтаксиса для определения таких методов с помощью =>:
public Point Move(int dx, int dy) => new Point(x + dx, y + dy);
public void Print() => Console.WriteLine(First + " " + Last);
// Works with operators, properties, and indexers too.
public static Complex operator +(Complex a, Complex b) => a.Add(b);
public string Name => First + " " + Last;
public Customer this[long id] => store.LookupCustomer(id);
Если метод возвращает void или является асинхронным, текст этого метода должен быть выражением оператора (как и при использовании лямбда-выражений). Для свойств и индексаторов они должны быть доступны только для чтения, и вы не используете get метод доступа ключевое слово.
Итераторы
Итератор выполняет настраиваемую итерацию по коллекции, например по списку или массиву. Итератор использует инструкцию yield return для возврата всех элементов по одному. По достижении оператора yield return текущее расположение запоминается, чтобы вызывающий объект мог запросить следующий элемент в последовательности.
Тип возвращаемого итератора может быть IEnumerable, IEnumerable<T>, IAsyncEnumerable<T>, IEnumeratorили IEnumerator<T>.
Дополнительные сведения см. в разделе Итераторы.
См. также
Обратная связь
Ожидается в ближайшее время: в течение 2024 года мы постепенно откажемся от GitHub Issues как механизма обратной связи для контента и заменим его новой системой обратной связи. Дополнительные сведения см. в разделе https://aka.ms/ContentUserFeedback.
Отправить и просмотреть отзыв по