C# Types de retour complexes

Question

Je suis nouveau en C# et je me retrouve parfois dans des situations où je dois retourner des types de retour complexes pour certaines fonctions. Comme la fonction peut prendre dans un objet et retourner une vue différente de cet objet: certains champs ajoutés, certains supprimés, etc. Et d'autres fois, je peux prendre une liste d'objets et je veux retourner une liste de certains objets modifiés et éventuellement quelques calculs agrégés sur tous ensemble. Je pourrais accomplir ce genre de choses en retournant des types natifs C# (comme object []), mais il devient moche d'avoir object [] de object [] et ensuite en code de "connaitre" cet objet [ 0] [1] correspond à quelque chose.

Je soupçonne que cela est logique de créer une classe vraiment nouveau appelé comme un FnFooReturn, mais où est-il le plus logique d'inclure la définition de ces classes afin que partout qui appelle la fonction peut l'utiliser?

Edit: Un exemple spécifique: J'ai une Foo fonction qui prend dans une liste d'objets tels que:

(int id, int num, string name) 

de sorte que certaines données exemple pourrait être:

(1, 100, "foo") 
(1, 203, "foo") 
(2, 400, "bar") 
(3, 10, "cat") 

et je veux pour retourner une liste d'objets tels que:

(int id, string name, int[] nums) 

à ressembler à:

[(1, "foo", [100, 103]), (2, "bar", [400]), (3, "cat", [10])] 

il est fondamentalement juste une vue différente de la liste originale des objets sauf qu'il combine ensemble tous les objets avec le même identifiant pour le rendre plus facile à boucle sur dans un autre code plus tard.

Answer 1

Dans votre exemple spécifique, vous devriez avoir un type concret qui gère ces propriétés, et utilize LINQ to reinterpret the data in a different "view".

public class Item 
{ 
    public int Id { get; private set; } 
    public int Category { get; set; } 
    public string Name { get; set; } 

    public Item(int id, int category, string name) 
    { 
     this.Id = id; 
     this.Category = category; 
     this.Name = name; 
    } 
} 

plus tard:

var items = new [] { new Item(1, 103, "foo"), ... }; 

var query = from item in items 
      where item.Category != 108 /* example */ 
      group by item.Id into g 
      select new 
      { 
       Id = g.Key, 
       Categories = g.Select(x => x.Category).ToArray() 
      }; 

Answer 2

Vous pouvez ajouter une classe ordinaire à votre projet et l'utiliser où vous le souhaitez.

Answer 3

Essayez LINQ:

var items = new[] { 
    new { id = 1, num = 100, name = "foo" }, 
    new { id = 1, num = 203, name = "foo" }, 
    new { id = 2, num = 400, name = "bar" }, 
    new { id = 3, num = 10, name = "cat" }, 
}; 

var result = items.GroupBy(x => x.id, (k, i) => new { id = k, nums = i.Select(y => y.num).ToArray(), name = i.Select(x => x.name).First() }).ToArray(); 

Si vous avez besoin encapsuler cette logique dans une méthode, utilisez un Extension Method sur votre liste (si nécessaire et lui donner les moyens avec Generics).

Answer 4

Vos fonctions devraient être comme b = F(a) où a et b sont des types menaingful dans votre conception.

Il y a une place limitée pour les types ad-hoc, comme Tuple<Customer, decimal> mais si vous vous trouvez à écrire des classes spéciales pour accommoder une méthode, quelque chose s'est mal passé.