Как создать метод в c
Если переменные хранят некоторые значения, то методы содержат собой набор инструкций, которые выполняют определенные действия. По сути метод — это именованный блок кода, который выполняет некоторые действия.
Общее определение методов выглядит следующим образом:
[модификаторы] тип_возвращаемого_значения название_метода ([параметры]) < // тело метода >
Модификаторы и параметры необязательны.
Ранее мы уже использовали как минимум один метод — 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#. Я уже не раз употреблял этот термин, и пришла пора разобраться с ним. Как всегда, я не буду перегружать Вас информацией, дам только самое необходимое (разумеется, на мой взгляд).
И так, что же такое метод? В контексте объектно-ориентированного программирования, метод – это подпрограмма. А подпрограмма, в свою очередь – это фрагмент программы, который написать нужно один раз, а использовать его можно многократно (для выполнения однотипных действий). Это довольно удобно по нескольким причинам, например, можно реализовать определенный алгоритм один раз, хорошо его отладить, и быть уверенным в правильности его работы применяя его в дальнейшем многократно. Да и использование подпрограмм, значительно сокращает объем исходного кода проекта. Или еще представьте такую ситуацию, мы один раз написали подпрограмму, которая выполняет определенные действия, и многократно её используем, а потом, технические требования заставляют нас модифицировать алгоритм этих самых действий, так вот, нам достаточно всего один раз изменить код подпрограммы (изменения применяется во всех местах её использования). Думаю я убедил Вас в том, что познакомиться с методами в C# обязательно стоит!
И так, к делу! Мы уже знакомы с методом «Main» в главном файле программы. Это, так называемая точка входа в программу, главный метод наших программ. Этот метод, Visual Studio сгенерила сама, давайте рассмотрим, как он выглядит в исходном состоянии (сразу после создания нового проекта). Для этого создадим новый проект консольного приложения и рассмотрим код метода «Main», что называется под детально! А выглядит он вот так:
class Program < static void Main(string[] args) < >>
Я преднамеренно привел код метода «Main» вместе с объемлющим его кодом. Метод «Main» относится к классу «Program» (т.е. находится внутри класса «Program«).
Что такое классы в C# я сейчас подробно рассказывать не буду, скажу лишь, что класс – это описание некого типа данных, который характеризуется набором представляемых данных и набором возможных операций над ними.
Метод состоит из так называемого заголовка и тела:
//Заголовок метода static void Main(string[] args) < //Тело метода >
Разберем подробно заголовок метода. Ключевое слово static обозначает, что метод относится ко всему классу. Пока не задавайте себе вопрос, что же это значит, просто примите как должное. Придет время, и я расскажу об этом подробнее. На данном этапе, мы перед каждым создаваемым методом будем писать ключевое слово static.
Далее идет ключевое слово void, в этом месте, указывается тип возвращаемого методом значения. Что это значит? Это значит, что выполнив какую-то работу, метод может вернуть её результат, а мы можем сохранить его в какой-либо переменной (и использовать для дальнейших нужд). А тип переменной, должен совпадать с типом возвращаемого значения! Но не каждый метод должен возвращать какое-то значение, и именно в тех случаях, когда метод «ничего не возвращает» указывается ключевое слово void.
Если бы метод «Main» должен был возвращать целое число, то вместо слова void было бы использовано слово int.
После ключевого слова void следует название метода, в данном случае – это Main. После названия идут круглые скобки, в которых определяются аргументы метода. В нашем случае – это «string[] args». Т.е. массив строк. Аргументы метода – это входные данные, которые получает метод. Аргументы метода в заголовке еще называют его формальными параметрами.
Как и в случае возвращаемого значения, не каждый метод нуждается во входных данных, и тогда круглые скобки после названия метода будут пустыми.
Для примера, рассмотри заголовок статического метода, который будет принимать два целочисленных аргумента, и возвращать их сумму:
/*Этот метод принимает два целых числа и *возвращает их сумму*/ static int Sum(int aFirstArg, int aSecondArg)
Думаю что с заголовками методов более или менее понятно, давайте рассмотрим, что такое тело метода. А это просто набор операторов, заключенный в фигурные скобки сразу после заголовка метода.
Метод, чей заголовок мы рассматривали ранее, целиком, может выглядеть примерно так:
/*Этот метод принимает два целых числа и *возвращает их сумму*/ static int Sum(int aFirstArg, int aSecondArg)
Т.е. по факту, мы уже имеем написанный метод (подпрограмму), но теперь нужно им как-то воспользоваться, иначе, зачем он нам нужен? А чтобы воспользоваться методом, нужно его, так сказать, вызвать! Делается это следующим образом:
static void Main(string[] args) < //Вызов метода Sum с фактическими параметрами int result = Sum(24, 6); //Вывод результата в консоль Console.WriteLine(result); >
В примере выше мы вызвали метод «Sum» с фактическими параметрами, где первый из них равен 24 а второй – 6. Результат метода будет сохранен в переменной «result» и позже мы выводим его в консоль. В принципе, все просто!
А теперь, давайте применим полученные знания на практике! Улучшим пример из предыдущего урока. В нем мы дважды просили пользователя ввести целое число с клавиатуры, т.е. выполняли однотипные действия. Давайте оптимизируем наш код, создадим метод, который будет принимать в качестве аргумента текст приглашения пользователю, а возвращать введенное им число, после чего дважды вызовем этот метод с разными формальными параметрами.
class Program < /* * Данный метод выводит пользователю приглашение, * указанное в аргументе anOutputStr, получает введенную * с клавиатуры строку, преобразует её в целое число и * возвращает это число */ static int GetNumber(string anOutputStr) < //Вывод приглашения пользователю Console.Write(anOutputStr); //Получение строки string tmpString = Console.ReadLine(); //Преобразование строки в число int tmpArg = Convert.ToInt32(tmpString); return tmpArg; >static void Main(string[] args) < //Потенциально опасный блок try < //Первый вызов метода (получение первого числа) int firstArg = GetNumber("Введите первое число и нажмите клавишу Enter: "); //Второй вызов метода (получение второго числа) int secondArg = GetNumber("Введите второе число и нажмите клавишу Enter: "); //Сложение двух переменных int result = firstArg + secondArg; //Вывод результата Console.WriteLine("Результат сложения введенных чисел: " + result.ToString()); >//Блок обработки ошибок, SystemException - самый общий тип ошибок catch (SystemException) < Console.WriteLine("Во время выполнения программы произошла ошибка, вероятно, были введены некорректные данные!"); >> >
Функциональность программы осталась той же, но исходный код принял более оптимальный вид. На этот раз хватит информации, в дальнейшем мы еще не раз будет работать с различными методами, и Вы получите новые знания! А в следующем уроке, подробнее вернемся к обработке ошибок, в нем тоже будет интересная информация!
Методы
При разработке программ, некоторые строки с инструкциями повторяются, для того, чтобы уменьшить количество кода, улучшить его читабельность и упростить повторное использование этих инструкций, их можно объединить в метод.
Метод – это конструкция в виде блока кода, которая выполняет некоторые действия, и имеет логическую смысловую нагрузку. Аналогом методов языка 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.
Урок #10 – Создание функций (методов класса)
Для сокращения кода в программировании используются функции. Они позволяют вынести повторяющийся код в отдельное место. За урок мы научимся работать с функциями в языке C#.
Видеоурок
Функции можно назвать небольшими подпрограммами, куда можно вынести повторяющийся код и обращаться к нему, когда это будет нужно. Функции значительно облегчают построение программ, так как нам не надо копировать однотипный код множество раз, а можно просто воспользоваться одной общей функцией.
Многие путают функции и методы и не понимают отличий между ними. На самом деле отличий нет, так как что методы, что функции являются одним и тем же. Функции что записаны вне классов называют функциями, а функции что записаны внутри классов называются методами. Поскольку C# это объектно ориентированный язык, то лучше говорить методы, хотя это не имеет никакого значения.
Точно такая же ситуация обстоит с переменным. В классах переменные называются полями, а вне классов — переменными.
Для создания функций необходимо указать возвращаемый тип данных, указать название и параметры. В случае когда функция ничего не возвращает, то указывается тип данных void .
Перед типом данных всегда прописывается модификатор доступа. Сейчас мы их детально рассматривать не будем, так как это тема ООП. В уроке мы будем постоянно устанавливать модификатор public, тем самым будем говорить что функция доступна всем внутри класса.
Зачем static?
Поскольку мы хотим обращаться к функциям напрямую без создания объекта, то мы прописываем ключевое слово static . Оно говорит компилятору что функция принадлежит всему классу, а не конкретным объектам.
В будущем мы более детально ознакомимся с данным модифактором, но пока будем представлять его как удобное слово для обращения к функциям.
Создание функции
На основе всех данных наша функция будет выглядеть следующим образом:
public static void test ()
Функция выше не принимает никаких параметров и ничего не возвращает. Она просто пишет слово в консоль. Давайте разнообразим функцию и добавим параметр:
public static void test (string word)
Теперь функция принимает параметр, который будет отображен в консоли.
Если функция должна что-либо вернуть, то прописываем тип данных который будет возвращен. Для возвращения данных используем ключевое слово return :
public static double test (double some_number)
Создание функций
using System; namespace project < class Program < static void Main() < // Print("Hello"); // string words = "Hello world"; // Print(words); // Print(); int res1 = Summa(5, 9); int a = 4, b = 7; int res2 = Summa(a, b); Print(res1.ToString()); Print(res2.ToString()); >public static void Print(string word) < Console.WriteLine(word); >public static int Summa(int x, int y) < return x + y; >> >Посмотреть остальной код можно после подписки на проект!Задание к уроку
Необходимо оформить подписку на проект, чтобы получить доступ ко всем домашним заданиям
Большое задание по курсу
Вам необходимо оформить подписку на сайте, чтобы иметь доступ ко всем большим заданиям. В задание входит методика решения, а также готовый проект с ответом к заданию.
PS: подобные задания доступны при подписке от 1 месяца