Методы в C#

Методы в C# — это именованные блоки кода, в которых выполняется ряд операций. С методами мы так или иначе сталкивались при изучении возможностей C# с самого начала.  Пишем мы первую программу, выводящую на экран строку «Hello world» или изучаем циклы и способы сортировки массивов — мы вызываем в нашей программе хотя бы один метод.  И сегодня мы попробуем более детально изучить методы в C#, а также научимся их вызывать.

Для чего нужны методы в программировании?

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

Чтобы понять суть использования методов, вначале разберемся с тем, как они определяются в приложении C# и постепенно создадим свой более менее серьезный метод.

Определение методов в C#

В самом общем случае, определение метода в C# выглядит следующим образом:

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

обязательными элементами для определения метода в C# являются: тип возвращаемого значения и имя метода.

Самый первый пример метода, который мы могли видеть в C# — это метод Main(), если создать приложение без использования операторов верхнего уровня. Этот метод является и точкой входа для нашего приложения.

Создайте новое консольное приложение C# без операторов верхнего уровня. Вы должны увидеть вот такой код файла Program.cs:

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

Рассмотрим описание метода Main:

static void Main(string[] args)
{
    Console.WriteLine("Hello World!");
}
  • static — это модификатор. О том, что он обозначает, мы поговорим позднее, когда доберемся до работы с классами и объектами в C#.
  • void — тип возвращаемого значения. Это ключевое слово используется для того, чтобы указать, что метод не возвращает ничего.
  • Main — это имя метода.
  • string[] args— это единственный параметр метода — массив строк.

В фигурных скобках Visual Studio создала нам тело метода, состоящее по умолчанию всего из одной строки — вывод в консоль «Hello world», что, кстати, также является вызовом метода класса Console.

Попробуем написать свой первый собственный метод C#.

Первый собственный метод в C#

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

void WriteText(string text)
{ 
    Console.WriteLine(text);
}

здесь мы определили тип возвращаемого значения как void — метод ничего не возвращает. Далее идёт название метода WriteText, а в круглых скобках перечень параметров — наш метод принимает всего один параметр — строку, которую необходимо вывести в консоль. В фигурных скобках содержится всего одна инструкция, которую выполняет метод — выводит в консоль заданную в параметрах строку.

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

Чтобы вызвать метод C# необходимо написать его имя и, при необходимости, в круглых скобках передать методу необходимые параметры. Например, изменим код Main() приложения следующим образом:

namespace FirstMethod
{
    internal class Program
    {
        static void WriteText(string text)
        { 
            Console.WriteLine(text);
        }

        static void Main(string[] args)
        {
            //Console.WriteLine("Hello, World!");
            WriteText("Привет, мир!");
            WriteText("Это наш первый метод C#");
        }
    }
}

Здесь мы дважды вызываем метод WriteText(), чтобы вывести в консоль две строки:

Привет, мир!
Это наш первый метод C#

Мы можем вызывать код, содержащийся в методах, многократно и в любых частях приложения (при наличии соответствующих модификаторов доступа, конечно). Также, следует упомянуть, что в C# нет принципиальной разницы идёт ли вначале вызов метода или его определение. Например, мы могли бы переписать наш пример так:

namespace FirstMethod
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Console.WriteLine("Hello, World!");
            WriteText("Привет, мир!");
            WriteText("Это наш первый метод C#");
        }

        static void WriteText(string text)
        {
            Console.WriteLine(text);
        }
    }
}

В данном случае метод WriteText() находится ниже, чем его вызов.

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

Если метод выполняет всего одну инструкцию, как в нашем случае, то допускается его сокращенная запись, например, определим такой метод:

static void WriteText(string text) => Console.WriteLine(text);

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

Пример метода C#

Приведенный выше пример метода, возможно, не в полной мере отражает смысл использования методов в C#. Давайте поэкспериментируем с методами в C# и разберемся с преимуществами, которые несёт их использование в C#. Например, напишем метод, которые будет выводить в консоль разноцветный текст.

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

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //выводим текст, используя белый цвет текста (стандартный)
            Console.WriteLine("Привет, мир! Эта программа использует различные цвета текста для работы");
            
            //запрос на получение данных от пользователя
            ConsoleColor oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = ConsoleColor.Blue; //меняем цвет текста на синий
            Console.Write("Введите свое имя:");
            Console.ForegroundColor = oldColor; //возвращаем старый цвет
            string name = Console.ReadLine();


            //вывод результата
            oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = ConsoleColor.Red; //меняем цвет на красный
            Console.WriteLine($"Добро пожаловать, {name}");
            Console.ForegroundColor = oldColor; //возвращаем старый цвет

        }
    }
}

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

