Cómo leer el archivo de texto de recursos incrustado

693

¿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();
}
Yo.Cerrar
fuente

Respuestas:

1195

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();
    }
}
dtb
fuente
55
@ Me.Close: Echa un vistazo Environment.SpecialFolderpara obtener la carpeta del escritorio. Debe tener en cuenta que el recurso tendrá un espacio de nombres en función de su ruta dentro del proyecto, por lo que su nombre puede no ser justo file1.txt.
adrianbanks
15
El argumento para GetManifestResourceStreamnecesita la ruta como indica @adrian. Si se ayuda a nadie, ese camino es como lo muestra @SimpleCoder en el ejemplo: MyNamespace.Filename.Ext. Lo había intentado anteriormente, MyNamespace.Resources.Filename.Extpero eso da como resultado un nulo.
JYelton
61
Si su recurso no está directamente en la raíz del proyecto, sino en alguna subcarpeta, no olvide poner también el nombre de esta carpeta en resourceName (por ejemplo, "MyProjectNameSpace.MyProjectSubFolder.FileName.FileExtention")
Sasha
19
Vale la pena decir que el recurso "Build Action" debe establecerse como "Embedded Resource"
Illidan
77
Un punto importante no cubierto aquí. Si guardó su archivo como un tipo de codificación alternativo para hacer frente a caracteres extraños (en mi caso UTF8), puede recuperar un archivo vacío cuando lea la transmisión. Solucione esto especificando el tipo de codificación en el constructor del lector de flujo:using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
Kinetic
140

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 )

ingrese la descripción de la imagen aquí

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

ingrese la descripción de la imagen aquí

Aplazamiento de pago
fuente
55
Un tercer método es agregar el archivo al proyecto, luego establecer "Copiar al directorio de salida" en "Verdadero". En la compilación, el archivo se copia en el directorio de salida, y puede leer el archivo utilizando los medios normales. Ejemplo: en una aplicación WPF cuando desea mostrar una imagen.
Contango
Entonces, ¿configurar la acción de compilación para Resourceque no haga nada que le permita leer el elemento como un recurso? tienes que usar EmbeddedResourceo agregar a un Resources.resxarchivo?
Maslow
3
@Maslow Establecer la acción de compilación en 'Recurso' crea un recurso vinculado, mientras que establecer la acción de compilación en 'Recurso incorporado' compila el recurso en el ensamblaje de salida. El término 'recurso vinculado' es un término elegante para 'copiar el archivo en el directorio de salida en la compilación' (luego puede leer el archivo en tiempo de ejecución utilizando cualquier método normal). Para obtener más información sobre la diferencia entre estos dos tipos, consulte Agregar y editar recursos (Visual C #) en msdn.microsoft.com/en-us/library/7k989cfy(v=vs.90).aspx .
Contango
Si desea utilizar los recursos de esta manera, pero de forma dinámica, tal vez de esto: Properties.Resources.Your_resource_name escribir lo siguiente: Properties.Resources.ResourceManager.GetObject("Your_resource_name").
Lkor
86

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!");
   }
Chris Laplante
fuente
32
+1 Por incluir namespacecomo parte del nombre del recurso
Kirk Broadhurst
41
var auxList= System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames(); Este método podría ser muy útil cuando desee aprender el nombre exacto del recurso. (Tomado de la pregunta stackoverflow.com/questions/27757/… )
Oscar Foley
69

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). captura de pantalla de Visual Studio: pestaña Recursos

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)
Andrew Hill
fuente
11
También puede usar esto con un archivo de texto, en cuyo caso tendría: string jsonSecrets = YourNameSpace.Properties.Resources.YourFileName;
ouflak
30

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.

Caminante nocturno
fuente
55
¿Podrías explicar esto más? Cuando i-click-derecho> propiedades en un archivo en el explorador de soluciones, y después fijar Actiona Incorporated ressource, no tengo ningún Access Modifierscampo en el panel de propiedades. Además, no tengo una Propersites.Resourcesclase, recibo un The name 'Properties' does not exist in the current contexterror al compilar su código.
Suzanne Dupéron
2
Esto solo funcionará si incrusta el archivo Resources.resx, vea mi respuesta sobre los diferentes métodos para incrustar archivos en un proyecto.
Contango
13

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

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

ingrese la descripción de la imagen aquí

miciry89
fuente
2
Devolverá
12

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'

S_Teo
fuente
8

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();
    }
}
Timmerz
fuente
¿Estás seguro de eso? de acuerdo con este enlace, parece que estoy ... stackoverflow.com/questions/1065168/…
Timmerz
8

Algo que aprendí ahora es que no se permite que su archivo tenga un "." (punto) en el nombre del archivo.

UNA "."  en nombre de archivo no es bueno.

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

Peter Gfader
fuente
3
Lo siento. Esto está mal. Los puntos funcionan. (al menos funcionó para mí, NET4.5) No sé por qué tuvo este error.
Felix Keil
Sí, funcionan, pero actúan como separador de directorios. Templates.plainEmailBodyTemplate.en.txt buscará el recurso "\ Templates \ plainEmailBodyTemplate \ en.txt"
Peter Gfader
No. Lo intenté. GetManifestResourceStream puede acceder a recursos integrados con más de un punto en el nombre del archivo. (NET4.5)
Felix Keil
1
Tuve el mismo problema en .NET 4.5. Los archivos con puntos en el nombre ni siquiera se agregaron a la colección de recursos. El método de ensamblado. GetManifestResourceNames () me devuelve una lista vacía. Más tarde descubrí que el problema era solo con el código de idioma. ca.abcd.sk.crt no se agregó a los recursos mientras que ca.abcd.crt se agregó sin problemas.
a.farkas2508
1
Todavía correcto en 2020. Muchas gracias por esto, me estaba volviendo loco con esto.
ZeRemz
8

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();
            }
        }
    }
}
t3chb0t
fuente
3
más uno para el planeta capitán: P
Alok
4

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);
});
Harveyt
fuente
3

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

dreamwork801
fuente
3

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 "";      
}
Bill Moore
fuente
3

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.

Jamisco
fuente
2

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

}
Felix Keil
fuente
1
Y qué pasa con la solución súper simple: var resName = assembly.GetManifestResourceNames (). Where (i => i.EndsWith (fileName)). FirstOrDefault (); No funcionará si coloca directorios completos en el ensamblaje, pero de lo contrario es solo una línea;)
Harry
@Harry seguro de que puedes hacer esto. ¿Cómo se correlaciona esto con mi respuesta? ¿Quieres mejorar el Método GetStream? ¿Y cómo manejas la ambigüedad entonces?
Felix Keil
1
@Estevez usando el sistema; usando System.IO; usando System.Linq; usando System.Reflection;
Felix Keil
2
Por alguna razón, la clase no funciona cuando se coloca en otro proyecto. Los conjuntos de llamada y ejecución se refieren al conjunto con esta clase, no al que realmente ejecuta las pruebas. Sin inicialización estática y perezosa todo bien, aunque.
Brazalete rizado el
1
@CurlyBrace Gracias. La evaluación perezosa es un defecto real en esta respuesta, porque los ensamblajes de llamada y ejecución cambian dependiendo del contexto. Deben resolverse en cada acceso.
Felix Keil
2

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.
Dietrich Baumgarten
fuente
1
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;
    }
}
bytedev
fuente
0

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

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.

SwatDoge
fuente
0

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"))
Schlebe
fuente
-1

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.

MasterCassidy
fuente