Uso della varianza nelle interfacce per le raccolte generiche (C#)

Un'interfaccia covariante consente ai metodi di restituire più tipi derivati rispetto a quelli specificati nell'interfaccia. Un'interfaccia controvariante consente ai metodi di accettare parametri di tipi meno derivati rispetto a quelli specificati nell'interfaccia.

In .NET Framework 4 diverse interfacce esistenti sono diventate covarianti e controvarianti. Questi includono IEnumerable<T> e IComparable<T>. In questo modo è possibile riutilizzare i metodi che operano con raccolte generiche di tipi di base per le raccolte di tipi derivati.

Per un elenco di interfacce varianti in .NET, vedere Varianza nelle interfacce generiche (C#).

Conversione di raccolte generiche

L'esempio seguente illustra i vantaggi del supporto della covarianza nell'interfaccia IEnumerable<T> . Il PrintFullName metodo accetta una raccolta del IEnumerable<Person> tipo come parametro. Tuttavia, è possibile riutilizzarlo per una raccolta del IEnumerable<Employee> tipo perché Employee eredita Person.

// Simple hierarchy of classes.
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Employee : Person { }

class Program
{
    // The method has a parameter of the IEnumerable<Person> type.
    public static void PrintFullName(IEnumerable<Person> persons)
    {
        foreach (Person person in persons)
        {
            Console.WriteLine("Name: {0} {1}",
            person.FirstName, person.LastName);
        }
    }

    public static void Test()
    {
        IEnumerable<Employee> employees = new List<Employee>();

        // You can pass IEnumerable<Employee>,
        // although the method expects IEnumerable<Person>.

        PrintFullName(employees);

    }
}

Confronto di raccolte generiche

Nell'esempio seguente vengono illustrati i vantaggi del supporto della controvarianza nell'interfaccia IEqualityComparer<T> . La classe PersonComparer implementa l'interfaccia IEqualityComparer<Person>. Tuttavia, è possibile riutilizzare questa classe per confrontare una sequenza di oggetti del Employee tipo perché Employee eredita Person.

// Simple hierarchy of classes.
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Employee : Person { }

// The custom comparer for the Person type
// with standard implementations of Equals()
// and GetHashCode() methods.
class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (Object.ReferenceEquals(x, y)) return true;
        if (Object.ReferenceEquals(x, null) ||
            Object.ReferenceEquals(y, null))
            return false;
        return x.FirstName == y.FirstName && x.LastName == y.LastName;
    }
    public int GetHashCode(Person person)
    {
        if (Object.ReferenceEquals(person, null)) return 0;
        return HashCode.Combine(person.FirstName, person.LastName);
    }
}

class Program
{

    public static void Test()
    {
        List<Employee> employees = new List<Employee> {
               new Employee() {FirstName = "Michael", LastName = "Alexander"},
               new Employee() {FirstName = "Jeff", LastName = "Price"}
            };

        // You can pass PersonComparer,
        // which implements IEqualityComparer<Person>,
        // although the method expects IEqualityComparer<Employee>.

        IEnumerable<Employee> noduplicates =
            employees.Distinct<Employee>(new PersonComparer());

        foreach (var employee in noduplicates)
            Console.WriteLine(employee.FirstName + " " + employee.LastName);
    }
}

Vedere anche

• Varianza nelle interfacce generiche (C#)