c# - ¿Cuál es la clase de implementación para IGrouping?

.net wcf-data-services

Question

Estoy intentando crear una operación de servicio de datos de WCF que agrupe en el lado del servidor y luego envíe los datos al cliente.

Cuando intento llamarlo (o incluso conectarme al servicio), aparece un error. Dice que no puede construir una interfaz.

La única interfaz que estoy usando es IGrouping.

¿Qué es una / la clase real para esta interfaz?

Actualizar:

Verifiqué el tipo mientras depuraba una aplicación de muestra y me dijo que era:

System.Linq.Lookup<TKey,TElement>.Grouping

¿Pero en qué asamblea es?

Answer 1

Verifiqué el tipo con una aplicación de ejemplo y es este: System.Linq.Lookup<TKey,TElement>.Grouping . ¿Pero en qué asamblea es?

Es un tipo anidado en System.Linq.Lookup<TKey,TElement> ; interno al ensamblaje System.Core .

 var groupingType = "1".GroupBy(x => x).Single().GetType().GetGenericTypeDefinition();
 Console.WriteLine("Type: " + groupingType);
 Console.WriteLine("Public: " + groupingType.IsPublic);
 Console.WriteLine("Assembly: " + groupingType.Assembly);

Salida:

Type: System.Linq.Lookup`2+Grouping[TKey,TElement]
Public: False
Assembly: System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

A partir de .NET 4.0, no hay ningún tipo público en el marco .NET central que implementa System.Linq.IGrouping<TKey,TElement> . Si necesita un tipo de este tipo (digamos que es serializable), es probable que tenga que tirar uno, desafortunadamente.

Answer 2

Esta es probablemente la implementación más básica y genérica de IGrouping. Su constructor toma una clave y un conjunto de valores.

public class Grouping<TKey, TElement> : IGrouping<TKey, TElement>
{
    private readonly TKey key;
    private readonly IEnumerable<TElement> values;

    public Grouping(TKey key, IEnumerable<TElement> values)
    {
        if (values == null)
            throw new ArgumentNullException("values");
        this.key = key;
        this.values = values;
    }

    public TKey Key
    {
        get { return key; }
    }

    public IEnumerator<TElement> GetEnumerator()
    {
        return values.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Answer 3

System.Core (en System.Core.dll) http://msdn.microsoft.com/en-us/library/bb344977.aspx

Answer 4

Varios tipos en el BCL implementan IGrouping , sin embargo, todos son internos y no se puede acceder, excepto por la interfaz de IGrouping .

Pero un grupo de IGrouping es simplemente un IEnumerable<TElement> con una clave asociada. Puede implementar fácilmente un grupo de IGrouping respaldado por un List<TElement> y que no debería ser difícil de serializar a través de un límite de llamada:

public class Grouping<TKey, TElement> : IGrouping<TKey, TElement> {

  readonly List<TElement> elements;

  public Grouping(IGrouping<TKey, TElement> grouping) {
    if (grouping == null)
      throw new ArgumentNullException("grouping");
    Key = grouping.Key;
    elements = grouping.ToList();
  }

  public TKey Key { get; private set; }

  public IEnumerator<TElement> GetEnumerator() {
    return this.elements.GetEnumerator();
  }

  IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }

}

Después de aplicar el operador GroupBy , puede crear una lista de instancias de Grouping :

var listOfGroups =
  source.GroupBy(x => ...).Select(g => new Grouping<TKey, TElement>(g)).ToList();