Методы в C#

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

Методы в C#

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

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

  1. запоминаем предыдущий цвет
  2. меняем цвет текста на новый
  3. выводим текст
  4. меняем цвет на предыдущий

Вот эти четыре действия (инструкции код) и будут составлять тело метода. Теперь определимся с параметрами. Для работы метода нам необходимо знать:

  1. Цвет, который необходимо использовать для вывода текста
  2. Сам текст

Таким образом, мы получаем два параметра для нашего будущего метода. Что касается возвращаемого результата, то наш метод просто выводит текст в консоль и сам по себе ничего не возвращает нам обратно в программу, поэтому в качестве возвращаемого результата мы будем использовать ключевое слово void. Теперь реализуем наш метод в программе (назовем его WriteColorText). Вот как будет выглядеть наша программа после добавления нового метода:

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //выводим текст, используя белый цвет текста (стандартный)
            Console.WriteLine("Привет, мир! Эта программа использует различные цвета текста для работы");
            
            //запрос на получение данных от пользователя
            ConsoleColor oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = ConsoleColor.Blue; //меняем цвет текста на синий
            Console.Write("Введите свое имя:");
            Console.ForegroundColor = oldColor; //возвращаем старый цвет
            string name = Console.ReadLine();


            //вывод результата
            oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = ConsoleColor.Red; //меняем цвет на красный
            Console.WriteLine($"Добро пожаловать, {name}");
            Console.ForegroundColor = oldColor; //возвращаем старый цвет

        }

        static void WriteColorText(string text, ConsoleColor color)
        {
            ConsoleColor oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = color; //меняем цвет на тот, который задан в параметрах
            Console.WriteLine(text); //выводим текст
            Console.ForegroundColor = oldColor; //возвращаем старый цвет
        }
    }
}

Метод WriteColorText() выполняет заданные четыре инструкции. При этом выводимый в консоль текст и его цвет задаются в его параметрах (text и color). Теперь мы можем избавиться от лишних инструкций в методе Main(), просто заменив их на вызов нашего метода. Вот как будет выглядеть окончательная версия нашей программы:

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //выводим текст, используя белый цвет текста (стандартный)
            WriteColorText("Привет, мир! Эта программа использует различные цвета текста для работы", ConsoleColor.White);

            //запрос на получение данных от пользователя
            WriteColorText("Введите свое имя:", ConsoleColor.Blue);
            string name = Console.ReadLine();

            //вывод результата
            WriteColorText ($"Добро пожаловать, {name}", ConsoleColor.Red);
        }

        static void WriteColorText(string text, ConsoleColor color)
        {
            ConsoleColor oldColor = Console.ForegroundColor; //запоминаем текущий цвет текста
            Console.ForegroundColor = color; //меняем цвет на тот, который задан в параметрах
            Console.WriteLine(text); //выводим текст
            Console.ForegroundColor = oldColor; //возвращаем старый цвет
        }
    }
}

Как видите, если убрать из кода Main() все комментарии, то этот метод будет содержать всего четыре строки кода три из которых — это вызов нашего метода. Более того, код приложения стал более легким в поддержке. Например, если нам потребуется вывести приветствие желтым цветом, то нам будет достаточно изменить только значение параметра color при первом вызове метода WriteColorText():

//выводим текст, используя белый цвет текста (стандартный)
WriteColorText("Привет, мир! Эта программа использует различные цвета текста для работы", ConsoleColor.Yellow); //теперь текст будет желтого цвета

Методы в C#

Таким образом, используя свой собственный метод мы:

  1. Сократили исходный код приложения, выделим часть инструкций в отдельный логический блок (метод)
  2. Сделали код более понятным — достаточно посмотреть на исходный код метода, чтобы понять как он работает
  3. Сам код программы стал более легким в поддержке — нам не требуется просматривать весь код приложения, выискивая участки кода для замены. Например, чтобы изменить цвет текста в определенном месте программы, нам достаточно задать новое значение параметра color нашего метода.

Итого

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

Подписаться
Уведомить о
guest
1 Комментарий
Старые
Новые Популярные
Межтекстовые Отзывы
Посмотреть все комментарии