Cómo leer el archivo de texto de recursos incrustado

¿Cómo leo un recurso incrustado (archivo de texto) usando StreamReadery lo devuelvo como una cadena? Mi script actual utiliza un formulario y cuadro de texto de Windows que permite al usuario buscar y reemplazar texto en un archivo de texto que no está incrustado.

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

Puedes usar el Assembly.GetManifestResourceStreamMétodo :

1. Agregue los siguientes usos

   using System.IO;
   using System.Reflection;

2. Establecer propiedad del archivo relevante:
   parámetro Build Actioncon valorEmbedded Resource

3. Usa el siguiente 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();
}

resourceNamees el nombre de uno de los recursos integrados en assembly. Por ejemplo, si incrusta un archivo de texto llamado "MyFile.txt"que se coloca en la raíz de un proyecto con un espacio de nombres predeterminado "MyCompany.MyProduct", entonces resourceNamees "MyCompany.MyProduct.MyFile.txt". Puede obtener una lista de todos los recursos en un ensamblaje utilizando el Assembly.GetManifestResourceNamesMétodo .

Un astuto obvio para obtener resourceNamesolo del nombre del archivo (pasando el espacio del nombre):

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

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

Puede agregar un archivo como recurso utilizando dos métodos separados.

El código C # requerido para acceder al archivo es diferente , dependiendo del método utilizado para agregar el archivo en primer lugar.

Método 1: Agregue el archivo existente, establezca la propiedad en Embedded Resource

Agregue el archivo a su proyecto, luego establezca el tipo en Embedded Resource.

NOTA: Si agrega el archivo usando este método, puede usarlo GetManifestResourceStreampara acceder a él (vea la respuesta de @dtb )

Método 2: agregar archivo a Resources.resx

Abra el Resources.resxarchivo, use el cuadro desplegable para agregar el archivo, configurado Access Modifieren public.

NOTA: Si agrega el archivo usando este método, puede usarlo Properties.Resourcespara acceder a él (consulte la respuesta de @Night Walker ).

Básicamente, se utiliza System.Reflectionpara obtener una referencia a la Asamblea actual. Entonces, lo usas GetManifestResourceStream().

Ejemplo, de la página que publiqué:

Nota : es necesario agregar using System.Reflection;para que esto funcione

   Assembly _assembly;
   StreamReader _textStreamReader;

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

En Visual Studio, puede incrustar directamente el acceso a un recurso de archivo a través de la pestaña Recursos de las propiedades del Proyecto ("Análisis" en este ejemplo).

Se puede acceder al archivo resultante como una matriz de bytes por

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

Si lo necesita como una secuencia, entonces (de https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Cuando agrega el archivo a los recursos, debe seleccionar sus Modificadores de acceso como públicos de lo que puede hacer algo como lo siguiente.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 es el nombre del archivo incrustado.

En realidad, puede ir a resources.Designer.cs y ver cuál es el nombre del getter.

agregando, por ejemplo, Testfile.sql Menú del proyecto -> Propiedades -> Recursos -> Agregar archivo existente

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

Sé que es un hilo viejo, pero esto es lo que funcionó para mí:

1. agregar el archivo de texto a los recursos del proyecto
2. establecer el modificador de acceso a público, como se muestra arriba por Andrew Hill

3. lee el texto así:

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

El texto que agregué a los recursos: 'SomeText.txt'

También puede usar esta versión simplificada de la respuesta de @ 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 aprendí ahora es que no se permite que su archivo tenga un "." (punto) en el nombre del archivo.

Templates.plainEmailBodyTemplate-en.txt -> Funciona !!!
Templates.plainEmailBodyTemplate.en.txt -> no funciona a través de GetManifestResourceStream ()

Probablemente porque el marco se confunde sobre espacios de nombres frente a nombre de archivo ...

Con todos sus poderes combinados, uso esta clase auxiliar para leer recursos de cualquier ensamblado y cualquier espacio de nombres de manera 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();
            }
        }
    }
}

Leí el uso de un archivo de texto de recurso incrustado:

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

Muestra:

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

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

Sé que esto es antiguo, pero solo quería señalar NETMF (.Net MicroFramework), puede hacer esto fácilmente:

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

