Leer GeoJson con .Net Core

A continuación explicaré cómo se puede acceder a un archivo en el servidor (wwwroot) y leerlo. En este caso voy a centrarme en leer archivos de tipo .geojson.

Ejemplo de documento .GeoJson :

{
«type»: «FeatureCollection»,
«features»: [
{
«type»: «Feature»,
«geometry»: {
«type»: «Point»,
«coordinates»: [ -2.780104,37.14114 ]
},
«properties»: {
«province»:»Almería»,
«population»:»Abla»,

}]

Para poder representar el documento y acceder a las claves, tenemos que crear las clases que lo representan.

Las clases quedarían así:

   public class Geometry
{
public string type { get; set; }
public List coordinates { get; set; }
}

public class Properties
    {
        public string province { get; set; }
        public string population { get; set; }
        public string id { get; set; }
        public String name_provider { get; set; }
        public Properties(string province, string population,string id, String name_provider)
        {
            this.province = province;
            this.population = population;
            this.name_provider = name_provider;
            this.id = id;
        }
    }

    public class Feature
    {
        public string type { get; set; }
        public Geometry geometry { get; set; }
        public Properties properties { get; set; }
        public Feature(string type, Geometry geometry, Properties properties)
        {
            this.type = type;
            this.geometry = geometry;
            this.properties = properties;
        }
    }

    public class Root
    {
        public string type { get; set; }
        public List<Feature> features { get; set; }
    }

Existe una página que nos genera las clases automáticamente pasándole el documento, esta se llama: https://json2csharp.com/

A continuación nos creamos una clase llamada PathServices con un método que nos devuelva la ruta a la carpeta donde tenemos el archivo. Lo vamos a llamar MapPath():

Antes de nada añadiremos un Enumerado que va a contener los nombres de las carpetas que tenemos en el servidor:

public enum Folder{
Documents=0
}

Nuestro método para recuperar la ruta recibe el nombre de la carpeta donde está guardado, en nuestro caso es en Documents, y recibiría también el nombre del archivo

 public String MapPath(String filename, Folder folder)
{
String carpeta="";   
if(folder == Folder.Documents)
  {
    carpeta = "documents";
   }else if(folder == Folder.Images)
    {
        carpeta = "images";
    }else if (folder == Folder.Temporal)
    {
        carpeta = "temporal";
    }
String path = Path.Combine(this.environment.WebRootPath, carpeta, filename);

        return path;
    }

El siguiente paso es crearnos un repositorio donde crearemos el método que lee y nos devuelve la información del documento.

Necesitamos inyectar PathSerices.

   PathService paths;
   private String ruta;
   public RepositoryMap(PathService paths)
   {
    this.paths = paths;
    this.ruta = this.paths.MapPath("map.geojson", Folder.Documents);   
        }

En el constructor vamos a llamar al metodo MapPath(«nombreArchivo», Folder.Carpeta) para que nos devuelva la ruta a la carpeta donde está nuestro .geojson.

Nuestro método necesitamos que nos devuelva la clase que engloba todas las clases que representan el documento, en este caso se llama Root. Si nos fijamos bien, esta clase tiene las propiedades que contienen el resto de elementos:

 public string type { get; set; }
 public List<Feature> features { get; set; }

Dentro de Features estarán: properties, geometry, province, population etc…

Generamos, entonces, el método que nos devuelve Root y lo vamos a llamar GetGeoJson(), quedaría asi:

public Root GetGeoJson()
        {
            Root map;
            using (StreamReader reader = File.OpenText(this.ruta))
            {
                var json = reader.ReadToEnd();
                map = JsonConvert.DeserializeObject<Root>(json);  
            }

            return map;
        }

En la variable reader vamos a volcar el archivo y con reader.ReadToEnd() lo leemos. Seguidamente deserializamos la información que estamos recibiendo y le indicamos que lo represente con la clase Root. A partir de ahora podemos acceder a la información a través de la clase.

Ahora podriamos visualizar las provincias escribiendo la clase y la propiedad:

Controllador:


 public class EjemploController : Controller
    {
        RepositoryMap map;
        public EjemploController(RepositoryMap map)
        {
            this.map = map;
        }
        public IActionResult Index()
        {
            
            return View(this.map.GetGeoJson());
        }
    }

Vista:

@model Map.Root

    <ul>
        @foreach (Map.Feature f in Model.features)
        {
<li>@f.properties.population</li>
        }
    </ul>

Resultado

Autor/a: Carlota Lobo Sanz

Curso: Desarrollo Web Full Stack, MultiCloud y Multiplataforma 

Centro: Tajamar 

Año académico: 2020-2021 

Código / recursos utilizados / Otros datos de interés: Enlace a GitHub