如何读取嵌入式资源文本文件

您可以使用 Assembly.GetManifestResourceStream Method：

使用 System.IO 添加以下用法；使用 System.Reflection；设置相关文件的属性：带有值 Embedded Resource 的参数 Build Action 使用以下代码 var assembly = Assembly.GetExecutingAssembly(); var resourceName = "MyCompany.MyProduct.MyFile.txt";使用 (Stream stream = assembly.GetManifestResourceStream(resourceName)) 使用 (StreamReader reader = new StreamReader(stream)) { string result = reader.ReadToEnd(); } resourceName 是嵌入在程序集中的资源之一的名称。例如，如果您嵌入了一个名为“MyFile.txt”的文本文件，该文件位于具有默认命名空间“MyCompany.MyProduct”的项目的根目录中，则 resourceName 为“MyCompany.MyProduct.MyFile.txt”。您可以使用 Assembly.GetManifestResourceNames 方法获取程序集中所有资源的列表。

仅从文件名中获取 resourceName 的明智之举（通过命名空间的东西）：

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

一个完整的例子：

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

---

您可以使用两种不同的方法将文件添加为资源。

访问文件所需的 C# 代码会有所不同，具体取决于最初用于添加文件的方法。

方法一：添加已有文件，设置属性为 Embedded Resource

将文件添加到您的项目中，然后将类型设置为 Embedded Resource。

注意：如果您使用此方法添加文件，则可以使用 GetManifestResourceStream 访问它（请参阅 answer from @dtb）。

https://i.stack.imgur.com/qimwi.png

方法2：将文件添加到Resources.resx

打开 Resources.resx 文件，使用下拉框添加文件，将 Access Modifier 设置为 public。

注意：如果您使用此方法添加文件，则可以使用 Properties.Resources 访问它（请参阅 answer from @Night Walker）。

https://i.stack.imgur.com/m56aJ.png

---

基本上，您使用 System.Reflection 来获取对当前程序集的引用。然后，您使用 GetManifestResourceStream()。

例如，从我发布的页面：

注意：需要添加 using System.Reflection; 才能使用

   Assembly _assembly;
   StreamReader _textStreamReader;

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

---

https://i.stack.imgur.com/Q5rXc.png

然后可以通过以下方式将生成的文件作为字节数组访问

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

如果您需要它作为流，那么（来自 https://stackoverflow.com/a/4736185/432976 ）

Stream stream = new MemoryStream(jsonSecrets)

---

当您将文件添加到资源中时，您应该选择它的访问修饰符作为公共而不是您可以进行如下操作。

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 是嵌入文件的名称。

其实你可以去resources.Designer.cs看看getter的名字是什么。

---

添加例如 Testfile.sql 项目菜单 -> 属性 -> 资源 -> 添加现有文件

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

https://i.stack.imgur.com/FFklR.png

---

我知道这是一个旧线程，但这对我有用：

将文本文件添加到项目资源中，将访问修饰符设置为公共，如 Andrew Hill 所示，阅读文本如下： textBox1 = new TextBox(); textBox1.Text = Properties.Resources.SomeText;

我添加到资源中的文本：'SomeText.txt'

---

我刚才学到的是，你的文件不允许有“.”。 （点）在文件名中。

https://i.stack.imgur.com/NuoOi.jpg

Templates.plainEmailBodyTemplate-en.txt --> 有效！！！ Templates.plainEmailBodyTemplate.en.txt --> 不能通过 GetManifestResourceStream() 工作

可能是因为框架对命名空间和文件名感到困惑......

---

您还可以使用@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();
    }
}

---

结合你的所有力量，我使用这个帮助程序类以通用方式从任何程序集和任何命名空间读取资源。

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

---

我知道这是旧的，但我只想指出 NETMF（.Net MicroFramework），你可以轻松地做到这一点：

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

由于 NETMF 没有 GetManifestResourceStream

---

我读了一个嵌入式资源文本文件使用：

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

样本：

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

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

---

某些 VS .NET 项目类型不会自动生成 .NET (.resx) 文件。以下步骤将资源文件添加到您的项目中：

