Como ler o arquivo de texto de recurso incorporado

Como leio um recurso incorporado (arquivo de texto) usando StreamReadere o retorno como uma string? Meu script atual usa um formulário e caixa de texto do Windows que permite ao usuário localizar e substituir texto em um arquivo de texto que não está incorporado.

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

Você pode usar o Assembly.GetManifestResourceStreammétodo :

1. Adicione os seguintes usos

   using System.IO;
   using System.Reflection;

2. Definir propriedade do arquivo relevante:
   Parâmetro Build Actioncom valorEmbedded Resource

3. Use o seguinte código

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é o nome de um dos recursos incorporados assembly. Por exemplo, se você incorporar um arquivo de texto chamado "MyFile.txt"colocado na raiz de um projeto com espaço para nome padrão "MyCompany.MyProduct", resourceNameserá "MyCompany.MyProduct.MyFile.txt". Você pode obter uma lista de todos os recursos em uma montagem usando o Assembly.GetManifestResourceNamesmétodo .

Um esperto astuto para obter resourceNameapenas o nome do arquivo (passe o material do espaço para nome):

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

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

Você pode adicionar um arquivo como um recurso usando dois métodos separados.

O código C # necessário para acessar o arquivo é diferente , dependendo do método usado para adicionar o arquivo em primeiro lugar.

Método 1: Adicionar arquivo existente, defina a propriedade como Embedded Resource

Adicione o arquivo ao seu projeto e defina o tipo como Embedded Resource.

NOTA: Se você adicionar o arquivo usando esse método, poderá usá GetManifestResourceStream-lo para acessá-lo (consulte a resposta em @dtb ).

Método 2: Adicionar arquivo ao Resources.resx

Abra o Resources.resxarquivo, use a caixa suspensa para adicionar o arquivo, defina Access Modifiercomo public.

NOTA: Se você adicionar o arquivo usando este método, poderá usá Properties.Resources-lo para acessá-lo (consulte a resposta do @Night Walker ).

Basicamente, você usa System.Reflectionpara obter uma referência à montagem atual. Então você usa GetManifestResourceStream().

Exemplo, na página que publiquei:

Nota : é necessário adicionar using System.Reflection;para que isso funcione

   Assembly _assembly;
   StreamReader _textStreamReader;

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

No Visual Studio, você pode incorporar diretamente o acesso a um recurso de arquivo através da guia Recursos das propriedades do projeto ("Análise" neste exemplo).

O arquivo resultante pode ser acessado como uma matriz de bytes por

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

Se você precisar dele como um fluxo, então (em https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Quando você adicionou o arquivo aos recursos, deve selecionar seus Modificadores de Acesso como públicos, para fazer algo como o seguinte.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 é o nome do arquivo incorporado.

Na verdade, você pode acessar o resources.Designer.cs e ver qual é o nome do getter.

adicionando, por exemplo, o menu Projeto Testfile.sql -> Propriedades -> Recursos -> Adicionar arquivo existente

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

Eu sei que é um tópico antigo, mas é isso que funcionou para mim:

1. adicione o arquivo de texto aos recursos do projeto
2. defina o modificador de acesso como público, como mostrado acima por Andrew Hill

3. leia o texto assim:

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

O texto que eu adicionei aos recursos: 'SomeText.txt'

Você também pode usar esta versão simplificada da resposta da @ 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();
    }
}

Algo que aprendi agora é que seu arquivo não pode ter um "." (ponto) no nome do arquivo.

Templates.plainEmailBodyTemplate-en.txt -> Funciona !!!
Templates.plainEmailBodyTemplate.en.txt -> não funciona via GetManifestResourceStream ()

Provavelmente porque o framework fica confuso sobre namespaces vs nome do arquivo ...

Por todos os seus poderes combinados, eu uso essa classe auxiliar para ler recursos de qualquer assembly e qualquer namespace de maneira genérica.

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

Eu li um arquivo de texto de recurso incorporado:

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

Amostra:

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

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

Eu sei que isso é antigo, mas eu só queria destacar o NETMF (.Net MicroFramework), você pode fazer isso facilmente:

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

Como o NETMF não possuiGetManifestResourceStream

