Преобразование типов - это основная часть языка программирования C #, обеспечивающая гибкость при работе с типами.

Остановимся на секунду и подумаем, что мы передаем кому-то мяч. Человек, который его получает, не знает, баскетбольный ли это, теннисный мяч или футбольный мяч. Это означает, что они должны либо угадывать, либо нам нужен способ сообщить человеку, чтобы он ответил правильным движением.

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

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

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

Например, если мы попытаемся присвоить переменную типа double переменной int, компилятор выдаст ошибку неявного типа, потому что мы теряем контекст (десятичные числа).

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

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

По сути, когда мы говорим о приведении, мы имеем в виду изменение типа переменной с A на B. Например, если переменная имеет тип int, и мы хотим изменить его на double, этот процесс называется приведением или преобразование типов.

Что мы будем решать

  1. Неявное приведение
  2. Явное приведение
  3. is оператор
  4. as оператор

1. Неявное приведение

Неявное приведение типов - это когда мы выполняем преобразование типов без потери данных, это также известно как неявно преобразовываемое. Это означает, что компилятор автоматически выполняет преобразование.

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

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

// Implicit conversion
int price = 27;
double totalPrice = price; (success)

Как показано выше, при преобразовании типа int в double значение 27 остается неизменным. Но если мы получим другой результат, например 26 вместо 27, то мы потеряем исходные данные.

Теперь давайте посмотрим, что происходит, когда происходит неявное преобразование наоборот, из типа double в int, и на этот раз с некоторыми дополнительными десятичными знаками:

// Implicit conversion
double price = 49.55; 
int totalPrice = price; // Implicit conversion error
Output: Error CS0266 Cannot implicitly convert type ‘double’ to ‘int’. An explicit conversion exists (are you missing a cast?)

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

Тип int не поддерживает десятичные дроби (значения после запятой), но тип double поддерживает, по этой причине мы теряем десятичные дроби .55. Все это происходит потому, что компилятор достаточно умен, чтобы понять, что мы имеем дело с поврежденными данными.

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

2. Явная трансляция

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

Давайте посмотрим на пример выполнения конверсии, при которой мы теряем некоторые данные:

// Explicit conversion
double price = 49.55; 
int totalPrice = (int)price; // output: 49

Как показано выше, единственное отличие состоит в том, что мы добавили оператор приведения () с типом, в который мы хотим преобразовать, например (int)price, который является примером явного приведения.

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

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

3. is Оператор

Оператор is используется для проверки типов перед безопасным преобразованием типов для уменьшения ошибок типов.

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

Например, представим, что у нас есть два класса, базовый класс (User) и производный класс (Student), и мы хотим выполнить преобразование типа с помощью оператора is:

public class User
{
    public string Id = "1234567";
}

public class Student : User { }

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

var student = new Student();

if (student is User) // true
{
    var stud = (User) student; 
    Console.WriteLine(stud.Id); // output: 1234567
}

Как показано выше, первая инструкция student is User возвращает true, потому что класс ученика наследуется от класса пользователя public class Student : User {}.

Если мы попробуем наоборот, проверим, является ли базовый класс типом производного класса, он вернет false. Это обычная ошибка новичка, и простое правило состоит в том, что мы можем сравнивать производный класс только с классом, от которого он наследуется, другими словами, с базовым классом.

Оператор is великолепен и легко читается (декларативный), но что, если мы хотим сделать все, что показано выше, всего в одной строке. Поговорим об операторе as.

4. в качестве оператора

Оператор as почти идентичен оператору is, за исключением того, что он выполняет преобразование типов в одном месте.

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

Давайте воспользуемся тем же примером, что и ранее, с использованием оператора as:

var stud = new Student() as User;
Console.WriteLine(stud.Id); // output: 1234567

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

Однако нам все равно нужно убедиться, что у нас нет доступа к каким-либо полям, если stud экземпляр - null. Это означает, что нам нужен дополнительный условный оператор, чтобы гарантировать эту безопасность.

Резюме

Хорошо, теперь мы узнали несколько способов трансляции на C #, и какой из них использовать для правильной работы. Вот краткое описание каждого из них:

  • Неявное приведение - это когда компилятор выполняет преобразование автоматически, пока мы не теряем никаких данных.
  • Явное приведение типов - это когда разработчик вручную определяет, в какие типы преобразовывать.
  • Оператор is - это то место, где мы хотим проверить типы между двумя значениями перед преобразованием типа. Возвращает либо true, либо false.
  • Оператор as - это то место, где мы хотим проверить типы между двумя значениями перед преобразованием типа. Он возвращает либо результат (преобразованное значение), либо false.

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

Вы можете найти меня на Medium, где я публикую еженедельно. Или вы можете подписаться на меня в Twitter.