Lesen einer eingebetteten Ressourcentextdatei

Wie lese ich eine eingebettete Ressource (Textdatei) mit StreamReaderund gebe sie als Zeichenfolge zurück? Mein aktuelles Skript verwendet ein Windows-Formular und ein Textfeld, mit denen der Benutzer Text in einer nicht eingebetteten Textdatei suchen und ersetzen kann.

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();
}

Sie können die Assembly.GetManifestResourceStreamMethode verwenden :

1. Fügen Sie die folgenden Verwendungen hinzu

   using System.IO;
   using System.Reflection;

2. Eigenschaft der relevanten Datei
   festlegen : Parameter Build Actionmit WertEmbedded Resource

3. Verwenden Sie den folgenden Code

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();
}

resourceNameist der Name einer der eingebetteten Ressourcen assembly. Zum Beispiel, wenn Sie eine Textdatei mit dem Namen einbetten , "MyFile.txt"die in der Wurzel eines Projektes mit Standard - Namespace platziert wird "MyCompany.MyProduct", dann resourceNameist "MyCompany.MyProduct.MyFile.txt". Mit der Assembly.GetManifestResourceNamesMethode können Sie eine Liste aller Ressourcen in einer Assembly abrufen .

Ein Kinderspiel, um den resourceNameDateinamen nur aus dem Dateinamen zu erhalten ( umgehen Sie das Namespace-Zeug):

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

Ein vollständiges Beispiel:

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();
    }
}

Sie können eine Datei mit zwei separaten Methoden als Ressource hinzufügen.

Der für den Zugriff auf die Datei erforderliche C # -Code unterscheidet sich je nach der Methode, mit der die Datei zuerst hinzugefügt wurde.

Methode 1: Vorhandene Datei hinzufügen, Eigenschaft auf setzen Embedded Resource

Fügen Sie die Datei Ihrem Projekt hinzu und setzen Sie den Typ auf Embedded Resource.

HINWEIS: Wenn Sie die Datei mit dieser Methode hinzufügen, können Sie GetManifestResourceStreamdarauf zugreifen (siehe Antwort von @dtb ).

Methode 2: Datei hinzufügen zu Resources.resx

Öffnen Sie die Resources.resxDatei, verwenden Sie die Dropdown - Box die Datei hinzuzufügen, Satz Access Modifierzu public.

HINWEIS: Wenn Sie die Datei mit dieser Methode hinzufügen, können Sie Properties.Resourcesdarauf zugreifen (siehe Antwort von @Night Walker ).

Grundsätzlich verwenden Sie System.Reflection, um einen Verweis auf die aktuelle Assembly zu erhalten. Dann benutzt du GetManifestResourceStream().

Beispiel von der Seite, die ich gepostet habe:

Hinweis : Sie müssen hinzufügen, using System.Reflection;damit dies funktioniert

   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 können Sie den Zugriff auf eine Dateiressource direkt über die Registerkarte Ressourcen der Projekteigenschaften (in diesem Beispiel "Analytics") einbetten.

Auf die resultierende Datei kann dann als Byte-Array von zugegriffen werden

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

Sollten Sie es als Stream benötigen, dann (von https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Wenn Sie die Datei zu den Ressourcen hinzugefügt haben, sollten Sie die Zugriffsmodifikatoren als öffentlich auswählen, damit Sie Folgendes tun können.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 ist der Name der eingebetteten Datei.

Tatsächlich können Sie zu resources.Designer.cs gehen und sehen, wie der Getter heißt.

Hinzufügen zB Testfile.sql Projektmenü -> Eigenschaften -> Ressourcen -> Vorhandene Datei hinzufügen

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

Ich weiß, dass es ein alter Thread ist, aber das hat bei mir funktioniert:

1. Fügen Sie die Textdatei zu den Projektressourcen hinzu
2. Setzen Sie den Zugriffsmodifikator auf public, wie oben von Andrew Hill gezeigt

3. Lesen Sie den Text folgendermaßen:

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

Der Text, den ich zu den Ressourcen hinzugefügt habe: 'SomeText.txt'

Sie können auch diese vereinfachte Version der Antwort von @ dtb verwenden:

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

Ich habe gerade gelernt, dass Ihre Datei kein "" haben darf. (Punkt) im Dateinamen.

Templates.plainEmailBodyTemplate-de.txt -> Funktioniert !!!
Templates.plainEmailBodyTemplate.en.txt -> funktioniert nicht über GetManifestResourceStream ()

Wahrscheinlich, weil das Framework zwischen Namespaces und Dateinamen verwechselt wird ...

Bei all Ihren Kräften zusammen verwende ich diese Hilfsklasse, um Ressourcen aus jeder Assembly und jedem Namespace generisch zu lesen.

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();
            }
        }
    }
}

Ich habe eine eingebettete Ressourcentextdatei gelesen.

    /// <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));
    }

Stichprobe:

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

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

Ich weiß, dass dies alt ist, aber ich wollte nur auf NETMF (.Net MicroFramework) hinweisen. Sie können dies einfach tun:

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

Da hat NETMF nichtGetManifestResourceStream

Nachdem Sie alle hier veröffentlichten Lösungen gelesen haben. So habe ich es gelöst:

// 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 "";      
}

