For starters, if all of the articles on the internet have not helped you to solve the problem of 2D pathfinding then you aren't looking hard enough haha.

Using a 2D tile array for your world/level generation and representation will definitely simplify things i.e.

using System;
using System.Collections.Generic;
using System.Text;

namespace Tiles {
    public class Vector2 {
        public int x; public int y;
        public Vector2(int x, int y) {
            this.x = x; this.y = y;
        }
    }

    public enum TileType {
        None,
        Grass,
        Dirt,
        Stone,
        Water,
        Air,
    }

    public class Tile {
        public Vector2 position;
        public TileType tileType;

        public Tile(int x, int y, TileType tileType) {
            this.position = new Vector2(x, y);
            this.tileType = tileType;
        }
    }

    public class World {
        public Tile[,] tiles;
        public int sizeX; public int sizeY;

        public World(int sizeX, int sizeY) {
            this.sizeX = sizeX;
            this.sizeY = sizeY;
            int tileCount;

            // build the world
            tiles = new Tile[sizeX, sizeY];

            Random rnd = new Random();
            tileCount = Enum.GetValues(typeof(TileType)).Length;
            // construct grid of tiles
            for (int x = 0; x < sizeX; x++) {
                for (int y = 0; y < sizeX; y++) {
                    tiles[x, y] = new Tile(x, y, (TileType)rnd.Next(tileCount));
                }
            }
        }
    }

    class Program {
        static void Main(string[] args) {
            World world = new World(20, 20);
            for (int y = 0; y < world.sizeY; y++) {
                for (int x = 0; x < world.sizeX; x++) {
                    Console.Write((int)world.tiles[x, y].tileType + " ");
                }
                Console.WriteLine();
            }
        }
    }
}

Once you have a tile grid testing if you can move a unit to a neighbouring tile is very straight forward as you have all of the information you need to test neighbours in your pathfinding algorithm.

For example you could just have a bit of logic code in your TryGetNeighbours function call in each step of your pathfinding algorithm [untested code example] :

void Search(Node start, Node goal) {
    // ...
    Node[] neighbours = new Node[];
    if(TryGetNeighbours(currentNode, out neighbours) {
        foreach(var node in neighbours) {
            // do pathfinding calcs i.e. f = g + h. etc
        ...
        }
    }
    // ...
}

bool TryGetNeighbours(Node current, out Node[] neighbours) {
    Node neighbour;
    for(int x = 0; x < 4; x++) {
        // determine neighbouring node by Vector addition etc
        neighbour = current.pos + x
        if(neighbour.CanTraverse(current) {
            neighbours[x] = neighbour;
        }
    }
    if(neighbours[0] != null) return true;
    return false;
}