Comment passer un résultat LINQ à une méthode?

Question

De Efficient data structure to hold employee's activities?, j'ai une liste de type ActividadEmpleado qui est déclarée comme:

public string Empleado { get; set; } 
public DateTime Fecha { get; set; } 
public string Actividad { get; set; } 

La variable de requête LINQ réordonne le résultat de la manière dont j'ai besoin, ce qui est de stocker par date et par ActividadEmpleado et une chaîne . Cependant, les types var ne peuvent pas être passés aux méthodes, donc en cherchant ce site, je découvre que je dois créer une classe pour stocker les résultats ou modifier la variable LINQ pour retourner une liste, mais j'ai des problèmes avec la déclaration correcte .

La variable LINQ est:

var queryActividades = listaActividad 
       .GroupBy(a => a.Fecha, (fecha, fechaActividades) => new 
       { 
        Fecha = fecha, 
        FechaActividades = fechaActividades 
         .GroupBy(a => a.Empleado, (nombreEmpleado, actividadesEmpleado) => new 
         { 
          Actividades = actividadesEmpleado, 
          NombreEmpleado = nombreEmpleado 
         }) 
         .OrderBy(a => a.NombreEmpleado) 
       }) 
       .OrderBy(a => a.Fecha); 

Visual Studio dit que queryActividades est:

IOrderedEnumerable<'a> 
Anonymous Types: 
'a new datetime fecha, iorderedenumerable<'b> 
'b new IEnumerable<ActividadEmpleado> Actividades, string NombreEmpleado 

Je dois passer queryActividades à une autre méthode. J'ai essayé de le passer comme un objet, mais je perds les méthodes d'extension telles que Où <> (puis-je le lancer en quelque sorte?)

Je lis aussi que déclarer les résultats en tant que tuple devrait fonctionner, mais je pense que déclarer un nouveau la classe est plus propre.

Je commence avec LINQ, je l'ai évité d'utiliser des structures de données régulières, mais dans ce cas, il est vraiment utile et je voudrais savoir comment soit gérer des types anonymes en eux ou convertir le résultat à une liste régulière

solution finale:

class GrupoActividad 
{ 
    public DateTime Fecha { get; set; } 
    public IEnumerable<Actividad> Actividades { get; set; } 
} 

class Actividad 
{ 
    public IEnumerable<ActividadEmpleado> Actividades { get; set; } 
    public string NombreEmpleado { get; set; } 
} 

var queryActividades = listaActividad 
       .GroupBy(a => a.Fecha, (fecha, fechaActividades) => new GrupoActividad 
       { 
        Fecha = fecha, 
        Actividades = fechaActividades 
         .GroupBy(a => a.Empleado, (nombreEmpleado, actividadesEmpleado) => new Actividad 
         { 
          Actividades = actividadesEmpleado, 
          NombreEmpleado = nombreEmpleado 
         }) 
         .OrderBy(a => a.NombreEmpleado) 
       }) 
       .OrderBy(a => a.Fecha); 

méthode de réception:

var actividades = from a in queryActividades 
         where a.Fecha == fechaCiclo 
         select new { a.Fecha, a.Actividades }; 
      foreach (var item in actividades) 
      { 
       //cycle that holds each day's activities 
       foreach (var empleado in item.Actividades) 
       { 
        //cycle that holds each employee with activities in that day 
        foreach (var actividad in empleado.Actividades) 
        { 
         //final cycle that actually reads the activity 
         ActividadEmpleado actividadEmpleado = (ActividadEmpleado)actividad; 
        } 
       } 
      } 

Answer 1

Actuellement, vous créez une collection basée sur un type anonyme (en fait deux types anonymes), qui ne peut pratiquement pas être transmis à une autre méthode (autre que l'utilisation de la réflexion ou dynamic). La façon la plus propre est de créer un type de béton qui représente la collection - quelque chose comme

puis modifiez votre requête:

var queryActividades = listaActividad 
       .GroupBy(a => a.Fecha, (fecha, fechaActividades) => new ActivityGroup 
       { 
        Fecha = fecha, 
        FechaActividades = fechaActividades 
         .GroupBy(a => a.Empleado, (nombreEmpleado, actividadesEmpleado) => new Activity 
         { 
          Actividades = actividadesEmpleado, 
          NombreEmpleado = nombreEmpleado 
         }) 
         .OrderBy(a => a.NombreEmpleado) 
       }) 
       .OrderBy(a => a.Fecha); 

et le transmettre comme IEnumerable<ActivityGroup>

Answer 2

Vous ne pouvez pas passer des types anonymes entre les méthodes; Si vous devez transmettre les données à une autre méthode, vous devez créer un type nommé explicite qui contient les propriétés Actividades et NombreEmpleado, et un autre avec Fecha et FechaActividades.

Answer 3

Vous pouvez utiliser le approche présentée par D Stanley. Mais il serait ennuyeux d'avoir à créer de telles classes pour toute requête similaire que vous écrivez dans le futur. Au lieu de cela, vous pouvez présenter comme classe générique pour cela, comme celui-ci

public class Grouping<TKey, TElement> 
{ 
    public TKey Key { get; set; } 
    public IEnumerable<TElement> Elements { get; set; } 
} 

et de l'utiliser au lieu des types anonymes comme celui-ci

var queryActividades = listaActividad 
    .GroupBy(a => a.Fecha, (fecha, fechaActividades) => new Grouping<DateTime, Grouping<string, ActividadEmpleado>> 
    { 
     Key = fecha, 
     Elements = fechaActividades 
      .GroupBy(a => a.Empleado, (nombreEmpleado, actividadesEmpleado) => new Grouping<string, ActividadEmpleado> 
      { 
       Key = nombreEmpleado, 
       Elements = actividadesEmpleado 
      }) 
      .OrderBy(a => a.Key) 
    }) 
    .OrderBy(a => a.Key); 

qui peut être être passé comme IEnumerable<Grouping<DateTime, Grouping<string, ActividadEmpleado>>>.

Comme vous pouvez le voir, il y a un compromis entre réutilisabilité et lisibilité. Fondamentalement, il s'agit d'un Tuple avec un peu plus de noms significatifs. Notez que même si nous ne pouvons pas améliorer la verbosité dans le résultat, on peut utiliser une technique similaire à Tuple.Create pour éliminer la verbosité dans la requête, en ajoutant une classe comme cette

public static class Grouping 
{ 
    public static Grouping<TKey, TElement> Create<TKey, TElement>(TKey key, IEnumerable<TElement> elements) 
    { 
     return new Grouping<TKey, TElement> { Key = key, Elements = elements }; 
    } 
} 

et l'utiliser comme ceci

var queryActividades = listaActividad 
    .GroupBy(a => a.Fecha, (fecha, fechaActividades) => Grouping.Create(
     fecha, fechaActividades 
      .GroupBy(a => a.Empleado, (nombreEmpleado, actividadesEmpleado) => Grouping.Create(
       nombreEmpleado, actividadesEmpleado)) 
      .OrderBy(a => a.Key))) 
    .OrderBy(a => a.Key);