So lesen Sie die eingebettete Ressource-Textdatei

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

Der für den Zugriff auf die Datei erforderliche C # -Code ist unterschiedlich , abhängig von der Methode, mit der die Datei an erster Stelle hinzugefügt wurde.

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

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 mit GetManifestResourceStream darauf zugreifen (siehe Antwort von @dtb).

Methode 2: Datei zu Resources.resx hinzufügen

Öffnen Sie die Resources.resx-Datei, fügen Sie die Datei über die Dropdown-Box hinzu, und setzen Sie Access Modifier auf public.

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

Schauen Sie sich diese Seite an: http://support.Microsoft.com/kb/319292

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

Beispiel von der Seite, die ich gepostet habe:

Note: Damit dies funktioniert, müssen Sie using System.Reflection; hinzufügen

   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 einbetten (in diesem Beispiel "Analytics").

Auf die resultierende Datei kann dann als Bytearray von zugegriffen werden 

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

Wenn 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 Zugriffsmodifizierer als "öffentlich" auswählen, als könnten Sie Folgendes machen.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 ist der Name der eingebetteten Datei.

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

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

1. fügen Sie die Textdatei den Projektressourcen hinzu 
2. setzen Sie den Zugriffsmodifizierer auf public, wie oben von Andrew Hill gezeigt 

3. lesen Sie den Text so:

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

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

hinzufügen von z. Testdatei.sql Projektmenü -> Eigenschaften -> Ressourcen -> Vorhandene Datei hinzufügen

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

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 -> Works !!!
Templates.plainEmailBodyTemplate.en.txt -> funktioniert nicht über GetManifestResourceStream ()

Wahrscheinlich weil das Framework über Namespaces vs. Dateiname verwirrt wird ...

Mit all Ihren Kräften kombiniere ich diese Hilfsklasse, um Ressourcen aus beliebigen Assemblys und Namespaces 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 Ressource-Textdatei 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));
    }

Probe:

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

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

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

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

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

DaNETMFkeine GetManifestResourceStream hat

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

}

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

Die Antwort ist ziemlich 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 Stringvariable eingefügt.

Eingebettete TXT -DATEI beim Formularladeereignis lesen.

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

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

Füge 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 zum Kombinieren mehrerer TXT-Dateien und Lesen der eingebetteten Daten in einem einzigen Rich Text-Feld. Das war mein gewünschter Effekt mit diesem Code-Beispiel.