右键单击项目节点并选择 Add/New Item，滚动到 Resources File。在名称框中选择适当的名称，例如资源，然后单击添加按钮。资源文件 Resources.resx 被添加到项目中，并且可以被视为解决方案资源管理器中的一个节点。实际上，创建了两个文件，还有一个自动生成的 C# 类 Resources.Designer.cs。不要编辑它，它由 VS 维护。该文件包含一个名为 Resources 的类。

现在您可以将文本文件添加为资源，例如 xml 文件：

双击 Resources.resx。选择添加资源 > 添加现有文件并滚动到要包含的文件。为访问修改保留默认值内部。一个图标代表新的资源项。如果选中，属性窗格将显示其属性。对于 xml 文件，在属性 Encoding 下选择 Unicode (UTF-8) – Codepage 65001 而不是默认的本地代码页。对于其他文本文件，请选择此文件的正确编码，例如代码页 1252。对于像 xml 文件这样的文本文件，资源类有一个字符串类型的属性，该属性以包含的文件命名。如果文件名是例如 RibbonManifest.xml，那么属性应该具有名称 RibbonManifest。您可以在代码文件 Resources.Designer.cs 中找到确切的名称。像使用任何其他字符串属性一样使用字符串属性，例如：string xml = Resources.RibbonManifest。一般形式是 ResourceFileName.IncludedTextFileName。不要使用 ResourceManager.GetString，因为字符串属性的 get-function 已经这样做了。

---

这是一个您可能会发现非常方便从当前 Assembly 读取嵌入资源文件的类：

using System.IO;
using System.Linq;
using System.Text;
using System.Reflection;

public static class EmbeddedResourceUtils
{
    public static string ReadFromResourceFile(string endingFileName)
    {
        var assembly = 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 = Path.GetDirectoryName(stringBuilder.ToString());
        return fileName == null ? null : new string(fileName.Reverse().ToArray());
    }
}

---

阅读此处发布的所有解决方案后。这就是我解决它的方法：

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

---

答案很简单，如果您直接从 resources.resx 添加文件，只需执行此操作即可。

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

使用那行代码，文件中的文本直接从文件中读取并放入字符串变量中。

---

我想以字节数组的形式读取嵌入式资源（不假设任何特定编码），最后我使用了 MemoryStream，这使得它非常简单：

using var resStream = assembly.GetManifestResourceStream(GetType(), "file.txt");
var ms = new MemoryStream();
await resStream .CopyToAsync(ms);
var bytes = ms.ToArray();

---

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

// To use the code above:
var reader = new AssemblyTextFileReader(assembly);

string text = await reader.ReadFileAsync(@"MyFile.txt");

---

我很生气您必须始终在字符串中包含名称空间和文件夹。我想简化对嵌入式资源的访问。这就是我写这个小班的原因。随意使用和改进！

用法：

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

班级：

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

}

---

正如 SonarCloud 所指出的，最好做：

public class Example
{
    public static void Main()
    { 
        // Compliant: type of the current class
        Assembly assembly = typeof(Example).Assembly; 
        Console.WriteLine("Assembly name: {0}", assem.FullName);

        // Non-compliant
        Assembly assembly = Assembly.GetExecutingAssembly();
        Console.WriteLine("Assembly name: {0}", assem.FullName);
    }
}

---

对于所有快速想要winforms中硬编码文件文本的人；

在解决方案资源管理器中右键单击您的应用程序 > 资源 > 添加您的文件。单击它，然后在属性选项卡中将“文件类型”设置为“文本”。在你的程序中只做 Resources..toString();读取文件。

我不建议将此作为最佳实践或任何东西，但它可以快速运行并完成它需要做的事情。

---

在表单加载事件中读取嵌入式 TXT 文件。

动态设置变量。

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

调用 Try Catch。

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

为 IncludeText() 创建 Void，Visual Studio 会为您执行此操作。单击灯泡以自动生成代码块。

将以下内容放入生成的代码块中

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

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

资源 3

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

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

如果您希望将返回的变量发送到其他地方，只需调用另一个函数并...

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

}

这样做的结果是，一种在单个富文本框中组合多个 txt 文件并读取其嵌入数据的方法。这是我对这个代码示例想要的效果。

---

对于使用 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()

其中 MyApplicationName 是我的应用程序的命名空间。它不是程序集名称。此名称在项目的属性（应用程序选项卡）中定义。

如果找不到正确的资源名称，可以使用 GetManifestResourceNames() 函数

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

或者

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

或者

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

---