Come leggere il file di testo delle risorse incorporato

Come posso leggere una risorsa incorporata (file di testo) usando StreamReadere restituirla come stringa? Il mio script corrente utilizza un modulo di Windows e una casella di testo che consente all'utente di trovare e sostituire il testo in un file di testo che non è incorporato.

private void button1_Click(object sender, EventArgs e)
{
    StringCollection strValuesToSearch = new StringCollection();
    strValuesToSearch.Add("Apple");
    string stringToReplace;
    stringToReplace = textBox1.Text;

    StreamReader FileReader = new StreamReader(@"C:\MyFile.txt");
    string FileContents;
    FileContents = FileReader.ReadToEnd();
    FileReader.Close();
    foreach (string s in strValuesToSearch)
    {
        if (FileContents.Contains(s))
            FileContents = FileContents.Replace(s, stringToReplace);
    }
    StreamWriter FileWriter = new StreamWriter(@"MyFile.txt");
    FileWriter.Write(FileContents);
    FileWriter.Close();
}

Puoi usare il Assembly.GetManifestResourceStreammetodo :

1. Aggiungi i seguenti usi

   using System.IO;
   using System.Reflection;

2. Imposta la proprietà del file pertinente:
   parametro Build Actioncon valoreEmbedded Resource

3. Usa il seguente codice

var assembly = Assembly.GetExecutingAssembly();
var resourceName = "MyCompany.MyProduct.MyFile.txt";

using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
    string result = reader.ReadToEnd();
}

resourceNameè il nome di una delle risorse incorporate assembly. Ad esempio, se si incorpora un file di testo denominato "MyFile.txt"che viene inserito nella radice di un progetto con spazio dei nomi predefinito "MyCompany.MyProduct", lo resourceNameè "MyCompany.MyProduct.MyFile.txt". È possibile ottenere un elenco di tutte le risorse in un assembly utilizzando il Assembly.GetManifestResourceNamesmetodo .

Un gioco da ragazzi astuto per ottenere il solo resourceNamedal nome del file (passando la roba dello spazio dei nomi):

string resourceName = assembly.GetManifestResourceNames()
  .Single(str => str.EndsWith("YourFileName.txt"));

Un esempio completo:

public string ReadResource(string name)
{
    // Determine path
    var assembly = Assembly.GetExecutingAssembly();
    string resourcePath = name;
    // Format: "{Namespace}.{Folder}.{filename}.{Extension}"
    if (!name.StartsWith(nameof(SignificantDrawerCompiler)))
    {
        resourcePath = assembly.GetManifestResourceNames()
            .Single(str => str.EndsWith(name));
    }

    using (Stream stream = assembly.GetManifestResourceStream(resourcePath))
    using (StreamReader reader = new StreamReader(stream))
    {
        return reader.ReadToEnd();
    }
}

È possibile aggiungere un file come risorsa utilizzando due metodi separati.

Il codice C # richiesto per accedere al file è diverso , a seconda del metodo utilizzato per aggiungere il file in primo luogo.

Metodo 1: aggiungi un file esistente, imposta la proprietà su Embedded Resource

Aggiungi il file al tuo progetto, quindi imposta il tipo su Embedded Resource.

NOTA: se si aggiunge il file utilizzando questo metodo, è possibile utilizzare GetManifestResourceStreamper accedervi (vedere la risposta da @dtb ).

Metodo 2: aggiungi il file a Resources.resx

Aprire il Resources.resxfile, utilizzare la casella a discesa per aggiungere il file, impostare Access Modifiersu public.

NOTA: se si aggiunge il file con questo metodo, è possibile utilizzarlo Properties.Resourcesper accedervi (vedere la risposta di @Night Walker ).

Fondamentalmente, si utilizza System.Reflectionper ottenere un riferimento all'Assemblea corrente. Quindi si usa GetManifestResourceStream().

Esempio, dalla pagina che ho pubblicato:

