Error de compilación dinámico + linq

Question

Diré desde el principio que estoy haciendo cosas realmente aterradoras con linq en datos dinámicos. pero no puedo entender por qué esta consulta falla al compilar:

de error 1 La propiedad '<> h__TransparentIdentifier0' no se puede usar con argumentos de tipo

 
public class Program 
{ 
    public static void Main(string[] args) 
    { 
     var docs = new dynamic[0]; 
     var q = from doc in docs 
       where doc["@metadata"]["Raven-Entity-Name"] == "Cases" 
       where doc.AssociatedEntities != null 
       from entity in doc.AssociatedEntities 
       where entity.Tags != null // COMPILER ERROR HERE 
       from tag in entity.Tags 
       where tag.ReferencedAggregate != null 
       select new {tag.ReferencedAggregate.Id, doc.__document_id}; 
    } 
} 

public static class LinqOnDynamic 
{ 
    private static IEnumerable<dynamic> Select(this object self) 
    { 
     if (self == null) 
      yield break; 
     if (self is IEnumerable == false || self is string) 
      throw new InvalidOperationException("Attempted to enumerate over " + self.GetType().Name); 

     foreach (var item in ((IEnumerable) self)) 
     { 
      yield return item; 
     } 
    } 

    public static IEnumerable<dynamic> SelectMany(this object source, 
                Func<dynamic, int, IEnumerable<dynamic>> collectionSelector, 
                Func<dynamic, dynamic, dynamic> resultSelector) 
    { 
     return Enumerable.SelectMany(Select(source), collectionSelector, resultSelector); 
    } 

    public static IEnumerable<dynamic> SelectMany(this object source, 
                Func<dynamic, IEnumerable<dynamic>> collectionSelector, 
                Func<dynamic, dynamic, dynamic> resultSelector) 
    { 
     return Enumerable.SelectMany(Select(source), collectionSelector, resultSelector); 
    } 

    public static IEnumerable<dynamic> SelectMany(this object source, 
                Func<object, IEnumerable<dynamic>> selector) 
    { 
     return Select(source).SelectMany<object, object>(selector); 
    } 

    public static IEnumerable<dynamic> SelectMany(this object source, 
                    Func<object, int, IEnumerable<dynamic>> selector) 
    { 
     return Select(source).SelectMany<object, object>(selector); 

    } 
} 

Para colmo de males, las siguientes obras :

 
var docs = new dynamic[0]; 
var q = from doc in docs 
     where doc["@metadata"]["Raven-Entity-Name"] == "Cases" 
     where doc.AssociatedEntities != null 
     from entity in doc.AssociatedEntities 
     where entity.Tags != null 
     from tag in entity.Tags 
     select new { tag.ReferencedAggregate.Id, doc.__document_id }; 

es sólo cuando agrego:

donde tag.ReferencedAggregate = null

Eso me da un error de dos líneas antes:

donde entity.Tags = null // ERROR COMPILER AQUÍ

No está seguro de lo que está pasando

Answer 1

si lo intento simplemente convertir sus llamadas a:

var q = from doc in docs.Where(doc => doc["@metadata"]["Raven-Entity-Name"] == "Cases" || doc.AssociatedEntities != null) 
     from entity in doc.AssociatedEntities.Where(entity => entity.Tags != null) 

me sale un error de compilación diferente, que quizá revela lo que está pasando:

'No se puede utilizar una expresión lambda como un argumento a una dinámicamente operación despachada sin enviarla primero a un árbol delegado o de expresión tipo '

Supongo que tiene que sobrecargar el operador Where.

Answer 2

El tipo de retorno anónimo es <> h__TransparentIdentifier0 y se elabora por el compilador en tiempo de compilación - el problema parece "orden de precedencia dinámico" - Tiene una lectura aquí: Method-missing difficulties in C# 4.0: dynamic vs RealProxy

acabo de ir a través de este trabajo hasta hoy ar ecent post. Tendré una pequeña suposición y diré que el tipo Anónimo está preparado después de la asignación dinámica :) - el compilador lo sabe y lo está frustrando.

¿El problema desaparece si utiliza un retorno de tipo normal? Supongo que debe.

Answer 3

 
var q = from doc in docs 
     where doc["@metadata"]["Raven-Entity-Name"] == "Cases" 
     where doc.AssociatedEntities != null 
     from entity in 
      ((IEnumerable<dynamic>)doc.AssociatedEntities) 
      .Where(entity => entity.Tags != null) 
     from tag in 
      ((IEnumerable<dynamic>)entity.Tags) 
      .Where(tag => tag.ReferencedAggregate != null) 
     select new { tag.ReferencedAggregate.Id, doc.__document_id }; 

Eso es un poco mejor. No es perfecto, pero es como un principio: solo puedes llegar a muchos niveles antes de que te pierdas en el limbo.