implementazione interna di AsEnumerable() in LINQ

Question

Ho due domande:

Domanda 1 Background: ho notato quando guardando la realizzazione di 'AsEnumerable()' metodo LINQ da Microsoft, che è stato:

public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source) 
{ 
    return source; 
} 

domanda 1: mi aspettavo un qualche tipo di fusione o qualcosa qui, ma restituisce semplicemente il valore è stato passato. Come funziona ?

Domanda 2/3 Contesto: Ho cercato di capire la covarianza, la contravarianza e l'invariante. Penso, ho una vaga comprensione che le parole chiave "in" e "out" determinano il comportamento polimorfico quando si assegna un sottotipo a un tipo genitore.

Domanda 2: so da letto che IEnumerable è covariante, e la lista è invariante allora perché è questo non è possibile:

List<char> content = "testString".AsEnumerable(); 

Domanda 3:
Se IList implementa IEnumerable allora perché non è possibile:

IEnumerable<char> content1 = "testString"; 
IList<char> content2 = content1; 

Per favore aiutami a capire, grazie in un dvance.

Answer 1

1. L'argomento di input è già noto per il tipo IEnumerable<TSource>. Perché dovrebbe lanciare qualcosa? La trasmissione degli oggetti al tipo TSource non ha alcun effetto, poiché è già garantito che siano di quel tipo (o di un tipo più derivato).

2. Non è possibile assegnare un valore di tipo IEnumerable<char> a una variabile di tipo List<char>. Penso che stai pensando al contrario qui; List<char> deriva da IEnumerable<char>, non viceversa. Questo non ha nulla a che fare con List<T> invariante. IEnumerable<T> è covariante (per la precisione, il parametro di tipo T è covariante), che ci dà questa situazione:

   IEnumerable enumerable = Enumerable.Empty<string>(); // Allowed 
   IEnumerable<string> genericEnumerable = enumerable; // Not allowed 
   

3. Nuovamente, IList<char> eredita da IEnumerable<char>, non viceversa. Puoi fare ciò:

   Quello che chiedi non ha senso, ho paura, e non ha niente a che fare con la covarianza. Il fatto che IEnumerable<T> è covariante significa che si è permesso di fare questo:

   IEnumerable<object> asObject = new List<string>() { "test" }; 
   

   Ma List<T> è invariante, quindi non è possibile fare questo:

   List<object> asObject = new List<string>() { "test" };