Nota : è necessario aggiungerlo using System.Reflection;affinché funzioni

   Assembly _assembly;
   StreamReader _textStreamReader;

   try
   {
      _assembly = Assembly.GetExecutingAssembly();
      _textStreamReader = new StreamReader(_assembly.GetManifestResourceStream("MyNamespace.MyTextFile.txt"));
   }
   catch
   {
      MessageBox.Show("Error accessing resources!");
   }

In Visual Studio è possibile incorporare direttamente l'accesso a una risorsa di file tramite la scheda Risorse delle proprietà del Progetto ("Analytics" in questo esempio).

È quindi possibile accedere al file risultante come array di byte da

byte[] jsonSecrets = GoogleAnalyticsExtractor.Properties.Resources.client_secrets_reporter;

Dovresti averne bisogno come stream, quindi (da https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Quando hai aggiunto il file alle risorse, dovresti selezionare i Modificatori di accesso come pubblici di quanto puoi fare come segue.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 è il nome del file incorporato.

In realtà puoi andare su resources.Designer.cs e vedere qual è il nome del getter.

aggiungendo ad es. Testfile.sql Menu Progetto -> Proprietà -> Risorse -> Aggiungi file esistente

    string queryFromResourceFile = Properties.Resources.Testfile.ToString();

So che è un vecchio thread, ma questo è ciò che ha funzionato per me:

1. aggiungere il file di testo alle risorse del progetto
2. impostare il modificatore di accesso su pubblico, come mostrato sopra da Andrew Hill

3. leggi il testo in questo modo:

   textBox1 = new TextBox();
   textBox1.Text = Properties.Resources.SomeText;

Il testo che ho aggiunto alle risorse: "SomeText.txt"

Puoi anche usare questa versione semplificata della risposta di @ dtb:

public string GetEmbeddedResource(string ns, string res)
{
    using (var reader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("{0}.{1}", ns, res))))
    {
        return reader.ReadToEnd();
    }
}

Qualcosa che ho imparato proprio ora è che al tuo file non è permesso avere un "." (punto) nel nome del file.

Templates.plainEmailBodyTemplate-en.txt -> Works !!!
Templates.plainEmailBodyTemplate.en.txt -> non funziona tramite GetManifestResourceStream ()

Probabilmente perché il framework viene confuso su spazi dei nomi vs nome file ...

Con tutti i tuoi poteri combinati utilizzo questa classe di supporto per leggere risorse da qualsiasi assembly e qualsiasi spazio dei nomi in modo generico.

public class ResourceReader
{
    public static IEnumerable<string> FindEmbededResources<TAssembly>(Func<string, bool> predicate)
    {
        if (predicate == null) throw new ArgumentNullException(nameof(predicate));

        return
            GetEmbededResourceNames<TAssembly>()
                .Where(predicate)
                .Select(name => ReadEmbededResource(typeof(TAssembly), name))
                .Where(x => !string.IsNullOrEmpty(x));
    }

    public static IEnumerable<string> GetEmbededResourceNames<TAssembly>()
    {
        var assembly = Assembly.GetAssembly(typeof(TAssembly));
        return assembly.GetManifestResourceNames();
    }

