C# 9 – Covariant returns

Quando ereditiamo da una classe in C#, se il metodo è dichiarato come abstract oppure virtual possiamo sovrascriverlo ma non possiamo modificarne il tipo ritornato.

In C# 9, ora si può restituire un tipo differente rispetto al tipo iniziale dichiarato nella classe genitore.

Questo consente di mantenere la firma della classe padre, ritornando però un oggetto differente.

La regola che deve essere rispettata è che il tipo ritornato deve essere più specifico di quello del padre.

Fino a C# 9, non era possibile modificare il tipo restituito del metodo sottoposto a override nella classe derivata.

Prendiamo come esempio la solita classe 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();
        }
  
    }

oltre ai due costruttori è presente un metodo virtual che consente di ritorna un nuovo oggetto di tipo Person.

Definiamo ora una nuova classe Employee che eredita da Person:

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();
        }
    }

Anche in questo caso sono presenti due costruttori, uno senza parametri ed uno con i parametri.

Inoltre è presente un metodo GetPerson() che consente di ottenere un oggetto di tipo Employee.

Da notare che il tipo GetPerson ereditato da Person è stato cambiato nel tipo Employee.

Da notare che il codice precedente non verrebbe compilato nelle versioni C# prima di C# 9 perchè non è possibile modificare la firma nella classe derivata.