texto - manejo de archivos en c# ejemplos

Cómo leer el archivo de texto de recursos incrustados

Question

¿Cómo leo un recurso incrustado (archivo de texto) utilizando StreamReader y lo devuelvo como una cadena? Mi script actual utiliza un formulario de Windows y un cuadro de texto que le permite al usuario encontrar 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();
}

Answer 1

Lea el archivo de texto incrustado 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 una prueba 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.

Coloque 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 varios archivos de texto y leer sus datos incrustados, dentro de un único cuadro de texto enriquecido. Cuál fue mi efecto deseado con esta muestra de Código.

Answer 2

Algo que acabo de enterarme ahora es que tu archivo no tiene permitido tener un "." (punto) en el nombre del archivo.

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

Probablemente porque el marco se confunde con los espacios de nombres vs nombre de archivo ...

Answer 3

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

Answer 4

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, puedes ir a resources.Designer.cs y ver cuál es el nombre del getter.

Answer 5

Después de leer todas las soluciones publicadas aquí. Así 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 "";
}

Answer 6

Eche un vistazo a esta página: http://support.microsoft.com/kb/319292

Básicamente, usted usa System.Reflection para obtener una referencia al ensamblado actual. A continuación, utiliza GetManifestResourceStream() .

Ejemplo, desde 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!");
}

Answer 7

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 mediante

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

Si lo necesita como una transmisión, entonces (de https://.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Answer 8

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

Answer 9

Me molestó que siempre tuvieras que incluir 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)));
}

Answer 10

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

El código de 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 a Embedded Resource

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

NOTA: Si agrega el archivo con este método, puede usar GetManifestResourceStream para acceder a él (vea la respuesta de @dtb).

Método 2: Agregar archivo a Resources.resx

Abra el archivo Resources.resx , use el cuadro desplegable para agregar el archivo, configure el Access Modifier como public .

NOTA: Si agrega el archivo con este método, puede usar Properties.Resources para acceder a él (vea la respuesta de @Night Walker).

Answer 11

Puede utilizar el método Assembly.GetManifestResourceStream :

1. Agrega los siguientes usos

   using System.IO;
   using System.Reflection;

2. Establecer propiedad del archivo relevante:
   Build Action parámetros con valor Embedded 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();
}

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

Un astuto obvio para obtener el nombre de recurso solo del nombre del archivo (al pasar las cosas del espacio de nombres):

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

Answer 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. configurar 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''

Answer 13

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

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

Ya que NETMF no tiene GetManifestResourceStream

Answer 14

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

Answer 15

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

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

Answer 16

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