    public static string ReadEmbededResource<TAssembly, TNamespace>(string name)
    {
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));
        return ReadEmbededResource(typeof(TAssembly), typeof(TNamespace), name);
    }

    public static string ReadEmbededResource(Type assemblyType, Type namespaceType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (namespaceType == null) throw new ArgumentNullException(nameof(namespaceType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        return ReadEmbededResource(assemblyType, $"{namespaceType.Namespace}.{name}");
    }

    public static string ReadEmbededResource(Type assemblyType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        var assembly = Assembly.GetAssembly(assemblyType);
        using (var resourceStream = assembly.GetManifestResourceStream(name))
        {
            if (resourceStream == null) return null;
            using (var streamReader = new StreamReader(resourceStream))
            {
                return streamReader.ReadToEnd();
            }
        }
    }
}

Ho letto l'uso di un file di testo di risorse incorporato:

    /// <summary>
    /// Converts to generic list a byte array
    /// </summary>
    /// <param name="content">byte array (embedded resource)</param>
    /// <returns>generic list of strings</returns>
    private List<string> GetLines(byte[] content)
    {
        string s = Encoding.Default.GetString(content, 0, content.Length - 1);
        return new List<string>(s.Split(new[] { Environment.NewLine }, StringSplitOptions.None));
    }

Campione:

var template = GetLines(Properties.Resources.LasTemplate /* resource name */);

template.ForEach(ln =>
{
    Debug.WriteLine(ln);
});

So che questo è vecchio, ma volevo solo sottolineare NETMF (.Net MicroFramework), puoi farlo facilmente:

string response = Resources.GetString(Resources.StringResources.MyFileName);

Poiché NETMF non haGetManifestResourceStream

Dopo aver letto tutte le soluzioni pubblicate qui. Ecco come l'ho risolto:

// How to embedded a "Text file" inside of a C# project
//   and read it as a resource from c# code:
//
// (1) Add Text File to Project.  example: 'myfile.txt'
//
// (2) Change Text File Properties:
//      Build-action: EmbeddedResource
//      Logical-name: myfile.txt      
//          (note only 1 dot permitted in filename)
//
// (3) from c# get the string for the entire embedded file as follows:
//
//     string myfile = GetEmbeddedResourceFile("myfile.txt");

public static string GetEmbeddedResourceFile(string filename) {
    var a = System.Reflection.Assembly.GetExecutingAssembly();
    using (var s = a.GetManifestResourceStream(filename))
    using (var r = new System.IO.StreamReader(s))
    {
        string result = r.ReadToEnd();
        return result;
    }
    return "";      
}

La risposta è abbastanza semplice, basta farlo se hai aggiunto il file direttamente da resources.resx.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Con quella riga di codice, il testo del file viene letto direttamente dal file e inserito nella variabile stringa.

Ero infastidito dal fatto che dovevi includere sempre lo spazio dei nomi e la cartella nella stringa. Volevo semplificare l'accesso alle risorse incorporate. Questo è il motivo per cui ho scritto questa piccola lezione. Sentiti libero di usare e migliorare!

Uso:

using(Stream stream = EmbeddedResources.ExecutingResources.GetStream("filename.txt"))
{
 //...
}

Classe:

public class EmbeddedResources
{
    private static readonly Lazy<EmbeddedResources> _callingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetCallingAssembly()));

    private static readonly Lazy<EmbeddedResources> _entryResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetEntryAssembly()));

    private static readonly Lazy<EmbeddedResources> _executingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetExecutingAssembly()));

    private readonly Assembly _assembly;

    private readonly string[] _resources;

    public EmbeddedResources(Assembly assembly)
    {
        _assembly = assembly;
        _resources = assembly.GetManifestResourceNames();
    }

    public static EmbeddedResources CallingResources => _callingResources.Value;

    public static EmbeddedResources EntryResources => _entryResources.Value;

    public static EmbeddedResources ExecutingResources => _executingResources.Value;

    public Stream GetStream(string resName) => _assembly.GetManifestResourceStream(_resources.Single(s => s.Contains(resName)));

}

Alcuni tipi di progetti VS .NET non generano automaticamente un file .NET (.resx). I seguenti passaggi aggiungono un file di risorse al progetto:

1. Fare clic con il tasto destro del mouse sul nodo del progetto e selezionare Aggiungi / Nuovo elemento, scorrere fino a File risorse. Nella casella Nome selezionare un nome appropriato, ad esempio Risorse e fare clic sul pulsante Aggiungi.
2. Il file di risorse Resources.resx viene aggiunto al progetto e può essere visto come un nodo in Esplora soluzioni.
3. In realtà, vengono creati due file, c'è anche una classe C # generata automaticamente Resources.Designer.cs. Non modificarlo, è gestito da VS. Il file contiene una classe denominata Resources.

