Appliquer des opérations sur un tableau à une dimension de cas en une ligne, en utilisant LINQ

Question

Examiner les structures suivantes:

internal struct Coordinate 
{ 
    public Double Top { get; set; } 
    public Double Left { get; set; } 
} 

internal struct Dimension 
{ 
    public Double Height { get; set; } 
    public Double Width { get; set; } 
} 

internal struct Property 
{ 
    public Boolean Visible { get; set; } 
    internal String Label { get; set; } 
    public String Value { get; set; } 
    internal Coordinate Position { get; set; } 
    public Dimension Dimensions { get; set; } 
} 

J'ai besoin de manipuler 20 ou si les instances de propriété. Je voudrais le faire aussi proprement que possible ... Est-il possible d'appliquer plusieurs opérations sur un tableau de Propriété dans une ligne de code?

Je pense quelque chose le long des lignes de:

new [] 
{ 
    InstanceOfProperty, 
    InstanceOfProperty, 
    InstanceOfProperty ... 
}.Each(p => p.Dimensions.Height = 100.0); 

Answer 1

Je fini par faire ceci:

new List<Property> { InstanceOfProperty, InstanceOfProperty, ... }.ForEach((p => 
{ 
    p.Dimensions.Height = 0.0; 
})); 

note: J'ai converti les structures en classes. Si je suis allé avec la conception originale basée sur la structure; J'aurais dû "rajeunir" les structures afin de changer leur valeur. Comme ceci:

new List<Property> { InstanceOfProperty, InstanceOfProperty, ... }.ForEach((p => 
{ 
    p.Dimensions = new Dimension { Height = 0.0 }; 
})); 

Answer 2

Si vous avez écrit votre propre méthode Each prendre un délégué Action<T>, vous pourriez.

Edit:

En fait, il ne fonctionnera pas. Vous utilisez des types de valeur. Une raison pour laquelle il ne peut pas être class?

Les deux Dimension et Property doivent être des types de référence pour que cette affectation soit reflétée après le traitement de la liste.

Answer 3

Vous pouvez écrire une méthode d'extension Each, mais puisque vos objets sont des structures, vous ne pouvez pas le faire fonctionner sur un . Cependant, vous pouvez faire une méthode d'extension qui fonctionne sur un tableau, en utilisant un délégué avec un paramètre ref:

public static class ExtensionMethods 
{ 
    public delegate void RefAction<T>(ref T arg); 

    public static void Each<T>(this T[] array, RefAction<T> action) 
    { 
     for(int i = 0; i < array.Length; i++) 
     { 
      action(ref array[i]); 
     } 
    } 
} 

... 

new [] 
{ 
    InstanceOfProperty, 
    InstanceOfProperty, 
    InstanceOfProperty ... 
}.Each((ref Property p) => p.Dimensions.Height = 100.0); 

Cependant depuis Dimension est aussi un struct, il ne fonctionnera pas de cette façon (et le compilateur détecter et vous donner une erreur). Vous devez faire quelque chose comme ça à la place:

new [] 
{ 
    InstanceOfProperty, 
    InstanceOfProperty, 
    InstanceOfProperty ... 
}.Each((ref Property p) => p.Dimensions = new Dimension 
          { 
           Width = p.Dimensions.Width, 
           Height = 100.0 
          }); 

Dans l'ensemble, tout serait beaucoup plus simple si vos types étaient des classes plutôt que struct ...