Lancer la liste du type anonyme dans la liste des objets dynamiques

Pourquoi ne puis-je pas jeté un List<AnonymousObject> à un List<dynamic>? J'ai ce code suivant:

var datasource = someList.Select(o => new { x = o.A, y = o.B });
dgvSomeGridView.DataSource = datasource.ToList();
dgvSomeGridView.DataBind();

Puis-je accéder à la GridView.DataSource avec le code suivant:

var ds = ((List<dynamic>)dgvSomeGridView.DataSource);
....

Mais il déclenche une erreur sur la ligne où je l'ai jeté à List<dynamic>il dit:

Impossible de convertir l'objet de type System.Collections.Generic.List'1[<>f__AnonymousType0'8[System.Int32,System.String]] de type System.Collections.Generic.List'1[System.Object].

Pourquoi ne puis-je pas jeté une liste de type anonyme à un dynamicou que l'erreur est dit à un object type? Comment puis-je résoudre ce problème?

Mon Code est en C#, framework 4.0, de construire dans VS2010 Pro, la plate-forme est ASP.NET.

S'il vous plaît aider, merci d'avance.

source d'informationauteur John Isaiah Carmona

38

Depuis List<T> est en variante, pas de co-variante, de sorte que vous avez à cast en IEnumerable<dynamic> qui prend en charge la co-variant:
```
var ds = ((IEnumerable<dynamic>)dgvSomeGridView.DataSource).ToList();
```
Pour plus d' informations sur covariante
7

Tout d'abord, la fonderie et le générique ne fonctionne pas de cette façon. Cette distribution n'est pas valide:
```
List<string> source = GetStrings();
List<object> source2 = (List<object>) source;
```
La raison en est que la Liste n'est pas co-variante. Si c'était le cas, vous pourriez source2.Add(source2); et tout à coup source1 contient lui-même quand il ne devrait avoir que des chaînes de caractères.

Deuxièmement, Les types anonymes sont juste compilateur classes déclarées avec readonly propriétés et la valeur de l'égalité sémantique. Si vous avez créé une classe avec des propriétés readonly et de la valeur de l'égalité de la sémantique, de votre classe serait la même que pour un type anonyme, à l'exception de votre type serait un développeur nom fixe, tandis que le type anonyme a un compilateur nom fixe. Anon types ne sont pas spéciales.

Troisièmement, dynamique variables sont un moyen de faire le tour du compilateur vérification de type. Ils ne vont pas autour d'exécution vérification de type. Vous pouvez utiliser le c# casting de la syntaxe pour convertir explicitement le type de dynamique... remarque: ce n'est pas un casting! Vous ne pouvez pas faire une exécution en fonte pour un type qui n'existe pas au moment de l'exécution.

Toutefois, les opérations qui contiennent des expressions de type dynamique ne sont pas résolus ou de type vérifié par le compilateur. Le compilateur des paquets d'information sur l'opération, et que l'information est ensuite utilisée pour évaluer le fonctionnement au moment de l'exécution. Dans le cadre du processus, les variables de type dynamique sont compilés dans des variables de type objet. Par conséquent, le type de dynamique n'existe qu'au moment de la compilation, et non pas au moment de l'exécution.
```
static void convertToDynamic()
{
    dynamic d;
    int i = 20;
    d = (dynamic)i;
    Console.WriteLine(d);

    string s = "Example string.";
    d = (dynamic)s;
    Console.WriteLine(d);

    DateTime dt = DateTime.Today;
    d = (dynamic)dt;
    Console.WriteLine(d);

}
//Results: 
//20 
//Example string. 
//2/17/2009 9:12:00 AM
```
Enfin, si vous voulez encore un List<dynamic>faites ceci:
```
var anonList = GetAnonList();
List<dynamic> dynamicList = anonList.Select(x => (dynamic)x).ToList();
```
Mais vous pourriez tout aussi bien le faire:
```
var anonList = GetAnonList();
List<object> objectList = anonList.Cast<object>().ToList();
```

Vous devez vous connecter pour publier un commentaire.