Что такое метод в си шарп

Методы

Следует отметить, что официальная терминология C# делает различие между функциями и методами. Согласно этой терминологии, понятие «функция-член» включает не только методы, но также другие члены, не являющиеся данными, класса или структуры. Сюда входят индексаторы, операции, конструкторы, деструкторы, а также — возможно, несколько неожиданно — свойства. Они контрастируют с данными-членами: полями, константами и событиями.

Объявление методов

В C# определение метода состоит из любых модификаторов (таких как спецификация доступности), типа возвращаемого значения, за которым следует имя метода, затем список аргументов в круглых скобках и далее — тело метода в фигурных скобках:

[модификаторы] тип_возврата ИмяМетода([параметры]) < // Тело метода >

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

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

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

В целом, возврат из метода может произойти при двух условиях. Во-первых, когда встречается фигурная скобка, закрывающая тело метода. И во-вторых, когда выполняется оператор return. Имеются две формы оператора return: одна — для методов типа void (возврат из метода), т.е. тех методов, которые не возвращают значения, а другая — для методов, возвращающих конкретные значения (возврат значения).

Давайте рассмотрим пример:

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class MyMathOperation < public double r; public string s; // Возвращает площадь круга public double sqrCircle() < return Math.PI * r * r; >// Возвращает длину окружности public double longCircle() < return 2 * Math.PI * r; >public void writeResult() < Console.WriteLine("Вычислить площадь или длину? s/l:"); s = Console.ReadLine(); s = s.ToLower(); if (s == "s") < Console.WriteLine("Площадь круга равна ",sqrCircle()); return; > else if (s == "l") < Console.WriteLine("Длина окружности равна ",longCircle()); return; > else < Console.WriteLine("Вы ввели не тот символ"); >> > class Program < static void Main(string[] args) < Console.WriteLine("Введите радиус: "); string radius = Console.ReadLine(); MyMathOperation newOperation = new MyMathOperation < r = double.Parse(radius) >; newOperation.writeResult(); Console.ReadLine(); > > > 

Использование параметров

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

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

Давайте рассмотрим пример:

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class myClass < public void someMethod(double[] myArr, int i ) < myArr[0] = 12.0; i = 12; >> class Program < static void Main(string[] args) < double[] arr1 = < 0, 1.5, 3.9, 5.1 >; int i = 0; Console.WriteLine("Массив arr1 до вызова метода: "); foreach (double d in arr1) Console.Write("\t",d); Console.WriteLine("\nПеременная i = \n",i); Console.WriteLine("Вызов метода someMethod . "); myClass ss = new myClass(); ss.someMethod(arr1,i); Console.WriteLine("Массив arr1 после вызова метода:"); foreach (double d in arr1) Console.Write("\t",d); Console.WriteLine("\nПеременная i = \n",i); Console.ReadLine(); > > >

Обратите внимание, что значение i осталось неизменным, но измененные значения в myArr также изменились в исходном массиве arr1, так как массивы являются ссылочными типами.

Поведение строк также отличается. Дело в том, что строки являются неизменными (изменение значения строки приводит к созданию совершенно новой строки), поэтому строки не демонстрируют поведение, характерное для ссылочных типов. Любые изменения, проведенные в строке внутри метода, не влияют на исходную строку.

Что такое метод в си шарп

Если переменные хранят некоторые значения, то методы содержат собой набор инструкций, которые выполняют определенные действия. По сути метод — это именованный блок кода, который выполняет некоторые действия.

Общее определение методов выглядит следующим образом:

[модификаторы] тип_возвращаемого_значения название_метода ([параметры]) < // тело метода >

Модификаторы и параметры необязательны.

Ранее мы уже использовали как минимум один метод — Console.WriteLine() , который выводит информацию на консоль. Теперь рассмотрим, как мы можем создавать свои методы.

Определение метода

Определим один метод:

void SayHello()

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

Перед названием метода идет возвращаемый тип данных. Здесь это тип void , который указыает, что фактически ничего не возвращает, он просто производит некоторые действия.

