IEnumerable <T> .Cast non funziona anche se è definito un operatore di cast esplicito?

Question

Ho una conversione esplicita definita dal tipo Bar per digitare Foo.

public class Bar 
{ 
    public static explicit operator Foo(Bar bar) 
    { 
    return new Foo(bar.Gar); 
    } 
} 

public class Foo 
{ 
    public string Gar { get; set; } 

    public Foo() { } 

    public Foo(string gar) { Gar = gar; } 
} 

Tuttavia, quando lo faccio:

using System.Linq; 

... 

var manyFoos = manyBars.Cast<Foo>(); 

viene generata un'eccezione dicendo che non può lanciare.

Come faccio a comunicare allo Cast l'operatore di trasmissione per provare la conversione?

Answer 1

Uso Select:

var manyFoos = manyBars.Select(bar => (Foo)bar); 

Answer 2

Il codice in realtà non compilazione. Suppongo che ci sia una proprietà "Gar" anche nella classe "Bar"?

public class Bar 
    { 
     public string Gar { get; set; } 

     public static explicit operator Foo(Bar bar) 
     { 
      return new Foo(bar.Gar); 
     } 
    } 

    public class Foo 
    { 
     public string Gar { get; set; } 

     public Foo() { } 

     public Foo(string gar) { Gar = gar; } 
    } 

static void Main(string[] args) 
     { 

      List<Bar> bars = new List<Bar>(); 
      for (int i = 0; i < 10; i++) 
       bars.Add(new Bar() { Gar = i.ToString() }); 

      var result = bars.Cast<Foo>(); 
     } 

+

ho encaurage di leggere su covarianza.

Supponendo che A sia convertibile in B, X è covariante se è convertibile in X<B>.

Con la nozione di covarianza (e controvarianza) di C#, "convertibile" significa convertibile tramite una conversione di riferimento implicita, come A sottoclassi B, o A implementazione B. Conversioni numeriche, conversioni di boxe e conversioni personalizzate non sono incluse.

Devi farlo con le interfacce.

Answer 3

Il metodo linq Cast essenzialmente esegue una casella e un unbox. Non è a conoscenza di operatori di cast impliciti o espliciti definiti in C#, che il compilatore tratta le chiamate di metodo standard.

Avresti per fare qualcosa di simile:

var manyFoos = manyBars.Select(bar => (Foo)bar); 

Answer 4

operatori cast sono metodi statici che le compilatore chiamate quando si utilizza calchi in codice. Non possono essere usati dinamicamente. Enumerable.Cast esegue un cast runtime di due tipi generici non vincolati, quindi non può sapere durante il periodo di compilazione che gli operatori cast devono utilizzare. Per fare ciò che si desidera, è possibile utilizzare Select:

manyFoos.Select(foo => (Bar)foo); 

Answer 5

Come tutte le altre risposte di tipo punta non è noto in fase di compilazione in quanto Cast metodo non è generic. Detiene il tipo di object e crea un cast esplicito su T. ciò non riesce perché non si dispone di operatore di conversione da object a Foo. E questo non è possibile anche.

Ecco un lavoro su come utilizzare le dinamiche in cui il cast verrà eseguito in runtime.

public static class DynamicEnumerable 
{ 
    public static IEnumerable<T> DynamicCast<T>(this IEnumerable source) 
    { 
     foreach (dynamic current in source) 
     { 
      yield return (T)(current); 
     } 
    } 
} 

Poi utilizzarlo come

var result = bars.DynamicCast<Foo>();//this works