Leggere i file di dati della soluzione ASP.Net Core

Question

Ho una soluzione MVC ASP.NET Core (1.0-rc1-final) e desidero memorizzare un semplice file di testo all'interno del progetto che contiene un elenco di stringhe che ho letto in un array di stringhe nel mio controller.

Dove devo archiviare questo file nel mio progetto e come posso leggere quei file nei miei controller?

In ASP.net 4.x avrei usato la cartella app_data e fatto qualcosa di simile

string path = Server.MapPath("~/App_Data/File.txt"); 
string[] lines = System.IO.File.ReadAllLines(path); 

Ma Server.MapPath non sembra essere valido in ASP.Net core 1 e io non sono sicuro che sia la cartella app_data.

Answer 1

Ho trovato una soluzione semplice a questo.

In primo luogo, è possibile creare una cartella ovunque nella soluzione, non è necessario attenersi alle convenzioni come "app_data" da .net 4.x.

Nel mio scenario, ho creato una cartella chiamata 'dati' alla base del mio progetto, ho messo il mio file txt in là e usato questo codice per leggere il contenuto di un array di stringhe

var owners = System.IO.File.ReadAllLines(@"..\data\Owners.txt");

Answer 2

nel controller, è possibile eseguire una dipendenza da IApplicationEnvironment e averlo inserito nel costruttore, quindi è possibile utilizzarlo per stabilire il percorso del file in modo che il file possa vivere in una cartella all'interno del progetto. Nell'esempio di seguito "env" è l'istanza di IApplicationEnvironment

using Microsoft.Extensions.PlatformAbstractions; 

var pathToFile = env.ApplicationBasePath 
    + Path.DirectorySeparatorChar.ToString() 
    + "yourfolder" 
    + Path.DirectorySeparatorChar.ToString() 
    + "yourfilename.txt"; 

string fileContent; 

using (StreamReader reader = File.OpenText(pathToFile)) 
{ 
    fileContent = reader.ReadToEnd(); 
} 

ApplicationBasePath rappresenta l'applicationRootFolder

nota che esiste anche IHostingEnvironment che ha il metodo .MapPath familiare, ma è cosa c'è memorizzati sotto la wwwroot cartella. È necessario archiviare solo le cose sotto la cartella wwwroot che si desidera servire con le richieste http, quindi è meglio mantenere l'elenco di stringhe in una cartella diversa.

Answer 3

IApplicationEnvironment e IRuntimeEnvironment sono stati rimossi a partire da un announcement on github in data 2016/04/26.

ho sostituito @ codice di JoeAudette con questo

private readonly string pathToFile; 

public UsersController(IHostingEnvironment env) 
{ 
    pathToFile = env.ContentRootPath 
     + Path.DirectorySeparatorChar.ToString() 
     + "Data" 
     + Path.DirectorySeparatorChar.ToString() 
     + "users.json"; 
} 

Dove il mio file .json si trova a src/WebApplication/Data/users.json

Ho poi letto/analizzare questi dati in questo modo

private async Task<IEnumerable<User>> GetDataSet() 
{ 
    string source = ""; 

    using (StreamReader SourceReader = OpenText(pathToFile)) 
    { 
     source = await SourceReader.ReadToEndAsync(); 
    } 

    return await Task.Factory.StartNew(() => JsonConvert.DeserializeObject<IEnumerable<User>>(source)); 
} 

Answer 4

Questo metodo ha funzionato per a livello locale e in ambiente Azure.Si è preso dalla risposta di Joe sopra

public static string ReadFile(string FileName) 
    { 
     try 
     { 
      using (StreamReader reader = File.OpenText(FileName)) 
      { 
       string fileContent = reader.ReadToEnd(); 
       if (fileContent != null && fileContent != "") 
       { 
        return fileContent; 
       } 
      } 
     } 
     catch (Exception ex) 
     { 
      //Log 
      throw ex; 
     } 
     return null; 
    } 

E questo è come invocato che il metodo

string emailContent = ReadFile("./wwwroot/EmailTemplates/UpdateDetails.html"); 

Answer 5

È possibile ottenere l'ambiente con Dependency Injection nel controller:

using Microsoft.AspNetCore.Hosting; 
.... 

public class HomeController: Controller 
{ 
    private IHostingEnvironment _env; 

    public HomeController(IHostingEnvironment env) 
    { 
    _env = env; 
    } 
... 

allora si può ottieni la posizione di wwwroot nelle tue azioni: _env.WebRootPath

var owners = System.IO.File.ReadAllLines(System.IO.Path.Combine(_env.WebRootPath,"File.txt")); 

Answer 6

Questo ha sempre funzionato per me localmente e su IIS.

AppDomain.CurrentDomain.BaseDirectory