После названия метода в скобках идет перечисление параметров. Но в данном случае скобки пустые, что означает, что метод не принимает никаких параметров.

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

Console.WriteLine("Hello");

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

Вызов методов

Чтобы использовать метод SayHello, нам надо его вызвать. Для вызова метода указывается его имя, после которого в скобках идут значения для его параметров (если метод принимает параметры).

название_метода (значения_для_параметров_метода);

Например, вызов метода SayHello будет выглядеть следующим образом:

SayHello();

Поскольку метод не принимает никаких параметров, то после названия метода идут пустые скобки.

Объединим определение и вызов метода:

void SayHello() < Console.WriteLine("Hello"); >SayHello(); // Hello SayHello(); // Hello

Консольный вывод программы:

Hello Hello

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

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

SayHello(); // Hello SayHello(); // Hello void SayHello()

Определим и вызовем еще несколько методов:

void SayHelloRu() < Console.WriteLine("Привет"); >void SayHelloEn() < Console.WriteLine("Hello"); >void SayHelloFr() < Console.WriteLine("Salut"); >string language = «en»; switch (language)

Здесь определены три метода SayHelloRu() , SayHelloEn() и SayHelloFr() , которые также имеют тип void , не принимают никаких параметров и также выводит некоторую строку на консоль. Условно говоря, они выводят приветствие на определенном языке.

В конструкции switch проверяется значение переменной language , которая условно хранит код языка, и в зависимости от ее значения вызывается определенный метод. Так, в данном случае на консоль будет выведено

Hello

Сокращенная запись методов

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

void SayHello()

Мы можем его сократить следующим образом:

void SayHello() => Console.WriteLine("Hello");

То есть после списка параметров ставится оператор => , после которого идет выполняемая инструкция.

