Using LINQ to Extract Specific Values from Multi-Dimensional Array

Question

I am working with multi-dimentioned arrays of bool, int, and various struct. The code loops through these arrays and performs some operation on specific values. For instance,

        for (int x = 0; x < this.Size.Width; x++) {
            for (int y = 0; y < this.Size.Height; y++) {
                if (this.Map[x, y]) {
                    DrawTerrain(this.Tile[x, y].Location, Terrain.Water);
                }
            }
        }

I can do simple LINQ stuff, but I can't do what I would like. What I would like to do is use LINQ. Maybe something like

from x in this.Map where x == true execute DrawTerrain(...)

But, I don't understand how I can get the x and y locations or how to call a method in the LINQ statement.

Also, it would be great if I can put this code into a function and be able to call it with a delegate or a predicate? I don't know if delegate or predicate are the correct words.

    void Draw(Delegate draw, bool[,] map, struct[,] tiles) 
        from x in map where x == true draw(titles[x,y]).invoke;
    }

Answer 1

Well, you could do it with LINQ if you work hard enough, but it would be a pain. It sounds like your first bit of code is absolutely fine.

Having a version of that which is generalised to take an action seems very reasonable though:

public delegate void Drawer(int x, int y, Tile tile);

public void Draw(Drawer drawer, bool[,] map, Tile[,] tiles) {
    for (int x = 0; x < this.Size.Width; x++) {
        for (int y = 0; y < this.Size.Height; y++) {
            if (this.Map[x, y]) {
                drawer(x, y, tiles[x, y]);
            }
        }
    }
}

If you really want the LINQ version, it would be something like:

var query = from x in Enumerable.Range(0, Size.Width)
            from y in Enumerable.Range(0, Size.Height)
            where Map[x, y]
            select new { x, y };

foreach (var pair in query)
{
    DoWhatever(pair.x, pair.y, tiles[pair.x, pair.y]);
}

Answer 2

You can do the following Linq query to get the x,y values then iterate over them to run your method.

var points = from x in Enumerable.Range(0, this.Size.Width - 1)
             from y in Enumerable.Range(0, this.Size.Width - 1)
             where this.Map[x, y]
             select new { X = x, Y = y };
foreach (var p in points)
    DrawTerrain(this.Tile[p.X, p.Y].Location, Terrain.Water);

Answer 3

The LINQ query syntax isn't really designed for working with 2-dimensional data structures, but you can write an extension method that will convert the 2D array into a sequence of values that contain the coordinates in the original 2D array and the value from the array. You'll need a helper type to store the data:

class CoordinateValue<T> {
  public T Value { get; set; }
  public int X { get; set; }
  public int Y { get; set; }
}

Then you can write the extension method (for any 2D array) like this:

IEnumerable<CoordinateValue<T>> AsEnumerable(this T[,] arr) {
  for (int i = 0; i < arr.GetLength(0); i++)
    for (int j = 0; j < arr.GetLength(0); j++)
      yield new CoordinateValue<T> { Value = arr[i, j]; X = i; Y = j; };
}

Now you can finally start using LINQ. To get coordinates of all elements from the 2D array such that the value stored in the element is true, you can use the following:

var toDraw = from tile in this.Map.AsEnumerable()
             where tile.Value == true
             select tile;

// tile contains the coordinates (X, Y) and the original value (Value)
foreach(var tile in toDraw)
    FillTile(tile.X, tile.Y);

This lets you specify some interesting conditions when filtering the tiles. For example if you wanted to get only diagonal elements, you could write:

var toDraw = from tile in this.Map.AsEnumerable()
             where tile.Value == true && tile.X == tile.Y
             select tile;

To answer your second question - if you want to encapsulate the behavior into the method, you'll probably need to use some Action<...> delegate to represent the drawing function that will be passed to the method. It depends on the type signature of your drawing method though.