Leer y escribir en ficheros de texto

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.

Los formatos (codificación) de los ficheros

Antes de empezar "de verdad" con la forma de leer y escribir en los ficheros mediante las clase de .NET, debemos saber que en .NET se
pueden leer y escribir los ficheros usando diferentes codificaciones.

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.

¿Qué problema hay con esto?

Ninguno, al menos si siempre lees y escribes usando las clases de .NET, pero si tu intención es poder leer un fichero guardado, por ejemplo,
con una aplicación de Visual Basic 6 (o el Notepad de Windows), o quieres que lo que tu guardes se pueda abrir también con cualquier otra
aplicación, deberás tener cuidado con la codificación usada.
Al menos si el contenido de ese fichero tiene caracteres como la eñe, vocales acentuadas, signos de apertura de admiración o interrogación,
etc., ya que en esos casos, el formato usado por defecto por otras aplicaciones para Windows no será el adecuado, y esos caracteres no se
leerán correctamente.
Por tanto, si decides que lo que vas a guardar o leer debe ser "compatible", tendrás que usar la codificación predeterminada de Windows
(ANSI), esa codificación puedes indicarla mediante la clase Encoding (definida en el espacio de nombres System.Text) y usando el
valor Default, después verás ejemplos de cómo usar esos valores a la hora de leer o de escribir en un fichero.

Leer y escribir ficheros de texto

Leer y escribir en ficheros de texto es lo más sencillo del mundo, (al menos cuando se sabe cómo hacerlo, je, je), ya que lo podemos hacer
usando un par de líneas de código.

Veamos un ejemplo de cómo guardar en un fichero el contenido de una cadena de texto:

C#:

const string fic = @"E:\tmp\Prueba.txt";

string texto = "Érase una vez una vieja con un moño...";

System.IO.StreamWriter sw = new System.IO.StreamWriter(fic);

sw.WriteLine(texto);
sw.Close();

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#:

const string fic = @"E:\tmp\Prueba.txt";

string texto;

System.IO.StreamReader sr = new System.IO.StreamReader(fic);

texto = sr.ReadToEnd();
sr.Close();

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.

Anexar contenido a un fichero existente

Antes de ver otras cosas, veamos cómo agregar contenido a un fichero, es decir, si ese fichero existe, lo que haremos es añadir más
contenido, de forma que después de escribir, lo que tendrá será lo que antes hubiere más lo que ahora escribamos.

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.

Veamos el código para añadir texto a un fichero existente (o crearlo si no existe):

C#:

private static void agregarTexto() {

const string fic = @"E:\tmp\Prueba.txt";
string texto = "Pablito tenía una moto con un pito.";

System.IO.StreamWriter sw = new System.IO.StreamWriter(fic, true);

sw.WriteLine(texto);
sw.Close();
}

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.

Usar una codificación específica

Como te he comentado antes, si no indicamos lo contrario, los ficheros se leerán y se guardarán usando la codificación UTF-8. Pero si
queremos usar una distinta, debemos indicarlo de forma expresa.

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#:

const string fic = @"E:\tmp\Prueba2.txt";

string texto;

System.IO.StreamReader sr = new System.IO.StreamReader(fic, System.Text.Encoding.Default);

texto = sr.ReadToEnd();
sr.Close();

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#:

const string fic = @"E:\tmp\Prueba2.txt";

string texto = "Érase una vez una vieja con un moño...";

System.IO.StreamWriter sw = new System.IO.StreamWriter(fic, false, System.Text.Encoding.Default);

sw.WriteLine(texto);
sw.Close();
Por supuesto, si lo que queremos hacer es agregar el texto al fichero, en vez de usar false en el segundo argumento, debemos usar true.

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#:

private static void guardarTexto437()

{
const string fic = @"E:\tmp\Prueba4.txt";
string texto = "Érase una vez una vieja con un moño...";

System.IO.StreamWriter sw =
new System.IO.StreamWriter(fic, false, System.Text.Encoding.GetEncoding(437));
sw.WriteLine(texto);
sw.Close();
}

private static void leerTexto437()