Depois de ler todas as soluções postadas aqui. Foi assim que eu resolvi:

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

A resposta é bastante simples, basta fazer isso se você adicionou o arquivo diretamente do resources.resx.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Com essa linha de código, o texto do arquivo é lido diretamente do arquivo e colocado na variável string.

Fiquei aborrecido por você sempre incluir o espaço para nome e a pasta na string. Eu queria simplificar o acesso aos recursos incorporados. Foi por isso que escrevi esta pequena turma. Sinta-se livre para usar e melhorar!

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

}

Alguns tipos de projeto do VS .NET não geram automaticamente um arquivo .NET (.resx). As etapas a seguir adicionam um arquivo de recursos ao seu projeto:

1. Clique com o botão direito do mouse no nó do projeto e selecione Adicionar / Novo Item, role para Arquivo de Recursos. Na caixa Nome, escolha um nome apropriado, por exemplo, Recursos e clique no botão Adicionar.
2. O arquivo de recurso Resources.resx é adicionado ao projeto e pode ser visto como um nó no gerenciador de soluções.
3. Na verdade, dois arquivos são criados, também há uma classe C # gerada automaticamente Resources.Designer.cs. Não edite, ele é mantido pelo VS. O arquivo contém uma classe chamada Resources.

Agora você pode adicionar um arquivo de texto como um recurso, por exemplo, um arquivo xml:

1. Clique duas vezes em Resources.resx. Selecione Adicionar recurso> Adicionar arquivo existente e vá até o arquivo que você deseja incluir. Deixe o valor padrão Internal for Access Modify.
2. Um ícone representa o novo item de recurso. Se selecionado, o painel de propriedades mostra suas propriedades. Para arquivos xml, na propriedade Codificação, selecione Unicode (UTF-8) - Página de códigos 65001 em vez da página de códigos local padrão. Para outros arquivos de texto, selecione a codificação correta desse arquivo, por exemplo, a página de código 1252.
3. Para arquivos de texto como arquivos xml, a classe Resourcespossui uma propriedade do tipo stringque é nomeada após o arquivo incluído. Se o nome do arquivo é, por exemplo RibbonManifest.xml, em seguida, a propriedade deve ter o nome RibbonManifest. Você encontra o nome exato no arquivo de código Resources.Designer.cs.
4. Use a propriedade string como qualquer outra propriedade de cadeia, por exemplo: string xml = Resources.RibbonManifest. A forma geral é ResourceFileName.IncludedTextFileName. Não use, ResourceManager.GetStringpois a função get da propriedade string já fez isso.

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

Esta é uma classe que você pode achar muito conveniente para ler arquivos de recursos incorporados do atual 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());
    }
}

Para todas as pessoas que desejam rapidamente o texto de um arquivo codificado em winforms;

1. Clique com o botão direito do mouse no seu aplicativo no Solution Explorer> Recursos> Adicionar seu arquivo.
2. Clique nele e, na guia de propriedades, defina o "FileType" como "Text".
3. No seu programa, basta fazer Resources.<name of resource>.toString();para ler o arquivo.

Eu não recomendaria isso como prática recomendada ou algo assim, mas funciona rapidamente e faz o que precisa.

Para usuários que estão usando o 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()

Onde MyApplicationName está o namespace do meu aplicativo. Não é o nome do assembly. Este nome é definido nas propriedades do projeto (guia Aplicativo).

Se você não encontrar o nome correto do recurso, poderá usar a GetManifestResourceNames()função

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

ou

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

ou

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

Leia o arquivo TXT incorporado no evento de carregamento de formulário.

Defina as variáveis ​​dinamicamente.

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

Chame uma tentativa de captura.

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

Criar void para IncludeText (), Visual Studio Faz isso por você. Clique na lâmpada para gerar automaticamente o CodeBlock.

Coloque o seguinte dentro do bloco de código gerado

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

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

Recurso 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 você deseja enviar a variável retornada para outro lugar, basta chamar outra função 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);
  }

}

O que isso foi alcançado foi um método para combinar vários arquivos txt e ler seus dados incorporados, dentro de uma única caixa de rich text. qual foi o efeito desejado com esse exemplo de código.