Currently able to calculate total neighbors, I need just the neighbors that are alive

Question

I have a bool [,] board that stores if the cell is alive or dead. The code I have provided is correctly telling me the total neighbors for each cell, the problem is I need to only count the alive neighbors. My thought was to have a check in the

   if (WithinBounds (row, col) ) {
      if (board[row, col] == true)
         liveNeighbor++;

These are my two relevant methods for calculating total neighbors.

        private int TotalLiveNeighbors(int x, int y)
        {
            int liveNeighbors = 0;


            for (int row = x - 1; row <= x + 1; row++)
            {
                for (int col = y - 1; col <= y + 1; col++)
                {
                    if (! (row == x && col == y))
                    {
                        if (WithinBounds(row, col)) {
                            liveNeighbors++;
                        }

                    }
                }
            }

            return liveNeighbors;
        }

        public bool WithinBounds(int x, int y)
        {
            if (x < 0 || y < 0)
                return false;
            if (x >= 3 || y >= 3)
                return false;
            
            return true;
        }

I was also working on a different approach that used an offset as so:

int[,] neighborLocations = { { -1,-1 }, { -1,0 }, { -1, +1 },
                             { 0, -1},            { 0, +1 },
                             {+1, -1},  {+1, 0 }, { +1, +1 } };

int countAliveNeighbors (int x, int y) {
    int count = 0;
    foreach (int[] offset in neighborLocations) {
        if (board.hasAliveNeighborsAt(x + offset[1], y + offset[0])
            count++;
    }
    return count;
}

Not really sure if this would be more efficient than my first approach

Answer 1

assuming that the array is called 'alive'

 if (alive[row,col] && WithinBounds(row, col))