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

Типизация цели относится к использованию выражения, которое получает свой тип из контекста, в котором оно используется, вместо того, чтобы указывать тип явно. В C # 9 теперь можно использовать целевую типизацию в new выражения и с условными операторами. Поддержка ковариантных возвращаемых типов в C # 9 позволяет переопределить метод для объявления «более производного» (т. Е. Более конкретного) возвращаемого типа, чем метод, который он переопределяет.

Для работы с примерами кода, приведенными в этой статье, в вашей системе должна быть установлена ​​Visual Studio 2019. Если у вас еще нет копии, вы можете скачать Visual Studio 2019 здесь. C # 9.0 доступен в Visual Studio 2019 16.9 Preview 1 или более поздней версии или в пакете SDK для .NET 5.0.

Создайте проект консольного приложения в Visual Studio

Прежде всего, давайте создадим проект консольного приложения .NET Core в Visual Studio. Предполагая, что в вашей системе установлена ​​Visual Studio 2019, выполните действия, описанные ниже, чтобы создать новый проект консольного приложения .NET Core в Visual Studio.

  1. Запустите интегрированную среду разработки Visual Studio.
  2. Нажмите «Создать новый проект».
  3. В окне «Создать новый проект» выберите «Консольное приложение (.NET Core)» из отображаемого списка шаблонов.
  4. Нажмите “Далее.
  5. В окне «Настроить новый проект» укажите имя и расположение для нового проекта.
  6. Щелкните “Создать”.

Мы будем использовать этот проект консольного приложения .NET Core для работы с целевой типизацией и ковариантными возвратами в следующих разделах этой статьи.

Использовать целевую типизацию с новыми выражениями в C # 9

В C # 9 улучшена поддержка целевой печати. Есть два новых способа реализовать целевую типизацию – в new выражения и с условными операторами.

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

public class Author
{
   private int Id { get; set; }
   private string FirstName { get; set; }
   private string LastName { get; set; }
   public Author(int id, string firstName, string lastName)
   {
      Id = id;
      FirstName = firstName;
      LastName = lastName;
   }
}

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

static void Main(string[] args)
{
    var authors = new List<Author>
    {
        new (1, "Joydip", "Kanjilal"),
        new (2, "Dean", "Jones"),
        new (3, "Steve", "Smith")
    };
   Console.Read();
}

Используйте целевую типизацию с условными операторами в C # 9

В C # 9 теперь можно выводить типы с помощью условных операторов. Рассмотрим приведенный ниже класс Person:

public class Person
    {
        private int Id { get; set; }
        private string FirstName { get; set; }
        private string LastName { get; set; }
        public Person(int id, string firstName, string lastName)
        {
            Id = id;
            FirstName = firstName;
            LastName = lastName;
        }
    }

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

public class Employee : Person
    {
        private string Department { get; set; }
        public Employee(int id, string firstName, string lastName,
        string department) :
        base(id, firstName, lastName)
        {
            Department = department;
        }
    }
    public class Consultant : Person
    {
        private int RatePerHour { get; set; }
        public Consultant(int id, int ratePerHour,
        string firstName, string lastName) :
        base(id, firstName, lastName)
        {
            RatePerHour = ratePerHour;
        }
    }

Следующий код будет компилироваться в C # 9, но не будет компилироваться в более ранних версиях C #:

Сотрудник Сотрудник = новый Сотрудник (1, «Joydip», «Kanjilal», «Развитие»);
Консультант-консультант = новый Консультант (1, 150, «Джойдип», «Канжилал»);
Человек person = сотрудник ?? консультант; // Ошибка компиляции до C # 9

C # 9 позволяет использовать условные операторы целевого типа в тернарных операторах.

Использование ковариантных возвращаемых типов в C # 9

Ковариантные возвращаемые типы – это функция, которая позволяет вам переопределить метод базового класса методом в производном классе, чтобы вернуть более конкретный тип. Более ранние версии C # не позволяли возвращать тип, отличный от его базовой версии, в переопределенном методе производного класса. Это изменилось в C # 9.

Например, предположим, что у вас есть два класса A и B, и последний расширяет первый. Если у вас есть виртуальный или абстрактный метод в классе A, вы можете переопределить его в классе B. Это можно сделать, потому что язык программирования C # обеспечивает поддержку полиморфизма времени выполнения или позднего связывания. Однако до C # 9 вы не могли изменить тип возвращаемого значения переопределенного метода в производном классе.

Давайте разберемся в этом на примере. Рассмотрим приведенную ниже обновленную версию класса Person.

public class Person
    {
        private int Id { get; set; }
        private string FirstName { get; set; }
        private string LastName { get; set; }
        public Person()
        { }
        public Person(int id, string firstName, string lastName)
        {
            Id = id;
            FirstName = firstName;
            LastName = lastName;
        }
        public virtual Person GetPerson()
        {
            return new Person();
        }
    }

Обратите внимание, что мы добавили виртуальный метод и конструктор по умолчанию. Здесь мы возвращаем экземпляр класса Person из метода GetPerson, вызывая конструктор по умолчанию для класса Person.

Теперь рассмотрим приведенный ниже класс Employee:

public class Employee : Person
    {
        private string Department { get; set; }
        public Employee()
        { }
        public Employee(int id, string firstName, string lastName,
        string department) : base(id, firstName, lastName)
        {
            Department = department;
        }
        public override Employee GetPerson()
        {
            return new Employee();
        }
    }

И мы также добавили сюда конструктор по умолчанию. Здесь экземпляр класса Employee возвращается методом GetPerson, который переопределяет класс Employee. Интересно, что возвращаемый тип метода GetPerson – это Employee в классе Employee.

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

Ковариация и контравариантность – это давние функции C # (добавленные в C # 4.0), которые предоставляют полиморфное расширение для делегатов, массивов и универсальных шаблонов. Ковариация позволяет использовать более производный тип (более конкретный), чем указано изначально, в то время как контравариантность позволяет использовать менее производный тип (менее конкретный). Вы можете узнать больше о ковариации и контравариантности из Электронная документация Microsoft.

Как сделать больше на C #:

Авторские права © 2021 IDG Communications, Inc.


#Как #использовать #целевую #типизацию #ковариантный #возврат

Source link