Die Antwort ist ganz einfach. Tun Sie dies einfach, wenn Sie die Datei direkt aus der Datei resources.resx hinzugefügt haben.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Mit dieser Codezeile wird der Text aus der Datei direkt aus der Datei gelesen und in die Zeichenfolgenvariable eingefügt.

Ich war verärgert, dass Sie immer den Namespace und den Ordner in die Zeichenfolge aufnehmen mussten. Ich wollte den Zugriff auf die eingebetteten Ressourcen vereinfachen. Deshalb habe ich diese kleine Klasse geschrieben. Fühlen Sie sich frei zu verwenden und zu verbessern!

Verwendungszweck:

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

Klasse:

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)));

}

Einige VS .NET-Projekttypen generieren keine .NET-Datei (.resx) automatisch. Mit den folgenden Schritten fügen Sie Ihrem Projekt eine Ressourcendatei hinzu:

1. Klicken Sie mit der rechten Maustaste auf den Projektknoten und wählen Sie Hinzufügen / Neues Element. Scrollen Sie zu Ressourcendatei. Wählen Sie im Feld Name einen geeigneten Namen aus, z. B. Ressourcen, und klicken Sie auf die Schaltfläche Hinzufügen.
2. Die Ressourcendatei Resources.resx wird dem Projekt hinzugefügt und kann im Lösungs-Explorer als Knoten angesehen werden.
3. Tatsächlich werden zwei Dateien erstellt, es gibt auch eine automatisch generierte C # -Klasse Resources.Designer.cs. Bearbeiten Sie es nicht, es wird von VS verwaltet. Die Datei enthält eine Klasse mit dem Namen Resources.

Jetzt können Sie eine Textdatei als Ressource hinzufügen, beispielsweise eine XML-Datei:

1. Doppelklicken Sie auf Resources.resx. Wählen Sie Ressource hinzufügen> Vorhandene Datei hinzufügen und scrollen Sie zu der Datei, die Sie einschließen möchten. Behalten Sie den Standardwert Intern für Zugriff ändern bei.
2. Ein Symbol steht für das neue Ressourcenelement. Wenn diese Option ausgewählt ist, werden im Eigenschaftenbereich die Eigenschaften angezeigt. Wählen Sie für XML-Dateien unter der Eigenschaft Codierung die Option Unicode (UTF-8) - Codepage 65001 anstelle der lokalen Standardcodepage aus. Wählen Sie für andere Textdateien die richtige Codierung dieser Datei aus, z. B. Codepage 1252.
3. Bei Textdateien wie XML-Dateien verfügt die Klasse Resourcesüber eine Eigenschaft vom Typ string, die nach der enthaltenen Datei benannt ist. Wenn der Dateiname z. B. RibbonManifest.xml lautet, sollte die Eigenschaft den Namen haben RibbonManifest. Den genauen Namen finden Sie in der Codedatei Resources.Designer.cs.
4. Verwenden Sie die Zeichenfolgeeigenschaft wie jede andere Zeichenfolgeeigenschaft, zum Beispiel : string xml = Resources.RibbonManifest. Die allgemeine Form ist ResourceFileName.IncludedTextFileName. Nicht verwenden, ResourceManager.GetStringda die get-Funktion der String-Eigenschaft dies bereits getan hat.

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;
    }
}

Dies ist eine Klasse, die Sie möglicherweise sehr praktisch finden, um eingebettete Ressourcendateien aus der aktuellen zu lesen 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());
    }
}

Für alle Leute, die nur schnell den Text einer fest codierten Datei in Winforms wollen;

1. Klicken Sie mit der rechten Maustaste auf Ihre Anwendung im Lösungs-Explorer> Ressourcen> Datei hinzufügen.
2. Klicken Sie darauf und setzen Sie auf der Registerkarte "Eigenschaften" den "Dateityp" auf "Text".
3. In Ihrem Programm Resources.<name of resource>.toString();lesen Sie einfach die Datei.

Ich würde dies nicht als Best Practice oder so empfehlen, aber es funktioniert schnell und macht das, was es tun muss.

Für Benutzer, die VB.Net verwenden

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()

Wo MyApplicationNameist der Namespace meiner Anwendung? Es ist nicht der Assemblyname. Dieser Name wird in den Projekteigenschaften (Registerkarte Anwendung) definiert.

Wenn Sie den richtigen Ressourcennamen nicht finden, können Sie die GetManifestResourceNames()Funktion verwenden

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

oder

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

oder

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

Lesen Sie die eingebettete TXT-Datei beim Laden des Formulars.

Stellen Sie die Variablen dynamisch ein.

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

Rufen Sie einen Try Catch an.

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.
}

Void für IncludeText () erstellen, Visual Studio erledigt dies für Sie. Klicken Sie auf die Glühbirne, um den CodeBlock automatisch zu generieren.

Fügen Sie Folgendes in den generierten Codeblock ein

Ressource 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 );
}

Ressource 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 );
}

Ressource 3

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

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

Wenn Sie die zurückgegebene Variable an einen anderen Ort senden möchten, rufen Sie einfach eine andere Funktion auf und ...

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);
  }

}

Dies wurde erreicht, eine Methode, um mehrere txt-Dateien zu kombinieren und ihre eingebetteten Daten in einem einzigen Rich-Text-Feld zu lesen. Das war mein gewünschter Effekt mit diesem Code-Beispiel.