Ora puoi aggiungere un file di testo come risorsa, ad esempio un file XML:

1. Fare doppio clic su Resources.resx. Selezionare Aggiungi risorsa> Aggiungi file esistente e scorrere fino al file che si desidera includere. Lasciare il valore predefinito Interno per Modifica accesso.
2. Un'icona rappresenta il nuovo elemento di risorsa. Se selezionato, il riquadro delle proprietà mostra le sue proprietà. Per i file XML, sotto la proprietà Codifica selezionare Unicode (UTF-8) - Codepage 65001 invece della codepage locale predefinita. Per altri file di testo selezionare la codifica corretta di questo file, ad esempio la tabella codici 1252.
3. Per file di testo come file XML, la classe Resourcesha una proprietà di tipo stringche prende il nome dal file incluso. Se il nome del file è ad esempio RibbonManifest.xml, la proprietà dovrebbe avere il nome RibbonManifest. Il nome esatto si trova nel file di codice Resources.Designer.cs.
4. Utilizzare la proprietà di stringa come qualsiasi altra proprietà di stringa, per esempio: string xml = Resources.RibbonManifest. La forma generale è ResourceFileName.IncludedTextFileName. Non usare ResourceManager.GetStringpoiché la funzione get della proprietà stringa lo ha già fatto.

public class AssemblyTextFileReader
{
    private readonly Assembly _assembly;

    public AssemblyTextFileReader(Assembly assembly)
    {
        _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
    }

    public async Task<string> ReadFileAsync(string fileName)
    {
        var resourceName = _assembly.GetManifestResourceName(fileName);

        using (var stream = _assembly.GetManifestResourceStream(resourceName))
        {
            using (var reader = new StreamReader(stream))
            {
                return await reader.ReadToEndAsync();
            }
        }
    }
}

public static class AssemblyExtensions
{
    public static string GetManifestResourceName(this Assembly assembly, string fileName)
    {
        string name = assembly.GetManifestResourceNames().SingleOrDefault(n => n.EndsWith(fileName, StringComparison.InvariantCultureIgnoreCase));

        if (string.IsNullOrEmpty(name))
        {
            throw new FileNotFoundException($"Embedded file '{fileName}' could not be found in assembly '{assembly.FullName}'.", fileName);
        }

        return name;
    }
}

Questa è una classe che potresti trovare molto utile per leggere i file di risorse incorporati dall'attuale Assembly:

using System.IO;
using System.Linq;
using System.Text;
using static System.IO.Path;
using static System.Reflection.Assembly;

public static class EmbeddedResourceUtils
{
    public static string ReadFromResourceFile(string endingFileName)
    {
        var assembly = GetExecutingAssembly();
        var manifestResourceNames = assembly.GetManifestResourceNames();

        foreach (var resourceName in manifestResourceNames)
        {
            var fileNameFromResourceName = _GetFileNameFromResourceName(resourceName);
            if (!fileNameFromResourceName.EndsWith(endingFileName))
            {
                continue;
            }

            using (var manifestResourceStream = assembly.GetManifestResourceStream(resourceName))
            {
                if (manifestResourceStream == null)
                {
                    continue;
                }

                using (var streamReader = new StreamReader(manifestResourceStream))
                {
                    return streamReader.ReadToEnd();
                }
            }
        }

        return null;
    }

    // https://stackoverflow.com/a/32176198/3764804
    private static string _GetFileNameFromResourceName(string resourceName)
    {
        var stringBuilder = new StringBuilder();
        var escapeDot = false;
        var haveExtension = false;

        for (var resourceNameIndex = resourceName.Length - 1;
            resourceNameIndex >= 0;
            resourceNameIndex--)
        {
            if (resourceName[resourceNameIndex] == '_')
            {
                escapeDot = true;
                continue;
            }

            if (resourceName[resourceNameIndex] == '.')
            {
                if (!escapeDot)
                {
                    if (haveExtension)
                    {
                        stringBuilder.Append('\\');
                        continue;
                    }

                    haveExtension = true;
                }
            }
            else
            {
                escapeDot = false;
            }

            stringBuilder.Append(resourceName[resourceNameIndex]);
        }

        var fileName = GetDirectoryName(stringBuilder.ToString());
        return fileName == null ? null : new string(fileName.Reverse().ToArray());
    }
}