Методы (Руководство по программированию на C#)

Метод — это блок кода, содержащий ряд инструкций. Программа инициирует выполнение инструкций, вызывая метод и указывая все аргументы, необходимые для этого метода. В C# все инструкции выполняются в контексте метода.

Метод Main является точкой входа для каждого приложения C# и вызывается общеязыковой средой выполнения (CLR) при запуске программы. В приложении, использующем инструкции верхнего уровня, метод Main создается компилятором и содержит все инструкции верхнего уровня.

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

Сигнатуры методов

Методы объявляются в классе, структуре или интерфейсе путем указания уровня доступа, такого как public или private , необязательных модификаторов, таких как abstract или sealed , возвращаемого значения, имени метода и всех параметров этого метода. Все эти части вместе представляют собой сигнатуру метода.

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

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

abstract class Motorcycle < // Anyone can call this. public void StartEngine() // 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 must implement this. public abstract double GetTopSpeed(); > 

Доступ к методу

Вызов метода в объекте аналогичен доступу к полю. После имени объекта добавьте точку, имя метода и круглые скобки. Аргументы перечисляются в этих скобках и разделяются запятыми. Таким образом, методы класса Motorcycle могут вызываться, как показано в следующем примере:

class TestMotorcycle : Motorcycle < public override double GetTopSpeed() < return 108.4; >static void Main() < TestMotorcycle moto = new TestMotorcycle(); moto.StartEngine(); moto.AddGas(15); moto.Drive(5, 20); double speed = moto.GetTopSpeed(); Console.WriteLine("My top speed is ", speed); > > 

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

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

public void Caller() < int numA = 4; // Call with an int variable. int productA = Square(numA); int numB = 32; // Call with another int variable. int productB = Square(numB); // Call with an integer literal. int productC = Square(12); // Call with an expression that evaluates to int. productC = Square(productA * 3); >int Square(int i) < // Store input argument in a local variable. int input = i; return input * input; >

Передача по ссылке и передача по значению

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

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

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

public class SampleRefType

Теперь, если передать объект, основанный на этом типе, в метод, то будет передана ссылка на объект. В следующем примере объект типа SampleRefType передается в метод ModifyObject :

public static void TestRefType() < SampleRefType rt = new SampleRefType(); rt.value = 44; ModifyObject(rt); Console.WriteLine(rt.value); >static void ModifyObject(SampleRefType obj)

В этом примере, в сущности, делается то же, что и в предыдущем примере, — аргумент по значению передается в метод. Но поскольку здесь используется ссылочный тип, результат будет другим. В данном случае в методе ModifyObject изменено поле value параметра obj , а также изменено поле value аргумента, rt в методе TestRefType . В качестве выходных данных метод TestRefType отображает 33.

Дополнительные сведения о передаче ссылочных типов по ссылке и по значению см. в разделах Передача параметров ссылочного типа и Ссылочные типы.

Возвращаемые значения

Методы могут возвращать значение вызывающему объекту. Если тип возврата, указываемый перед именем метода, не void , этот метод может возвращать значение с помощью оператора return . Инструкция с ключевым словом return , за которым следует значение, соответствующее типу возврата, будет возвращать это значение объекту, вызвавшему метод.

Значение можно вернуть вызывающему объекту по значению или по ссылке. Значения возвращаются вызывающему объекту по ссылке, если ключевое слово ref используется в сигнатуре метода и указывается после каждого ключевого слова return . Например, следующая сигнатура метода и оператор return указывают, что метод возвращает переменную с именем estDistance вызывающему объекту по ссылке.

public ref double GetEstimatedDistance()

Ключевое слове return также останавливает выполнение метода. Если тип возврата — void , инструкцию return без значения по-прежнему можно использовать для завершения выполнения метода. Без ключевого слова return этот метод будет останавливать выполнение при достижении конца блока кода. Методы с типом возврата, отличным от void, должны использовать ключевое слово return для возврата значения. Например, в следующих двух методах ключевое слово return используется для возврата целочисленных значений.

class SimpleMath < public int AddTwoNumbers(int number1, int number2) < return number1 + number2; >public int SquareANumber(int number) < return 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 , для сохранения значения является необязательным. Это может улучшить читаемость кода или может оказаться необходимым, если нужно сохранить исходное значение аргумента для всей области метода.

Чтобы использовать значение, возвращаемое по ссылке из метода, необходимо объявить локальную ссылочную переменную, если планируется изменение значения. Например, если метод Planet.GetEstimatedDistance возвращает значение Double по ссылке, можно определить его как локальную ссылочную переменную с использованием кода следующего вида:

ref double distance = ref Planet.GetEstimatedDistance(); 

Возвращать многомерный массив из метода M , который изменяет содержимое массива, необязательно, если вызывающая функция передает массив в M . В целях оптимизации можно возвращать полученный массив из M или функциональный поток значений, однако это необязательно. Это связано с тем, что C# передает все ссылочные типы по значению, а значение ссылки на массив представляет собой указатель на массив. В методе M любые изменения содержимого массива отслеживаются любым кодом, имеющим ссылку на массив, как показано в приведенном ниже примере:

static void Main(string[] args) < int[,] matrix = new int[2, 2]; FillMatrix(matrix); // matrix is now full of -1 >public static void FillMatrix(int[,] matrix) < for (int i = 0; i < matrix.GetLength(0); i++) < for (int j = 0; j < matrix.GetLength(1); j++) < matrix[i, j] = -1; >> > 

Асинхронные методы

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

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

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

В следующем примере метод Main служит примером асинхронного метода с типом возврата Task. Он переходит к методу DoSomethingAsync и, поскольку он выражается в одной строке, он может опустить ключевые слова async и await . Поскольку DoSomethingAsync является асинхронным методом, задача для вызова DoSomethingAsync должна быть ожидаемой, как показывает следующая инструкция: await DoSomethingAsync(); .

class Program < static Task Main() =>DoSomethingAsync(); static async Task DoSomethingAsync() < TaskdelayTask = DelayAsync(); int result = await delayTask; // The previous two statements may be combined into // the following statement. //int result = await DelayAsync(); Console.WriteLine($"Result: "); > static async Task DelayAsync() < await Task.Delay(100); return 5; >> // Example output: // Result: 5 

Асинхронный метод не может объявить все параметры ref или out , но может вызывать методы, которые имеют такие параметры.

Определения текста выражений

Часто используются определения методов, которые просто немедленно возвращаются с результатом выражения или которые имеют единственную инструкцию в тексте метода. Для определения таких методов существует сокращенный синтаксис с использованием => :

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 текущее расположение в коде запоминается. При следующем вызове итератора выполнение возобновляется с этого места.

Итератор вызывается из клиентского кода с помощью инструкции foreach .

Дополнительные сведения см. в разделе Итераторы.

Спецификация языка C#

Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.

См. также

• Руководство по программированию на C#
• Система типов C#
• Модификаторы доступа
• Статические классы и члены статических классов
• Наследование
• Абстрактные и запечатанные классы и члены классов
• params
• out
• ref;
• Параметры методов

Совместная работа с нами на GitHub

Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.

The .NET documentation is open source. Provide feedback here.

Обратная связь

Отправить и просмотреть отзыв по

Методы

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

Метод – это конструкция в виде блока кода, которая выполняет некоторые действия, и имеет логическую смысловую нагрузку. Аналогом методов языка C#, являются математические функции.

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

Синтаксически метод выглядит следующим образом:

 type name( ) < //тело метода > 

• modifiers – необязательные модификаторы доступа;
• type – возвращаемый тип данных:
  • если метод не возвращает значения, то используется тип void;
  • если возвращает, то в теле метода должно присутствовать ключевое слово return, после которого указывается возвращаемое значение(того же типа что и тип метода);

  Рассмотрим примеры методов:

  using System; class Program < static void PrintHelloWorld( ) < Console.WriteLine("Hello World!"); > static void PrintHello(string name) < var text = "Hello " + name + "!"; Console.WriteLine(text); > static int Cube(int x) < return x * x * x; > static void Main(string[] args) < PrintHelloWorld(); PrintHello("Andrew"); var b1 = Cube(2); //8 var b2 = Cube(3); //27 Console.ReadLine(); > > 

  Все три метода вызываются в основном методе программы – Main. Они имеют модификатор доступа static. Первые два метода типа void, то есть ничего не возвращают.
  PrintHelloWorld – вызывает Console.WriteLine с текстовым аргументом.
  PrintHello – принимает в качестве аргумента текстовую строку и после модификации текста, передает его в другой метод Console.WriteLine, который выводит текст в консоль.
  Cube – принимает на вход целое число, возводит его в куб и возвращает результат.

  Когда использовать методы

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

  var a = new int[10]; var b = new int[7]; for (int i = 0; i < a.Length; i++) < Console.Write($"a[ ] hljs-keyword">for (int i = 0; i < b.Length; i++) < Console.Write($"b[ ] language-cs hljs">static int[] GetArrayFromConsole(string arrayName, int elementCount) < var retVal = new int[elementCount]; for (int i = 0; i < retVal.Length; i++) < Console.Write($" [ ] hljs-keyword">return retVal; > 

  В качестве аргументов, методу передаются: название массива и количество элементов(длина).

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

  static void Main(string[] args) < int[] t = GetArrayFromConsole("t", 5); var g = GetArrayFromConsole("g", 4); > 

  Оператор return

  Оператор return завершает выполнение метода, и может возвращать значение. Инструкции которые размещены после return игнорируются. В методе разрешается многократное использование оператора return, но иногда это усложняет читабельность кода программы. Если метод имеет тип void – оператор return может использоваться для преждевременного выхода:

  static void Test(int i) < if (i 0 || i > 5) < return; Console.Write("123"); //эта строка кода всегда игнорируется > Console.WriteLine(i); > static string ZeroCompare(double number) < if (number < 0) < return "Число меньше нуля"; > else if (number > 0) < return "Число больше нуля"; > return "Число равно нулю"; > 

  Параметры методов

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

  Передача параметров по значению

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

  using System; class Program < static int Add(int x1, int x2) < x1 += x2; //изменение x1 не влияет на переданную в качестве аргумента переменную num1 return x1; > static void Main(string[] args) < var num1 = 2; var num2 = 5; var sum = Add(num1, num2); Console.WriteLine($" + = "); Console.ReadLine(); > > 

  Передача параметров по ссылке

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

  using System; class Program < static int Mult(ref int x1, int x2) < x1 *= x2; //изменение x1 влияет на переменную n1 return x1; > static void Main(string[] args) < var n1 = 24; var n2 = 4; var mult = Mult(ref n1, n2); //переменная n1 содержит новое значение Console.WriteLine($" "); Console.ReadLine(); > > 

  Модификатор ref указывается как в описании, так и при вызове метода.

  Выходные параметры

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

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

  using System; class Program < static string Div(int a, int b, out int result) < if (b == 0) < result = int.MinValue; return "Ошибка: Деление на ноль!"; > else < result = a / b; return ""; > > static void PrintResult(string errorText, int res) < if (string.IsNullOrEmpty(errorText)) < Console.WriteLine(res); >else < Console.WriteLine(errorText); >> static void Main(string[] args) < int r1; var err1 = Div(64, 8, out r1); PrintResult(err1, r1); //переменная r2 объявляется в списке аргументов var err2 = Div(34, 0, out int r2); PrintResult(err2, r2); Console.ReadLine(); > > 

  Как видно из примера, C# 7.0 поддерживает две равносильные формы синтаксиса для записи выходных параметров:

  • переменная объявляется перед вызовом метода;
  • переменная объявляется в списке аргументов.

  Выходному параметру, в теле метода, обязательно должно быть присвоено значение.
  Как и в случае с ref, модификатор out указывается в описании и при вызове метода.

  Именованные аргументы

  В C# есть возможность передавать параметры в произвольном порядке, для этого используются именованные аргументы(named arguments). Для явного указания имени аргумента, используется следующий синтаксис:

  arg_name : arg_value 

  Пример программы с именованными аргументами:

  static string GetPrettyName(string firstName, string lastName) < return firstName + " " + lastName; > static void Main(string[] args) < var s = GetPrettyName(lastName: "Jackson", firstName: "Anna"); > 

  Опциональные параметры

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

  Рассмотрим пример метода для вычисления процентов по банковскому депозиту. Обычная депозитная ставка 10%, кроме того, постоянные клиенты могут получить бонус:

  static decimal CalcDeposit(decimal sum, decimal percent = 10m, decimal bonus = 0m) < return sum + sum * ((percent + bonus) / 100m); > 

  //депозит со ставкой и бонусом по умолчанию var d1 = CalcDeposit(10000); //бонус 2.5% (передается как именованный аргумент), ставка по умолчанию - 10% var d2 = CalcDeposit(15000, bonus: 2.5m); //передаем все три аргумента var d3 = CalcDeposit(20000, 15m, 3m); 

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

  Упрощенная запись методов

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

  К примеру, математическую функцию y = x 2 — 2/x, можно записать:

  static double Y(double x) < return x * x - 2 / x; > 

  Использовав лямбда-выражение, код будет иметь следующий вид:

  static double Y(double x) => x * x - 2 / x; 

  Аналогичным образом можно упростить метод, который не возвращает значений:

  static void DisplayHello(string n) < Console.WriteLine("Привет !", n); > 

  static void DisplayHello(string n) => Console.WriteLine("Привет !", n); 

  Локальные функции

  В версии C# 7.0, появилась возможность использовать методы вложенные в метод, такие конструкции носят название – локальные функции. Они поддерживают как классическую, так и упрощенную форму синтаксиса:

  static void Main(string[] args) < //максимальное из двух целых чисел int Max(int a, int b) < if (a > b) return a; return b; > // минимальное из двух целых чисел int Min(int c, int d) => c < d ? c : d; var t1 = Max(13, 22); var t2 = Min(42, 56); > 

  Для всех рассмотренных методов используется модификатор static, поскольку предполагается их непосредственное использование в главном методе программы – Main.