{
const string fic = @"E:\tmp\Prueba4.txt";
 string texto;

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.

Indicar una codificación si no existe un valor BOM

Para terminar, vamos a ver cómo podemos abrir un fichero para que intente detectar el valor BOM del fichero, si es que hay alguno, y en
caso de que no exista esa marca se use la codificación que indiquemos.

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#:

private static void guardarTextoBOM()

{
const string fic = @"E:\tmp\Prueba5.txt";
string texto = "Érase una vez una vieja con un moño...";

System.IO.StreamWriter sw =
new System.IO.StreamWriter(fic, false, System.Text.Encoding.UTF8);
sw.WriteLine(texto);
sw.Close();
}

private static void leerTextoBOM()

{
 const string fic = @"E:\tmp\Prueba5.txt";
string texto;

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:

?rase una vez una vieja con un mo?o...

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

Explicamos cómo exportar el contenido de un DataGridView a un fichero de

texto plano separado por punto y coma, que se puede abrir con Office Excel,
OpenOffice Calc o con LibreOffice Calc, incluso con cualquier editor de texto
plano (notepad, vi, nano).

dlGuardar.Filter = "Fichero CSV (*.csv)|*.csv";

dlGuardar.FileName = "Datos_sqlite";
dlGuardar.Title = "Exportar a CSV";
if (dlGuardar.ShowDialog() == DialogResult.OK)
{
StringBuilder csvMemoria = new StringBuilder();

//para los títulos de las columnas, encabezado

for (int i = 0; i < dbTabla.Columns.Count; i++)
{
if (i == dbTabla.Columns.Count - 1)
{
csvMemoria.Append(String.Format("\"{0}\"",
dbTabla.Columns[i].HeaderText));
}
else
{
csvMemoria.Append(String.Format("\"{0}\";",
dbTabla.Columns[i].HeaderText));
}
}
csvMemoria.AppendLine();

for (int m = 0; m < dbTabla.Rows.Count; m++)

{
for (int n = 0; n < dbTabla.Columns.Count; n++)
{
//si es la última columna no poner el ;
if (n == dbTabla.Columns.Count - 1)
{
csvMemoria.Append(String.Format("\"{0}\"",
dbTabla.Rows[m].Cells[n].Value));
}
else
{
csvMemoria.Append(String.Format("\"{0}\";",
dbTabla.Rows[m].Cells[n].Value));
}
}
csvMemoria.AppendLine();
}
System.IO.StreamWriter sw =
new System.IO.StreamWriter(dlGuardar.FileName, false,
System.Text.Encoding.Default);
sw.Write(csvMemoria.ToString());
 sw.Close();
}
Donde:
* dlGuardar: componente de tipo SaveFileDialog.
* dbTabla: componente de tipo DataGridView con los datos a exportar a fichero.

Crear Archivos CSV en C#

En esta ocasion publicare como crear un archivo de separacion por comas (.CSV) que se
utilizan comunmente por Microsoft EXCEL en compatibilidad con sistemas informaticos de
gestion de recursos humanos y otros.

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.

private void ExportarExcel()

{
saveFileDialog1.Filter = "csv files (*.csv)|*.csv";//***Se asigna un filtro para la pantalla
de dialogo para guardar el archivo en el directorio de tu preferencia***//

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.

private void ExportarExcel()

{

saveFileDialog1.Filter = "csv files (*.csv)|*.csv";

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
{

string cadena = gridNuevo.Rows[n].Cells[0].Value.ToString() + "," +

gridNuevo.Rows[n].Cells[1].Value.ToString() + "," +
gridNuevo.Rows[n].Cells[2].Value.ToString() + "," +
gridNuevo.Rows[n].Cells[3].Value.ToString();
Tex.WriteLine(cadena);
n += 1;
}
Tex.Write(Tex.NewLine);
Tex.Close();
}
catch (Exception ex)
{
ban = 1;
}
if (ban == 0)
MessageBox.Show("El Archivo " + saveFileDialog1.FileName + " ha sido creado");
else
MessageBox.Show("No se pudo crear el archivo. Intente de Nuevo");
}

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:

//Variable donde almacenaremos el resultado de la sumatoria.

double sumatoria = 0;

//Método con el que recorreremos todas las filas de nuestro Datagridview

foreach (DataGridViewRow row in gvGastos.Rows)

//Aquí seleccionaremos la columna que contiene los datos numericos.

sumatoria += Convert.ToDouble(row.Cells["Cantidad"].Value);

//Por ultimo asignamos el resultado a el texto de nuestro Label

lblTotal.Text = Convert.ToString(sumatoria);

Print textbox contents in C#

PrintDocument document = new PrintDocument();

PrintDialog dialog = new PrintDialog();
public Form1()
{
InitializeComponent();
document.PrintPage += new PrintPageEventHandler(document_PrintPage);
}

void document_PrintPage(object sender, PrintPageEventArgs e)

{
 e.Graphics.DrawString(textBox1.Text, new Font("Arial", 20,
FontStyle.Regular), Brushes.Black, 20, 20);
}

private void btnPrint_Click(object sender, EventArgs e)

{
dialog.Document = document;
if (dialog.ShowDialog() == DialogResult.OK)
{
document.Print();
}
}

Import Data from Text and CSV file to DataGridView

in .Net
First add a browser control, TextBox, Button and a DataGridView Control on form
Add the following code in Button Click Event

private void button1_Click_1(object sender, EventArgs e)

{
OpenFileDialog fdlg = new OpenFileDialog();
fdlg.Title = "Select file";
 fdlg.InitialDirectory = @"c:\";
fdlg.FileName = txtFileName.Text;
fdlg.Filter = "Text and CSV Files(*.txt, *.csv)|*.txt;*.csv|Text Files(*.txt)|*.txt|CSV
Files(*.csv)|*.csv|All Files(*.*)|*.*";
fdlg.FilterIndex = 1;
fdlg.RestoreDirectory = true;
if (fdlg.ShowDialog() == DialogResult.OK)
{
txtFileName.Text = fdlg.FileName;
Import();
Application.DoEvents();
}
}

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

Pues bien, la siguiente clase a la

que llame NumLetra.cs realiza justamente esa operacion, esta
extracomentada y trate de hacerla lo mas entendible posible. El proyecto
en C#, lo llame con_NumLetraC
La lógica que se utiliza es la siguiente:
La clase recibe un numero ej. 123456789,50
valida este número, si el número no es válido devuelve NULL
Si el número es válido según sea este unidad, decena, centena, mil o
millón, va clasificando el número y llama a sus procedimientos
correspondientes, estas funciones, son utilizadas en cascada, ósea:
nuestro número de ejemplo es 123456789,50, entonces separa en
123456789 y 50, siendo 50 nuestra parte decimal.
El numero entero, 123456789 es clasificado = es millón, entonces llama a
la función getMillones, esta función a la vez divide el numero en miles y
millones
123456789 = 123 456789 donde 123 corresponde a millones y 456789 a
miles
entonces la misma función llama a las funciones getMiles, getCentenas,
getUnidades, segun corresponda, al igual que la funcion getMiles, hace
uso de getCentenas, getDecenas getUnidades, lo mismo getCentenas,
hace uso de getDececas, getUnidades.
Espero se entienda
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

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;

public String Convertir(String numero, bool mayusculas) {

String literal = "";

String parte_decimal;
//si el numero utiliza (.) en lugar de (,) -> se reemplaza
numero = numero.Replace(".", ",");

//si el numero no tiene parte decimal, se le agrega ,00

 if(numero.IndexOf(",")==-1){
numero = numero + ",00";
}
//se valida formato de entrada -> 0,00 y 999 999 999,00
r = new Regex(@"\d{1,9},\d{1,2}");
MatchCollection mc = r.Matches(numero);
if (mc.Count > 0) {
//se divide el numero 0000000,00 -> entero y decimal
String[] Num = numero.Split(',');

//de da formato al numero decimal

parte_decimal = Num[1] + "/100 Bolivianos.";
//se convierte el numero a literal
if (int.Parse(Num[0]) == 0) {//si el valor es cero
literal = "cero ";
}
else if (int.Parse(Num[0]) > 999999)
{//si es millon
literal = getMillones(Num[0]);
}
else if (int.Parse(Num[0]) > 999)
{//si es miles
literal = getMiles(Num[0]);
}
else if (int.Parse(Num[0]) > 99)
{//si es centena
literal = getCentenas(Num[0]);
}
else if (int.Parse(Num[0]) > 9)
{//si es decena
literal = getDecenas(Num[0]);
} else {//sino unidades -> 9
literal = getUnidades(Num[0]);
}
//devuelve el resultado en mayusculas o minusculas
if (mayusculas) {
return (literal + parte_decimal).ToUpper();
} else {
return (literal + parte_decimal);
}
} else {//error, no se puede convertir
return literal = null;
}
}

/* funciones para convertir los numeros a literales */

private String getUnidades(String numero)

{ // 1 - 9
//si tuviera algun 0 antes se lo quita -> 09 = 9 o 009=9
String num = numero.Substring(numero.Length - 1);
return UNIDADES[int.Parse(num)];
}
 private String getDecenas(String num)
{// 99
int n = int.Parse(num);
if (n < 10)
{//para casos como -> 01 - 09
return getUnidades(num);
}
else if (n > 19)
{//para 20...99
String u = getUnidades(num);
if (u.Equals(""))
{ //para 20,30,40,50,60,70,80,90
return DECENAS[int.Parse(num.Substring(0, 1)) + 8];
}
else
{
return DECENAS[int.Parse(num.Substring(0, 1)) + 8] + "y " + u;
}
}
else
{//numeros entre 11 y 19
return DECENAS[n - 10];
}
}

private String getCentenas(String num)

{// 999 o 099
if (int.Parse(num) > 99)
{//es centena
if (int.Parse(num) == 100)
{//caso especial
return " cien ";
}
else
{
return CENTENAS[int.Parse(num.Substring(0, 1))] +
getDecenas(num.Substring(1));
}
}
else
{//por Ej. 099
//se quita el 0 antes de convertir a decenas
return getDecenas(int.Parse(num) + "");
}
}

private String getMiles(String numero)

{// 999 999
//obtiene las centenas
String c = numero.Substring(numero.Length - 3);
//obtiene los miles
String m = numero.Substring(0, numero.Length - 3);
String n = "";
//se comprueba que miles tenga valor entero
 if (int.Parse(m) > 0)
{
n = getCentenas(m);
return n + "mil " + getCentenas(c);
}
else
{
return "" + getCentenas(c);
}

private String getMillones(String numero)

{ //000 000 000
//se obtiene los miles
String miles = numero.Substring(numero.Length - 6);
//se obtiene los millones
String millon = numero.Substring(0, numero.Length - 6);
String n = "";
if (millon.Length > 1)
{
n = getCentenas(millon) + "millones ";
}
else
{
n = getUnidades(millon) + "millon ";
}
return n + getMiles(miles);
}

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

String numero = "57.60";

Console.WriteLine(nl.Convertir(numero,true));

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:

Conexión a base de datos Access con

C#
En este post veremos como conectarnos a una base de datos Access con
C#
En un nuevo proyecto en consola con Visual Studio llamado “AccessCon”
pegamos el siguiente código:
01 using System;
02 using System.Collections.Generic;
03 using System.Linq;
04 using System.Text;
05 using System.Data.OleDb;//Para base de datos Access
06
07 namespace AccessCon
08 {
09 class Program
10 {
11 static void Main(string[] args)
12 {
13 OleDbConnection con;//Representa una conexión abierta a un origen de datos
14 String ds = "E:/dbproblem.mdb"; //direccion de la base de datos Access
15 String stringConexion = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+ds;
16
17 try {
18 con = new OleDbConnection(@stringConexion);
19 con.Open();//se abre una conexion
20 Console.WriteLine("Conectado a la base de datos.");
21 con.Close();//se cierra la conexion
22 Console.WriteLine("La conexion ha terminado.");
23 }
24 catch (System.Exception ex)
25 {
26 Console.WriteLine("ERROR:" + ex.Message);
27 }
28
29 Console.WriteLine("Presione cualquier tecla para terminar");
30 Console.ReadKey();
31 }
32 }
33 }
05 Lo primero que debemos hacer es añadir la referencia
a “System.Data.OleDb”que nos permite trabajar con base de datos access.
14 Declaramos una variable String que contendrá la dirección de nuestra
base de datos, en este caso se llama “dbproblem.mdb” y se encuentra en
la raiz del disco E:\
15 Declaramos nuestra cadena de conexión donde se indica el proveedor
de la base de datos “Microsoft.Jet.OLEDB.4.0″ y se completa la cadena
con la base de datos con la que queremos trabajar.
17,24 Abrimos un Try/Catch para manejar los problemas que pudiéramos
tener
18,22 Abrimos una conexión a la base de datos Access mostramos un
mensaje de éxito y cerramos la conexión.
26 Si ocurriera algún problema lo mostramos en pantalla
Ejecuta y tendremos:

FIN