Per tutte le persone che vogliono rapidamente il testo di un file hardcoded in winforms;

1. Fare clic con il tasto destro del mouse sull'applicazione Esplora soluzioni> Risorse> Aggiungi il file.
2. Fare clic su di esso e nella scheda delle proprietà impostare "Tipo file" su "Testo".
3. Nel tuo programma devi solo Resources.<name of resource>.toString();leggere il file.

Non lo consiglierei come best practice o altro, ma funziona rapidamente e fa quello che deve fare.

Per gli utenti che utilizzano VB.Net

Imports System.IO
Imports System.Reflection

Dim reader As StreamReader
Dim ass As Assembly = Assembly.GetExecutingAssembly()
Dim sFileName = "MyApplicationName.JavaScript.js" 
Dim reader = New StreamReader(ass.GetManifestResourceStream(sFileName))
Dim sScriptText = reader.ReadToEnd()
reader.Close()

dov'è lo MyApplicationNamespazio dei nomi della mia applicazione. Non è il nome dell'assembly. Questo nome è definito nelle proprietà del progetto (scheda Applicazione).

Se non trovi il nome della risorsa corretto, puoi usare la GetManifestResourceNames()funzione

Dim resourceName() As String = ass.GetManifestResourceNames()

o

Dim sName As String 
    = ass.GetManifestResourceNames()
        .Single(Function(x) x.EndsWith("JavaScript.js"))

o

Dim sNameList 
    = ass.GetManifestResourceNames()
        .Where(Function(x As String) x.EndsWith(".js"))

Leggi il file TXT incorporato sull'evento di caricamento del modulo.

Imposta dinamicamente le variabili.

string f1 = "AppName.File1.Ext";
string f2 = "AppName.File2.Ext";
string f3 = "AppName.File3.Ext";

Chiama un tentativo di cattura.

try 
{
     IncludeText(f1,f2,f3); 
     /// Pass the Resources Dynamically 
     /// through the call stack.
}

catch (Exception Ex)
{
     MessageBox.Show(Ex.Message);  
     /// Error for if the Stream is Null.
}

Crea vuoto per IncludeText (), Visual Studio Fa questo per te. Fare clic sulla lampadina per generare automaticamente CodeBlock.

Inserisci quanto segue all'interno del blocco di codice generato

Risorsa 1

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file1))
using (StreamReader reader = new StreamReader(stream))
{
string result1 = reader.ReadToEnd();
richTextBox1.AppendText(result1 + Environment.NewLine + Environment.NewLine );
}

Risorsa 2

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file2))
using (StreamReader reader = new StreamReader(stream))
{
string result2 = reader.ReadToEnd();
richTextBox1.AppendText(
result2 + Environment.NewLine + 
Environment.NewLine );
}

Risorsa 3

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file3))

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    richTextBox1.AppendText(result3);
}

Se desideri inviare la variabile restituita da qualche altra parte, chiama semplicemente un'altra funzione e ...

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    ///richTextBox1.AppendText(result3);
    string extVar = result3;

    /// another try catch here.

   try {

   SendVariableToLocation(extVar)
   {
         //// Put Code Here.
   }

       }

  catch (Exception ex)
  {
    Messagebox.Show(ex.Message);
  }

}

Ciò che è stato raggiunto è stato questo, un metodo per combinare più file txt e leggere i loro dati incorporati, all'interno di una singola casella di testo. quale era il mio effetto desiderato con questo esempio di codice.