Como NETMF no tieneGetManifestResourceStream

Después de leer todas las soluciones publicadas aquí. Así es como lo resolví:

// 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 respuesta es bastante simple, simplemente haga esto si agregó el archivo directamente desde resources.resx.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Con esa línea de código, el texto del archivo se lee directamente del archivo y se coloca en la variable de cadena.

Me molestó que tuvieras que incluir siempre el espacio de nombres y la carpeta en la cadena. Quería simplificar el acceso a los recursos integrados. Por eso escribí esta pequeña clase. ¡Siéntase libre de usar y mejorar!

Uso:

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

Clase:

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

}

Algunos tipos de proyectos VS .NET no generan automáticamente un archivo .NET (.resx). Los siguientes pasos agregan un archivo de Recursos a su proyecto:

1. Haga clic con el botón derecho en el nodo del proyecto y seleccione Agregar / Nuevo elemento, desplácese hasta Archivo de recursos. En el cuadro Nombre, elija un nombre apropiado, por ejemplo Recursos y haga clic en el botón Agregar.
2. El archivo de recursos Resources.resx se agrega al proyecto y se puede ver como un nodo en el explorador de soluciones.
3. En realidad, se crean dos archivos, también hay una clase C # autogenerada Resources.Designer.cs. No lo edite, lo mantiene VS. El archivo contiene una clase llamada Resources.

Ahora puede agregar un archivo de texto como recurso, por ejemplo, un archivo xml:

1. Haga doble clic en Resources.resx. Seleccione Agregar recurso> Agregar archivo existente y desplácese hasta el archivo que desea incluir. Deje el valor predeterminado Interno para Modificar acceso.
2. Un icono representa el nuevo elemento de recurso. Si se selecciona, el panel de propiedades muestra sus propiedades. Para archivos xml, en la propiedad Codificación, seleccione Unicode (UTF-8) - Página de códigos 65001 en lugar de la página de códigos local predeterminada. Para otros archivos de texto, seleccione la codificación correcta de este archivo, por ejemplo, la página de códigos 1252.
3. Para archivos de texto como archivos xml, la clase Resourcestiene una propiedad de tipo stringque lleva el nombre del archivo incluido. Si el nombre del archivo es, por ejemplo, RibbonManifest.xml, la propiedad debe tener el nombre RibbonManifest. Encontrará el nombre exacto en el archivo de código Resources.Designer.cs.
4. Utilice la propiedad de cadena como cualquier otra propiedad de la cadena, por ejemplo: string xml = Resources.RibbonManifest. La forma general es ResourceFileName.IncludedTextFileName. No lo use ResourceManager.GetStringya que la función get de la propiedad string ya lo ha hecho.

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 es una clase que puede resultarle muy útil para leer archivos de recursos incrustados del actual 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 las personas que solo quieren rápidamente el texto de un archivo codificado en winforms;

1. Haga clic con el botón derecho en su aplicación en el explorador de soluciones> Recursos> Agregar su archivo.
2. Haga clic en él y, en la pestaña de propiedades, configure el "Tipo de archivo" en "Texto".
3. En su programa solo haga Resources.<name of resource>.toString();para leer el archivo.

No recomendaría esto como práctica recomendada ni nada, pero funciona rápidamente y hace lo que debe hacer.

Para usuarios que usan 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()

donde MyApplicationNameestá el espacio de nombres de mi aplicación. No es el nombre del ensamblado. Este nombre se define en las propiedades del proyecto (pestaña Aplicación).

Si no encuentra el nombre de recurso correcto, puede usar la GetManifestResourceNames()función

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

Lea el archivo TXT incorporado en el evento de carga de formulario.

Establecer las variables dinámicamente.

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

Llame a un intento 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.
}

Crear vacío para IncludeText (), Visual Studio lo hace por usted. Haga clic en la bombilla para generar automáticamente el CodeBlock.

Ponga lo siguiente dentro del bloque de código generado

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

Si desea enviar la variable devuelta a otro lugar, simplemente llame a otra función y ...

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

}

Lo que esto logró fue esto, un método para combinar múltiples archivos txt y leer sus datos incrustados, dentro de un único cuadro de texto enriquecido. cual fue mi efecto deseado con esta muestra de Código.