Professional Documents
Culture Documents
Publicado el 09/Ene/2007
Actualizado el 09/Ene/2007
Autor: Guillermo 'guille' Som
En este artículo te explico cómo leer y guardar cosas en ficheros de texto usando funciones y clases del propio .NET Framework. Y como de costumbre, con
código tanto para Visual Basic como para C#.
Introducción:
Una de las operaciones más comunes o al menos que se hacen con bastante frecuencia en cualquier aplicación es la de leer y escribir en
ficheros, particularmente de texto, es decir, ficheros normales y corrientes, sin contenidos especiales.
Nota:
De cómo leer y escribir en ficheros que no sean "texto plano" nos ocuparemos en otra ocasión.
En este artículo veremos cómo realizar esas operaciones usando exclusivamente funciones y clases del propio .NET Framework. Aclaro
esto, porque en Visual Basic se pueden usar tanto las clases del propio .NET como las definidas en la librería/espacio de nombres
Microsoft.VisualBasic.
No te voy a explicar qué es eso de la codificación, ya que en la ayuda lo puedes leer, lo que te voy a decir es que en .NET, de forma
predeterminada, el formato o codificación usado para leer o escribir en los ficheros es UTF-8.
C#:
Como puedes comprobar, lo único que necesitamos es crear un objeto del tipo StreamWriter (definido en el espacio de
nombres System.IO), pasarle al constructor el nombre del fichero en el que queremos guardar y usar el método WriteLine al que le
indicamos como argumento la cadena que queremos guardar.
Ahora vamos a leer de un fichero y asignaremos el contenido del mismo a una variable.
El código para Visual Basic y C# sería el siguiente:
C#:
Console.WriteLine(texto);
En este caso también es muy simple, ya que solo necesitamos usar un objeto del tipo StreamReader, (también definido en el espacio de
nombres System.IO) al que le indicamos de que fichero queremos leer y por medio del método ReadToEnd leemos todo el contenido, el
cual asignamos a la variable que usemos en la asignación.
En estos dos ejemplos al no indicar lo contrario estamos usando la codificación predeterminada, es decir, UTF-8, por tanto, si escribimos
primero en ese fichero y después lo leemos, el texto se mostrará correctamente, a pesar de que en el primer ejemplo hayamos usado vocales
acentuadas y eñes.
Además de que al usar la clase StreamWriter de esa forma, si había un fichero con ese mismo nombre, se eliminará y se quedará el que
acabamos de escribir, es decir, se sustituye el contenido del fichero.
Para conseguir esto lo único que tenemos que hacer es indicar en el constructor de la clase StreamWriter un segundo argumento con un
valor verdadero.
De esa forma, si el fichero existe, se añadirá el texto al final de lo que ya tuviera. Si el fichero no existe, simplemente se creará y se guardará
el texto actual, pero no dará error de que no existe.
C#:
Como ves lo único que hay que hacer es indicar como segundo argumento del constructor de la claseStreamWriter un valor verdadero, y
de esa forma le indicamos que queremos agregar el texto al fichero.
Si en vez de usar un valor verdadero, indicas un valor falso (false) el comportamiento será como el del primer ejemplo, es decir, se
sobrescribirá el fichero eliminando lo que antes hubiera.
Por ejemplo, si queremos leer ficheros escritos por otros programas que usan la codificación estándar de Windows, por ejemplo los ficheros
creados con Visual Basic 6.0, debemos indicar que NO queremos usar el formato predeterminado, esto lo haremos de la siguiente forma:
C#:
Console.WriteLine(texto);
En este caso lo único que debemos hacer es indicar en el constructor de la clase StreamReader un segundo argumento que es la
codificación que queremos usar, en este caso System.Text.Encoding.Default.
Para escribir en esa codificación (o en cualquier otra) tendremos que indicar la codificación a usar en el tercer argumento del constructor de
la clase StreamWriter, ya que en el segundo debemos indicar si queremos agregar el texto a lo que ya tuviera o bien crear el fichero usando
solo el contenido que queremos guardar.
En caso de que queramos crear un fichero con el contenido que tenemos en una variable, usaremos el siguiente código:
C#:
Y si en vez de usar el valor "Default" queremos usar otro tipo de codificación, lo indicaremos en el tercer argumento, seleccionando uno de
los valores de la clase Encoding.
Debo aclarar que si usamos el valor UTF8, se guardará (o leerá) usando la codificación UTF-8, pero a la hora de guardarlo, se indicará al
principio del fichero que la codificación usada es UTF-8, esto es algo que no se guarda cuando no indicamos la codificación. Es decir, se
guarda en formato UTF-8, pero no se almacena nada que indique que ese es el formato del fichero.
Esto es lo que se conoce como BOM (Byte Order Marks), que no es otra cosa que una marca al principio del fichero en la que se indica la
codificación usada. Las tres codificaciones que almacenan valores BOM son: UTF-8, Unicode Little-Endian y Unicode Big-Endian, estos
dos últimos pueden ser UTF-16 o UTF-32 (este último solo en .NET Framework 2.0 o superior). Si quieres saber más sobre esto del BOM,
puedes ver en la ayuda de Visual Studio 2005 el método GetPreamble de la clase Encoding.
Utilizar una codificación para leer y escribir ficheros compatibles con MS-DOS
Si quieres escribir o leer ficheros compatibles con MS-DOS (no pienses que el Guille es muy viejo, que lo es, pero ese formato también
puedes usarlo si abres una ventana de comandos de Windows), puedes usar el valor 437 de la página de código, ese valor lo puedes obtener
mediante el método GetEncoding de la claseEncoding.
El siguiente código servirá para leer y guardar usando esa página de código:
C#:
System.IO.StreamWriter sw =
new System.IO.StreamWriter(fic, false, System.Text.Encoding.GetEncoding(437));
sw.WriteLine(texto);
sw.Close();
}
System.IO.StreamReader sr =
new System.IO.StreamReader(fic, System.Text.Encoding.GetEncoding(437), true);
texto = sr.ReadToEnd();
sr.Close();
Console.WriteLine(texto);
}
Recuerda que esa página de código (437) será válida para los ficheros creados con utilidades que trabajen con el "viejo" MS-DOS o bien los
que crees directamente usando una ventana de comandos de Windows.
Pero no será muy común que la uses... aunque si te hace falta, ya sabes cómo usarla.
Esto solo se puede hacer a la hora de leer el contenido del fichero, y será útil para los casos en los que no sepamos con certeza el formato
que se ha usado para guardar el fichero, de forma que si se ha usado uno de los formatos que almacenan los valores en el BOM, se use ese
formato, y si el fichero no tiene esa marca se use la que nosotros indiquemos.
C#:
System.IO.StreamWriter sw =
new System.IO.StreamWriter(fic, false, System.Text.Encoding.UTF8);
sw.WriteLine(texto);
sw.Close();
}
System.IO.StreamReader sr =
new System.IO.StreamReader(fic, System.Text.Encoding.Default, true);
texto = sr.ReadToEnd();
sr.Close();
Console.WriteLine(texto);
}
Para indicar que se use una codificación en concreto cuando no existe la marca BOM, debemos usar un valor verdadero después de indicar
la codificación que queremos usar.
En este ejemplo, se usará la codificación Default si no tiene esa marca.
En el método guardarTextoBOM, se guarda usando la codificación UTF8, de esa forma puedes comprobar que aunque
en leerTextoBOM se haya indicado Default, los caracteres "raros" se leerán correctamente, lo que demuestra que se está usando la
codificación correcta.
Si modificas el código del método leerTextoBOM para que no se detecte la codificación usada, (quitando el tercer argumento del
constructor de StreamReader), el texto se mostrará también correctamente, algo que no ocurrirá si en lugar de guardarlo como UTF-8 lo
hubiésemos guardado como Default y lo leyéramos comoUTF8, en ese caso, el texto mostrado sería el siguiente, que es lo que a algunos
les ocurre cuando leen ficheros de Visual Basic 6.0 sin indicar el valor Encoding.Default:
Bueno, pues esto es todo por ahora, espero que ahora tenga más claro cómo leer y guardar ficheros de texto usando las clases de .NET.
En otra ocasión te explicaré cómo leer ficheros "binarios" y cómo convertir ristras de bytes en texto y viceversa, pero eso será otro día, que
ya es noche ;-)))
Nos vemos.
Guillermo
Exportar DataGridView a fichero CSV C# C Sharp
Lenguaje de programación Visual C# .Net
Lo haremos desde C# 2010, El primer ejemplo como se hace de manera Manual y otro
exportando la informacion de un DataGridView al asrchivo .CSV.
if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK
&& saveFileDialog1.FileName.Length > 0)//***Aqui se evalua si le damos click en el
boton 'ok' de la ventana y si escribimos el nombre del archivo***//
{
int ban = 0;//***Esta es una variable bandera, que indicara si el archivo fue creado o
no lo fue.***//
try
{
FileInfo t = new FileInfo(saveFileDialog1.FileName);//***Se crea un objeto de la
clase FileInfo que recibe como parametro el nombre del Archivo***//
StreamWriter Tex = t.CreateText();//***Creamos un objeto StreamWriter donde se
guardara lo que vayamos escribiendo o el contenido del archivo CSV ***//
string cadena = "Columna1,Columna2,Columna3,Columna4";//*** En la variable 'cadena'
tipo string debe ir lo que ira en el primer renglon separado por ',' (COMAS), cada coma indica
la separacion de las columnas***//
Tex.WriteLine(cadena);//***Agrega el renglon al archivo StreamWrite***//
Tex.Write(Tex.NewLine);//***Escribe una nueva linea en el archivo***//
Tex.Close();//***Cierra el archivo***//
}
catch (Exception ex)
{
ban = 1;//Si existe algun error en el codigo del Try enciende la Bandera//
}
if (ban == 0)//Se evalua la Bandera, si no hubo error dice que el archio se creo
satisfactoriamente, en caso contrario dice que lo vuelvas a intentar
MessageBox.Show("El Archivo " + saveFileDialog1.FileName + " ha sido creado");
else
MessageBox.Show("No se pudo crear el archivo. Intente de Nuevo");
}
}
Ahora miraremos como crear el archivo y cargarlo con informacion de un DataGridView con 4
columnas.
if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK
&& saveFileDialog1.FileName.Length > 0)
{
int ban = 0;
try
{
FileInfo t = new FileInfo(saveFileDialog1.FileName);
StreamWriter Tex = t.CreateText();
int n = 0; //Creamos una variable entera que llevara el control del numero de
renglones que contiene el DataGridView//
foreach (DataGridViewRow row in gridNuevo.Rows)//Es un ciclo con un numero
de iteraciones que variara dependiendo del numero de columnas del Grid
{
Espero les sea de ayuda. Como tip en la creacion del archivo dinamico con un DataGridView
se puede crear un script que genere el numero de columnas de manera dinamica asi como
genera el numero de renglones.
Tutorial C#
Cuando llenemos el DataGridView debemos de especificar
en algún momento alguna columna de Cantidad, Piezas, Unidades
o como desees llamarlo donde tendrás valores numéricos los
cuales son los que queremos sumar pues para hacer este proceso
basta con hacer este pequeña operación, donde obtendremos el
valor de cada celda de una columna que especificaremos con el
Nombre "Cantidad" lo recorreremos y asignaremos el valor a un
control Label, el código a continuación:
double sumatoria = 0;
sumatoria += Convert.ToDouble(row.Cells["Cantidad"].Value);
lblTotal.Text = Convert.ToString(sumatoria);
When you select any Text or CSV file from Browser page then you get the full path of Text
or CSV file.
You will pass this path in the following function that will return the dbf file data in a
dataset.
public static DataTable GetDataTable(string strFileName)
{
ADODB.Connection oConn = new ADODB.Connection();
oConn.Open("Provider=Microsoft.Jet.OleDb.4.0; Data Source = " +
System.IO.Path.GetDirectoryName(strFileName) + "; Extended Properties =
\"Text;HDR=YES;FMT=Delimited\";", "","", 0);
string strQuery = "SELECT * FROM [" + System.IO.Path.GetFileName(strFileName)
+ "]";
ADODB.Recordset rs = new ADODB.Recordset();
System.Data.OleDb.OleDbDataAdapter adapter
= new System.Data.OleDb.OleDbDataAdapter();
DataTable dt = new DataTable();
rs.Open(strQuery, "Provider=Microsoft.Jet.OleDb.4.0; Data Source = " +
System.IO.Path.GetDirectoryName(strFileName) + "; Extended Properties =
\"Text;HDR=YES;FMT=Delimited\";",
ADODB.CursorTypeEnum.adOpenForwardOnly,
ADODB.LockTypeEnum.adLockReadOnly, 1);
adapter.Fill(dt, rs);
return dt;
}
You can easily show dataset data in Datagridview.
private void Import()
{
if (txtFileName.Text.Trim() != string.Empty)
{
try
{
DataTable dt = GetDataTable(txtFileName.Text);
dataGridView1.DataSource = dt.DefaultView;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString());
}
}
}
Output:
Convertir Número a Letras en C#
uando se realizan trabajos donde se necesita mostrar al cliente un
determinado monto de dinero, tipo factura, recibo, cheque, etc, el cliente
desea ver el monto en numeral asi como en literal.
Por ejemplo:
877866,50 = ochocientos setenta y siete mil ochocientos sesenta y seis
50/100 Bolivianos
namespace con_NumLetraC
{
class NumLetra
{
private String[] UNIDADES = { "", "un ", "dos ", "tres ", "cuatro ", "cinco ", "seis ",
"siete ", "ocho ", "nueve " };
private String[] DECENAS = {"diez ", "once ", "doce ", "trece ", "catorce ", "quince ",
"dieciseis ",
"diecisiete ", "dieciocho ", "diecinueve", "veinte ", "treinta ", "cuarenta ",
"cincuenta ", "sesenta ", "setenta ", "ochenta ", "noventa "};
private String[] CENTENAS = {"", "ciento ", "doscientos ", "trecientos ", "cuatrocientos ",
"quinientos ", "seiscientos ",
"setecientos ", "ochocientos ", "novecientos "};
private Regex r;
}
Esta clase, recibe un numero de 0,00 a 999999999.00 en formato String,
el separador decimal puede ser un punto (.) o una coma (,), ademas tiene
un parametro booleano “mayusculas” el cual sea verdadero (true) o falso
(false), retorna el resultado en mayusculas o minusculas, esta clase no
acepta numeros negativos ni tampoco numero mayores o iguales a mil
millones, aunque claro trate de escribir esta clase para que sea facilmente
comprensible y asi pueda ser ampliado o modificado segun sus
necesidades.
La forma de llamara a esta clase es:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace con_NumLetraC
{
class Program
{
static void Main(string[] args)
{
NumLetra nl = new NumLetra();
numero = "34557.70";
Console.WriteLine(nl.Convertir(numero, false));
numero = "4357,60";
Console.WriteLine(nl.Convertir(numero, true));
numero = "969.90";
Console.WriteLine(nl.Convertir(numero, false));
Console.ReadKey();
}
}
}
Y al ejecutar el proyecto tenemos:
FIN