Ir arriba

Lenguaje C, C++, C#
Funciona bajo paradigma "Orientado a Objetos".
Permite:
  • Optimizar la creatividad heurística para Empresa/Internet.
  • Operar en bajo nivel y estructuras de alto nivel.
  • Mezclar códigos ensamblador con C o acceder a memoria o dispositivos periféricos.
  • Usar palabras clave con parámetros por valor o por referencia a funciónes.
  • Usar bibliotecas de funciones matemáticas y manejo de ficheros.
  • Intercalar Objetos, Controles, Interfaces de Múltiples Documentos
  • Intercambio Dinámico de Datos, mensajería, Multitarea en Windows
Control
Clases
Fichero
Puntero
Lista
Cola
Pila
Arbol

Programar en C:
Implica las siguientes acciones:
  1. Analiza el PROBLEMA
    Define el proceso de solución.
    Ejemplo:
    Problema: Agenda telefónica
    Solución:
    Una agenda como mínimo: Guardará/Mostrará/Borrará nombres y números telefónicos de contactos

  2. Diseña ALGORITMOS
    Es la secuencia ordenada de pasos para resolver el problema, abarca:
    a) Entrada de datos a procesar
    b) Procesamiento de datos
    c) Salida de resultados

    Ejemplo: Agenda telefónica
    Solución:
    Los algoritmos deben guardar los nombres y números telefónicos de tus contactos
    a) Entrada: Grabar en una ficha de un archivo cada Nombre y Número telefónico.
    b) Borrar una ficha del archivo permanente los datos.
    c) Salida: Mostrar en pantalla los datos de la agenda
    Graficando este proceso:

    
                Inicio
                  |
                  v    
                  |---------<-----------
                  |                     |
             ====Display====            |
             | Contacto:   |         ----------
             |  1-Nuevo    |          Ejecutar
             |  2-Borrar   |          la opción 
             |  3-Ver      |          elegida 
             | Elige Opción|         ----------
            ================            |      
                   |                    |
                   v                    |
                   |                    |
                  /\                    |     
                 /  \                   |     
                /Hay \                  |
                opcion ---Si-->----------                
                \    /           
                 \  / 
                  \/ 
                   |
                   No 
                   |
                   v
                  Fin             
    
    Siempre los algoritmos deben:
    a) Ser precisos que describan el orden de ejecución de cada paso.
    b) Tener una cantidad finita de pasos.
    c) Ser independientes del lenguaje de programación.
    d) Generar los mismos resultados al alimentarlos con los mismos datos.

  3. Codifica los ALGORITMOS
    Para ello, adopta un lenguaje adecuado.

    Ejemplo: Agenda telefónica
    Solución:
    Codifiquemos el algoritmo anterior en lenguaje C: Con este fin:
    - Ejecuta paso a paso las indicaciones siguientes y aún NO te preocupes por entender esta codificación.
    - Solo mira como luce un programa codificado en "C".
    - Mas adelante te describiré detalladamente cada parte de estos algoritmos.

    
    using System;
    using System.IO;
    
    namespace Agenda
    {
        public class Clase
        {
            char resp;
            string salida = "";
    
            public Clase()
            {
            }
    
            private void menu()
            {
                Clase C = new Clase();
    
                do
                {
                    salida = "NO";
                    Console.Clear();
                    Console.WriteLine("==== AGENDA de WILO ======");
                    Console.WriteLine("*                         *");
                    Console.WriteLine("*  1) NUEVO contacto      *");
                    Console.WriteLine("*  2) BORRAR contacto     *");
                    Console.WriteLine("*  3) VER mis contactos   *");
                    Console.WriteLine("*  4) Salir               *");
                    Console.WriteLine("*                         *");
                    Console.WriteLine("===========================");
                    ConsoleKeyInfo info = Console.ReadKey(true);
                    resp = info.KeyChar;
                    switch (resp)
                     {
                        case '1': C.Agregar();
                            break;
                        case '2': C.Eliminar(0);
                            break;
                        case '3': C.Eliminar(1);
                            break;
                        case '4': salida = "SI";
                            break;
                        default: Console.WriteLine("\nOpción incorrecta");
                            break;
                     }
                } while (salida != "SI");
            }
    
            private void Agregar()
            {
                Console.Clear();
    
                string lectura = "";
                string nombre = "";
                string tel = "";
    
                Console.WriteLine("Nombre:");
                nombre = Console.ReadLine();
                Console.WriteLine("Teléfono:");
                tel = Console.ReadLine();
    
                StreamReader lector = new StreamReader("Agenda.txt");            
                StreamWriter escritor = new StreamWriter("AgendaBACK.txt");
    
                while ((lectura = lector.ReadLine()) != null)
                {
                    escritor.WriteLine(lectura);
                }
                lector.Close();
    
                escritor.WriteLine(nombre);
                escritor.WriteLine(tel);
                escritor.Close();
    
                File.Delete("Agenda.txt");
                File.Copy("AgendaBACK.txt", "Agenda.txt");
                File.Delete("AgendaBACK.txt");
            }
    
            private void Eliminar(int num)
            {
                if (num == 0)
                {
                  Console.Clear();
                  StreamReader lector = new StreamReader("Agenda.txt");
    
                  string lectura = "";
                  string busqueda = "";
    
                  while ((lectura = lector.ReadLine()) != null)
                  {
                    Console.WriteLine(lectura);
                    lectura = lector.ReadLine();
                    Console.WriteLine(lectura);
                    Console.WriteLine("************");
                    }
                    lector.Close();
    
                    Console.WriteLine("Digita nombre del contacto a borrar");
                    busqueda = Console.ReadLine();
    
                    lector = new StreamReader("Agenda.txt");
                    StreamWriter escritorback = new StreamWriter("AgendaBACK.txt");
                    while ((lectura = lector.ReadLine()) != null)
                    {
                        if (lectura == busqueda)
                        {
                            lector.ReadLine();
                        }
                        else
                        {
                            escritorback.WriteLine(lectura);
                        }
                    }
                    escritorback.Close();
                    lector.Close();
                    File.Delete("Agenda.txt");
                    File.Copy("AgendaBACK.txt", "Agenda.txt");
                    File.Delete("AgendaBACK.txt");
                }
                else
                {
                    Console.Clear();
                    StreamReader lector = new StreamReader("Agenda.txt");
    
                    string lectura = "";
    
                    while ((lectura = lector.ReadLine()) != null)
                    {
                      Console.WriteLine(lectura);
                      lectura = lector.ReadLine();
                      Console.WriteLine(lectura);
                      Console.WriteLine("****************************");
                    }
                    lector.Close();
                    Console.WriteLine("'Enter' para ir al menú principal");
                    Console.ReadLine();
                }
            }
    
            static void Main()
            {
              if (!File.Exists("Agenda.txt"))
               {
                StreamWriter escritor = new StreamWriter("Agenda.txt");
                escritor.Close();
               }
               Clase C = new Clase();
               C.menu();
            }
        }
    }
    
  4. Ejecuta el PROGRAMA
    Ejemplo: Agenda telefónica
    Solución:
    Sigue los 4 pasos siguientes:
    • Paso 1: Crea tu Proyecto

      1.- Ingresa a Microsoft Visual Studio.Net, luego Clickea
      - - | Start | , | Programs | , | Microsoft Visual Studio .NET | Microsoft Visual Studio .NET.

      2.- Dentro de Microsoft Visual Studio.NET: | menú File | New | y | Project |
      - - Aparece la ventana de diálogo New Project.
      - - Dentro de Project Types, selecciona la carpeta Visual C++ Projects.
      - - Dentro de Templates Seleccionar Win32 Project para abrir el asistente.
      - - En la caja de texto Name escribe el nombre del proyecto “MiAgenda” Presionar luego OK.

      3.- Define la configuración de tu aplicación y selecciona Console application como tipo de aplicación.
      - - Seleccionar Empty project (proyecto en blanco) como opción adicional.

      4.- Click en Finish para cerrar el asistente.

    • Paso 2:
      Introduce el Código de tus algoritmos

      2.1.- En el menú View, selecciona Solution Explorer.

      2.2.- En Project, selecciona Add New Item. | En ventana Templates: C++File(.cpp) | En caja texto Name: escribe “agenda”.

      2.3.- Copia con el mause la codificación anterior, luego pega en el editor y graba. ( Se guarda como agenda.cpp )

    • Paso 3: COMPILA:
      Presiona Ctrl + F7

    • Paso 4: EJECUTA:
      Presiona Ctrl + F5 y veras aparecer en tu pantalla . .

      Esta agenda telefónica te permite:

      1.- GRABAR tus contatos:
      - Nombre
      - Telefono
      2.- BORRAR un contacto
      3.- VER tus contactos

En los siguientes links te describo paso a paso el contenido de este ejemplo

C: CONTROLES
Datos
Controles
Funciones

DATOS:
Son la información a procesar con los programas y se organizan en:

1.- DATO SIMPLE

2.- DATO ESTRUCTURADO

ESTRUCTURAS DE CONTROL:

A.- ESTRUCTURAS DE SELECCION

a.- SELECCIÓN SIMPLE:
La estructura If Else opera asi:


             |
            / \
      --<- Condi ->--          If (Condi)
     |      \ /      |            {
  ------          ------           Opc 1
   Opc 1           Opc 2          }
  ------          ------        else
     |               |            {
     ---->--------<---             Opc 2
              |                    } 
              V                  
  Ejemplo:
                    if (lectura == busqueda)
                       {
                        lector.ReadLine();
                       }
                    else
                       {
                        escritorback.WriteLine(lectura);
                        }

b.- SELECCIÓN MULTIPLE:
SELECCIÓN IF ELSE IF, selección es típica en C y permite efectuar varias comparaciones sucesivas


             |
            / \
           Cond1 -->-          If (Cond1)
            \ /      |            {
             |    ------           Opci 1
             V    Opci 1          }
             |    ------         else If (Cond2)
             |       |            {
            / \      V             Opci 2
           Cond2 -->-|             }
            \ /      |             
             |     ------           
             V     Opci 2                
             |     ------              
             |       V 
             |---<----   
  Ejemplo:       
 If ( equivalencia == yardas)
   Valor = largo / 3;
   else if ( equivalencia == pulgadas)
   Valor = largo * 12;
  else if ( equivalencia == metros)
   Valor = ( largo * 12 * 2.54 ) / 100;
 else
   prinf ( "termina la conversión.!!";

c.- SELECCIÓN MULTIPLE SWITCH:
Permite una entre múltiples opciones mediante una variable "Selector"
que puede tomar distintos valores Constante1, Constante2, hasta ConstanteN, o puede direccionar acción/es por defecto.
Con break hace que se ignore la parte restante de la instrucción switch.
si se omite break el programa continuaría en operando las acciones de default. Ejemplo:

                
  switch (resp)
    {
       case '1': C.Agregar();
                break;
       case '2': C.Eliminar(0);
                break;
       case '3': C.Eliminar(1);
               break;
       case '4': salida = "SI";
                break;
       default: Console.WriteLine("\nOpción incorrecta");
                break;
     }

B.- ESTRUCTURAS DE ITERACION
Repeticiones o iteraciones o ciclos donde uno o grupo de instrucciones se repiten mientras se cumpla la condición de continuidad.
Se usa bloques FOR, WHILE y DO WHILE y la cantidad de iteraciones se controla por:
- Validación de la expresión booleana planteada en una condición.
- Condiciones de error que alteran el bucle tal como "break" o "exit" y "continue".

  1. BUCLES "FOR" O ITERACIÓN CONTROLADA POR CONTADOR O ITERACIÓN DEFINIDA:
    Usa una variable de control para registrar el número de iteraciones; cuando esta alcanza su valor máximo predefinido el ciclo concluye.
    Pueden haber dos variables de control y además en su sintaxis se pueden omitir partes.
    EJEMPLO: Para generar la tabla de multiplicar del número 5

    for ( Contador = 1; Contador = 10; Contador = Contador + 1 )
    printf("%d\n", 5," x ",Contador, " = ", 5 * Contador );

    También, podemos lograr el mismo resultado con
    for ( Contador = 1; Contador = 50; Contador ++ )
    printf ( " %d \ n ", 5 , " x " , Contador, " = ", 5 * Contador )

  2. BUCLE WHILE O ITERACIÓN CONTROLADA POR CENTINELA O ITERACIÓN INDEFINIDA:
    El "valor centinela" controla el número de tales iteraciones. En estos ciclos, se pueden usar dos alternativas:

    - 2.a.- CICLO WHILE:
    El número de bucles comienza en cero, luego puede no efectuarse ninguna acción operativo. Ejemplo:

    
            |       
            |----<---
            V       |
            |   ---------          while (Condi)
            |   Operacion           {
            |   ---------             Operacion
            |       |               } 
           / \      |
          Condi ->--       
           \ /  
            |
            V  
      Ejemplo: 
      
      while ((lectura = lector.ReadLine()) != null)
         {
            Console.WriteLine(lectura);
            lectura = lector.ReadLine();
            Console.WriteLine(lectura);
            Console.WriteLine("*****************");
          }
    

    - 2.b.- CICLO DO WHILE:
    El número de bucles comienza en uno; luego al menos se efectuará un ciclo operativo. Ejemplo:

    
                 |       
                 |----<---
                 V       |
             ---------   |    do
             Operacion   |     {
             ---------   |      Operacion
                 |       |      } 
                / \      |     while (Condi)
               Condi ->--       
                \ / 
                 |
                 V               
      Ejemplo:
       do
    	 {
    	   Opcion=VerMenu();
    	   LeyDeOhm(Opcion);
    	 }
       while  ( ( Opcion != 's'  ) && ( Opcion != 'S' ) );
    

3.- DATO ESTANDAR

- Texto: char
- Entero: int
- Flotante: float
- Doble precisión: double
- Enumarado: enum
- Sin valor: void
- Puntero:

OPERADORES:
Son instrucciones codificadas para generar acciones para producir efectos determinados. Dentro de ellos los más comununes son:

- Desplazamiento izquierdo: << Mueve los bits hacia la izquierda. Ejemplo Valor<<=1; cout << Valor

- Desplazamiento derecho: >> Mueve los bits hacia la derecha. Ejemplo Valor>>=1; prinf("%d",Valor)

- Incremento: Valor = Valor + 1 equivale a Valor++; o también ++Valor;

- Decremento: Valor = Valor - 1 equivale a Valor-; o también -Valor;

- Aritméticos: Suma(+); resta(-); multiplicación(*); división(/) y módulo(%) Este último es el resto de la división de los enteros.

- Asignación: Simple (=) ejemplo: Valor = Valor + Incremento;

- Compuesto: el ejemplo anterior se puede escribir como: Valor + = Incremento.

- Relacionales: Igual(==), distinto(¡=), mayor(>), menor(<), mayor o igual (>=), menor o igual (<=).

- Lógicos: And ( && ), OR ( || ), NOT ( ¡ )

BIBLIOTECA ESTANDAR:
Evita la reiteración de escribir siempre las mismas rutinas. Definen:

- Iostream.h Rutinas básicas de flujo de entrada y salida

- Fstream.h Flujos que soportan entrada y salida de archivos.

- Graphics.h Prototipos para las funciones gráficas

- Stdio.h Rutinas básicas de flujo de entrada y salida

INGRESO Y SALIDA de datos:
Opera los datos como flujos o secuencias o "stream" de bytes, usando tres tipos de funciones:

- 1- Entrada salida orientadas a Flujo:
Tanto los datos simples como los archivos de datos son procesados como un flujo de caracteres individuales,
Cuando el programa usa una función de flujo para abrir un archivo de E/S, este se asocia con la estructura de tipo FILE,
predefinida por la función "stdio.h" que posee la información básica del archivo.

- 2- Entrada salida orientadas a Consola y puerto:
Permiten escribir en una terminal, o una consola, o en un puerto de entrada o salida como la impresora.
En todos estos casos la información llega como un flujo de bytes.

- 3- Entrada salida orientadas a Bajo nivel:
Funciones que usan capacidades directas del sistema operativo, ninguna de estas usan memoria intermedia, ni formateo.
Acceden a archivos o dispositivos periféricos a nivel más básico que el usado por las funciones de flujo,
devuelven un valor entero, como identificador para referirse a tal archivo en acciones posteriores.

C: ESTRUCTURAS
Array, Vector, Matriz
Funciones
Clases

DATOS ESTRUCTURADOS:

C++NET
Clases
Fichero
Puntero
Lista
Cola
Pila
Arbol

C++.NET: Abarca tecnologías de bloques de estructuras tipo armazón o Framework como soporte de trabajo, de la infraestructura de la plataforma ".NET", sobre la cual convergen herramientas y servicios para desarrollar sistemas en lenguajes, C#.NET, J#.NET, Jscript, Visual Basic.NET, C++.NET y más.

Visual C++ proporciona bibliotecas que ayudan a escribir código para las aplicaciones, incluyendo la biblioteca ATL (Active Template Library, un conjunto de clases de C++ basadas en plantillas para objetos COM), Servidor Active Template Library (un conjunto de clases de C++ nativo para crear aplicaciones Web, servicios Web y otras aplicaciones de servidor) y Microsoft Foundation Classes (un conjunto de clases compatibles con aplicaciones escritas para la API de Windows).

Extensiones administradas de C++:
Crear una nueva aplicación o componente, puedes utilizar tus conocimientos actuales de C++ para escribir código administrado con las extensiones administradas de C++. Cuando utilizas las extensiones administradas, obtienes los beneficios de la compatibilidad y de los servicios que proporciona Common Language Runtime (como la administración de memoria, integración entre lenguajes, seguridad de acceso a código y control automático de la vida de los objetos).
Ejemplo:

Las primeras líneas del código ‘saludo1.cpp’ corresponde al comentario que se hace del programa.
El símbolo // le indica al compilador que ignore esas líneas.


   ///////////////////////////////////////////
   //  saludo1.cpp            Wilo Carpio
   //  proyecto en C++.NET de Visual studio.Net
   ///////////////////////////////////////////

Las líneas siguientes son instrucciones del preprocesador.


   #include "stdafx.h"
   #using < mscorlib.dll>
   using namespace System;

La función _tmain( ) indica donde comienza la ejecución del programa y finaliza con return.


int _tmain()
{
    printf("!BIENVENIDO A VISUAL STUDIO .NET (Wilo Carpio)!");        
    Console::ReadLine();
    return 0;
}

C# CSharp
Aplicación de Consola
Windows
Matriz
Pisis
Super
A pulmón
Automata
Cadena
Bonus

Trataré de mostrarte el manejo de variables implementadas automáticamente, los métodos extensores, métodos parciales, expresiones lambda, árboles de expresiones, las consultas integradas.

Visual C#: Matriz
Aplicacion Windows
Cadena Chomsky

Aplica el siguiente proceso:


///////////////////////////////////////////////////////////
// C# PROGRAMA CONSOLA MODELO BASE 2006 Wilo Carpio
// Manejo de estructuras simples 230806
// Control de datos sin archivo
// Clases y Vectores
///////////////////////////////////////////////////////////
using System;
using System.Runtime.InteropServices;

namespace ModeloBase2006
{
 public class ClaseWilo
 {
 [STAThread]
 //////////////////////////////////////////////////
 // FUNCION PRINCIPAL
 //////////////////////////////////////////////////
 static void Main(string[] args)
 {
 MiClaseMenu ClaseMenu = new MiClaseMenu();

 string ClienteNombre;
 string[] NombreyPrecioDelProducto = new String[50];
 string[] NombreDelProducto = new String[50];
 double[] PrecioDelProducto = new double[50];
 string[] NominaDeClientes = new String[50];
 string[,] Articulo = new string[20, 20];
 int TotalComprasRealizadas = 0, OpcionPrincipal, ClienteNumero = 0;
 double MontoEnCaja = 0;

 Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear();
 ClaseMenu.MarcoDobleConTitulo("\t SOFTWARE LOCO");

		 do
		 {
		 OpcionPrincipal = ClaseMenu.OpcionMenuPrincipal();
		 switch (OpcionPrincipal)
		 {
		 //////////////////////////////////////////////////
		 // OPCION DE VENTAS
		 //////////////////////////////////////////////////
		 case 1:
		 int Indice = -1;
		 double SubTotalCaja = 0;
		 do
		 {
		 MenuVentas:
		 Console.Clear();
		 MatrizProductos(Articulo);
		 switch (VerMatriz(Articulo, "\n\t\t PRODUCTOS DISPONIBLES"))
		 {
		 case 1:
		 Indice++;
		 NombreDelProducto[Indice] = Articulo[1, 1];
		 PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[1, 2]);
		 NombreyPrecioDelProducto[Indice] = "\t" + Articulo[1, 1] + "\t $" + Articulo[1, 2];
		 break;
		 case 2:
		 Indice++;
		 NombreDelProducto[Indice] = Articulo[2, 1];
		 PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[2, 2]);
		 NombreyPrecioDelProducto[Indice] = "\t" + Articulo[2, 1] + "\t $" + Articulo[2, 2];
		 break;
		 case 3:
		 Indice++;
		 NombreDelProducto[Indice] = Articulo[3, 1];
		 PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[3, 2]);
		 NombreyPrecioDelProducto[Indice] = "\t" + Articulo[3, 1] + "\t $" + Articulo[3, 2];
		 break;
		 case 4:
		 Indice++;
		 NombreDelProducto[Indice] = Articulo[4, 1];
		 PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[4, 2]);
		 NombreyPrecioDelProducto[Indice] = "\t" + Articulo[4, 1] + "\t $" + Articulo[4, 2];
		 break;
		 default:
		 Aguarda("METISTE MAL EL DEDO.");
		 goto MenuVentas;
		 }
		 TotalComprasRealizadas = TotalComprasRealizadas + 1;
		 SubTotalCaja = SubTotalCaja + PrecioDelProducto[Indice];
		 }
		 while (OtraVez("Queres comprar otro producto"));
		 MontoEnCaja = MontoEnCaja + SubTotalCaja;
		 ClienteNumero = ClienteNumero + 1;
		 ClienteNombre = LeerNombreCliente();
		 NominaDeClientes[ClienteNumero] = "\t" + ClienteNombre + "\t $" + SubTotalCaja / 100;
		 ImprimeTicket(ClienteNombre, NombreyPrecioDelProducto, Indice, SubTotalCaja);
		 break;

		 //////////////////////////////////////////////////
		 // OPCION REPORTE TOTAL
		 //////////////////////////////////////////////////
		 case 2:
		 VerReporteDelDia(NominaDeClientes, ClienteNumero, MontoEnCaja);
		 break;
		
		 //////////////////////////////////////////////////
		 // OPCION ARTICULOS COMPRADOS
		 //////////////////////////////////////////////////
		 case 3:
		 VerProductosComprados(NombreDelProducto, TotalComprasRealizadas);
		 break;
		
		 //////////////////////////////////////////////////
		 // OPCION ACERCA DE
		 //////////////////////////////////////////////////
		 case 4: Console.Clear();
		 ClaseMenu.MarcoDobleConTitulo("\twww.wilocarpio.com");
		 Aguarda(" Visual Studio 2005 \n" + " Autor: Wilo Carpio ");
		 break;
		
		 //////////////////////////////////////////////////
		 // SALIR DEL PROGRAMA
		 //////////////////////////////////////////////////
		 case 5: Aguarda("CERRARAS EL PROGRAMA.."); break;
		 default: Aguarda(OpcionPrincipal + " METISTE MAL EL DEDO"); break;
		 }
		 }
		 while (OpcionPrincipal != 5);
		 }
		
		
		 //////////////////////////////////////////////////
		 // MIEMBROS DE LA CLASE
		 //////////////////////////////////////////////////
		 static void TrazarRayaSimple(int TotalRayitas)
		 {
		 int i;
		 Console.ForegroundColor = ConsoleColor.Red;
		 for (i = 1; i <= TotalRayitas; i++) Console.Write("─");
		 Console.ForegroundColor = ConsoleColor.DarkBlue;
		 }
		
		 static bool OtraVez(string Pregunta)
		 {
		 bool Respuesta = false;
		 string Opcion;
		 Console.Write("\n\t" + Pregunta + "? (s/n)");
		 Opcion = Console.ReadLine();
		 if ((Opcion == "s") || (Opcion == "S"))
		 Respuesta = true;
		 return Respuesta;
		 }

		 static void Aguarda(string Mensaje)
		 {
		 Console.Write("\n ");
		 Console.BackgroundColor = ConsoleColor.Red; Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write(" " + Mensaje + "..!!\n");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" ");
		 Console.BackgroundColor = ConsoleColor.Red;
		 Console.ForegroundColor = ConsoleColor.White; Console.Write(" ENTER para seguir ");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue;
		 Console.ReadLine();
		 }
		
		 static string LeerNombreCliente()
		 {
		 string nomCliente;
		 TrazarRayaSimple(78);
		 Console.Write("\n Nombre del cliente: "); nomCliente = Console.ReadLine();
		 return nomCliente;
		 }

		 static void MatrizProductos(string[,] Articulo)
		 {
		 Articulo[1, 1] = "Sistema Ventas y Facturación Win 1.0";
		 Articulo[1, 2] = "300.00";
		 Articulo[2, 1] = "Soft de Administración de Personal";
		 Articulo[2, 2] = "200.00";
		 Articulo[3, 1] = "Sistema Liquidación de Impuestos";
		 Articulo[3, 2] = "250.00";
		 Articulo[4, 1] = "Soft de Control de Compras y Stock";
		 Articulo[4, 2] = "300.00";
		 }
		 static void RotuloAzul(string TextoDelRotulo)
		 {
		 Console.ForegroundColor = ConsoleColor.White; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Blue;
		 Console.Write(TextoDelRotulo + "\n");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue;
		 }
		
		 static int VerMatriz(string[,] MatrizDeDatos, string Titulo)
		 {
		 MiClaseMenu ClaseMenu = new MiClaseMenu();
		 int i;
		 ClaseMenu.MarcoDobleConTitulo(Titulo);
		 RotuloAzul(" Art Precio Denominacion ");
		 for (i = 1; i <= 4; i++)
		 Console.WriteLine("\t {0}{1}{2}{3}{4}", i, "\t", MatrizDeDatos[i, 2], "\t", MatrizDeDatos[i, 1]);
		 TrazarRayaSimple(78);
		 Console.Write("\n\t ¿Qué producto deseas comprar?: ");
		 int Opcion = Convert.ToInt32(System.Console.ReadLine());
		 return Opcion;
		 }
		
		 static void ImprimeTicket(string NombreCliente, string[] NombreyPrecioDelProducto, int iMax, double subTotal)
		 {
		 MiClaseMenu ClaseMenu = new MiClaseMenu();
		 ClaseMenu.MarcoDobleConTitulo("\n TICKET - " + " Sr/Sra: " + NombreCliente + "\t" + DateTime.Now);
		 TrazarRayaSimple(78); Console.WriteLine("");
		 RotuloAzul(" Art Denominacion Precio ");
		 for (int j = 0; j <= iMax; j++)
		 Console.WriteLine("\t" + (j + 1) + NombreyPrecioDelProducto[j]);
		 Console.WriteLine("\n\t\t\t\t\t TOTAL : $" + subTotal / 100);
		 TrazarRayaSimple(78);
		 Aguarda("Gracias por tu compra");
		 }
		
		 static void VerReporteDelDia(string[] Cliente, int TotalClientes, double MontoEnCaja)
		 {
		 MiClaseMenu ClaseMenu = new MiClaseMenu();
		 ClaseMenu.MarcoDobleConTitulo("\n\n REPORTE DÍA " + DateTime.Now);
		 TrazarRayaSimple(78);
		 Console.WriteLine("\n Nomina de Clientes: " + TotalClientes);
		 RotuloAzul(" Cliente Compra $ ");
		 for (int NroCliente = 0; NroCliente <= TotalClientes; NroCliente++)
		 Console.WriteLine("\t" + Cliente[NroCliente]);
		 Console.WriteLine("\n Recaudación : $" + MontoEnCaja / 100 + "\n");
		 TrazarRayaSimple(78);
		 Aguarda("No hay mas ventas");
		 }
		
		 static void VerProductosComprados(string[] ProductoComprado, int TotalCompras)
		 {
		 MiClaseMenu ClaseMenu = new MiClaseMenu();
		 ClaseMenu.MarcoDobleConTitulo("\n\n NOMINA PRODUCTOS VENDIDOS DÍA " + DateTime.Now);
		 TrazarRayaSimple(78);
		 RotuloAzul(" Articulo comprado Compra $ ");
		 for (int NroCompra = 0; NroCompra <= TotalCompras; NroCompra++)
		 Console.WriteLine("\t" + ProductoComprado[NroCompra]);
		 TrazarRayaSimple(78);
		 Aguarda("Esto es todo lo vendido");
		 }
		 }

PARADIGMA: OLVÍDA de que tu eres indispensable en tu trabajo, tu casa o tu grupo habitual.
Por más que eso te desagrade, todo camina sin tu actuación, salvo tu mismo. ( Wilucha )

		 ///////////////////////////////////////////////////////////////
		 // OTRA CLASE
		 ///////////////////////////////////////////////////////////////
		 public class MiClaseMenu
		 {
		 public void MarcoDobleConTitulo(string Mensaje)
		 {
		 int i;
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear();
		 Console.Write("\n"); Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
		 Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" ");
		 Console.BackgroundColor = ConsoleColor.DarkYellow;
		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.White;
		 Console.Write(" C#: MODELO BASICO SIMPLE 2006 "); Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write(" WILUCHA 1.0 "); Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
		 Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Red;
		 Console.WriteLine("\t\t\t\t\t\t" + Mensaje); Console.ForegroundColor = ConsoleColor.White;
		 }

		 public int OpcionMenuPrincipal()
		 {
		 MarcoDobleConTitulo(""); int i;
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" ");
		 Console.ForegroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗");
		 Console.BackgroundColor = ConsoleColor.DarkGreen; Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Red;
		 Console.Write(" M E N U "); Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" ");
		 Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("╠"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╣");
		
		 Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow;
		
		 Console.Write(" 1 → OPERACION DE VENTAS "); Separacion();
		 Console.Write(" 2 → REPORTE TOTAL VENTAS "); Separacion();
		 Console.Write(" 3 → VER ARTICULOS VENDIDOS "); Separacion();
		 Console.Write(" 4 → Acerca de.. "); Separacion();
		 Console.Write(" "); Separacion();
		 Console.Write(" 5 → SALIR "); Console.ForegroundColor = ConsoleColor.Yellow;
		
		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝");
		 Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Red;
		 Console.Write("\n\n\t Digita opción (Luego ENTER): ");
		 int OpcionElegida = Convert.ToInt32(Console.ReadLine());
		 return OpcionElegida;
		 }
		
		 public void Separacion()
		 {
		 Console.ForegroundColor = ConsoleColor.Yellow;
		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.BackgroundColor = ConsoleColor.Yellow;
		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen;
		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow;
		 }
		
		 }
		 ///////////////////////////////////////////////////////////////
		 // Fin del programa
		 ///////////////////////////////////////////////////////////////
		}

PARADIGMA: Disfruta de las cosas simples.
Ríe más a menudo, fuerte y por largo tiempo.
Ríe hasta que te quedes sin aire ( Wilucha )

EJEMPLO 2 DE MATRICES


using System;

namespace Matriz
{
	class Class1
	{
		[STAThread]
		static void Main()
		{
			int I,J,n,m,May,Men,IMayor,JMayor,Ran,IMenor,JMenor,SF,SC;
			int[]V;
			V = new int [100];
			int[,] A = new int[10,10];
			
			Console.WriteLine("=================================================");
			Console.WriteLine("\t MATRICES C# Wilo Carpio 2006");
			Console.WriteLine("=================================================");
			Console.WriteLine("\n CARGA LA MATRIZ");
			Console.WriteLine(" Digita la cantidad de:");
			Console.Write("\n Filas = ");
			n=Int32.Parse(Console.ReadLine());
			Console.Write(" Columnas = ");
			m=Int32.Parse(Console.ReadLine());
			////////////////////////////////
			// Carga de la matriz
			////////////////////////////////
			for(I=1; I<=n; I++)
			{
				Console.WriteLine("\n Fila["+I+"]");
				for(J=1; J<=m;J++)
				{
					Console.Write(" A("+I+","+J+")= ");
					A[I,J]=Int32.Parse(Console.ReadLine());
				}
			}
			////////////////////////////////
			// Mostrar la matriz
			////////////////////////////////
			Console.WriteLine("\n MATRIZ CARGADA:");
			for(I=1; I<=n; I++)
			{
				for(J=1; J<=m;J++)
				{
				Console.Write(A[I,J]);
				Console.Write(" ");
				}
				Console.WriteLine("\n");
			}
			////////////////////////////////
			// Calculos de la matriz
			////////////////////////////////
			May=A[1,1];
			Men=A[1,1];
			for(I=1;I<=n;I++)
			{
				for(J=1;J<=m;J++)
				{
					if(A[I,J]>May)
					{
						May=A[I,J];
						IMayor=I;
						JMayor=J;
					}
					if(A[I,J]< Men)
					{
						Men=A[I,J];
						IMenor=I;
						JMenor=J;
					}
				}
			}
			Ran=May-Men;
			Console.WriteLine("Rango = "+Ran);
			Console.WriteLine("SUMA de los elementos de las filas");
			for(I=1;I<=n;I++)
			{
				SF=0;
				for(J=1;J<=m;J++)
				{
					SF=A[I,J]+SF;
				}
				Console.WriteLine("Fila" +I+ "="+SF);
			}
			Console.WriteLine("SUMA de los elementos de las Columnas");
			for(J=1;J<=n;J++)
			{
				SC=0;
				for(I=1;I<=m;I++)
				{
					SC=A[I,J]+SC;
				}
				Console.WriteLine("Columna"+J+"="+SC);
			}
			Console.ReadLine();
		}
	}
}

EJEMPLO: VECTORES


using System;

namespace MiVector
{
	class Class1
	{
		[STAThread]
		static void Main(string[] args)
		{
			int[]Vector;
			Vector = new int [100];
			int Valor,TotalElementos, Aux, Posmin, j;
			int Indice=1;
			int Suma, Mayor, Esta;
			Suma=0;
			Console.WriteLine(" OPERACIONES CON VECTORES \n");
			Console.WriteLine("Cuantos elementos tiene tu vector?:");
			TotalElementos = Convert.ToInt32(Console.ReadLine());
			while(Indice <= TotalElementos)
			{
				Console.WriteLine("Digita el valor: Vector["+Indice+"]= ");
				Valor = Convert.ToInt32(Console.ReadLine());
				Vector[Indice]=Valor;
				Suma = Suma + Vector[Indice];
				Indice=Indice+1;
			}
			Console.WriteLine("\n ELEMENTOS DEL VECTOR");
			Mayor=Vector[1];
			Esta=0;
			for(Indice=1; Indice <= TotalElementos; Indice++)
			{
				Console.WriteLine("Vector["+Indice+"]="+Vector[Indice]);
				if (Vector[Indice] > Mayor)
				{
					Mayor=Vector[Indice];
					Esta=Indice;
				}
			}
			Console.WriteLine("La suma de los elementos es:"+Suma);
			Console.WriteLine("El mayor es Vector["+(Esta)+"]="+(Mayor));	
			
			Console.WriteLine("Vector ordenado:");
			for(Indice=1; Indice<=TotalElementos;Indice++)
			{
				Posmin=Indice;
				for(j=Indice;j<=TotalElementos;j++)
					if (Vector[j]< Vector[Posmin])
						Posmin=j;
				Aux=Vector[Indice];
				Vector[Indice]=Vector[Posmin];
				Vector[Posmin]=Aux;
			}
			for(Indice=1;Indice<=TotalElementos;Indice++)
				Console.WriteLine("Vector ["+Indice+"] =" +Vector[Indice]);
			Console.ReadLine();
		}		
	}
}

Puntero: C++ y C#
Clases
Archivo
Lista
Cola
Pila
Arbol

Las variables dinámicas llamadas punteros, constituyen la herramienta más potente de los lenguajes C, C++, C++Builder y Visual C++. Permiten operar las estructuras de datos dinámicas tipo listas, pilas, colas, árboles y grafos.

Iniciaremos el manejo de las estructuras de datos como entidades dinámicas, pues verás que mientras se ejecuta el programa que lo comanda, ellas cambian de tamaño de manera de ajustarse a las necesidades de memoria requeridas en cada momento.

Lo anterior significa la optimización de la administración de la memoria operativa de la máquina, porque la estructura dinámica se ajusta automáticamente a la cantidad de datos a procesar.

Los apuntadores llamados también punteros son variables dinámicas cuyo contenido es la dirección del casillero de la pila de memoria donde se almacena un valor. Como cualquier variable, los punteros deben ser préviamente declarados inicializados aplicando la siguiente sintaxis

Los operadores & y * son de efecto inverso entre ellos cuando se aplican a una variable puntero, por ello los siguientes ejemplos producen el mismo efecto:
& * MiPuntero;
* & Mi Puntero;

En el siguiente ejemplo podras apreciar las declaraciones y algunos algoritmos para que inicies tus práctica.
Te recomiendo que veas cómo se usan los operadores de dirección & y el operador de indirección *


		/////////////////////////////////////
		//  Wilo Carpio            5/4/95
		//  MANEJO DE PUNTEROS      C++
		/////////////////////////////////////
		#include iostream.h>
		int main()
		{
		  ////////////////////////////
		  // Declaración del puntero
		  ////////////////////////////
		
		  int *aPuntero;               // Asi declaro una variable puntero
		 
		  int MiVariable;              // Asi declaro una variable numérica entera
		
		  MiVariable = 7;              // Asi asigno un valor a la variable
		
		  aPuntero = &MiVariable;   // Asi asigno la dirección de la variable MiVariable
		  
		  
		  //////////////////////////////////////////////
		  // Visualización de la dirección de memoria
		  //////////////////////////////////////////////
		
		  cout<<"La dirección de MiVariable es "<<& MiVariable
		  
		  //////////////////////////////////////////////
		  // Visualización del contenido de la dirección 
		  // de memoria que es apuntada por el puntero
		  //////////////////////////////////////////////
		  
			<<"\n el valor de aPuntero es  " << aPuntero;
			
		
		  ///////////////////////////////////////////////////
		  // Visualización mostrando el efecto inverso que
		  // producen los operadores
		  //                         &  de dirección
		  //                         *      de indirección
		  ///////////////////////////////////////////////////
		
		  cout << " \n  Mostrando que * y & son operadores inversos entre si "
		  
			   << " \n  & * aPuntero =   " << & * aPuntero
			   
			   << " \n  * & aPuntero =  "  << * & aPuntero 
			   
			   << end1;
		 
		 return (0);
		}

Las aplicaciones de punteros para manejar funciones, pueden activarse tal indican los siguientes ejemplos, que al compilarlos, generan los mismos resultados.
Compara la estructura de los algoritmos, de manera de deducir las ventajas de usar punteros en la aplicación de las funciones.
  1. LLAMADO DE FUNCIONES POR VALOR
    
    		//////////////////////////////////
    		//  Wilo Carpio       5/5/95
    		//  Llamado de función por valor
    		//////////////////////////////////
    		
    		#include iostream.h >
    		
    		int SuperfieCuadrado(int);  // Prototipo
    		
    		int main()
    		{
    		  int Lado = 10;
    		
    		  cout<<"La longitud del lado = " << Lado;
    		  
    		  Superficie = SuperfieCuadrado(Lado)
    		
    		  cout<<"\n La superfie del cuadrado es " << Superficie << end1;
    		
    		return 0;
    		}
    		
    		/////////////////////////////
    		//  Función Superficie
    		/////////////////////////////
    		int SuperfieCuadrado(int UnLado);
    		  {
    			return UnLado * UnLado; // Opera sobre la variable local UnLado
    		  }
    

    La enema si no cura, entretiene..!!

  2. LLAMADO DE FUNCIONES POR REFERENCIA CON ARGUMENTO DE PUNTERO:
    Esta función no devuelve un valor y en el prototipo no requiere indicar el nombre del apuntador.
    
    		///////////////////////////////////////
    		//  Wilo Carpio       5/5/95
    		//  Llamado de función por referencia
    		///////////////////////////////////////
    		
    		#include iostream.h >
    		
    		void SuperfieCuadrado(int*);  // Prototipo
    		
    		int main()
    		{
    		  int Lado = 10;
    		
    		  cout<<"La longitud del lado = " << Lado;
    		  
    		  SuperfieCuadrado(&Lado);
    		
    		  cout<<"\n La superfie del cuadrado es " << Lado << end1;
    		
    		return 0;
    		}
    		
    		/////////////////////////////
    		//  Función Superficie
    		/////////////////////////////
    		int SuperfieCuadrado(int *MiPuntero);
    		  {
    			*MiPuntero = *MiPuntero * *MiPuntero; // Opera sobre el número del main 
    		   }
    

L I S T A S
Colas
Pilas
Arboles

Las estructuras de datos estáticas, como arreglos requieren tamaños y posiciones de memoria asociados, fijados en tiempo de compilación.
Las estructuras dinámicas de datos:
- Se expanden o contraen solo a medida que se requiera para su proceso.
- Son colecciones de elementos llamados nodos, intervinculados por punteros que permiten crear estructuras con capacidad de variar su tamaño y ocupar solo la memoria necesaria para alojar variables dinámicas, que se crean y se destruyen durante la ejecución.
- Los nodos de la estructura, generalmente del tipo registro, se enlazan o encadenan de modo que se establece asociando a cada nodo un puntero que apunta al nodo siguiente de la estructura.
- Existen diferentes tipos de estructuras dinámicas de datos. Ejemplos: Estas estructuras permiten almacenar y procesar conjuntos de datos cuyos tamaños cambian durante la ejecución del programa, por ejemplo, el conjunto de nombres de alumnos que se inscribiran como postulantes a ingesar a la universidad.

PUNTEROS:
Cada posición de la pila de memoria tiene una dirección y un valor específico almacenado en esa posición, identificada por nombres de variables en lugar de direcciones, pues los nombres son simples de recordar.
Para almacenar un nuevo valor en memoria se asigna a una variable y la computadora envía una dirección a la memoria seguida por el valor a almacenar en esa posición.

Para declarar un tipo puntero se indica el tipo de valor que se almacenarán en la posicion designada por el puntero, porque los diferentes tipos de datos requieren diferentes cantidades de memoria para almacenar sus constantes, una variable puntero puede contener una dirección de una posición de memoria adecuada sólo para un tipo dado.
Así, se dice que cada puntero apunta a una variable particular, es decir, a otra posición de memoria.

Dado que el puntero es una variable que registra la dirección de otra variable almacenada en una celda de memoria, es preciso diferenciar entre las dos entidades implicadas en el apuntamiento:

Se puede declarar un puntero a una variable carácter, a un arreglo de enteros, a un registro o a cualquier otro tipo de dato e incluso a otro puntero.

C++, Usa el asterisco (*) que sigue a los nodos, para indicar que "apunta a"; es decir el tipo de dato es una variable puntero que puede contener una dirección a un tipo de dato llamado nodo. Ej. MiNodo *nuevo;

La lista enlazada es una secuencia de nodos enlazados o conectados con el siguiente formando una estructura de datos dinámica. Tales nodos suelen ser normalmente registros y que no tienen un tamaño fijo.

La ventaja de una lista enlazada sobre un arreglo es que la lista enlazada puede crecer y decrecer en tamaño y que fácil insertar o suprimir un nodo en el centro de una lista enlazada. Por ello la lista enlazada es uno de los más utilizados en gestión de proyectos de software.

La lista enlazada es una estructura muy versátil, cuyos algoritmos para inserción y eliminación de datos constan de dos pasos:

ESTRUCTURA de LISTAS:
Una forma de almacenar elementos relacionados es alinearlos, formando una estructura de lista lineal que necesita un enlace por cada elemento o nodo, para referenciar al elemento siguiente, de manera que el número de nodos puede variar rápidamente en un proceso, aumentando los nodos por inserciones, o bien disminuyendo por eliminación de nodos.

Una lista se usa para almacenar información del mismo tipo, de modo que puede contener un número indeterminado de elementos, los cuales mantienen un orden explícito, pues contiene en sí mismo la dirección del siguiente elemento.En cada nodo podemos considerar que hay dos campos, campo de información (INFO) y campo de enlace (ENLACE) o dirección del elemento siguiente.

El campo de dirección, a partir del cual se accede a un nodo de la lista, se llama puntero. A una lista enlazada se accede desde un puntero externo que contiene la dirección (referencia) del primer nodo de la lista. El campo de dirección o enlace del último elemento de la lista no debe de apuntar a ningún elemento, no debe de tener ninguna dirección, por lo que contiene un valor especial denominado nulo (en Pascal o Delphi : nil, en C , C++ y Builder C: NULL).

A la lista de cero elementos se la llama lista vacía y es aquella que no tiene nodos, tiene el puntero externo de acceso a la lista apuntando a nulo.

Las inserciones se pueden realizar por cualquier punto de la lista. Así pueden realizarse inserciones por el comienzo de la lista, por el final de la lista, a partir o antes de un nodo determinado. Las eliminaciones también se pueden realizar en cualquier punto de la lista, aunque generalmente se hacen dando el campo de información que se desea eliminar.

MANEJANDO LISTAS:
Utilizan variables puntero que permiten crear variables dinámicas, que almacenan el campo de información y el campo de enlace al siguiente nodo de la lista.

Cada vez que sea necesario crear un nuevo nodo, la memoria ocupada por éste se devuelve a la pila de memoria libre. El proceso es dinámico, la lista crece o decrece según las necesidades.

Cuando se quiere acceder a un nodo hay que recorrer la lista, a través de los enlaces hasta alcanzar su dirección y tener en cuenta que cada nodo ocupa la memoria adicional del campo de enlace.

El tipo de variable puntero es aquella cuyo contenido va a ser la dirección de memoria de un dato. Las variables puntero, al igual que las variables enteras o reales, son variables estáticas, ya que se crean o reserva memoria para ellas en tiempo de compilación.

Especificación Formal de la Lista Simple:
Matemáticamente, una lista es una secuencia de cero o más elementos de un determinado tipo, ordenados de forma lineal.

(a1, a2, a3, ..., an) donde n >= 0 si n = 0 la lista es vacía.

Listas Simples: Tienen dos campos:
- Uno de información
- Uno de enlace que apunta al siguiente nodo.

Además de los típicos datos int, float, char y long, C++ nos permite declarar nuestros propios tipos de datos personalizados, aplicando para ello la correspondiente declaración de estructuras, tal como puedes apreciar en el siguiente ejemplo:


		//////////////////////////////////////////////////////////////
		// VARIABLE DINAMICA                 WILO CARPIO
		//   LISTA SIMPLE                     12/5/1998
		// Funciona OK: C++Borland
		//   Visual C++: 
		//   File/New/Projects/win32ConsoleAplicatión: 
		//        Asignar nombre del proyecto y el Path
		//   File/New/Files/C++SourceFile: Asignar Nombre al programa 
		//////////////////////////////////////////////////////////////
		#include < iostream.h >
		#include < stdlib.h >
		
		/////////////////////////////////////
		//  PROTOTIPOS DE LAS FUNCIONES
		////////////////////////////////////
		int MenuOpciones();
		char CerrarPrograma();
		void LaListaEstaVacia();
		
		////////////////////////////////////////////////////
		//        ESTRUCTURA DEL NODO A USAR
		////////////////////////////////////////////////////
		typedef struct PunteroDeNodo
		{
		  int    Legajo; //-----------------------Campo llave
		  float  Edad;
		  char   Nombre[15];
		  struct PunteroDeNodo *ProximoNodo; //---Campo enlace
		 }MiNodo;
		
		////////////////////////////////////
		//   VARIABLES GLOBALES
		////////////////////////////////////
		   int MiOpcion;
		   char Si_No, Salir;
		   MiNodo *NodoDeLaLista,
			*NodoAnterior,
			*NuevoNodoaInsertar,
			*NodoAuxiliar,
			*PunteroDelNodo;

Insertando nuevos nodos:
La creación de un nuevo nodo se realiza mediante la instrucción New.
Pero antes de realizar la inserción de un nodo se llama a un procedimiento para saber si el campo clave de código ya existe y en tal caso solo se pueden ingresar más cantidad del mismo.

Listas Simples:
- La inserción de nuevos se realiza al final de la lista.
- El último nodo ingresado apunta siempre a NULL o nil.


		///////////////////////////////////////////////////////
		//   INSERTANDO UN NODO CUANDO LA LISTA NO ESTA VACIA
		///////////////////////////////////////////////////////
		void InsertarNodoAuxiliar(MiNodo *NodoPuntero)
		 {
		  int EsUltimoNodo;
		  //---------------------------------------------
		  // Si el legajo actual es menor que el anterior, 
		  // el nuevo nodo se inserta antes
		  //---------------------------------------------
		  if (NuevoNodoaInsertar->Legajo < NodoAnterior->Legajo )
			 {  
			 NuevoNodoaInsertar->ProximoNodo = NodoDeLaLista;
			 NodoAnterior = NuevoNodoaInsertar;
			 NodoDeLaLista = NuevoNodoaInsertar;
			 } 
			else  //--------caso Contrario----------------
			 {
			   NodoAuxiliar = NodoAnterior;  // Se copia nodo anterior NodoAuxiliar
			   EsUltimoNodo = false;
			   //-----------------------------------------------
			   // Ciclo buscando el último nodo de NodoAuxiliar
			   // para direccionar el NodoPuntero
			   //-----------------------------------------------
			   do
			   {
				  PunteroDelNodo = NodoAuxiliar;
				  NodoAuxiliar = NodoAuxiliar->ProximoNodo;
				  if (NodoAuxiliar == NULL)  
					   EsUltimoNodo = true;
				   else
					if (NodoAuxiliar->Legajo > NuevoNodoaInsertar->Legajo)
					   EsUltimoNodo = true;
			   }
			  while (!EsUltimoNodo);
			  //-----------------------------------------Fin de ciclo
			  PunteroDelNodo->ProximoNodo = NodoPuntero;
			  NodoPuntero->ProximoNodo = NodoAuxiliar;
			}
		 return;
		 }

/////////////////////////////////////////////////////////////////////
//        ALTA DEL NUEVO NODO
////////////////////////////////////////////////////////////////////
MiNodo *InsertarUnNodo(MiNodo *NodoDeLaLista)
	{
       float EdadAux;             // Declarando variable numérica real
       MiNodo *NodoPuntero;	      //            variable dinámica 
	   NodoPuntero = new MiNodo;  // Asignación dinámica de memoria
       //--------------------------------------------------------
	   cout << "\t\n ALTA DE NODO   Legajo: "; cin >> NodoPuntero->Legajo;
       cout << "\t\n                Nombre: "; cin >> NodoPuntero->Nombre;
       cout << "\t\n                Edad  : "; cin >> EdadAux;
       NodoPuntero->Edad  = EdadAux;    // Asignando valor al Campo Llave
       NodoPuntero->ProximoNodo = NULL; // Asignando valor al Campo Enlace
       NuevoNodoaInsertar = NodoPuntero;        // Copiar contenido en NuevoNodoaInsertar
	   //--------------------------------------------------------
       if (NodoDeLaLista == NULL) //-- Si la lista esta vacia      
	   {
	    NodoDeLaLista= NuevoNodoaInsertar;       // Copiar NuevoNodoaInsertar a la lista          
	    NodoAnterior = NuevoNodoaInsertar;       // Copiar NuevoNodoaInsertar a NodoAnterior
	   }
       else //------------------------ Si la lista NO está vacia
	    InsertarNodoAuxiliar(NuevoNodoaInsertar);
   return(NodoAnterior);
   }         

///////////////////////////////////////////////
//   VER DATOS DE LOS NODOS
///////////////////////////////////////////////  
MiNodo *VerDatosDeLosNodos(MiNodo *NodoDeLaLista)
 {
  MiNodo *ElMayor;
  int NroNodos;
  float LaEdad,SumaEdad;
  LaEdad=0;
  SumaEdad=0;
  NroNodos=0;
  if (NodoDeLaLista == NULL)
     LaListaEstaVacia();
   else
   { 
     cout << "\t\n  CONTENIDO DE LOS NODOS  \n\n";
     cout << "Nodo  Ubicacion     LEGAJO  NOMBRE    EDAD  \n";
     cout << "--------------------------------------------\n";
	 while (NodoDeLaLista != NULL) 
	   {
        SumaEdad=SumaEdad + NodoDeLaLista->Edad; 
	    if (NodoDeLaLista->Edad > LaEdad)
	      {
		   LaEdad = NodoDeLaLista->Edad;
		   ElMayor= NodoDeLaLista;
		   }
		 //-------------------------Listado de nodos
	       cout << ++NroNodos << "   "
		       << &NodoDeLaLista->Legajo << "      "
		       << NodoDeLaLista->Legajo << "      "
		       << NodoDeLaLista->Nombre << "      "
		       << NodoDeLaLista->Edad  << "\n";

	     NodoDeLaLista = NodoDeLaLista->ProximoNodo;
	    }  
     cout << "--------------------------------------------\n";
     cout << "En " << NroNodos
		   << " nodos, la edad promedio es " << SumaEdad/NroNodos
          << " y el mayor es " << ElMayor->Nombre
		   << ", tiene  " << ElMayor->Edad << " anios  \n\n";
	 }
      return (0);
   }

///////////////////////////////////////////////////////
//           BUSQUEDA DE UN NODO
//////////////////////////////////////////////////////
MiNodo *BuscarUnNodo(MiNodo *NodoDeLaLista,int LegajoElegido)
     {
      int SiEsta = false;
	  PunteroDelNodo = NodoDeLaLista;
	    while ((PunteroDelNodo != NULL) && !SiEsta)
	    {
	    if (LegajoElegido == PunteroDelNodo->ProximoNodo->Legajo)
	       {
		    SiEsta = true;
	       }
	    else
	       {
		    PunteroDelNodo = PunteroDelNodo->ProximoNodo;
	       }
	    }

	   return(PunteroDelNodo);
      }

///////////////////////////////////////////////////////
//           BAJA DE UN NODOS
//////////////////////////////////////////////////////
MiNodo *BorrarUnNodo(MiNodo *NodoDeLaLista)
    {
      int LegajoElegido;
       cout << "\t\t\n  BAJA DE UN NODO  \n\n";
       cout << "\t\n Legajo del Nodo a eliminar: ";cin >> LegajoElegido;
       NodoAnterior = NodoDeLaLista;
       PunteroDelNodo = NodoDeLaLista;
       NodoAuxiliar = NodoDeLaLista;
      if (NodoDeLaLista == NULL)
	 {
      LaListaEstaVacia();
	  }
      else
	 {
	 if (LegajoElegido == NodoAuxiliar->Legajo)
	    {
	    NodoAuxiliar = NodoAuxiliar->ProximoNodo;
	    free(PunteroDelNodo);
	    PunteroDelNodo = NodoAuxiliar;
	    NodoDeLaLista = NodoAuxiliar;
	    NodoAnterior = NodoAuxiliar;
	     }
	 else
	    {
	     PunteroDelNodo = BuscarUnNodo(NodoDeLaLista,LegajoElegido);
	     NodoAuxiliar = PunteroDelNodo->ProximoNodo;
	     PunteroDelNodo->ProximoNodo = NodoAuxiliar->ProximoNodo;
	     delete NodoAuxiliar;
	    }
	}
     return (NodoAnterior);
 }   


MiNodo *liberar(MiNodo *NodoDeLaLista)
   {
      PunteroDelNodo = NodoDeLaLista;
      while (PunteroDelNodo != NULL)
	{
	  NodoAuxiliar = PunteroDelNodo->ProximoNodo;
	  free(PunteroDelNodo);
	  PunteroDelNodo = NodoAuxiliar;
	  NodoDeLaLista = PunteroDelNodo;
	  }
      if (NodoDeLaLista == NULL)
		 LaListaEstaVacia();
      return (NodoDeLaLista);
      }

///////////////////////////////////////
//        FUNCION PRINCIPAL
///////////////////////////////////////

void main(void)
{                                    
  
  NodoDeLaLista=NULL;
  do
  {                                  
   MiOpcion=MenuOpciones();   
   switch(MiOpcion) 
		{                            
         case 1:
			  Si_No ='s';
              do 
			  {
		       NodoDeLaLista = InsertarUnNodo(NodoDeLaLista);  
	           cout << "\t\t\t\t Ingresas otro nodo.? (s/n) ";
			   cin>>Si_No;
			  }
              while (!((Si_No !='s')&&(Si_No !='S')));             
	          break;
		 case 2:
              VerDatosDeLosNodos(NodoDeLaLista);
	          break;
         case 3:
		      NodoDeLaLista = BorrarUnNodo(NodoDeLaLista);
			  break;
         case 4:
		      Salir = CerrarPrograma();
			  break;
		}                            
  } 
  while (!(Salir =='S'));   
 NodoDeLaLista = liberar(NodoDeLaLista);
}

///////////////////////////////////////
//  FUNCION MENU DE OPCIONES
///////////////////////////////////////
int MenuOpciones()
{
    int MiOpcion;
	MiOpcion=1;
    cout << "================================================================\n\n";     
    cout << "       LISTAS ENLAZADAS                Wilo Carpio    12/5/2000 \n\n";
    cout << "   1 - ALTAS       3 - BORRAR NODO  \n\n";
    cout << "   2 - VER DATOS   4 - SALIR        Elige una Opcion: ";
    cin >> MiOpcion;          
    cout << "-----------------------------------------------------------------\n";     
	return MiOpcion;
}

///////////////////////////////////////
//      SALIR DEL PROGRAMA
///////////////////////////////////////
char CerrarPrograma()
{
    char Salir;
    cout << "OJO.!! ESTE PROGRAMA NO TIENE ARCHIVO DE DATOS, POR ELLO SI SALES \n\n";
    cout << "       PERDERAS LA INFORMACION GUARDADA EN LOS NODOS...!!!  \n\n";
    cout << "-----------------------------------------------------------------\n";     
    cout << "Deseas Cerrar el Programa ?  ( S / N ) ";cin>>Salir;          
	return toupper(Salir);
}

///////////////////////////////////////
//  FUNCION LISTA VACIA
///////////////////////////////////////
void LaListaEstaVacia()
{
 cout << "\t\t\n  LA LISTA VACIA...NO HAY NODOS..!!  \n\n";
}

C O L A S
Listas
Pilas
Arboles

Las filas de espera también llamadas colas, se producen cada vez que hacemos cola en la caja del comercio, cuando cargamos combustible en el automóvil, cuando abordamos un autobús, cuando pagamos en la caseta de cobro de la autopista; los estudiantes hacen cola para inscribirse en las materias que quieren y en los sistemas informáticos usamos internamente muchas colas de espera.

En estas estructuras de datos abstractos, los usuarios hacen altas o ponen cosas en ellas, una a la vez mediante una operación de encolamiento, y las retiran o dan de baja, un elemento a la vez por medio de una operación de desencolamiento.

Aunque en teoría la cola puede ser infinitamente grande, en la práctica, ella es finita y sus elementos se devuelven de la cola en orden de FIFO (Firts In Firts Out: primero en entrar, primero en salir): el primer elemento que entra en la cola es el primero en ser retirado de ella.

Del mismo modo que las pilas, también las colas son listas. Con una cola, no obstante, la inserción se hace por un extremo, mientras que la eliminación se realiza por el otro extremo.

Las operaciones básicas sobre una cola son encolar, que inserta un elemento al final de la lista, y dar de baja o desencolar, para eliminar el elemento del inicio de la lista o frente.

COLAS COMO ARREGLOS: Para las colas pueden aplicarse los procesos de los arreglos, usando la estructura de datos COLA[ ], y la posición Frente y Final, que representan los extremos de la cola, y Tamaño que es el numero de elementos de la cola.


Veamos el siguiente programa:

FUNCION PRINCIPAL


void main()
{
  textbackground(BLUE); textcolor(WHITE);
  NodoDeLaCola *MiColita;// puntero a la MiColita
  int  MiOpcion=0,LaOpcion;
  MiColita = NULL;
  do
    {
	textcolor(YELLOW); textbackground(BLUE);clrscr();
	cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
	cout <<"\n\t\t  C++             Wilo Carpio           25/6/98";
	cout <<"\n\t\t      ESTRUCTURAS DINAMICAS DE DATOS           ";
	cout <<"\n\t\t                                                ";
	cout <<"\n\t\t         MANEJO COLAS SIN ARCHIVO              ";
	cout <<"\n\t\t                                                ";
	cout <<"\n\t\t              MENU PRINCIPAL                    ";
	cout <<"\n\t\t\t         1- Altas";
	cout <<"\n\t\t\t         2- Consulta";
	cout <<"\n\t\t\t         3- Baja Logica";
	cout <<"\n\t\t\t         4- Baja Fisica";
	cout <<"\n\t\t\t         5- Ver 1er nodo";
	cout <<"\n\t\t\t         6- Modificar";
	cout <<"\n\t\t\t         7- Imprimir";
	cout <<"\n\t\t\t         8- SALIR";
	cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
	cout <<"\n\n\t\t\t\t     Elige una opci¢n -> ";cin >>MiOpcion;
	clrscr();
      switch(MiOpcion)
	 {
	case 1:
		 MiColita=AltaEnMiColita(MiColita); break;
	case 2:
		 MostrarTodosLosNodos(MiColita); break;
	case 3:
		 MiColita=BajaLogicaDelNodo(MiColita); break;
	case 4:
		 MiColita=BajaFisicaEnMiColita(MiColita); break;
	case 5:
		 ConsultaPrimerDato(MiColita); break;
	case 6:
		 MiColita=ModificarDatoDelNodo(MiColita); break;
	case 7:
		 ImprimirMiColita(MiColita); break;
	 }
    }
 while(MiOpcion != 8);
 MiColita=LiberarMemoria(MiColita); //libera memoria cuando sale del programa
}

ESTRUCTURA DE LA COLA


//°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
// C++   MANEJO DE COLA SIN ARCHIVO    Wilo Carpio
//               Colawilo.cpp
//°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
#include   //cout, cin
#include      //print, scanf,fopen,fclose
#include      //getch, gotoxy,clrscr,textbackground,textcolor
#include     //strcpy
#include      //free y malloc

typedef struct MiColita
   {
       int UnLegajo;          // Campo llave del NodoDeLaCola
       char UnNombre[30];     // Campo de informacion
       int MiFlag;
       struct MiColita *NodoSiguiente; // Puntero del NodoDeLaCola
    }NodoDeLaCola;

void Rotulo();
void Tecla();
void ColitaLimpia();

void Rotulo()
{   clrscr();
    cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
    cout <<"\n\t\t  C++             Wilo Carpio           25/6/98";
    cout <<"\n\t\t      ESTRUCTURAS DINAMICAS DE DATOS           ";
    cout <<"\n\t\t             COLAS SIN ARCHIVO           ";
    cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
    cout <<"\n\t\t                                                ";
}

void ColitaLimpia()
{
  cout<<"\n\t\t Mi colita esta limpita.. sin nodos..!!";
  getch();
}

void Tecla()
{
  cout<<"\n\n\t\t Tecla para seguir..\n";
  getch();
}

NodoDeLaCola *LiberarMemoria(NodoDeLaCola *MiColita)
{
   NodoDeLaCola *NodoAuxiliar,*NodoElegido;
   NodoAuxiliar=MiColita;
   while(NodoAuxiliar->NodoSiguiente!=NULL)     //Mientras MiColita contenga datos
   {
      NodoElegido=NodoAuxiliar->NodoSiguiente;  //Asigna a un NodoAuxiliar el NodoDeLaCola NodoSiguiente al que va a borrar
      free(NodoAuxiliar);        // Elimina el NodoDeLaCola
      NodoAuxiliar=NodoElegido;  // Asigna al auxiliar el valor del NodoDeLaCola siguiente al que tenia antes de ser liberado
      MiColita=NodoAuxiliar;     // Como se elimino 1ø nodo, cabecera toma valor de NodoAuxiliar, ya
   }
  free(MiColita);
 return(MiColita);           //devuelve la cabecera que es NULL
}

ALTAS


NodoDeLaCola *AltaEnMiColita(NodoDeLaCola *MiColita)
{
  NodoDeLaCola *NodoAuxiliar,*nuevo;                  // Nodos auxliliares
  nuevo=(NodoDeLaCola*)malloc(sizeof(NodoDeLaCola)); // Se pide memoria para cada NodoDeLaCola cargado
  Rotulo();
  cout <<"\n\t\t         ALTA EN COLAS SIN ARCHIVO  \n";
  cout <<"\n\t\t       Digita los siguientes datos \n";
  cout <<"\n\t\t\t         1- Legajo : ";cin >>nuevo->UnLegajo;
  cout <<"\n\t\t\t         2- Nombre : ";cin >>nuevo->UnNombre;
  nuevo->MiFlag=1;
  nuevo->NodoSiguiente =NULL;
  if(MiColita == NULL)      // MiColita estara vacia por lo que el NodoDeLaCola
     MiColita = nuevo;      // cabecera se inserta y el que se devolvera
  else
    {
      NodoAuxiliar=MiColita;    //NodoAuxiliar para recorrer MiColita y perder la cabecera
      while(NodoAuxiliar->NodoSiguiente!=NULL) //Recorre toda MiColita hasta llegar al final
       NodoAuxiliar=NodoAuxiliar->NodoSiguiente;
      NodoAuxiliar->NodoSiguiente=nuevo;       // para insertar el NodoDeLaCola
     }
  return(MiColita);             //Devuelve el 1§ NodoDeLaCola que se ingreso
}

CONTENIDO DE LOS NODOS


void MostrarPrimerNodo(NodoDeLaCola *NodoAuxiliar)
{
     Rotulo();
     cout <<"\n\t\t    PRIMER NODO DE LA COLA  \n";
     cout <<"\n\t LEGAJO  NOMBRE \n";
     cout <<"\n\t"<< NodoAuxiliar->UnLegajo<<"    "<UnNombre;
     Tecla();
}

void MostrarTodosLosNodos(NodoDeLaCola *MiColita)
{
  int y=9,n=0, x=7;
  NodoDeLaCola *NodoAuxiliar;
  NodoAuxiliar = MiColita;
  if( MiColita== NULL)
    {  //Si MiColita no contenga datos
    ColitaLimpia();
    }
  else
    {
     Rotulo();
     cout <<"\n\t\t         FICHAS DE LA COLA  \n";
     cout <<"\n\t LEGAJO  NOMBRE \n";
    while(NodoAuxiliar != NULL)//Mientras la MiColita contenga elementos
     {
      if(NodoAuxiliar->MiFlag == 1)//Verifica datos sin BajaLogica
	{
	 cout <<"\n\t"<< NodoAuxiliar->UnLegajo<<"    "<UnNombre;
	 n=n+1; y++;
	 if(n==15)//Muestra hasta 15 datos por vez
	   {
	    getch(); clrscr();
	    Rotulo();
	    cout <<"\n\t\t LOS NODOS DE LA COLA  \n";
	    cout <<"\n\t   LEGAJO  NOMBRE \n";
	    n=0; //inicializa el numero de datos que mostrara
	    y=9; //inicializa la coordenada desde donde mostrara el 1§ dato
	   }
	}
      NodoAuxiliar = NodoAuxiliar->NodoSiguiente;
    }
    getch();
  }
}

void ConsultaPrimerDato(NodoDeLaCola *MiColita)
{
   NodoDeLaCola *NodoAuxiliar;
   NodoAuxiliar=MiColita;
   if(NodoAuxiliar != NULL)
      {  if( NodoAuxiliar->MiFlag == 0)  //Si no se le dio de bajo logica
	  {
		clrscr();
		gotoxy(15,10);printf("­­ DATO con BAJA LOGICA !!");
		getch(); //En caso de ser asi lo pone en aviso
	   }
	 else
	      MostrarPrimerNodo(NodoAuxiliar); //Muestra el 1§ dato de la MiColita
       }
   else
      {
	ColitaLimpia();
      }
}

MODIFICACIONES DEL CONTENIDO DEL NODO


NodoDeLaCola *ModificarDatoDelNodo(NodoDeLaCola *MiColita)
{
  int n,LosNodosDeMiColita=0,MiOpcion,s=0;
  NodoDeLaCola *NodoAuxiliar;
  NodoAuxiliar=MiColita;

  if(NodoAuxiliar != NULL)
  {
      if (NodoAuxiliar->MiFlag == 0)
	     {
	      clrscr();
	      gotoxy(15,10);printf("­­ Dato con BAJA LOGICA !!");
	      s=1;
	      getch();

	     }
       else
	  {
	   LosNodosDeMiColita=1;
	   Rotulo();
	   cout <<"\n\t\t  MODIFICAR FICHAS DE LA COLA  \n";
	   cout <<"N§ de Legajo: ";cin>>NodoAuxiliar->UnLegajo;
	   cout <<"Nombre:       ";cin>>NodoAuxiliar->UnNombre;
	   Tecla();
	   do
	     {   //Menu de opciones para las ModificarDatoDelNodo
	      Rotulo();
	      cout <<"\n\t MENU DE MODIFICAR 1er NODO DE LA COLA  \n";
	      cout <<"\n\t\t 1. Nombre  \n";
	      cout <<"\n\t\t 2. Salir  \n";
	      cout <<"\n\t\t Digita tu opcion..  \n";
	      do
		 {
		  cin>>MiOpcion;
		 }
	      while (MiOpcion<1 || MiOpcion>2);
	      switch(MiOpcion)
		 {
		  case 1: //Depende de la Opcion de modificacion de cada campo
			 Rotulo();
			 cout <<"\n\t MODIFICA el 1er NODO DE LA COLA  \n";
			 cout <<"\n\t Nuevo Nombre: ";cin>>NodoAuxiliar->UnNombre;
			 Tecla();
			 break;
		 }
	   }
	   while(MiOpcion != 2);
	 }
  }
     if((LosNodosDeMiColita==0) && (s!=1)) //Si MiColita esta limpita
      {
       ColitaLimpia();
      }
return(MiColita);
}

ELIMINACION DE NODOS: puede hacerse por:


NodoDeLaCola *BajaFisicaEnMiColita(NodoDeLaCola *MiColita)
{
   NodoDeLaCola *NodoAuxiliar,*NodoElegido;
   NodoAuxiliar=MiColita;
   if(NodoAuxiliar != NULL)   // Si el dato a eliminar no es nulo
   {
      NodoElegido=NodoAuxiliar->NodoSiguiente;
      free(NodoAuxiliar);
      NodoAuxiliar=NodoElegido;
      MiColita=NodoAuxiliar;
   }
 return(MiColita);      //devuelve el segundo dato que se habia ingresado que
}                   //ahora sera el primero

NodoDeLaCola *BajaLogicaDelNodo(NodoDeLaCola * MiColita)
{

 char OpcionElegida;
 NodoDeLaCola *NodoAuxiliar;
 if(MiColita != NULL)
  {
    Rotulo();
    cout <<"\n\t\t BAJA LOGICA DE LA COLA  \n";
	//Antes de borrar confirma la accion
    gotoxy(13,7);printf("N§ de Legajo:%d\n",MiColita->UnLegajo);
    gotoxy(13,9);printf("Nombre:%s\n",MiColita->UnNombre);
    gotoxy(20,16);printf("¨Seguro que borras estos datos.?(s/n)");
    gotoxy(60,16);scanf("%c",&OpcionElegida);

    gotoxy(13,7);printf("N§ de Legajo:%d\n",MiColita->UnLegajo);
    gotoxy(13,9);printf("Nombre:%s\n",MiColita->UnNombre);
    gotoxy(20,16);printf("¨Seguro que borras estos datos?");
    gotoxy(60,16);scanf("%c",&OpcionElegida);

    if (OpcionElegida == 's')// Si la baja se cambia a 0 la bandera
	MiColita->MiFlag=0;
  }
 else
   {
    ColitaLimpia();
   }
 return(MiColita);
}

IMPRIMIENDO LOS NODOS


void ImprimirMiColita(NodoDeLaCola *TuColita)
{
  NodoDeLaCola *NodoAuxiliar=TuColita;
  if( TuColita == NULL)
  {
   ColitaLimpia() ;
  }
  else
  {
      while(NodoAuxiliar != NULL)
      {
	  if(NodoAuxiliar->MiFlag == 1)
	  {
	     fprintf(stdprn,"LEGAJO :%d\n",NodoAuxiliar->UnLegajo);  //standart printer
	     fprintf(stdprn,"NOMBRE :%s\n",NodoAuxiliar->UnNombre);  //Funcion que permite
	  }
	  NodoAuxiliar=NodoAuxiliar->NodoSiguiente;
      }
  }
 }

P I L A S
Colas
Listas
Arboles

Esta estructura es como una pila de platos, en la cual para poner un plato en ella, es necesario colocarla en la parte superior y para retirar un plato, debemos levantar el que está en la parte superior; por ello, las pilas son estructuras de datos tipo LIFO ( último en entrar, primero en salir): el último elemento que se coloca (inserta) en la pila es el primero que se quita (remueve) de ella.

La pila es una versión restringida de una lista enlazada, ya que los nuevos nodos solo pueden agregarse a una pila y eliminarse de una pila desde la parte superior de ésta. El miembro de enlace del último nodo de la pila está establecido a nulo (cero) para indicar el fondo de la pila.

En el mundo de los programas informáticos las pilas tienen aplicaciones como por ejemplo, cuando se realiza una llamada de función, la función llamada debe saber la manera de regresar a su invocador, y por esto la dirección de devolución se pone en una pila. También los compiladores utilizan a las pilas en el proceso de evaluación de expresiones y en la generación de código de lenguaje de maquina.

Cuando sucede una serie de llamadas de función, los valores de devolución sucesivos se ponen en la pila en un orden último en entrar, primero en salir, para que cada función pueda regresar a su invocador. Las pilas soportan las llamadas de función recursivas en la misma forma que lo hacen con las llamadas no recursivas convencionales.

Las pilas contienen el espacio que se crea para las variables automáticas en cada llamada a una función. Cuando la función regresa a su invocador, el espacio para las variables automáticas de la función se saca de la pila, y de ésta manera el programa ya no conoce dichas variables.

Como una pila es una lista, podemos plantear dos técnicas de proceso.

REGALO COMPLETO y CON MOÑO


		//////////////////////////////////////////////////////////////
		// VARIABLE DINAMICA                 WILO CARPIO
		//  PILA CON ARCHIVO                  12/5/1998
		// Funciona OK: C++Borland
		//   Visual C++: 
		//   File/New/Projects/win32ConsoleAplicatión: 
		//        Asignar nombre del proyecto y el Path
		//   File/New/Files/C++SourceFile: Asignar Nombre al programa 
		//////////////////////////////////////////////////////////////
		
		#include < iostream.h>
		#include < malloc.h>
		#include < string.h>
		#include < stdio.h>
		//////////////////////////////////////////////
		// Declaración de estructura del nodo 
		//////////////////////////////////////////////
		struct nodo
		{
			int  codigo;
			char nombre[30];
			char domicilio[30];
			char telefono[30];
			nodo*SiguienteNodo;
		};
		//////////////////////////////////////////////
		//  Declaración de la ficha del archivo
		//////////////////////////////////////////////
		struct registro
		{
			int codigo;
			char nombre[30];
			char domicilio[30];
			char telefono[30];
		};
		
		//////////////////////////////////////////////
		//  Declaración del puntero
		//////////////////////////////////////////////
		typedef struct nodo*puntero;
		  puntero cabecera;
		
		/////////////////////////////////
		// PROTOTIPOS DE LAS FUNCIONES //
		/////////////////////////////////
		int Codigo_Buscado(int);
		
		//////////////////////////////////////////////
		// Declaracion de variables globales
		//////////////////////////////////////////////
		int Opcion,OpcionGrabar,Flag,EstaGrabado,CodigoFicha;
		char Si_No;

Se realizan altas (Meter) insertando al frente de la lista y la baja (Sacar) eliminando el elemento que está al frente de la lista. Una operación cima solo examina el elemento del frente de la lista, devolviendo su valor. A veces la operación sacar y cima se combinan en una. Podríamos usar llamadas a las rutinas sobre listas enlazadas.

Primero implantamos la pila con cabecera. Después se examina una pila vacía en la misma manera que una lista vacía.

La creación de una pila vacía requiere crear una cabecera con un apuntador siguiente a NULL. El meter se implanta como inserción al frente de la lista enlazada, donde el frente de la lista se conoce como cima de la pila. La cima se efectúa examinando el elemento de la primera posición de la lista. Por ultimo, implantaremos sacar eliminando el frente de la lista.

Todas las operaciones tardan un tiempo constante, por que en ninguna de las rutinas tiene referencia al tamaño de la pila ( excepto en la comprobación de si esta vacía ); tampoco se encuentra un ciclo que dependa del tamaño.


		//////////////////////////////////////////////
		//  Carga de la pila
		//////////////////////////////////////////////
		void cargar_pila(void)
		{
			puntero MiNodo,NodoAuxiliar;
			do
			{                        //tamaño de memoria//  
				MiNodo=(puntero)malloc(sizeof(struct nodo));//pido memoria 
				cout << "Codigo: "; cin >> CodigoFicha;
				if(Codigo_Buscado(CodigoFicha)==1)
				{
				  cout < < "\t\n   **************CODIGO EXISTENTE**************\n";
				}
				else
				{
				MiNodo ->codigo=CodigoFicha; 
				cout < < "Nombre:   "; cin>>MiNodo->nombre; 		
				cout < < "Domicilio:"; cin>>MiNodo->domicilio; 	
				cout < < "Telefono: ";	cin>>MiNodo->telefono;  	
				MiNodo->SiguienteNodo=NULL;
				if (cabecera == NULL)
					cabecera=MiNodo;
				else
				{
					NodoAuxiliar=cabecera;
					while (NodoAuxiliar->SiguienteNodo!=NULL)
						NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
						NodoAuxiliar->SiguienteNodo=MiNodo;
				}
				}
				cout << "Deseas ingresar otro nodo(S/N)";cin >>Si_No;
				while(Si_No!='s' && Si_No!='n')
				{
				cout < < "Deseas ingresar otro nodo(S/N)";cin > > Si_No;
				}
				
			}while(Si_No=='s');
			Flag=1;
			return; 
		}
		////////////////////////////////////////////
		// BUSQUEDA DEL CODIGO EN NODO EN LA COLA //
		///////////////////////////////////////////
		int Codigo_Buscado(int codbus)
		{
		 int YaEsta;puntero NodoAuxiliar,temp;
		 YaEsta=0;
		 NodoAuxiliar=cabecera;
		 while(NodoAuxiliar!=NULL)
		 {
		  temp=NodoAuxiliar;
		  if(NodoAuxiliar->codigo==codbus)
			  YaEsta=1;
		  NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
		 }
		 return YaEsta;
		}

PARADIGMA: El que un hombre muera por una causa, no significa que esta sea verdadera...!!! (Anonimo)

	//////////////////////////////////////////////
	// Recorrido de la pila
	//////////////////////////////////////////////
	void recorrer_pila(void)
	{
		puntero NodoAuxiliar,aux1;
		NodoAuxiliar=cabecera;
		if(cabecera!=NULL)
		{
		cout <<"**** DATOS QUE CONTIENE LA PILA ****\n";
		cout <<"=================================================================\n";
		cout <<"      CODIOGO         NOMBRE         DOMICILIO         TELEFONO          \n";
		while(NodoAuxiliar->SiguienteNodo!=NULL)
		{
			NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
		}
		while (NodoAuxiliar!=cabecera)
		{
			aux1=cabecera;
			while (aux1->SiguienteNodo!=NodoAuxiliar)
			aux1=aux1->SiguienteNodo;
			cout<<"\t"< < NodoAuxiliar->codigo<<"\t"
			"\t"< < NodoAuxiliar->nombre<<"\t"
			"\t"< < NodoAuxiliar->domicilio<<"\t"
			"\t"< < NodoAuxiliar->telefono<<"\n";
			NodoAuxiliar=aux1;
		}
		cout<<"\t"< < NodoAuxiliar->codigo<<"\t"
			"\t"< < NodoAuxiliar->nombre<<"\t"
			"\t"< < NodoAuxiliar->domicilio<<"\t"
			"\t"< < NodoAuxiliar->telefono<<"\n";
		cout<<"=================================================================\n";
		}
		else
		cout<<" **** LA PILA ESTA VACIA **** \n";
	}
	//////////////////////////////////////////////
	//  Baja de la pila
	//////////////////////////////////////////////
	void baja_pila(void)
	{
		puntero NodoAuxiliar,ant;
		NodoAuxiliar=cabecera;
		if (cabecera!=NULL)
		{
		 if(cabecera->SiguienteNodo==NULL)
		 {
		  cabecera=NULL;
		  free(NodoAuxiliar);
		  cout<<" **** NODO ELIMINADO ****  \n";
		  Flag=1;
		 }
		 else
		 {
			 while(NodoAuxiliar->SiguienteNodo!=NULL)
			 {
			  ant=NodoAuxiliar;
			  NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
			 }
			 free(NodoAuxiliar);
			 ant->SiguienteNodo=NULL;
			 cout<<" **** NODO ELIMINADO ****  \n";
			 Flag=1;
		 }
		 }
		else
			cout<<"**** LA PILA ESTA VACIA ****\n";
	}
	
	

	//////////////////////////////////////////////
	// Modificación del nodo
	//////////////////////////////////////////////
	void modifi_pila(void)
	{
		int bandera=0;char tecla;
		int coding;
		puntero NodoAuxiliar;
	  cout<<"DIGITA EL CODIGO DEL NODO A MODIFICAR: ";
	  cin>>coding;
	  NodoAuxiliar=cabecera;
	  while(NodoAuxiliar!=NULL && bandera==0)
	  {
		  if (NodoAuxiliar->codigo==coding)
			  bandera=1;
		  else
			  NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
	  }
	  if(bandera==1)
	  {
		  cout<<" EL NODO CONTIENE ESTOS DATOS \n";
		  cout<<"==================================\n";
		  cout<<"CODIGO:  "<codigo<<"\n";
		  cout<<"Nombre:  "<nombre<<"\n";
		  cout<<"Domicilio:  "<domicilio<<"\n";
		  cout<<"Telefono:  "<telefono<<"\n";
		  cout<<"==================================\n";
		  cout<<"Esta seguro que desea modificar estos datos(S/N)";
		  cout<<"\n";
		  while(tecla!='s' && tecla!='n')
			  cin>>tecla;
		  if(tecla==115)
		  {
			  cout<<"CODIGO: ";cin>>NodoAuxiliar->codigo;
			  cout<<"Nombre: ";cin>>NodoAuxiliar->nombre;
			  cout<<"Domicilio: ";cin>>NodoAuxiliar->domicilio;
			  cout<<"Telefono: ";cin>>NodoAuxiliar->telefono;
		  }
		  Flag=1;
	  }
	  else
	  {
		  cout<<" ERROR--EL CODIGO NO EXISTE \n";
	  }
	}
	
	//////////////////////////////////////////////
	//  Carga de la pila en el archivo
	//////////////////////////////////////////////
	void pila_archivo(void)
	{
	 FILE*archivo;
	 registro MiFicha;
	 puntero NodoAuxiliar;
	 puntero aux1;
	 archivo=fopen("pila.dat","w");
	 NodoAuxiliar=cabecera;
	 if (cabecera!= NULL)
	 {
	 while(NodoAuxiliar->SiguienteNodo!=NULL)
	 {
		 NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
	 }
	 while(NodoAuxiliar!=cabecera)
	 {
	   aux1=cabecera;
	   while(aux1->SiguienteNodo!=NodoAuxiliar)
		aux1=aux1->SiguienteNodo;
		MiFicha.codigo=NodoAuxiliar->codigo;
		strcpy(MiFicha.nombre,NodoAuxiliar->nombre);
		strcpy(MiFicha.domicilio,NodoAuxiliar->domicilio);
		strcpy(MiFicha.telefono,NodoAuxiliar->telefono);
		fwrite(&MiFicha,sizeof(struct registro),1,archivo);
		NodoAuxiliar=aux1;
	 } 
		MiFicha.codigo=NodoAuxiliar->codigo;
		strcpy(MiFicha.nombre,NodoAuxiliar->nombre);
		strcpy(MiFicha.domicilio,NodoAuxiliar->domicilio);
		strcpy(MiFicha.telefono,NodoAuxiliar->telefono);
		fwrite(&MiFicha,sizeof(struct registro),1,archivo);
		fclose(archivo);
		cout<<"        ******************************** \n ";
		cout<<"******** LA PILA SE GRABO EN EL ARCHIVO *****\n";
		cout<<"        ******************************** \n  ";
		Flag=0;
	 }
	else
	{
		cout<<"*** NO HAY NODOS EN LA PILA ***\n"; 
	}
	}

		//////////////////////////////////////////////
		//  Recorrido del archivo
		//////////////////////////////////////////////
		void recorrer_archivo(void)
		{
		 FILE*archivo;
		 registro MiFicha;
		 archivo=fopen("pila.dat","r");
		 if(archivo!=NULL)
		 {
		 fread(&MiFicha,sizeof(struct registro),1,archivo);
		 cout<<"\n";
		 cout<<"*** DATOS QUE CONTIENE EL ARCHIVO ***\n";
		 cout<<"==================================================================\n";
		 cout<<"     CODIGO           NOMBRE          DOMICILIO         TELEFONO     \n";
		 while(!feof(archivo))
		 {
		  cout<<"\t"< < MiFicha.codigo<<"\t"
				"\t"< < MiFicha.nombre<<"\t"
				"\t"< < MiFicha.domicilio<<"\t"
				"\t"< < MiFicha.telefono<<"\n";
		  fread(&MiFicha,sizeof(struct registro),1,archivo);
		 }
		 fclose(archivo);
		 cout<<"==================================================================\n";
		 }
		 else
		 {	 cout < < " *** EL ARCHIVO ESTA VACIO *** \n";
		 }
		}

		//////////////////////////////////////////////////
		//  Transferencia de datos del archivo a la pila
		//////////////////////////////////////////////////
		void archivo_pila(void)
		{
			puntero MiNodo,NodoAuxiliar;
			FILE*archivo;
			registro MiFicha;
			archivo=fopen("pila.dat","r");
		 if(archivo!=NULL)
		 {
		   fread(&MiFicha,sizeof(struct registro),1,archivo);
		 
		   while(!feof(archivo))
		   {
			MiNodo=(puntero)malloc(sizeof(struct nodo));
			MiNodo->codigo=MiFicha.codigo;
			strcpy(MiNodo->nombre,   MiFicha.nombre);
			strcpy(MiNodo->domicilio,MiFicha.domicilio);
			strcpy(MiNodo->telefono, MiFicha.telefono);
			MiNodo->SiguienteNodo=NULL;
			if(cabecera==NULL)
			  cabecera=MiNodo;
			else
			{
			 NodoAuxiliar=cabecera;
			 while(NodoAuxiliar->SiguienteNodo!=NULL)
			   NodoAuxiliar=NodoAuxiliar->SiguienteNodo;
			 NodoAuxiliar->SiguienteNodo=MiNodo;
			}
		   fread(&MiFicha,sizeof(struct registro),1,archivo);
		   }
		 fclose(archivo);
		 }
		}

PARADIGMA: Mientras más te eleves más pequeño pareceras a los ojos de la envidia
.. y nadie tan odiado, como el que vuela..!! ( Nietzsche )

		//////////////////////////////////////////////
		// Menu principal
		//////////////////////////////////////////////
		void main (void)
		{
		Opcion = 0;OpcionGrabar=0;Flag=0;
				cabecera = NULL;
				archivo_pila();
			   do  {
				cout<<"\n";
				cout<<"******** MENU DEL SISTEMA ********\n";
				cout<<"* 1. ALTA DE PILA                *\n";
				cout<<"* 2. BAJA DE UN NODO             *\n";
				cout<<"* 3. MODIFICAR DATOS DE UN NODO  *\n";
				cout<<"* 4. RECORRIDO DE PILA           *\n";
				cout<<"* 5. GRABAR LA PILA EN ARCHIVO   *\n";
				cout<<"* 6. RECORRER ARCHIVO            *\n";
				cout<<"* 7. SALIR DEL SISTEMA           *\n";
				cout<<"** Ingrese opcion: ";
				cin>>Opcion;
				cout<<"\n";
				switch (Opcion) {
				  case 1:
					 cargar_pila();
					 break;
				  case 2:
					 baja_pila(); 
					 break;
				  case 3:
					 modifi_pila(); 
					 break;
				  case 4:
					 recorrer_pila(); 
					 break;
				  case 5:
					  pila_archivo();
					 break;
				  case 6:
					  recorrer_archivo();
					 break; 
				 }
				}
			  while (Opcion != 7);
			  if ( Flag!=0)
			  {
			  do
			  {
				EstaGrabado=0;
				cout<<"\n";
				cout<<"**** MENU FINAL DEL SISTEMA ****\n";
				cout<<"* 8. GRABAR LA PILA EN ARCHIVO *\n";
				cout<<"* 9. SALIR DEL SISTEMA         *\n";
				cout<<"********************************\n\n";
				cout<<"******************************************************\n";
				cout<<"*  !!YA GRABO LOS NODOS DE LA PILA EN EL ARCHIVO ??  *\n";
				cout<<"******************************************************\n\n";
				cout<<" OJITO.. SI NO GRABAS LOS DATOS DE TU COLA. \n";
				cout<<" ...SE PERDERAN AL SALIR DEL SISTEMA..!!    \n";
				cout<<" INGRESA UNA OPCION (Tecla 8 o 9): "; cin>>OpcionGrabar;
				switch (OpcionGrabar){
				case 8:
					pila_archivo();
					EstaGrabado=1;
					break;
				}
			  }while(OpcionGrabar !=9 && EstaGrabado!=1);
			  }
				cout<<" \n\n";
				cout<<"   ********  FIN DEL PROGRAMA  *******\n";
				cout<<"   ********    CHAU GRACIAS    *******\n\n";
		}

Sonrie.. yo existo.!!!

A R B O L
Colas
Listas
Pilas

Los árboles son estructuras dinámicas de datos que estan conformados por conjuntos de uno más nodos, quienes pueden o no estar vacíos y están dotados de enlaces jerárquicos.

LIO FAMILIAR: Aquellos nodos que tienen el mismo padre se llaman "Hermanos" y los hijos de estos son "Nietos" del "Padre". Está claro no.???

Los árboles tienen

ARBOL DE EXPRESION:
Los árboles pueden ser usados para representar expresiones de memoria; para ello se usan árboles binarios que tienen operaciones binarias y están constituidos por hojas que son operandos y los demás nodos contienen operadores. Ejemplo:

(a + b * c ) + (( d * e + f ) * g )

En este ejemplo, a + (d * c) se evalúa en el subárbol izquierdo y ((d * e) + f ) se evalúa en el subárbol derecho.

Este esquema "Izquierda, Nodo, Derecha" se denomina de "Recorrido simétrico"

RECURSIVIDAD: Recuerda que un proceso es recursivo cuando está parcial o totalmente definido en términos de sí mismo; de modo que algo que sea infinito pueda ser definido de forma finita; así, un programa recursivo podrá llamarse a sí mismo y deberá tener dos partes:
- Base: Definen los elementos del conjuntos que servirán para crear el resto del conjunto.
- Reglas de recurrencia: Permiten crear un elemento a partir de elementos ya creados.

DECLARAR NODOS DEL ÁRBOL:
Usa y analiza la sintaxis y la semántica del siguiente ejemplo para que aprendas a operar tus árboles


		/////////////////////////////////////////////////////////////////
		// ESTRUCTURA DINAMICA DE DATOS              Wilo Carpio
		//   ARBOL EN  C++ 6                   01/06/2000
		//      MiPino
		//      Pino2000.cpp
		/////////////////////////////////////////////////////////////////
		#include
		#include
		#include
		#include
		#include
		#include
		
		//////////////////////////////////////////////////
		//   ESTRUCTURA DEL NODO DEL ARBOL
		//////////////////////////////////////////////////
		typedef struct MiBelloPino
		{
		 int    CodigoLibro;
		 char   TituloLibro[10], AutorLibro[10], Editorial[10];
		 struct MiBelloPino *RamaIzquierda,*RamaDerecha;
		} nodo;
		
		//////////////////////////////////////////////////
		//   PROTOTIPOS DE LAS FUNCIONES
		//////////////////////////////////////////////////
		int  MenuOpciones();
		char CerrarPrograma();
		void CargarNuevoNodo();
		void PupaUnNodo();
		void HacerPupaElNodo (nodo *MiBelloPino);
		void CambiarDatoDeNodo();
		void VerLosNodos(nodo *VerDatoDeNodo);
		int  YaExisteEseNodo(int);
		void MiArbolEstaVacio();
		nodo* DuplicarNodo(nodo *MiBelloPino, nodo *Puntero,int Codigo);
		nodo* InsertarNodoEnPino(nodo *MiBelloPino,nodo *Puntero);
		void NoEstaEnElArbol(int);  
		void RegistroLosCamposDelNodo(int);
		
		/////////////////////////////////////////////////////
		//   DECLARACION DE VARIABLES GLOBALES
		/////////////////////////////////////////////////////
		int  Opcion;
		nodo *NodoRaiz;
		nodo *NodoAuxiliar;
		nodo *NodoTemporario;
		nodo *NodoNuevo;
		nodo *NodoDeReemplazo;
		int  Codigo;
		char Titulo[10],Autor[10],Editorial[10];
		int  NodoExistente;
		int  Flap;
		char Si_No;
		
		////////////////////////////////////////////////////////
		//         PROGRAMA PRINCIPAL
		//         ==================
		////////////////////////////////////////////////////////
		void main(void)
		{
		  NodoRaiz=NULL;
		  while(toupper(Si_No) !='S')
		  { 
		   switch(MenuOpciones())
			{
			case 1: 
					CargarNuevoNodo();  break;
			case 2: 
					PupaUnNodo();       break;
			case 3: 
					CambiarDatoDeNodo();break;
			case 4:
					cout<<"          LOS LIBROS DE WILO SON \n";
					cout<<"\n Memoria   Codigo     Titulo           Autor        Editorial \n";
					VerLosNodos(NodoRaiz);   break;
			case 5: Si_No=CerrarPrograma();break;
			}
		  }
		}

ALTA DEL NUEVO NODO:
Aplicamos un proceso recursivo para cargar datos en cada nodo, pero como puedes apreciar y para destacar el manejo del árbol, no hacemos grabación física, o sea cuando salgas del sistema tus datos se borrarán, porque no tenemos un archivo permanente.


///////////////////////////////////////////////////////
//                ALTA DEL NUEVO NODO
///////////////////////////////////////////////////////

void CargarNuevoNodo()
{Si_No='s';
 do
 {
   cout<<" Digita datos del libro ";
   NodoNuevo = new (nodo);
   cout<<" CODIGO   : "; cin>>Codigo;
   if (YaExisteEseNodo(Codigo) ==1)
   {
    cout<<"\n  ....YA CARGASTE ESE CODIGO chee..!!! \n\n";
   }
   else
   {
    RegistroLosCamposDelNodo(Codigo);
	if (NodoRaiz == NULL)
	   NodoRaiz= NodoNuevo;
	else
	{
	  NodoAuxiliar=NodoRaiz;
	  while (NodoAuxiliar != NULL)
		{
		  NodoTemporario=NodoAuxiliar;
		  if (NodoAuxiliar->CodigoLibro > NodoNuevo->CodigoLibro)
			 NodoAuxiliar= NodoAuxiliar->RamaIzquierda ;
		  else
			 NodoAuxiliar= NodoAuxiliar->RamaDerecha;
		}
	  if (NodoTemporario->CodigoLibro > NodoNuevo->CodigoLibro)
		  NodoTemporario->RamaIzquierda=NodoNuevo;
	  else
		  NodoTemporario->RamaDerecha=NodoNuevo;
	}
   }

  cout<<" Cargas otro nodo ? (s/n) ";cin>>Si_No;
 }
while(!((Si_No!='s')&&(Si_No!='S')));
}

///////////////////////////////////////////////////////////////
//     DIGITANDO LOS DATOS DEL NODO EN EL ARBOL
///////////////////////////////////////////////////////////////
void RegistroLosCamposDelNodo(int)
{
	NodoNuevo->CodigoLibro=Codigo;
    cout<<"\t\t\t TITULO   : ";cin>>Titulo;   strcpy(NodoNuevo->TituloLibro,Titulo);
    cout<<"\t\t\t AUTOR    : ";cin>>Autor;	  strcpy(NodoNuevo->AutorLibro,Autor);
    cout<<"\t\t\t EDITORIAL: ";cin>>Editorial;strcpy(NodoNuevo->Editorial,Editorial);
	NodoNuevo->RamaIzquierda =NULL;
	NodoNuevo->RamaDerecha =NULL;
}

///////////////////////////////////////////////////////////////
//       INSERTANDO UN NUEVO NODO
///////////////////////////////////////////////////////////////
nodo* InsertarNodoEnPino(nodo *MiBelloPino, nodo *Puntero)
{
  NodoNuevo=new(nodo);
  NodoNuevo->CodigoLibro=MiBelloPino->CodigoLibro;
  strcpy(NodoNuevo->TituloLibro,MiBelloPino->TituloLibro);
  strcpy(NodoNuevo->AutorLibro,MiBelloPino->AutorLibro);
  strcpy(NodoNuevo->Editorial,MiBelloPino->Editorial);
  NodoNuevo->RamaIzquierda=NULL;
  NodoNuevo->RamaDerecha=NULL;
  if (Puntero==NULL)
	Puntero=NodoNuevo;
  else
  {
	NodoAuxiliar=Puntero;
	while(NodoAuxiliar!=NULL)
	{
	  NodoTemporario=NodoAuxiliar;
	  if (NodoAuxiliar->CodigoLibro >NodoNuevo->CodigoLibro)
		NodoAuxiliar=NodoAuxiliar->RamaIzquierda;
	  else
		NodoAuxiliar=NodoAuxiliar->RamaDerecha;
	}
	if (NodoTemporario->CodigoLibro > NodoNuevo->CodigoLibro)
	  NodoTemporario->RamaIzquierda=NodoNuevo;
	else
	  NodoTemporario->RamaDerecha=NodoNuevo;
  }
  return (Puntero);
}

///////////////////////////////////////////////////////////////
//       COPIANDO EL CONTENIDO DEL NODO
///////////////////////////////////////////////////////////////
nodo* DuplicarNodo (nodo *MiBelloPino, nodo *Puntero, int Codigo)
{ if (MiBelloPino != NULL)
  { if(Codigo != MiBelloPino->CodigoLibro)
	  Puntero=InsertarNodoEnPino(MiBelloPino, Puntero);
  Puntero=DuplicarNodo(MiBelloPino->RamaIzquierda, Puntero ,Codigo);
  Puntero=DuplicarNodo(MiBelloPino->RamaDerecha,   Puntero ,Codigo);
  }
  return (Puntero);
}

RECORRIDO DE NODOS:
El recorrido también requiere del proceso recursivo


///////////////////////////////////////////////////////////////
//   RECORRIDO DE LOS NODOS PARA VER DATOS
///////////////////////////////////////////////////////////////
void VerLosNodos( nodo*VerDatoDeNodo)
{
  if (NodoRaiz==NULL)			 
  { MiArbolEstaVacio();}
   else
   {   
   if (VerDatoDeNodo!=NULL)
	{
	  VerLosNodos(VerDatoDeNodo->RamaIzquierda);
	  cout<<&VerDatoDeNodo->CodigoLibro<<"\t"
	      <CodigoLibro<<"\t"
		  <TituloLibro<<"\t\t"
		  <AutorLibro<<"\t\t"
		  <Editorial<<" \n";
	  VerLosNodos(VerDatoDeNodo->RamaDerecha);
	}
  }
}
///////////////////////////////////////////////////////////////
//     BUSQUEDA DEL NODO EN EL ARBOL
///////////////////////////////////////////////////////////////
int YaExisteEseNodo (int CodigoBuscado)
{ 
  int valor;
  valor=0;
  NodoAuxiliar=NodoRaiz;
  while (NodoAuxiliar!=NULL)
  {
	NodoTemporario=NodoAuxiliar;
	if (NodoAuxiliar->CodigoLibro == CodigoBuscado)
	   valor=1;
	if (NodoAuxiliar->CodigoLibro > CodigoBuscado)
	   NodoAuxiliar=NodoAuxiliar->RamaIzquierda;
	else
	   NodoAuxiliar=NodoAuxiliar->RamaDerecha;
  }
  return valor;
}

BORRANDO UN NODO: La baja puede ser lógica o física


///////////////////////////////////////////////////////////////
//    BORRANDO UN NODO DEL ARBOL
///////////////////////////////////////////////////////////////
void HacerPupaElNodo (nodo *MiBelloPino)
{ 
 if (MiBelloPino!=NULL)
  { 
	HacerPupaElNodo(MiBelloPino->RamaIzquierda);
	HacerPupaElNodo(MiBelloPino->RamaDerecha);
	delete(MiBelloPino);
	MiBelloPino=NULL;
  }
}

///////////////////////////////////////////////////////////////
//     BAJA DE UN NODO DEL ARBOL
///////////////////////////////////////////////////////////////

void PupaUnNodo()
{
if (NodoRaiz==NULL)
{ MiArbolEstaVacio();}
else
{ 
 cout<<"\n ESTAS POR HACER PUPA UN LIBRO..  Digita el Codigo: ";cin>>Codigo;
 NodoExistente=YaExisteEseNodo(Codigo);
 if (NodoExistente==0)
  {
   NoEstaEnElArbol(Codigo);
   } 
   else
   {	
	Flap=0;
	NodoAuxiliar=NodoRaiz;
	while ((NodoAuxiliar!=NULL)&& (Flap==0))
	{ 
	  NodoTemporario=NodoAuxiliar;
	  if (NodoAuxiliar->CodigoLibro > Codigo)
		 NodoAuxiliar=NodoAuxiliar->RamaIzquierda;
	  else
		 if (NodoAuxiliar->CodigoLibro < Codigo)
		   NodoAuxiliar=NodoAuxiliar->RamaDerecha;
		 else
		 {
		  cout<<"\n         ESTE ES LIBRO QUE HARAS PUPA \n";
		  cout<<"\n Memoria   Codigo     Titulo           Autor        Editorial \n";
    	  cout<<&NodoAuxiliar->CodigoLibro<<"\t"
	          << NodoAuxiliar->CodigoLibro<<"\t"
		      << NodoAuxiliar->TituloLibro<<"\t\t"
		      << NodoAuxiliar->AutorLibro <<"\t\t"
		      << NodoAuxiliar->Editorial  <<" \n";
		  cout<<"    Queres borrar este Nodo ? (S/N) "; cin>>Si_No;
		  Flap=1;
		 }
	}
  }
  if (toupper(Si_No)=='S')
   {
	 NodoDeReemplazo=NULL;
	 NodoDeReemplazo=DuplicarNodo(NodoRaiz,NodoDeReemplazo,Codigo);
	 HacerPupaElNodo(NodoRaiz);
	 NodoRaiz=NodoDeReemplazo;
   }
  }
}

MODIFICAR DATOS:
Ojito.. este ejemplo no opera un archivo


///////////////////////////////////////////////////////////////
//    MODIFICAR LOS DATOS DEL NODO
///////////////////////////////////////////////////////////////
void CambiarDatoDeNodo()
{ 
if (NodoRaiz==NULL)
 { MiArbolEstaVacio();}
else
 {
  cout<<"\n MODIFICAR DATOS DEL NODO.. Digita el Codigo: ";cin>>Codigo;
  NodoExistente=YaExisteEseNodo(Codigo);
  if (NodoExistente==0)
   { 
    NoEstaEnElArbol(Codigo);
   }
  else
   {
	 Flap=0;
	 NodoAuxiliar=NodoRaiz;
	 while ( (NodoAuxiliar!=NULL)&&(Flap==0) )
	 {
	  NodoTemporario=NodoAuxiliar;
	  if (NodoAuxiliar->CodigoLibro > Codigo)
		NodoAuxiliar=NodoAuxiliar->RamaIzquierda;
	  else
		if (NodoAuxiliar->CodigoLibro < Codigo)
		  NodoAuxiliar=NodoAuxiliar->RamaDerecha;
		else
		  {
		  cout<<"\n         ESTE ES LIBRO QUE MODIFICARAS \n";
		  cout<<"\n Memoria   Codigo     Titulo           Autor        Editorial \n";
    	  cout<<&NodoAuxiliar->CodigoLibro<<"\t"
	          << NodoAuxiliar->CodigoLibro<<"\t"
		      << NodoAuxiliar->TituloLibro<<"\t\t"
		      << NodoAuxiliar->AutorLibro <<"\t\t"
		      << NodoAuxiliar->Editorial  <<" \n";
		  cout<<"    Confirmas la opcion ? (S/N) "; cin>>Si_No;
		   Flap=1;
		  }
	 }
	 if (toupper(Si_No)=='S')
	   {
		  cout<<"Titulo del Libro: "; cin>>Titulo;
		  strcpy(NodoAuxiliar->TituloLibro,Titulo);
		  cout<<"Autor del Libro : "; cin>>Autor;
		  strcpy(NodoAuxiliar->AutorLibro,Autor);
		  cout<<"Editorial       : "; cin>>Editorial;
		  strcpy(NodoAuxiliar->Editorial,Editorial);
	   }
     }
   }
}

ALGORITMOS TIPICOS:
Estas funciones te pueden servir en todos tus sistemas codificados en C++


///////////////////////////////////////
//      SALIR DEL PROGRAMA
///////////////////////////////////////
char CerrarPrograma()
{
    char Salir;
    cout<<"OJO.!! ESTE PROGRAMA NO TIENE ARCHIVO DE DATOS, POR ELLO SI SALES \n\n";
    cout<<"       PERDERAS LA INFORMACION GUARDADA EN LOS NODOS...!!!  \n\n";
    cout<<"-----------------------------------------------------------------\n";     
    cout<<"Deseas Cerrar el Programa ?  ( S / N ) ";cin>>Salir;          
	return toupper(Salir);
}

///////////////////////////////////////
//  FUNCION MENU DE OPCIONES
///////////////////////////////////////
int MenuOpciones()
{
    int MiOpcion;
	MiOpcion=1;
    cout<<"=========================================================================\n\n";     
    cout<<"  LA BIBLIOTECA PERSONAL DE WILO        ARBOL en C++    Junio_2000 \n\n";
    cout<<"   1 - ALTAS        3 - MODIFICAR       5 - SALIR  \n\n";
    cout<<"   2 - BAJAS        4 - VER NODOS           Elige tu Opcion: ";
    cin>>MiOpcion;          
    cout<<"-------------------------------------------------------------------------\n";     
	return MiOpcion;
}


///////////////////////////////////////
//  FUNCION LISTA VACIA
///////////////////////////////////////
void MiArbolEstaVacio()
{
 cout<<"\t\t\n  ESTE PINO ESTA VACIO...NO HAY NODOS..!!  \n\n";
}

///////////////////////////////////////
//  EL NODO NO EXISTE
///////////////////////////////////////
void NoEstaEnElArbol(int)  
{
 cout<<"\n......CHE..!!! NO EXISTE EL CODIGO " << Codigo << " \n\n ";
} 

APLICACION de CONSOLA
Cadena de Chomsky
Autómata formal

Analiza el siguiente ejemplo de una aplicación de consola simple, para ello activemos en nuestra PC, Visual C++ y luego ejecuta la siguiente secuencia operativa: ... buena suerte..!!

//////////////////////////////////////////////////
//
//  LEY DE OHM            LeyOhm.cpp      09/06/96
//
//  Wilo Carpio            C++
//
///////////////////////////////////////////////////

  #include < iostream.h >

///////////////////////////////////
//  PROTOTIPOS DE LAS FUNCIONES
///////////////////////////////////
  char VerMenu();
  void LeyDeOhm(char Opcion);
  float CalculaTension();	  
  float CalculaCorriente();	  
  float CalculaResistencia();	 

///////////////////////////////////
//       FUNCION PRINCIPAL
///////////////////////////////////
void main()
{
  // Definicion de variables globales
     char Opcion='S';

  // Mensaje de título por pantalla
	 cout << "\n\t APLICACION DE LA LEY DE OHM  Tension = Corriente * Resistencia \n";
	 cout << "\t ===========================         LeyOhm.cpp  Wilo Carpio \n";

  // Bucle While para activar el menú de opciones
	 do
	 {
	   Opcion=VerMenu();
	   LeyDeOhm(Opcion);
	 }
	 while((Opcion!='s')&&(Opcion!='S'));
} // Fin de la funcion principal


////////////////////////////////////////////////////
//  FUNCION VerMenu: Visualiza opciones operativas
////////////////////////////////////////////////////
char VerMenu()
{
  // Declaración de variables locales
     char Opcion='S';
	 
  // Menú de opciones
	 cout << "\n\t ELIGE OPCION:   V  Calculo de Voltage \n";
	 cout << "\t\t\t C  Calculo de Corriente \n";
	 cout << "\t\t\t R  Calculo de Resistencia \n";
	 cout << "\t\t\t S  Salir \n";	 cin >> Opcion;
return Opcion;
} // Fin de la función VerMenu

PARADIGMA
Un padre que da consejos,
... mas que padre es un incha pelotas..!!
Grafiti

////////////////////////////////////////////////////
//   FUNCION PARA SELECCIONAR EL CALCULO DE OHM
////////////////////////////////////////////////////
void LeyDeOhm(char Opcion)
{
  switch(Opcion)      // Selector múltiple
  {
  case'V':  cout << "\n TENSION = Corriente * Resistencia =  " << CalculaTension() << " Volts \n";
		     break;
  case'C':  cout << "\n CORRIENTE = Tension * Resistencia =  " << CalculaCorriente() << " Amper \n";
		     break;
  case'R':  cout << "\n RESISTENCIA = Tension / Corriente =  " << CalculaResistencia() << " Ohm \n";
		     break;
  case'S':  cout << "\n CHAU..!! SE FINI..!! \n";
		     break;
  default: cout << "\n Caca nene..!! /n";
  } // Fin del selector switch

} // Fin de la función LeyDeOhm

PARADIGMA
Si no quieres ser un recuerdo,
... se un reloco..!!
Grafiti


////////////////////////////////////////////////////
//         FUNCION CAlCULO DEL VOLTAJE
////////////////////////////////////////////////////
float CalculaTension()
{
  // Declaración de variables locales
     float Corriente=0.0;
     float Resistencia=0.0;
	 
  // Datos por teclado: Corriente y Resistencia
	 cout << "\n\t Ingresa el valor de la Corriente   I = "; cin >> Corriente;
	 cout << "\n\t Ahora el valor de la Resistencia   R = "; cin >> Resistencia;
  // Verica que corriente menor que cero, luego calcula voltaje
	 if (Resistencia<0)
	 {
  	   cout << "\n\t OJO.!! Resistencia negativa.!!! "<<"\n";
	   return 0.0;  
	 }
	 else
       return Corriente*Resistencia; 
} // Fin de la función CalculaTension


////////////////////////////////////////////////////
//         FUNCION CAlCULO DE LA CORRIENTE
////////////////////////////////////////////////////
float CalculaCorriente()
{
  // Declaración de variables locales
     float Voltaje=0.0;
     float Resistencia=0.0;
	 
  // Datos por teclado: Voltaje y Resistencia
	 cout << "\n\t Ingresa el valor de la Tension     V = "; cin >> Voltaje;
	 cout << "\n\t Ahora el valor de la Resistencia   R = "; cin >> Resistencia;
  // Verica que corriente menor que cero, luego calcula voltaje
	 if (Resistencia<0)
	 {
  	   cout << "\n\t OJO.!! Resistencia negativa.!!! " << "\n";
	   return 0.0;  
	 }
	 else
       return Voltaje*Resistencia; 
} // Fin de la función CalculaCorriente


////////////////////////////////////////////////////
//         FUNCION CAlCULO DE LA RESISTENCIA
////////////////////////////////////////////////////
float CalculaResistencia()
{
  // Declaración de variables locales
     float Voltaje=0.0;
     float Corriente=0.0;
	 
  // Datos por teclado: Corriente y Resistencia
	 cout << "\n\t Ingresa el valor de la Tension     V = "; cin>>Voltaje;
	 cout << "\n\t Ahora el valor de la Corriente     I = "; cin>>Corriente;
  // Verica que corriente sea cero, luego calcula voltaje
	 if (Corriente==0)
	 {
  	   cout << "\n\t OJO.!! Resistencia negativa.!!! "<<"\n";
	   return 0.0;  
	 }
	 else
       return Voltaje/Corriente; 
} // Fin de la función CalculaResistencia
PARADIGMA: Para enrredar un problema, nada mejor
que usar una computadora !!! ( Wilucha)

H O R O S C O P O
Cadena de Chomsky
Autómata formal

Aplica el siguiente proceso para operar mi propuesta de horóscopo:

using System;
namespace Pisis
{
		
		static void Main(string[] args)
		{
			//////////////////////////////////////////////	
			// PARTE OPERATIVA
			//////////////////////////////////////////////
			Console.WriteLine("\n H O R O S C O P O Wilo Carpio {0} \n", DateTime.Now);

			//////////////////////////////////////////////	
			// DECLARACION DE DE VARIABLES
			//////////////////////////////////////////////
			string Amigo;
			string signo="Aries";
			string x="n";
			int DiaNacimiento,MesNacimiento,AnoNacimiento;
			//////////////////////////////////////////////	
			// FECHAS ACTUALES
			//////////////////////////////////////////////
			int AnoActual = DateTime.Now.Year;
			int MesActual = DateTime.Now.Month;
			int DiaActual = DateTime.Now.Day;

			//////////////////////////////////////////////	
			// BUCLE PRINCIPAL
			//////////////////////////////////////////////
			do
			{
			Console.Write("\n Decime tu nombre: ");
			Amigo=Console.ReadLine();
			Console.WriteLine("\n"+Amigo+" vos naciste el:");
			Console.Write("Dia: ");
			DiaNacimiento=Convert.ToInt16(Console.ReadLine());
			Console.Write("Mes: ");
			MesNacimiento=Convert.ToInt16(Console.ReadLine());
			Console.Write("Año: ");
			AnoNacimiento=Convert.ToInt16(Console.ReadLine());

			//////////////////////////////////////////////	
			// Determinación del signo
			//////////////////////////////////////////////
			if ((MesNacimiento==3 && DiaNacimiento>=21)||(MesNacimiento==4 && DiaNacimiento<=20))
			{
				signo="Aries";
			}
			else
			{
				if ((MesNacimiento==4 && DiaNacimiento>=21)||(MesNacimiento==5 && DiaNacimiento<=20))
				{
					signo="Tauro";
				}
				else
				{
					if ((MesNacimiento==5 && DiaNacimiento>=21)||(MesNacimiento==6 && DiaNacimiento<=20))
					{
						signo="Geminis";
					}
					else
					{
						if ((MesNacimiento==6 && DiaNacimiento>=21)||(MesNacimiento==7 && DiaNacimiento<=20))
						{
							signo="Cancer";
						}
						else
						{
							if ((MesNacimiento==7 && DiaNacimiento>=21)||(MesNacimiento==8 && DiaNacimiento<=20))
							{
								signo="Leo";
							}
							else
							{
								if ((MesNacimiento==8 && DiaNacimiento>=21)||(MesNacimiento==9 && DiaNacimiento<=20))
								{
									signo="Virgo";
								}
								else
								{
									if ((MesNacimiento==9 && DiaNacimiento>=21)||(MesNacimiento==10 && DiaNacimiento<=20))
									{
										signo="Libra";
									}
									else
									{
										if ((MesNacimiento==10 && DiaNacimiento>=21)||(MesNacimiento==11 && DiaNacimiento<=20))
										{
											signo="Escorpio";
										}
										else
										{
											if ((MesNacimiento==11 && DiaNacimiento>=21)||(MesNacimiento==12 && DiaNacimiento<=20))
											{
												signo="Sagitario";
											}
											else
											{
												if ((MesNacimiento==12 && DiaNacimiento>=21)||(MesNacimiento==1 && DiaNacimiento<=20))
												{
													signo="Capricornio";
												}
												else
												{
													if ((MesNacimiento==1 && DiaNacimiento>=21)||(MesNacimiento==2 && DiaNacimiento<=20))
													{
														signo="Acuario";
													}
													else
													{
														if ((MesNacimiento==2 && DiaNacimiento>=21)||(MesNacimiento==3 && DiaNacimiento<=20))
														{
															signo="Piscis";
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}

			//////////////////////////////////////////////	
			// Determinación de la edad
			//////////////////////////////////////////////
			int Edad=AnoActual-AnoNacimiento;
			if(MesNacimiento>MesActual)
			{
				Edad=Edad-1;
			}
			else
			{
				if (MesNacimiento==MesActual)
				{
					if (DiaNacimiento>DiaActual)
					{
						Edad=Edad-1;
					}
					else
					{
						if(DiaNacimiento==DiaActual)
						{
							Console.WriteLine("Feliz Cumple");
						}
					}
				}

			}
			//////////////////////////////////////////////	
			// Salida de resultados al monitor
			//////////////////////////////////////////////
			Console.WriteLine("\n"+Amigo+" sos de Signo: "+signo+" y tenes "+Edad+" años \n\n");
			Console.WriteLine(Amigo + " queres hacer otro calculo ? (s/n)");

			x=Console.ReadLine();
			}
			while (x=="s");
		}
	}
}

SUPER SOFT
Cadena de Chomsky
Autómata formal

En esta aplicación te muestro como se maneja todas las estructuras simples de control de datos.
Aplica el siguiente proceso:

		///////////////////////////////////////////////////////////
		// C# PROGRAMA CONSOLA MODELO BASE 2006 Wilo Carpio
		// Manejo de estructuras simples 240706
		// Control de datos sin archivo Hs.11.10
		// Clases y Vectores
		///////////////////////////////////////////////////////////
		using System;
		using System.Runtime.InteropServices;
		
		namespace SuperSoft
		{
		 public class MiClase
		 {
		 [STAThread]
		 //////////////////////////////////////////////////
		 // FUNCION PRINCIPAL
		 //////////////////////////////////////////////////
		 static void Main(string[] args)
		 {
		 Pantalla("\t SOFTWARE LOCO");
		 Aguarda("\t\t\t\t\t\t ENTER para seguir");
		 MiClase MiMonitor = new MiClase();
		 string ClienteNombre;
		 string[] ProductoPedido = new String[10];
		 string[] NominaDeClientes = new String[15];
		 string[,] Articulo = new string[15, 15];
		 int OpcionPrincipal, ClienteNumero = 0;
		 double PrecioDeProducto, MontoEnCaja = 0;

		 do
		 {
		 OpcionPrincipal = OpcionMenuPrincipa();
		 switch (OpcionPrincipal)
		 {
		 //////////////////////////////////////////////////
		 // OPCION DE VENTAS
		 //////////////////////////////////////////////////
		 case 1:
		 int Indice = -1;
		 double SubTotalCaja = 0;
		 do
		 {
			 MenuVentas:
			 MiMonitor.Limpiar();
			 MiClase.MatrizProductos(Articulo);
			 switch (MiClase.VerMatriz(Articulo, "\n PRODUCTOS DISPONIBLES"))
			 {
			 case 1:
			 Indice++;
			 ProductoPedido[Indice] = "\t" + Articulo[1, 1] + "\t $" + Articulo[1, 2];
			 PrecioDeProducto = Convert.ToDouble(Articulo[1, 2]);
			 break;
			 case 2:
			 Indice++;
			 ProductoPedido[Indice] = "\t" + Articulo[2, 1] + "\t $" + Articulo[2, 2];
			 PrecioDeProducto = Convert.ToDouble(Articulo[2, 2]);
			 break;
			 case 3:
			 Indice++;
			 ProductoPedido[Indice] = "\t" + Articulo[3, 1] + "\t $" + Articulo[3, 2];
			 PrecioDeProducto = Convert.ToDouble(Articulo[3, 2]);
			 break;
			 case 4:
			 Indice++;
			 ProductoPedido[Indice] = "\t" + Articulo[4, 1] + "\t $" + Articulo[4, 2];
			 PrecioDeProducto = Convert.ToDouble(Articulo[4, 2]);
			 break;
			 default:
			 Aguarda("METISTE MAL EL DEDO..!! Enter para volver");
			 goto MenuVentas;
			 }
			 SubTotalCaja = SubTotalCaja + PrecioDeProducto;
			 }
		 while (OtraVez("Queres comprar otro producto"));

		 MontoEnCaja = MontoEnCaja + SubTotalCaja;
		 ClienteNumero = ClienteNumero + 1;
		 ClienteNombre = LeerNombreCliente();
		 NominaDeClientes[ClienteNumero] = "\t" + ClienteNombre + "\t $" + SubTotalCaja / 100;
		 ImprimeTicket(ClienteNombre, ProductoPedido, Indice, SubTotalCaja);
		 break;
		
		 //////////////////////////////////////////////////
		 // OPCION REPORTE TOTAL
		 //////////////////////////////////////////////////
		 case 2:
		 VerReporteDelDia(NominaDeClientes, ClienteNumero, MontoEnCaja);
		 break;
		
		 //////////////////////////////////////////////////
		 // OPCION ACERCA DE
		 //////////////////////////////////////////////////
		 case 3: MiMonitor.Limpiar();
		 Pantalla("\twww.wilocarpio.com");
		 Aguarda("\t\t\t\t\t\t ENTER para seguir");
		 break;
		
		 //////////////////////////////////////////////////
		 // SALIR DEL PROGRAMA
		 //////////////////////////////////////////////////
		 case 4: Aguarda("CERRARAS EL PROGRAMA..!! Enter para seguir"); break;
		 default: Aguarda(OpcionPrincipal + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break;
		 }
		 }
		 while (OpcionPrincipal != 4);
		 }

PARADIGMA: Las niñas buenas van al cielo y las malas a todas partes..!! Wilucha

		 //////////////////////////////////////////////////
		 // METODOS DEL PROGRAMA
		 //////////////////////////////////////////////////
		 private const int EntradaManual = -11;
		 private const byte EMPTY = 32;
		
		 [StructLayout(LayoutKind.Sequential)]
		 struct CoordenadaXY
		 {
		 public short x;
		 public short y;
		 }
		
		 [StructLayout(LayoutKind.Sequential)]
		 struct MiRectita
		 {
		 public short Left;
		 public short Top;
		 public short Right;
		 public short Bottom;
		 }
		
		 [StructLayout(LayoutKind.Sequential)]
		 struct MiMonitor
		 {
		 public CoordenadaXY dwSize;
		 public CoordenadaXY dwCursorPosition;
		 public int wAttributes;
		 public MiRectita srWindow;
		 public CoordenadaXY dwMaximumWindowSize;
		 }
		
		 [DllImport("kernel32.dll", EntryPoint = "GetStdHandle", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
		 private static extern int GetStdHandle(int nStdHandle);
		
		 [DllImport("kernel32.dll", EntryPoint = "FillConsoleOutputCharacter", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
		 private static extern int FillConsoleOutputCharacter(int hConsoleOutput, byte cCharacter, int nLength, CoordenadaXY dwWriteCoordenadaXY, ref int lpNumberOfCharsWritten);
		
		 [DllImport("kernel32.dll", EntryPoint = "GetConsoleScreenBufferInfo", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
		 private static extern int GetConsoleScreenBufferInfo(int hConsoleOutput, ref MiMonitor lpConsoleScreenBufferInfo);
		
		 [DllImport("kernel32.dll", EntryPoint = "SetConsoleCursorPosition", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
		 private static extern int SetConsoleCursorPosition(int hConsoleOutput, CoordenadaXY dwCursorPosition);
		
		 private int hConsoleHandle;
		
		 public MiClase()
		 {
		 hConsoleHandle = GetStdHandle(EntradaManual);
		 }
		 public void Limpiar()
		 {
		 int EscribeCaracter = 0;
		 MiMonitor strConsoleInfo = new MiMonitor();
		 CoordenadaXY Home;
		 Home.x = Home.y = 0;
		 GetConsoleScreenBufferInfo(hConsoleHandle, ref strConsoleInfo);
		 FillConsoleOutputCharacter(hConsoleHandle, EMPTY, strConsoleInfo.dwSize.x * strConsoleInfo.dwSize.y, Home, ref EscribeCaracter);
		 SetConsoleCursorPosition(hConsoleHandle, Home);
		 }

		 static int OpcionMenuPrincipa()
		 {
		 MiClase MiMonitor = new MiClase();
		 MiMonitor.Limpiar();
		 Pantalla("\tMENU PRINCIPAL\n");
		 Console.WriteLine(" 1 → VENTAS");
		 Console.WriteLine("\n 2 → TOTAL VENTAS");
		 Console.WriteLine("\n 3 → ACERCA DE");
		 TrazarRayaSimple(78);
		 Console.WriteLine("\n 4 → SALIR");
		 Console.Write("\n Digita opción (Luego ENTER): ");
		 int OpcionElegida = Convert.ToInt32(Console.ReadLine());
		 return OpcionElegida;
		 }
		
		 static void TrazarRayaSimple(int TotalRayitas)
		 {
		 int i;
		 for (i = 1; i <= TotalRayitas; i++) Console.Write("─");
		 }
		 static bool OtraVez(string Pregunta)
		 {
		 bool Respuesta = false;
		 string Opcion;
		 Console.Write("\n\t" + Pregunta + "? (s/n)");
		 Opcion = Console.ReadLine();
		 if ((Opcion == "s") || (Opcion == "S"))
		 Respuesta = true;
		 return Respuesta;
		 }

		 static void Aguarda(string Mensaje)
		 {
		 Console.Write("\n\t" + Mensaje);
		 Console.ReadLine();
		 }
		
		 static string LeerNombreCliente()
		 {
		 string nomCliente;
		 TrazarRayaSimple(78);
		 Console.Write("\n Nombre del cliente: "); nomCliente = Console.ReadLine();
		 return nomCliente;
		 }
		 static void Pantalla(string Mensaje)
		 {
		 int i;
		 Console.Write("\n ╔");
		 for (i = 1; i <= 34; i++) Console.Write("═");
		 Console.WriteLine("╗");
		 Console.WriteLine(" ║ C#: Modelo Base 2006 ║");
		 Console.Write(" ╠");
		 for (i = 1; i <= 34; i++) Console.Write("═");
		 Console.WriteLine("╣");
		 Console.WriteLine(" ║ WILUCHA 1.0 ║");
		 Console.Write(" ╚");
		 for (i = 1; i <= 34; i++) Console.Write("═");
		 Console.Write("╝");
		 Console.WriteLine("\t\t\t\t\t\t" + Mensaje);
		 }

		 static void MatrizProductos(string[,] Articulo)
		 {
		 Articulo[1, 1] = "Ventas y Facturación Win 1.0";
		 Articulo[1, 2] = "300.00";
		 Articulo[2, 1] = "Administración de Personal";
		 Articulo[2, 2] = "200.00";
		 Articulo[3, 1] = "Liquidación de Impuestos";
		 Articulo[3, 2] = "250.00";
		 Articulo[4, 1] = "Control de Compras y Stock";
		 Articulo[4, 2] = "300.00";
		 }
		
		 static int VerMatriz(string[,] MatrizDeDatos, string Titulo)
		 {
		 int i;
		 Pantalla(Titulo);
		 Console.WriteLine("\n\t Art Precio Denominacion");
		 for (i = 1; i <= 4; i++)
		 Console.WriteLine("\t {0}{1}{2}{3}{4}", i, "\t", MatrizDeDatos[i, 2], "\t", MatrizDeDatos[i, 1]);
		 Console.Write("\n\n¿Qué producto deseas comprar?: ");
		 int Opcion = Convert.ToInt32(System.Console.ReadLine());
		 return Opcion;
		 }
		
		 static void ImprimeTicket(string NombreCliente, string[] ProductoPedido, int iMax, double subTotal)
		 {
		 MiClase MiMonitor = new MiClase();
		 MiMonitor.Limpiar();
		 Pantalla("\n TICKET - " + DateTime.Now);
		 Console.WriteLine(" Cliente Sr/Sra: " + NombreCliente);
		 TrazarRayaSimple(78); Console.WriteLine("");
		 Console.WriteLine("\tPRODUCTO PRECIO ");
		 for (int j = 0; j <= iMax; j++)
		 Console.WriteLine(j + 1 + ProductoPedido[j]);
		 Console.WriteLine("\n		TOTAL : $" + subTotal / 100);
		 TrazarRayaSimple(78);
		 Aguarda("Gracias por tu compra ENTER para volver");
		 }
		
		 static void VerReporteDelDia(string[] Cliente, int TotalClientes, double MontoEnCaja)
		 {
		 MiClase MiMonitor = new MiClase();
		 MiMonitor.Limpiar();
		 Console.WriteLine("\n\n REPORTE DÍA " + DateTime.Now);
		 TrazarRayaSimple(78);
		 Console.WriteLine("\n Nomina de Clientes: " + TotalClientes);
		 for (int NroCliente = 0; NroCliente <= TotalClientes; NroCliente++)
		 Console.WriteLine("\t" + Cliente[NroCliente]);
		 Console.WriteLine("\n Recaudación : $" + MontoEnCaja / 100 + "\n");
		 TrazarRayaSimple(78);
		 Aguarda("\n ENTER para volver al menú principal");
		 }
		 }
		}

Aplicaciones Windows
Cadena de Chomsky
Autómata formal

Para crear un programa con los elementos del entorno de desarrollo integrado (IDE) de Visual C# se utilizan los formularios Windows Forms que proporcionan componentes de la interfaz de usuario de aplicación para Windows estándar, como cuadros de diálogo, menús, botones y otros muchos controles. Estos controles son clases de la biblioteca de clases de .NET Framework.
La vista Diseñador de Visual C# permite arrastrar los controles hasta el formulario principal de la aplicación, así como ajustar su tamaño y posición, luego, cuando se realiza esta acción, el IDE agrega automáticamente el código fuente para crear una instancia de la clase apropiada e inicializarla.

El siguiente ejemplo muestra los pasos para crear una aplicación de explorador web, que se puede personalizar con accesos directos a los sitios Web favoritos.

  1. Cree una nueva aplicación para formularios Windows Forms.
  2. Alternar entre la vista Código y la vista Diseñador.
  3. Cambiar las propiedades del formulario Windows Forms.
  4. Agregar un control MenuStrip.
  5. Agregar un control Button.
  6. Crear y rellenar un control ComboBox.
  7. Usar un control WebBrowser.
  8. Crear controladores de eventos para controles.

Para crear tal aplicación para Windows en C#:
  1. En el menú Archivo, haga clic en Nuevo proyecto: Aparecerá el cuadro de diálogo Nuevo proyecto. En este cuadro de diálogo se muestra la lista de los diferentes tipos de aplicación predeterminados que puede crear Visual C#.

  2. Seleccione Aplicación de Windows Forms como tipo de proyecto.

  3. Cambie el nombre de la aplicación a Explorador web.

  4. Haga clic en Aceptar: Visual C# crea una nueva carpeta para el proyecto con el nombre del título del proyecto y, a continuación, muestra el nuevo formulario Windows Forms titulado Form1 en la vista Diseñador.
    Puede alternar entre esta vista y la vista Código en cualquier momento si hace clic con el botón secundario del mouse en la superficie de diseño o en la ventana de código y selecciona Ver código o Ver diseñador.

    El formulario Windows Forms que se ve en la vista Diseñador es una representación visual de la ventana que se abrirá al abrir la aplicación. En la vista Diseñador, puede arrastrar diversos controles desde el Cuadro de herramientas hasta el formulario.
    Estos controles no están realmente "activos"; son sólo imágenes que se pueden mover sin problemas por el formulario hasta ocupar un lugar preciso.

    Una vez colocado un control en el formulario, Visual C# funciona en segundo plano para crear el código que hará que el control real ocupe la posición correcta cuando se ejecute el programa.
    Este código fuente se encuentra en un archivo que, generalmente, permanece anidado fuera de la vista. Puede ver este archivo, denominado Form1.designer.cs, en el Explorador de soluciones si expande Form1.cs.

  5. Si está en la vista Código, cambie a la vista Diseñador haciendo clic con el botón secundario del mouse en la ventana de código y, a continuación, haciendo clic en Ver diseñador. Ahora, cambie el tamaño del formulario Windows Forms.
    - a.Haga clic en la esquina inferior derecha del formulario Windows Forms.
    - b.Cuando el puntero se convierta una flecha de dos puntas, arrastre la esquina del formulario hasta que sea por lo menos tan ancho y profundo como un cuarto de su pantalla.

  6. Asegúrese de que se muestra la ventana Propiedades. Su ubicación predeterminada es la sección inferior derecha del IDE, pero puede moverla a otra ubicación si lo desea. La ilustración siguiente la muestra en la esquina superior derecha. Si la ventana Propiedades no está visible, en el menú Ver haga clic en Ventana Propiedades. Esta ventana muestra las propiedades del control o formulario Windows Forms seleccionado y en ella se pueden cambiar los valores existentes.

  7. Cambie el título del formulario Windows Forms.
    - a.Haga clic en el formulario para seleccionarlo.
    - b.En la ventana Propiedades, desplácese hacia abajo hasta Text, seleccione el texto "Form1" y escriba Explorador web.
    - c.Presione ENTRAR o TAB para desplazar el foco del cuadro de texto "Text".

    Ahora verá que el texto situado en la parte superior del formulario Windows Forms (en el área denominada barra de título) ha cambiado.
    Para cambiar rápidamente el nombre de un control, haga clic con el botón secundario del mouse en el control y haga clic en Propiedades. Puede escribir el nuevo nombre para el control en la propiedad Name.

  8. Haga clic en el botón Cuadro de herramientas de la barra de herramientas, o bien, haga clic en Cuadro de herramientas en el menú Ver.
    Desplácese hacia abajo por la lista de controles y expanda Menús y barras de herramientas hasta que vea MenuStrip.
    Arrastre este control a cualquier lugar del formulario Windows Forms. Este control crea un menú predeterminado en la parte superior del formulario.

  9. En el cuadro que dice Escriba aquí, escriba el nombre del menú, en este caso Navegar. Cuando presione ENTRAR, aparecerán nuevos cuadros vacíos para crear otros menús y elementos de menú. En el cuadro inferior, escriba Inicio.
    Presione ENTRAR y aparecerán más cuadros. Escriba Hacia atrás. Presione ENTRAR y escriba Hacia delante.

    Estos elementos de menú forman los controles de navegación básicos del sitio Web.

  10. Agregue un botón: En el Cuadro de herramientas, en la categoría Controles comunes, arrastre un control Button hasta aproximadamente la mitad del formulario Windows Forms, justo debajo de la barra de menús. En la ventana Propiedades, cambie la propiedad Text a Ir en lugar de button1, y cambie el nombre del diseño, que se muestra como (Nombre), de button1 a BotonIr.

  11. Agregue un control ComboBox: En el Cuadro de herramientas, en la categoría Controles comunes, arrastre un control ComboBox y colóquelo a la izquierda del nuevo botón. Arrastre los bordes y las esquinas para cambiar el tamaño y la posición del control ComboBox hasta que quede alineado con el botón.

    Cuando mueva los controles en un formulario Windows Forms, verá aparecer líneas azules. Estas líneas son guías que ayudan a alinear los controles en dirección vertical y horizontal. También puede alinear controles seleccionando más de uno a la vez. Para ello, haga clic y arrastre un cuadro de selección alrededor de los controles, o mantenga presionada la tecla MAYÚS mientras hace clic en ellos.
    Después de tener varios controles seleccionados, puede modificar la alineación y el tamaño utilizando los iconos de alineación y cambio de tamaño. Estos iconos aparecen en la Barra de herramientas de diseño, en la parte superior de la ventana Diseño.

  12. Rellene el control ComboBox: Un control ComboBox proporciona una lista desplegable de opciones entre las que el usuario puede seleccionar. En este programa, el control ComboBox va a contener una lista de los sitios web favoritos para obtener un rápido acceso.

    Para crear la lista de sitios, seleccione el control ComboBox y vea sus propiedades. Seleccione la propiedad Items; verá la palabra (Colección) y un botón puntos suspensivos (...). Haga clic en este botón para modificar el contenido del control ComboBox.
    Agregue tantas direcciones URL del sitio Web como desee, presionando RETORNO después de cada una. Asegúrese de incluir http:// delante de cada una de las direcciones de sitio web.

  13. Agregue el control WebBrowser: En el Cuadro de herramientas, en la categoría Controles comunes, desplácese hacia abajo hasta llegar al control WebBrowser. Arrastre el control hasta el formulario Windows Forms. Cambie el tamaño del control WebBrowser para ajustarlo al formulario Windows Forms sin ocultar los controles ComboBox y Button.
    Si el tamaño del control WebBrowser no se puede cambiar fácilmente, configure primero el tamaño deseado, abra las propiedades, busque el valor Dock y asegúrese de que está establecido en ninguno. Al establecer la configuración de Anchor en Superior, Inferior, Izquierda, Derecha, el control WebBrowser cambiará su tamaño correctamente cuando se cambie el tamaño de la ventana de la aplicación.

    El control WebBrowser realiza todo el trabajo difícil de representación de páginas Web. El acceso a este control en la aplicación se realiza a través de una instancia de la clase WebBrowser. Observe form1.Designer.cs y verá que se ha agregado una instancia de esta clase al código de la aplicación, junto con instancias de clases que representan los demás elementos que se han agregado utilizando el diseñador.
    Estas son las instancias que utilizará cuando agregue controladores de eventos para los controles y llame a los métodos de los citados controles.

  14. Agregue un controlador de eventos para el control Button: Ya ha terminado la etapa de diseño de la aplicación y ahora puede empezar a agregar código para proporcionar la funcionalidad del programa.

    El programa debe tener los controladores de eventos para el botón y para cada opción de menú. Un controlador de eventos es un método que se ejecuta cuando el usuario interactúa con el control. Visual C# Express crea automáticamente controladores de eventos vacíos.

    Haga doble clic en el botón y verá aparecer el Editor de código para el proyecto. También verá que se ha creado el controlador para el evento Click, que es el mensaje que aparece cuando el usuario hace clic en un botón. Agregue código al método del controlador de eventos de modo similar al siguiente código.

    
    		private void goButton_Click(object sender, System.EventArgs e)
    		{
    			webBrowser1.Navigate(new Uri(comboBox1.SelectedItem.ToString()));
    		}
    

    Este código toma el elemento seleccionado del control ComboBox, una cadena que contiene una dirección URL web, y lo pasa al método Navigate del explorador web. El método Navigate se carga y muestra el contenido de la página Web en esa ubicación.

  15. Agregue controladores de eventos para las opciones de MenuStrip.
    Vuelva a la ventana Diseñador y haga doble clic en los subelementos del menú de uno en uno. Visual C# Express creará métodos de control de eventos para cada uno. Edite estos métodos, de modo que se asemejen al código siguiente.
    
    		private void homeToolStripMenuItem_Click(object sender, System.EventArgs e)
    		{
    			webBrowser1.GoHome();
    		}
    		
    		private void goForwardToolStripMenuItem_Click(object sender, System.EventArgs e)
    		{
    			webBrowser1.GoForward();
    		}
    		
    		private void goBackToolStripMenuItem_Click(object sender, System.EventArgs e)
    		{
    			webBrowser1.GoBack();
    		}
    

    Cada uno de estos controladores de menú llama a un método de navegación admitido en la clase WebBrowser.

    A partir de este código, puede ver que los nombres predeterminados dados a las opciones de menú pueden resultar muy confusos. Por esta razón, es una buena idea cambiar el nombre de cada control de menú al crearlo mediante el editor de Propiedades. El nombre del controlador reflejará entonces el nombre de la opción de menú.

  16. Vea el código que Visual C# ha escrito automáticamente.
    El IDE de Visual C# ya ha escrito código de inicialización. En la vista Código, busque el constructor de la clase Form1. Tiene una firma de public Form1().
    Haga clic con el botón secundario del mouse en el método InitializeComponent al que se llama desde dentro del constructor y, a continuación, haga clic en Ir a definición.
    Ahora verá todo el código que se iba escribiendo en segundo plano mientras arrastraba y colocaba controles y establecía propiedades en la ventana Propiedades.

  17. Agregue código de inicialización propio.
    La última tarea es agregar su propio código de inicialización a Form1. El constructor nunca debe utilizarse para llamar a código que pueda producir una excepción. Por consiguiente, cualquier código de este tipo se debe colocar en otra parte; ese lugar es el método Form1_Load.
    Haga clic en la ficha Form1.cs [Diseño] en la parte superior del editor de código para regresar al formulario Windows Forms.
    Seleccione el formulario y, en la ventana Propiedades, haga clic en el botón Eventos (el que tiene un icono de rayo) y, a continuación, haga doble clic en Cargar.
    Esto agregará un método de control de eventos y colocará el cursor en el método en la vista Código.

    Cuando un usuario final inicie el programa, Windows notificará este hecho al formulario de la aplicación enviando un evento Load. Cuando el formulario reciba ese evento, llamará al método Form1_Load. Los métodos a los que se llama en respuesta a eventos se denominan controladores de eventos.
    El sistema llamará al evento en el momento adecuado; ahora tiene que colocar el código en el controlador de eventos que desee que se ejecute cuando se produzca el evento.

    En la vista Código, agregue dos líneas al método Form1_Load, como se muestra a en el siguiente código. Esto hará que el control WebBrowser muestre la página principal predeterminada del equipo y establezca el valor inicial del control ComboBox.

    
    private void Form1_Load(object sender, EventArgs e)
    {
        comboBox1.SelectedIndex = 0;
        webBrowser1.GoHome();
    }
    

  18. Genere y ejecute el programa.
    Presione F5 para generar y ejecutar el explorador web. Se mostrará en pantalla el formulario Windows Forms creado y, a continuación, aparecerá la página principal predeterminada del equipo. Puede utilizar el control ComboBox para seleccionar un sitio web, y hacer clic en Ir para navegar al mismo.
    Las opciones de menú permiten volver a la página principal o desplazarse hacia delante y hacia atrás a través de los sitios Web visitados anteriormente.

Visual C# a pulmón
Aplicación Windows
Autómata formal

En el siguiente ejemplo te muestro la manera de generar una aplicación WINDOWs, sin necesidad de usar el entorno de desarrollo integrado(IDE), usando solamente el simple Block de Notas: Para esto desarrolla el siguiente proceso:

Con block de notas: escribir el siguiente código, guardarlo como .cs Ejemplo: MiFormu.cs

  • Para compilar: ir a "Simbolo del Sistema" Clickear en:

    Microsoft Visual Studio\ Visual Studio Tools\ Simbolo del Sistema
    Se abre una ventana tipo DOS:
    C:\Archivos de programa\ Microsoft Visual Studio 8\VC>

  • Completar:

    C:\Archivos de programa\ Microsoft Visual Studio 8\VC>csc MiFormu.cs

  • Si no hay errores:, se genera un ejecutable Ej. MiFormu.exe

  • Clickea sobre el ejecutable: y veras el resultado.

    BONUS TRACK !!!

    
    	////////////////////////////////////////////////////////////////////////////
    	// C#  PROGRAMA WINDOW MODELO BASE CON ARCHIVO 2006     Wilo Carpio
    	//                                                     21 Mayo 2007
    	//
    	//            GENERAR UN FORMULARIO POR CODIGO 
    	//
    	// 1. Con block de notas escribir el siguiente código, guardarlo como .cs
    	//    Ejemplo: MiFormu.cs 
    	// 2. Para compilar ir a "Simbolo del Sistema" Clickear en:
    	//    Microsoft Visual Studio\ Visual Studio Tools\ Simbolo del Sistema
    	//    Se abre una ventana tipo DOS:
    	//    C:\Archivos de programa\ Microsoft Visual Studio 8\VC>
    	// 3. Completar:
    	//    C:\Archivos de programa\ Microsoft Visual Studio 8\VC>csc/t:winexe MiFormu.cs
    	// 4. Si no hay errores, se genera un ejecutable Ej. MiFormu.exe
    	// 5. Clickea sobre el ejecutable "MiFormu.exe" y veras el resultado. 
    	//
    	//////////////////////////////////////////////////////////////////////////
    using System;
    using System.Runtime.InteropServices;
    using System.IO;
    using System.Drawing;
    using System.Drawing.Printing;
    using System.Collections;
    using System.Windows.Forms;
    
    namespace Programa 
    {
        public class MiFormulario:Form
        {
            //MAIN
            static void Main()
            {
                //CREAMOS MiFormulario
                MiFormulario MiFormulario = new MiFormulario();
                MiFormulario.Size = new System.Drawing.Size(300, 200);
                MiFormulario.StartPosition = FormStartPosition.CenterScreen;
                MiFormulario.FormBorderStyle = FormBorderStyle.FixedSingle;
                MiFormulario.Text = "Wilo Carpio";
    
                //LLAMAMOS A MiFormulario
                Application.EnableVisualStyles();
                Application.Run(MiFormulario);
            }
    
            //DISEÑO
            //MiFormulario: PRESENTACION
            public MiFormulario()
            {
                //PANEL
                Panel UnPanel = new Panel();
                UnPanel.Size = new System.Drawing.Size(200, 100);
                UnPanel.BorderStyle = BorderStyle.Fixed3D;
                UnPanel.Location = new Point(45, 12);
                Controls.Add(UnPanel);
    
                //LETRERO 1
                Label Rotulo1 = new Label();
                Rotulo1.Text = "C# Base Modelo 2006";
                Rotulo1.Size = new Size(150, 15);
                Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold);
                Rotulo1.Location = new Point(45, 15);
                UnPanel.Controls.Add(Rotulo1);
    
                //LETRERO 2
                Label Rotulo2 = new Label();
                Rotulo2.Text = "Wilucha 1.0";
                Rotulo2.Size = new Size(150, 15);
                Rotulo2.Location = new Point(65, 40);
                UnPanel.Controls.Add(Rotulo2);
    
                //LETRERO 3
                Label Rotulo3 = new Label();
                Rotulo3.Text = "SOFTWARE LOCO";
                Rotulo3.Size = new Size(150, 15);
                Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Italic);
                Rotulo3.Location = new Point(50, 65);
                UnPanel.Controls.Add(Rotulo3);
    
                //BOTON EntrarBoton
                Button EntrarBoton = new Button();
                EntrarBoton.Location = new Point(60, 130);
                EntrarBoton.Text = "Entrar";
                EntrarBoton.Click += new EventHandler(BotonEntrarBotonClick);
                Controls.Add(EntrarBoton);
    
                //BOTON SalirBoton
                Button SalirBoton = new Button();
                SalirBoton.Location = new Point(160, 130);
                SalirBoton.Text = "Salir";
                SalirBoton.Click += new EventHandler(BotonSalirBotonClick);
                Controls.Add(SalirBoton);
            }
    
            //EVENTOS:
            //BOTON EntrarBoton
            public void BotonEntrarBotonClick(object sender, EventArgs Arguments)
            {
                this.Hide();
    
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
    
                FormularioMenu.Show();
            }
    
            //BOTON SalirBoton
            public void BotonSalirBotonClick(object sender, EventArgs Arguments)
            {
                Text = "Adios amigo..!";
                MessageBox.Show("Estas por cerrar el programa","SalirBoton",MessageBoxButtons.OK,MessageBoxIcon.Stop);
                Application.Exit();
            }
        }
    
        public class FormularioMenu : Form
        {
            //DISEÑO
            //FORMA 2: MENU PRINCIPAL
            public FormularioMenu()
            {
                //PANEL
                Panel UnPanel = new Panel();
                UnPanel.Size = new System.Drawing.Size(570, 50);
                UnPanel.BorderStyle = BorderStyle.Fixed3D;
                UnPanel.Location = new Point(10, 10);
                Controls.Add(UnPanel);
    
                //PANEL 2
                Panel OtroPanel = new Panel();
                OtroPanel.Size = new System.Drawing.Size(570, 220);
                OtroPanel.BorderStyle = BorderStyle.Fixed3D;
                OtroPanel.Location = new Point(10, 70);
                Controls.Add(OtroPanel);
    
                //LETRERO 1
                Label Rotulo1 = new Label();
                Rotulo1.Text = "C# Base Modelo 2006";
                Rotulo1.Size = new Size(150, 15);
                Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold);
                Rotulo1.Location = new Point(45, 15);
                UnPanel.Controls.Add(Rotulo1);
    
                //LETRERO 2
                Label Rotulo2 = new Label();
                Rotulo2.Text = "Wilucha 1.0";
                Rotulo2.Size = new Size(150, 15);
                Rotulo2.Font = new Font(Rotulo1.Font, FontStyle.Bold);
                Rotulo2.Location = new Point(250, 15);
                UnPanel.Controls.Add(Rotulo2);
    
                //LETRERO 3
                Label Rotulo3 = new Label();
                Rotulo3.Text = "SOFTWARE LOCO";
                Rotulo3.Size = new Size(150, 15);
                Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Bold);
                Rotulo3.Location = new Point(400, 15);
                UnPanel.Controls.Add(Rotulo3);
    
                //BOTON VENTAS
                Button Ventas = new Button();
                Ventas.Location = new Point(10, 10);
                Ventas.Text = "Vender Producto";
                Ventas.Size = new Size(550, 20);
                Ventas.Click += new EventHandler(BotonVentasClick);
                OtroPanel.Controls.Add(Ventas);
    
                //BOTON VER NOMINA DE CLIENTES
                Button Ver = new Button();
                Ver.Location = new Point(10, 50);
                Ver.Text = "Ver Nómina de Clientes";
                Ver.Size = new Size(550, 20);
                Ver.Click += new EventHandler(BotonVerClick);
                OtroPanel.Controls.Add(Ver);
    
                //BOTON VER Lista DE PRODUCTOS
                Button BotonVerLista = new Button();
                BotonVerLista.Location = new Point(10, 90);
                BotonVerLista.Text = "Ver Lista de Productos";
                BotonVerLista.Size = new Size(550, 20);
                BotonVerLista.Click += new EventHandler(BotonBotonVerListaClick);
                OtroPanel.Controls.Add(BotonVerLista);
    
                //BOTON ACERCA DE
                Button Acerca = new Button();
                Acerca.Location = new Point(10, 170);
                Acerca.Text = "Acerca de...";
                Acerca.Size = new Size(550, 20);
                Acerca.Click += new EventHandler(BotonAcercaClick);
                OtroPanel.Controls.Add(Acerca);
    
                //BOTON BotonAlta
                Button BotonAlta = new Button();
                BotonAlta.Location = new Point(10, 130);
                BotonAlta.Text = "Alta Producto";
                BotonAlta.Size = new Size(550, 20);
                BotonAlta.Click += new EventHandler(BotonBotonAltaClick);
                OtroPanel.Controls.Add(BotonAlta);
    
                //BOTON SalirBoton
                Button SalirBoton = new Button();
                SalirBoton.Location = new Point(260, 300);
                SalirBoton.Text = "Salir";
                SalirBoton.Click += new EventHandler(BotonSalirBotonClick);
                Controls.Add(SalirBoton);
            }
    
            //EVENTOS
            //BOTON SalirBoton
            public void BotonSalirBotonClick(object sender, EventArgs Arguments)
            {
                Text = "Adios amigo..!";
                MessageBox.Show("Estas por cerrar el programa", "Salir", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                Application.Exit();
                File.Delete("C:\\temp3.txt");
            }
    
            //BOTON BotonAlta
            public void BotonBotonAltaClick(object sender, EventArgs Arguments)
            {
                PanelAltas PanelAltas = new PanelAltas();
                PanelAltas.Size = new System.Drawing.Size(400, 200);
                PanelAltas.StartPosition = FormStartPosition.CenterScreen;
                PanelAltas.FormBorderStyle = FormBorderStyle.FixedSingle;
                PanelAltas.Text = "Alta";
    
                Close();
    
                PanelAltas.Show();
            }
    
            //BOTON ACERCA DE
            public void BotonAcercaClick(object sender, EventArgs Arguments)
            {
                PanelAcercaDe PanelAcercaDe = new PanelAcercaDe();
                PanelAcercaDe.Size = new Size(200, 200);
                PanelAcercaDe.StartPosition = FormStartPosition.CenterScreen;
                PanelAcercaDe.FormBorderStyle = FormBorderStyle.FixedSingle;
                PanelAcercaDe.Text = "Acerca de...";
    
                Close();
    
                PanelAcercaDe.Show();
            }
    
            //BOTON VER BotonVerLista DE PRODUCTOS
            public void BotonBotonVerListaClick(object sender, EventArgs Arguments)
            {
                PanelListar PanelListar = new PanelListar();
                PanelListar.Size = new Size(370, 470);
                PanelListar.StartPosition = FormStartPosition.CenterScreen;
                PanelListar.FormBorderStyle = FormBorderStyle.FixedSingle;
                PanelListar.Text = "Lista de Productos";
    
                Close();
    
                PanelListar.Show();
            }
    
            //BOTON VER NOMINA DE CLIENTES
            public void BotonVerClick(object sender, EventArgs Arguments)
            {
                PanelListarClientes PanelListarClientes = new PanelListarClientes();
                PanelListarClientes.Size = new Size(370, 470);
                PanelListarClientes.StartPosition = FormStartPosition.CenterScreen;
                PanelListarClientes.FormBorderStyle = FormBorderStyle.FixedSingle;
                PanelListarClientes.Text = "Nómina de Clientes";
    
                Close();
    
                PanelListarClientes.Show();
            }
    
            //BOTON VENTAS
            public void BotonVentasClick(object sender, EventArgs Arguments)
            {
                File.Delete("C:\\temp.txt");
                File.Delete("C:\\temp2.txt");
                PanelVentas PanelVentas = new PanelVentas();
                PanelVentas.Size = new Size(370, 470);
                PanelVentas.StartPosition = FormStartPosition.CenterScreen;
                PanelVentas.FormBorderStyle = FormBorderStyle.FixedSingle;
                PanelVentas.Text = "Ventas";
    
                Close();
    
                PanelVentas.Show();
            }
        }
    
        public class PanelAltas : Form
        {
            //VARIABLES
            public string[,] UnaMatriz = new string[15,2];
            public int i = 0;
    
            StreamWriter ArchDeEscritura,ArchDeEscritura2;
            StreamReader ArchDeLectura,ArchDeLectura2;
    
            private System.Windows.Forms.TextBox textbox1;
            private System.Windows.Forms.TextBox textbox2;
    
            //DISEÑO
            //FORMA 3: BotonAlta PRODUCTO
            public PanelAltas()
            {
                //LABEL NOMBRE
                Label Rotulo1 = new Label();
                Rotulo1.Text = "Nombre del Producto";
                Rotulo1.Size = new Size(120, 15);
                Rotulo1.Location = new Point(20, 20);
                Controls.Add(Rotulo1);
    
                //TEXTBOX NOMBRE
                this.textbox1 = new System.Windows.Forms.TextBox();
                textbox1.Size = new Size(200, 20);
                textbox1.Location = new Point(150, 20);
                Controls.Add(textbox1);
    
                //LABEL PRECIO
                Label Rotulo2 = new Label();
                Rotulo2.Text = "Precio del Producto";
                Rotulo2.Size = new Size(120, 15);
                Rotulo2.Location = new Point(20, 60);
                Controls.Add(Rotulo2);
    
                //TEXTBOX PRECIO
                this.textbox2 = new System.Windows.Forms.TextBox();
                textbox2.Location = new Point(150, 60);
                textbox2.Size = new Size(200, 20);
                Controls.Add(textbox2);
    
                //BOTON ACEPTAR
                Button Aceptar = new Button();
                Aceptar.Location = new Point(20, 100);
                Aceptar.Text = "Aceptar";
                Aceptar.Click += new EventHandler(BotonAceptarClick);
                Controls.Add(Aceptar);
    
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(120, 100);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
            }
    
            //EVENTOS
            //BOTON VOLVER
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
    
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
    
                FormularioMenu.Show();
            }
    
            //BOTON ACEPTAR
            public void BotonAceptarClick(object sender, EventArgs Arguments)
            {
                if (textbox1.Text != "" && textbox2.Text != "")
                {
                    if (!File.Exists("C:\\Productos.txt"))
                    {
                        StreamWriter ArchDeEscritura = new StreamWriter("C:\\Productos.txt");
                        ArchDeEscritura.WriteLine(textbox1.Text);
                        StreamWriter ArchDeEscritura2 = new StreamWriter("C:\\Precios.txt");
                        ArchDeEscritura2.WriteLine(textbox2.Text);
                        ArchDeEscritura.Close();
                        ArchDeEscritura2.Close();
                        MessageBox.Show("El Producto fue introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    }
                    else
                    {
                        try
                        {
                            ListBox l = new ListBox();
                            ListBox l2 = new ListBox();
                            int cont = 0;
                            ArchDeLectura = new StreamReader("C:\\Productos.txt");
                            ArchDeLectura2 = new StreamReader("C:\\Precios.txt");
    
                            string linea;
                            string linea2;
                            linea = ArchDeLectura.ReadLine();
                            linea2 = ArchDeLectura2.ReadLine();
                            while (linea != null)
                            {
                                l.Items.Add(linea);
                                l2.Items.Add(linea2);
                                cont = cont + 1;
                                linea = ArchDeLectura.ReadLine();
                                linea2 = ArchDeLectura2.ReadLine();
                            }
                            l.Items.Add(textbox1.Text);
                            l2.Items.Add(textbox2.Text);
                            cont = cont + 1;
    
                            ArchDeLectura.Close();
                            ArchDeLectura2.Close();
    
                            ArchDeEscritura = new StreamWriter("C:\\Productos.txt");
                            ArchDeEscritura2 = new StreamWriter("C:\\Precios.txt");
                            for (int i = 0; i < cont; i++)
                            {
                                ArchDeEscritura.WriteLine(l.Items[i]);
                                ArchDeEscritura2.WriteLine(l2.Items[i]);
                            }
    
                            ArchDeEscritura.Close();
                            ArchDeEscritura2.Close();
    
                            textbox1.Clear();
                            textbox2.Clear();
                            MessageBox.Show("El Producto fue introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                        }
                        catch
                        {
                            MessageBox.Show("El Producto no pudo ser introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
                else
                {
                    MessageBox.Show("Complete los dos campos", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
        }
    
        public class PanelAcercaDe : Form
        {
            //DISEÑO
            //FORMA 4: ACERCA DE
            public PanelAcercaDe()
            {
                //PANEL                         
                Panel UnPanel = new Panel();
                UnPanel.Size = new System.Drawing.Size(175, 100);
                UnPanel.BorderStyle = BorderStyle.Fixed3D;
                UnPanel.Location = new Point(10, 12);
                Controls.Add(UnPanel);
    
                //LETRERO 1
                Label Rotulo1 = new Label();
                Rotulo1.Text = "C# Base Modelo 2006";
                Rotulo1.Size = new Size(150, 15);
                Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold);
                Rotulo1.Location = new Point(35, 15);
                UnPanel.Controls.Add(Rotulo1);
    
                //LETRERO 2
                Label Rotulo2 = new Label();
                Rotulo2.Text = "Wilucha 1.0";
                Rotulo2.Size = new Size(150, 15);
                Rotulo2.Font = new Font(Rotulo2.Font, FontStyle.Bold);
                Rotulo2.Location = new Point(35, 35);
                UnPanel.Controls.Add(Rotulo2);
    
                //LETRERO 3
                Label Rotulo3 = new Label();
                Rotulo3.Text = "SOFTWARE LOCO";
                Rotulo3.Size = new Size(150, 15);
                Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Bold);
                Rotulo3.Location = new Point(35, 55);
                UnPanel.Controls.Add(Rotulo3);
    
                //LETRERO 4
                Label lab4 = new Label();
                lab4.Text = "www.wilocarpio.com";
                lab4.Size = new Size(150, 15);
                lab4.Font = new Font(lab4.Font, FontStyle.Bold);
                lab4.Location = new Point(35, 75);
                UnPanel.Controls.Add(lab4);
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(60,125);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
            }
    
            //EVENTOS
            //BOTON VOLVER
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
    
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
                FormularioMenu.Show();
            }
        }
    
        public class PanelListarClientes : Form
        {
            //DISEÑO
            //FORMA 7: VER NOMINA DE CLIENTES
            public PanelListarClientes()
            {
                //BotonVerLista
                ListBox BotonVerLista = new ListBox();
                BotonVerLista.Size = new Size(340, 380);
                BotonVerLista.Location = new Point(12, 12);
                Controls.Add(BotonVerLista);
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(150, 400);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
    
                if (File.Exists("C:\\Ventas.txt"))
                {
                    StreamReader ArchDeLectura = new StreamReader("C:\\Ventas.txt");
                    string linea;
                    linea = ArchDeLectura.ReadLine();
    
                    while (linea != null)
                    {
                        BotonVerLista.Items.Add(linea);
                        linea = ArchDeLectura.ReadLine();
                    }
                    ArchDeLectura.Close();
                }
                else
                {
                    MessageBox.Show("El Archivo de nómina no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
    
            //EVENTOS
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
                FormularioMenu.Show();
            }
        }
    
        public class PanelVentas : Form
        {
            public System.Windows.Forms.TextBox textbox1;
            private System.Windows.Forms.ListBox BotonVerLista;
            private System.Windows.Forms.ListBox BotonVerLista2;
    
            public string[,] UnaMatriztor = new string[50, 2];
            int iUnaMatriz = 0;
            double tot = 0;
    
            //DISEÑO
            //FORMA 8: VENTAS
            public PanelVentas()
            {
                //BotonVerLista
                this.BotonVerLista = new System.Windows.Forms.ListBox();
                BotonVerLista.Size = new Size(300,340);
                BotonVerLista.Location = new Point(12,12);
                Controls.Add(BotonVerLista);
    
                //BotonVerLista2
                this.BotonVerLista2 = new System.Windows.Forms.ListBox();
                BotonVerLista2.Size = new Size(40, 340);
                BotonVerLista2.Location = new Point(310, 12);
                Controls.Add(BotonVerLista2);
    
                //LETRERO
                Label Rotulo1 = new Label();
                Rotulo1.Text = "Nombre del Cliente";
                Rotulo1.Size = new Size(110, 15);
                Rotulo1.Location = new Point(35, 365);
                Controls.Add(Rotulo1);
    
                //TEXTBOX
                this.textbox1 = new System.Windows.Forms.TextBox();
                textbox1.Size = new Size(200, 20);
                textbox1.Location = new Point(150, 360);
                Controls.Add(textbox1);
    
                //BOTON COMPRAR
                Button Comprar = new Button();
                Comprar.Location = new Point(100, 400);
                Comprar.Text = "Comprar";
                Comprar.Click += new EventHandler(BotonComprarClick);
                Controls.Add(Comprar);
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(200, 400);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
    
                if (File.Exists("C:\\Productos.txt"))
                {
                    StreamReader ArchDeLectura = new StreamReader("C:\\Productos.txt");
                    StreamReader ArchDeLectura2 = new StreamReader("C:\\Precios.txt");
                    string linea;
                    string linea2;
                    linea = ArchDeLectura.ReadLine();
                    linea2 = ArchDeLectura2.ReadLine();
    
                    while (linea != null)
                    {
                        BotonVerLista.Items.Add(linea);
                        BotonVerLista2.Items.Add(linea2);
                        linea = ArchDeLectura.ReadLine();
                        linea2 = ArchDeLectura2.ReadLine();
                    }
                    ArchDeLectura.Close();
                    ArchDeLectura2.Close();
                }
                else
                {
                    MessageBox.Show("El Archivo de los productos no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
    
            //EVENTOS
            //BOTON VOLVER
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
                FormularioMenu.Show();
            }
    
            //BOTON COMPRAR
            public void BotonComprarClick(object sender, EventArgs Arguments)
            {
                if (BotonVerLista.SelectedIndex != -1 && textbox1.Text != "")
                {
                    if(MessageBox.Show("¿Está seguro que quiere comprar el producto  " + BotonVerLista.SelectedItem.ToString() + "?", "¿Comprar Producto?", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes)
                    {
                        UnaMatriztor[iUnaMatriz, 0] = BotonVerLista.SelectedItem.ToString();
                        BotonVerLista2.SelectedIndex = BotonVerLista.SelectedIndex;
                        UnaMatriztor[iUnaMatriz, 1] = BotonVerLista2.SelectedItem.ToString();
                        iUnaMatriz++;
    
                        if (!File.Exists("C:\\temp.txt"))
                        {
                            StreamWriter ArchDeEscriturat = new StreamWriter("C:\\temp.txt");
                            ArchDeEscriturat.WriteLine(textbox1.Text);
                            ArchDeEscriturat.WriteLine(UnaMatriztor[iUnaMatriz - 1, 0] + "   " + UnaMatriztor[iUnaMatriz - 1, 1]);
                            ArchDeEscriturat.Close();
                        }
                        else
                        {
                            ListBox l = new ListBox();
    
                            int cont = 0;
                            StreamReader ArchDeLecturat = new StreamReader("C:\\temp.txt");
                            string linea;
                            linea = ArchDeLecturat.ReadLine();
    
                            while (linea != null)
                            {
                                l.Items.Add(linea);
                                cont = cont + 1;
                                linea = ArchDeLecturat.ReadLine();
                            }
    
                            l.Items.Add(UnaMatriztor[iUnaMatriz - 1, 0] + "   " + UnaMatriztor[iUnaMatriz - 1, 1]);
                            cont = cont + 1;
                            ArchDeLecturat.Close();
                            StreamWriter ArchDeEscriturat = new StreamWriter("C:\\temp.txt");
                            for (int k = 0; k < cont; k++)
                            {
                                ArchDeEscriturat.WriteLine(l.Items[k]);
                            }
                            ArchDeEscriturat.Close();
                        }
                        tot = tot + Convert.ToDouble(UnaMatriztor[iUnaMatriz-1, 1]);
    
                        if (MessageBox.Show("¿Desea Comprar otro Producto?", "Comprar Producto", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.No)
                        {
                            if (!File.Exists("C:\\Ventas.txt"))
                            {
                                StreamWriter ArchDeEscritura = new StreamWriter("C:\\Ventas.txt");
                                ArchDeEscritura.WriteLine(textbox1.Text);
                                for(int j=0;j<=iUnaMatriz;j++)
                                {
                                    ArchDeEscritura.WriteLine(UnaMatriztor[j, 0] + "   " + UnaMatriztor[j, 1]);
                                }
                                ArchDeEscritura.Close();
                            }
                            else
                            {
                                ListBox l = new ListBox();
                                int cont = 0;
                                StreamReader ArchDeLectura = new StreamReader("C:\\Ventas.txt");
                                string linea;
                                linea = ArchDeLectura.ReadLine();
    
                                while (linea != null)
                                {
                                    l.Items.Add(linea);
                                    cont = cont + 1;
                                    linea = ArchDeLectura.ReadLine();
                                }
    
                                l.Items.Add(textbox1.Text);
                                cont = cont + 1;
                                for (int j = 0; j <= iUnaMatriz; j++)
                                {
                                    l.Items.Add(UnaMatriztor[j, 0] + "   " + UnaMatriztor[j, 1]);
                                    cont = cont + 1;
                                }
                                ArchDeLectura.Close();
    
    
                                StreamWriter ArchDeEscritura = new StreamWriter("C:\\Ventas.txt");
    
                                for (int k = 0; k < cont; k++)
                                {
                                    ArchDeEscritura.WriteLine(l.Items[k]);
                                }
                                ArchDeEscritura.Close();
                            }
                            StreamWriter ArchDeEscriturat2 = new StreamWriter("C:\\temp2.txt");
                            ArchDeEscriturat2.WriteLine(Convert.ToString(tot));
                            ArchDeEscriturat2.Close();
                            Close();
    
                            PanelTicket PanelTicket = new PanelTicket();
                            PanelTicket.Size = new System.Drawing.Size(600, 450);
                            PanelTicket.StartPosition = FormStartPosition.CenterScreen;
                            PanelTicket.FormBorderStyle = FormBorderStyle.FixedSingle;
                            PanelTicket.Text = "Ticket";
                            PanelTicket.Show();
                        }
                    }
                }
                else
                {
                    MessageBox.Show("Elija los productos e ingrese el nombre del cliente", "Comprar Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
        }
    
        public class PanelTicket : Form
        {
            private System.Windows.Forms.ListBox BotonVerLista;
            private Font printFont;
            StreamReader streamToPrint;
    
            StreamReader ArchDeLectura = new StreamReader("C:\\temp.txt");
            StreamReader ArchDeLectura2 = new StreamReader("C:\\temp2.txt");
            StreamWriter ArchImpresion = new StreamWriter("C:\\print.txt");
            //DISEÑO
            //FORMA 8: VENTAS
            public PanelTicket()
            {
                //TICKET
                this.BotonVerLista = new System.Windows.Forms.ListBox();
                BotonVerLista.Size = new Size(400, 340);
                BotonVerLista.Location = new Point(12, 12);
                Controls.Add(BotonVerLista);
    
                //BOTON IMPRIMIR TICKET
                Button Imprimir = new Button();
                Imprimir.Location = new Point(450, 50);
                Imprimir.Text = "Imprimir";
                Imprimir.Click += new EventHandler(BotonImprimirClick);
                Controls.Add(Imprimir);
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(450, 100);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
    
                //DATOS DEL TICKET
                BotonVerLista.Items.Add("C# Modelo Base 2006");
                ArchImpresion.WriteLine("C# Modelo Base 2006");
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                BotonVerLista.Items.Add("TICKET");
                ArchImpresion.WriteLine("TICKET");
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                BotonVerLista.Items.Add("Fecha: " + DateTime.Now.ToShortDateString());
                ArchImpresion.WriteLine("Fecha: " + DateTime.Now.ToShortDateString());
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                BotonVerLista.Items.Add("Hora: " + DateTime.Now.ToShortTimeString());
                ArchImpresion.WriteLine("Hora: " + DateTime.Now.ToShortTimeString());
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                string cli;
                cli = ArchDeLectura.ReadLine();
                BotonVerLista.Items.Add("Cliente: " + cli);
                ArchImpresion.WriteLine("Cliente: " + cli);
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                BotonVerLista.Items.Add("Productos:");
                ArchImpresion.WriteLine("Productos:");
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
                string a;
                a = ArchDeLectura.ReadLine();
                while(a != null)
                {
                    BotonVerLista.Items.Add(a);
                    ArchImpresion.WriteLine(a);
                    a = ArchDeLectura.ReadLine();
                }
                BotonVerLista.Items.Add("");
                ArchImpresion.WriteLine("");
    
                a=ArchDeLectura2.ReadLine();
                BotonVerLista.Items.Add("Total: $" + a);
                ArchImpresion.WriteLine("Total: $" + a);
                ArchDeLectura.Close();
                ArchDeLectura2.Close();
                ArchImpresion.Close();
            }
    
            //EVENTOS
            //BOTON IMPRIMIR TICKET
            public void BotonImprimirClick(object sender, EventArgs Arguments)
            {
                try
                {
                    streamToPrint = new StreamReader("C:\\print.txt");
                    try
                    {
                        printFont = new Font("Arial", 10);
                        PrintDocument DocumentoDeImpresion = new PrintDocument();
                        DocumentoDeImpresion.PrintPage += new PrintPageEventHandler(this.DocumentoDeImpresion_PrintPage);
                        DocumentoDeImpresion.Print();
                    }
                    finally
                    {
                        streamToPrint.Close();
                    }
                }
                catch
                {
                    MessageBox.Show("No se puede imprimir", "Error al imprimir", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
    
            //Calculo para imprimir
            private void DocumentoDeImpresion_PrintPage(object sender, PrintPageEventArgs ev)
            {
                float lineArchImpresionerPage = 0;
                float yPos = 0;
                int count = 0;
                float leftMargin = ev.MarginBounds.Left;
                float topMargin = ev.MarginBounds.Top;
                string line = null;
    
                // Calcula el numero de linea por pagina
                lineArchImpresionerPage = ev.MarginBounds.Height /
                   printFont.GetHeight(ev.Graphics);
    
                // Imprime cada linea del archivo
                while (count < lineArchImpresionerPage &&
                   ((line = streamToPrint.ReadLine()) != null))
                {
                    yPos = topMargin + (count *
                       printFont.GetHeight(ev.Graphics));
                    ev.Graphics.DrawString(line, printFont, Brushes.Black,
                       leftMargin, yPos, new StringFormat());
                    count++;
                }
    
                // Si hay más lineas imprime otra pagina
                if (line != null)
                    ev.HasMorePages = true;
                else
                    ev.HasMorePages = false;
            }
    
            //Boton VOLVER
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
    
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
    
                File.Delete("C:\\print.txt");
                FormularioMenu.Show();
            }
        }
    
        public class PanelListar : Form
        {
            private System.Windows.Forms.ListBox BotonVerLista; 
    
            public PanelListar()
            {
                //BotonVerLista
                this.BotonVerLista = new System.Windows.Forms.ListBox();
                BotonVerLista.Size = new Size(340, 390);
                BotonVerLista.Location = new Point(12, 12);
                Controls.Add(BotonVerLista);
    
                //BOTON VOLVER
                Button Volver = new Button();
                Volver.Location = new Point(145, 400);
                Volver.Text = "Volver";
                Volver.Click += new EventHandler(BotonVolverClick);
                Controls.Add(Volver);
    
                if (File.Exists("C:\\Productos.txt"))
                {
                    StreamReader ArchDeLectura = new StreamReader("C:\\Productos.txt");
                    string linea;
                    linea = ArchDeLectura.ReadLine();
                    while (linea != null)
                    {
                        BotonVerLista.Items.Add(linea);
                        linea = ArchDeLectura.ReadLine();
                    }
                    ArchDeLectura.Close();
                }
                else
                {
                    MessageBox.Show("El Archivo de Productos no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
    
            //EVENTOS
            //Boton VOLVER
            public void BotonVolverClick(object sender, EventArgs Arguments)
            {
                Close();
                FormularioMenu FormularioMenu = new FormularioMenu();
                FormularioMenu.Size = new System.Drawing.Size(600, 370);
                FormularioMenu.StartPosition = FormStartPosition.CenterScreen;
                FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle;
                FormularioMenu.Text = "Menú Principal";
    
                FormularioMenu.Show();
            }
        }
    
    }
    

    A U T O M A T A
    Aplicaciones Windows
    Cadenas de Chomsky

    En el siguiente programa para el entorno Windows de C#, te propongo algoritmos de los métodos para:
    - Mover fisicamente imagenes de tu pantalla
    - Para generar cadenas pertenecientes a un lenguaje formal
    - Para procesar cadenas pertenecientes a una gramatica formal
    - Para procesar cadenas mediante un automata de Turing
    
    ///////////////////////////////////////////////////////////////////
    // MOVER UN AUTOMATA        Wilo Carpio           26/10/09     
    //      C#.NET
    ///////////////////////////////////////////////////////////////////
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    namespace MoverAutomata
    {
        public partial class FormuWilo : Form
        {
            public FormuWilo()
            {
                InitializeComponent();
            }
    
            private void salirToolStripMenuItem1_Click(object sender, EventArgs e)
            {
                Close();
            }
    
            private void pictCerrarAutomata_Click(object sender, EventArgs e)
            {
                panelAutomata.Visible = false;
            }
    
            private void picFlechaLeft_Click(object sender, EventArgs e)
            {
                int x = picPC.Location.X;
                int y = picPC.Location.Y;
                x = x - 5;
                picPC.Location = new System.Drawing.Point(x, y);
            }
    
            private void picFlechaDown_Click(object sender, EventArgs e)
            {
                int x = picPC.Location.X;
                int y = picPC.Location.Y;
                y = y + 5;
                picPC.Location = new System.Drawing.Point(x, y);
            }
    
            private void picUp_Click(object sender, EventArgs e)
            {
                int x = picPC.Location.X;
                int y = picPC.Location.Y;
                y = y - 5;
                picPC.Location = new System.Drawing.Point(x, y);
            }
    
            private void picFlechaRight_Click(object sender, EventArgs e)
            {
                int x = picPC.Location.X;
                int y = picPC.Location.Y;
                x = x + 5;
                picPC.Location = new System.Drawing.Point(x, y);
            }
            private void ejemploToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelAutomata.Visible = true;
            }
    
            private void picCerrarLenguaje_Click(object sender, EventArgs e)
            {
                panelLenguaje.Visible = false;
            }
    
            private void ejemplo1ToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelLenguaje.Visible = true;
                textBoxCadena.Focus();
            }
    
            private void buttonLeerCad_Click(object sender, EventArgs e)
            {
                string a = textBoxCadena.Text;
                bool OtraLetra = false;
                int i,c=0,d=0;
                labelLenguaje.Visible = true;
                CadenaDigitada.Visible = true;
                CadenaDigitada.Text = Convert.ToString(a[0]);
                for (i = 1; i < a.Length; i++)
                {
                    CadenaDigitada.Text = CadenaDigitada.Text + " " + Convert.ToString(a[i]);
                }            
                for (i = 0; i < a.Length; i++)
                {
                    if (a[i] == 'c' || a[i] == 'b' || a[i] == 'd')
                        OtraLetra = false;
                    else
                    {
                        OtraLetra = true;
                        break;
                    }
                    if (a[i] == 'c' && d == 0)
                        c++;
                    else
                        if (a[i] == 'd')
                            d++;
                        else
                            if (a[i] == 'b' && d==1)
                                c--;
                }
                if (OtraLetra)
                    labelNoPertenece.Visible = true;
                else
                    if (c == 0 && d==1)
                        labelPertenece.Visible = true;
                    else
                        labelNoPertenece.Visible = true;
                buttoNuevaCadena.Visible = true;
            }
    
            private void buttoNuevaCadena_Click(object sender, EventArgs e)
            {
                labelLenguaje.Visible = false;
                CadenaDigitada.Visible = false;
                labelPertenece.Visible = false;
                labelNoPertenece.Visible = false;
                buttoNuevaCadena.Visible = false;
                textBoxCadena.Text = "";
                textBoxCadena.Focus();
            }
    
            private void salirToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Close();
            }
    
            private void picCerrarGramatica_Click(object sender, EventArgs e)
            {
                panelGramatica.Visible = false;
                GeneraCadena.Visible = false;
                GeneraCadena.Text = "Cadena generada";
                Cadena.Text = "";
            }
    
            private void ejemplo2ToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelGramatica.Visible = true;
            }
    
            private void picClick1_Click_1(object sender, EventArgs e)
            {
                picCabezal.Visible = true;
                int x = picCabezal.Location.X;
                int y = picCabezal.Location.Y;
                x = x + 60;
                picCabezal.Location = new System.Drawing.Point(x, y);
                switch (x) 
                {
                    case 70: Cadena.Text = textProduc1.Text;
                        GeneraCadena.Text = "Producción usada: " + textProduc1.Text; 
                        break;
                    case 130: Cadena.Text = Cadena.Text + " -> wiX ";
                        GeneraCadena.Text = "Producción usada: " + textProduc2.Text;
                        break;
                    case 190: Cadena.Text = Cadena.Text + " -> wilY ";
                        GeneraCadena.Text = "Producción usada: " + textProduc3.Text;
                        break;
                    case 250: Cadena.Text = Cadena.Text + " -> wil? ";
                        GeneraCadena.Text = "Producción usada: " + textProduc4.Text;
                        break;
                    case 310: Cadena.Text = Cadena.Text + " -> wil";
                        GeneraCadena.Text = "Producción usada: " + textProduc5.Text;
                        break;
                    case 370: x = 10;
                        picCabezal.Location = new System.Drawing.Point(x, y);
                        GeneraCadena.Visible = false;
                        Cadena.Text = "";
                        GeneraCadena.Text = "EJEMPLO 2: Clickea para procesar";
                        GeneraCadena.Visible = true;
                        picClick1.Visible = false;
                        picClick2.Visible = true;
                        picClick3.Visible = false;
                        groupLenguaje.Visible = true;
                        textLenguaje.Text = "L = {w i l, . . }";
                        break;
                }
            }
    
            private void picClick2_Click_1(object sender, EventArgs e)
            {
                picCabezal.Visible = true;
                int x = picCabezal.Location.X;
                int y = picCabezal.Location.Y;
                x = x + 60;
                picCabezal.Location = new System.Drawing.Point(x, y);
                switch (x)
                {
    
                    case 70: Cadena.Text = textProduc1.Text;
                        GeneraCadena.Text = "Producción usada: " + textProduc1.Text;
                        break;
                    case 130: Cadena.Text = Cadena.Text + " -> wiX ";
                        GeneraCadena.Text = "Producción usada: " + textProduc2.Text;
                        break;
                    case 190: Cadena.Text = Cadena.Text + " -> wilY ";
                        GeneraCadena.Text = "Producción usada: " + textProduc3.Text;
                        break;
                    case 250: Cadena.Text = Cadena.Text + " -> wiloY ";
                        GeneraCadena.Text = "Producción usada: " + textProduc4.Text;
                        break;
                    case 310: Cadena.Text = Cadena.Text + " -> wilo?";
                        GeneraCadena.Text = "Producción usada: " + textProduc5.Text;
                        break;
                    case 370: Cadena.Text = Cadena.Text + " -> wilo";
                        GeneraCadena.Text = "Producción usada: " + textProduc6.Text;
                        break;
                    case 430: x = 10;
                        picCabezal.Location = new System.Drawing.Point(x, y);
                        GeneraCadena.Visible = false;
                        Cadena.Text = "";
                        GeneraCadena.Text = "EJEMPLO 3: Clickea para procesar";
                        GeneraCadena.Visible = true;
                        picClick1.Visible = false;
                        picClick2.Visible = false;
                        picClick3.Visible = true;
                        textLenguaje.Text = "L = {w i l,  w i l o, . .}";
                        break;
                }
            }
    
            private void picClick3_Click(object sender, EventArgs e)
            {
                picCabezal.Visible = true;
                int x = picCabezal.Location.X;
                int y = picCabezal.Location.Y;
                x = x + 60;
                picCabezal.Location = new System.Drawing.Point(x, y);
                switch (x)
                {
                    case 70: Cadena.Text = textProduc1.Text;
                        GeneraCadena.Text = "Producción usada: " + textProduc1.Text;
                        break;
                    case 130: Cadena.Text = Cadena.Text + " -> wiX ";
                        GeneraCadena.Text = "Producción usada: " + textProduc2.Text;
                        break;
                    case 190: Cadena.Text = Cadena.Text + " -> wilY ";
                        GeneraCadena.Text = "Producción usada: " + textProduc3.Text;
                        break;
                    case 250: Cadena.Text = Cadena.Text + " -> wiloY ";
                        GeneraCadena.Text = "Producción usada: " + textProduc4.Text;
                        break;
                    case 310: Cadena.Text = Cadena.Text + " -> wilonY";
                        GeneraCadena.Text = "Producción usada: " + textProduc5.Text;
                        break;
                    case 370: Cadena.Text = Cadena.Text + " -> wilon?";
                        GeneraCadena.Text = "Producción usada: " + textProduc6.Text;
                        break;
                    case 430: Cadena.Text = Cadena.Text + " -> wilon";
                        GeneraCadena.Text = "Producción usada: " + textProduc7.Text;
                        break;
                    case 490: x = 10;
                        picCabezal.Location = new System.Drawing.Point(x, y);
                        GeneraCadena.Visible = false;
                        Cadena.Text = "";
                        GeneraCadena.Text = "EJEMPLO 1: Clickea para procesar";
                        GeneraCadena.Visible = true;
                        picClick1.Visible = true;
                        picClick2.Visible = false;
                        picClick3.Visible = false;
                        textLenguaje.Text = "L = {w i l,  w i l o,  w i l o n, . .}";
                        MessageBox.Show("NO HAY MAS EJEMPLOS");
                        panelGramatica.Visible = false;
                        break;
                }
            }
    
            private void picGenerar_Click(object sender, EventArgs e)
            {
                    Cadena.Text = "";
                    GeneraCadena.Text = "Clickea para procesar EJEMPLO 1";
                    picGenerar.Visible = false;
                    GeneraCadena.Visible = true;
                    picClick1.Visible = true;
                    picClick2.Visible = false;
                    picClick3.Visible = false;
            }
    
            private void tourToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelTuring.Visible = true;
                TuringCadenaDigitada.Focus();
            }
    
            private void picCerrarPanelTouring_Click(object sender, EventArgs e)
            {
                panelTuring.Visible = false;
                TuringProceso.Visible = false;
                TuringCabezon.Visible = false;
                TuringLabelAcepta.Visible = false;
                TuringLabelNoAcepta.Visible = false;
                TuringCargaCadena.Visible = true;
                TuringCadenaDigitada.Text="";
            }
    
    
            private void TuringPasaCadena_Click(object sender, EventArgs e)
            {
                string CadenaLeida = TuringCadenaDigitada.Text;
                int i;
                TuringCintaMaquina.Text = "| ß ";
                for (i = 0; i < CadenaLeida.Length; i++)
                {
                    TuringCintaMaquina.Text = TuringCintaMaquina.Text + " | " + Convert.ToString(CadenaLeida[i]);
                }
                TuringCintaMaquina.Text = TuringCintaMaquina.Text + " | ß  |";
                TuringCargaCadena.Visible = false;
                TuringProceso.Visible = true;
                TuringAutomata.Visible = true;
            }
    
            private void TuringAutomata_Click(object sender, EventArgs e)
            {
                string a = TuringCadenaDigitada.Text;
                bool OtraLetra = false;
                int i, c = 0, d = 0;
                TuringCadenaDigitada.Text = Convert.ToString(a[0]);
                for (i = 0; i < a.Length; i++)
                {
                    if (a[i] == 'c' || a[i] == 'b' || a[i] == 'd')
                        OtraLetra = false;
                    else
                    {
                        OtraLetra = true;
                        break;
                    }
                    if (a[i] == 'c' && d == 0)
                        c++;
                    else
                        if (a[i] == 'd')
                            d++;
                        else
                            if (a[i] == 'b' && d == 1)
                                c--;
                }
                if (OtraLetra)
                {
                    TuringCabezon.Visible = true;
                    TuringAutomata.Visible = false;
                    TuringLabelNoAcepta.Visible = true;            
                }
                else
                    if (c == 0 && d == 1)
                    {
                        TuringCabezon.Visible = true;
                        TuringAutomata.Visible = false;
                        TuringLabelAcepta.Visible = true;
                    }
                    else
                        TuringLabelNoAcepta.Visible = true;
            }
    
            private void TuringNuevaCadena_Click(object sender, EventArgs e)
            {
                TuringCadenaDigitada.Clear();
                TuringCadenaDigitada.Focus();
            }
            private void TuringOtraCadena_Click(object sender, EventArgs e)
            {
                TuringCadenaDigitada.Clear();
                TuringCadenaDigitada.Focus();
            }
        }
    }
    

    ESTRUCTURA
    Archivo
    Puntero
    Lista
    Cola
    Pila
    Arbol

    MANEJO de CADENAS DE TEXTO de LENGUAJES FORMALES

    Formulario

    
    ///////////////////////////////////////////////////////////////
    // MODELO 111111      MANEJO DE ALFABETOS y CADENAS DE TEXTO
    //    Form1            Teoria de Lenguajes Formales
    ///////////////////////////////////////////////////////////////    
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    
    namespace Practico
    {
        public partial class Formulario1 : Form
        {
            Alfabeto MiAlfabeto = new Alfabeto();
            Lenguaje lenguaje1;
            Lenguaje lenguaje2;
            public Formulario1()
            {
                InitializeComponent();
            }
    
            private void salirToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Close();
            }
    
            private void alfabetoToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelIngAlfabeto.Visible = true;
                if (MiAlfabeto.isEmpty())
                {
                    richTextBoxAlfabeto.Text = "Digita cada letra, luego clickea Ok";
                }
                else
                {
                    richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                }
                panelIngLenguaje.Visible = false;
                panelAutor.Visible = false;
              
                textBoxIngresoAlfabeto.Focus();
            }
    
            private void buttonCerrarPanAlfa_Click(object sender, EventArgs e)
            {
                MessageBox.Show("Terminaste de cargar tu alfabeto", "Ahora carga los lenguajes", MessageBoxButtons.OK, MessageBoxIcon.Information);
    
                richTextBoxAlfabeto.Clear();
                panelIngAlfabeto.Visible = false;
            }
    
            private void buttonIngAlfabeto_Click(object sender, EventArgs e)
            {
                CargaDeAlfabeto();
            }
    
            private void habilitaMenu(int menu, Boolean estado)
            {
                switch (menu)
                {
                    case 0:
                        alfabetoToolStripMenuItem.Enabled = estado;
                        break;
                    case 1:
                        lenguajeToolStripMenuItem.Enabled = estado;
                        break;
                }
            }
    
            private void CargaDeAlfabeto()
            {
                MiAlfabeto.ingresarCaracteres(textBoxIngresoAlfabeto.Text.Trim());
                if (!MiAlfabeto.isEmpty())
                {
                    richTextBoxAlfabeto.Clear();
                    richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                }
                textBoxIngresoAlfabeto.Clear();
                textBoxIngresoAlfabeto.Focus();
            }
    
            private void textBoxIngresoAlfabeto_KeyPress(object sender, KeyPressEventArgs e)
            {
                if (e.KeyChar == (char)(Keys.Enter))
                {
                    CargaDeAlfabeto();
                }
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                MessageBox.Show("las Palabras del lenguaje", "Terminaste de cargar", MessageBoxButtons.OK, MessageBoxIcon.Information);
    
                panelIngLenguaje.Visible = false;
            }
    
            private void buttonIngCantLeng_Click(object sender, EventArgs e)
            {
                int cantidadPalabras = (int)numericUpDownIngLeng.Value;
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    lenguaje1 = new Lenguaje();
                    lenguaje1.setCantPal(cantidadPalabras);
                }
                else
                {
                    lenguaje2 = new Lenguaje();
                    lenguaje2.setCantPal(cantidadPalabras);
                }
                buttonBorrarLeng.Enabled = true;
                richTextBoxCompare.Text = MiAlfabeto.toString();
                buttonIngCantLeng.Enabled = false;
                numericUpDownIngLeng.Enabled = false;
                if (numericUpDownIngLeng.Value != 0)
                {
                    buttonIngLengueje.Enabled = true;
                    textBoxComparador.Enabled = true;
                    textBoxComparador.Focus();
                }
                else
                {
                    buttonIngLengueje.Enabled = false;
                    textBoxComparador.Enabled = false;
                }
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    richTextBoxCompare.Text += "\n" + lenguaje1.toString();
                }
                else
                {
                    richTextBoxCompare.Text += "\n" + lenguaje2.toString();
                }
            }
    
            private void lenguajeNº1ToolStripMenuItem_Click(object sender, EventArgs e)
            {
                labelNumLeng.Text = "1";
                abrirPanelLenguaje(1);
            }
    
            private void lenguajeNº2ToolStripMenuItem_Click(object sender, EventArgs e)
            {
                labelNumLeng.Text = "2";
                abrirPanelLenguaje(2);
            }
    
            private void abrirPanelLenguaje(int nuLeng)
            {
                panelIngLenguaje.Visible = true;
                panelIngAlfabeto.Visible = false;
                panelAutor.Visible = false;
                richTextBoxCompare.Clear();
                if (MiAlfabeto.isEmpty())
                {
                    richTextBoxCompare.Text = "Sin Alfabeto";
                    buttonIngLengueje.Enabled = false;
                    buttonIngCantLeng.Enabled = false;
                    numericUpDownIngLeng.Enabled = false;
                    textBoxComparador.Enabled = false;
                    buttonBorrarLeng.Enabled = false;
                    buttonCargarLengArchivo.Enabled = false;
                    buttonGuardarLeng.Enabled = false;
                }
                else
                {
                    richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                    buttonCargarLengArchivo.Enabled = true;
                    buttonGuardarLeng.Enabled = true;
                    if (nuLeng == 1)
                    {
                        if (lenguaje1 == null)
                        {
                            buttonBorrarLeng.Enabled = false;
                            buttonIngLengueje.Enabled = false;
                            textBoxComparador.Enabled = false;
                            buttonIngCantLeng.Enabled = true;
                            numericUpDownIngLeng.Enabled = true;
                            numericUpDownIngLeng.Value = 0;
                        }
                        else
                        {
                            buttonBorrarLeng.Enabled = true;
                            richTextBoxCompare.Text += "\n" + lenguaje1.toString();
                            buttonIngLengueje.Enabled = true;
                            textBoxComparador.Enabled = true;
                            buttonIngCantLeng.Enabled = false;
                            numericUpDownIngLeng.Enabled = false;
                            numericUpDownIngLeng.Value = lenguaje1.getCantPal();
                        }
                    }
                    else
                    {
                        if (lenguaje2 == null)
                        {
                            buttonBorrarLeng.Enabled = false;
                            buttonIngLengueje.Enabled = false;
                            textBoxComparador.Enabled = false;
                            buttonIngCantLeng.Enabled = true;
                            numericUpDownIngLeng.Enabled = true;
                            numericUpDownIngLeng.Value = 0;
                        }
                        else
                        {
                            buttonBorrarLeng.Enabled = true;
                            richTextBoxCompare.Text += "\n" + lenguaje2.toString();
                            buttonIngLengueje.Enabled = true;
                            textBoxComparador.Enabled = true;
                            buttonIngCantLeng.Enabled = false;
                            numericUpDownIngLeng.Enabled = false;
                            numericUpDownIngLeng.Value = lenguaje2.getCantPal();
                        }
                    }
                }
            }
    
            private void buttonBorrarLeng_Click(object sender, EventArgs e)
            {
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    lenguaje1 = null;
                    abrirPanelLenguaje(1);
                }
                else
                {
                    lenguaje2 = null;
                    abrirPanelLenguaje(2);
                }
                richTextBoxCompare.Clear();
            }
    
            private void buttonIngLengueje_Click(object sender, EventArgs e)
            {
                cargaLenguaje(textBoxComparador.Text.Trim());
            }
            private void cargaLenguaje(String pala)
            {
                richTextBoxCompare.Clear();
                richTextBoxCompare.Text = MiAlfabeto.toString();
                if (MiAlfabeto.comprobarPertenencia(pala) || pala.CompareTo("@") == 0)
                {
                    if (labelNumLeng.Text.CompareTo("1") == 0)
                    {
                        lenguaje1.setPalabra(pala);
                    }
                    else
                    {
                        lenguaje2.setPalabra(pala);
                    }
                }
                else
                {
                    richTextBoxCompare.Text += "\n" + pala + " NO PERTENECE AL LENGUAJE";
                }
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    richTextBoxCompare.Text += "\n" + lenguaje1.toString();
                }
                else
                {
                    richTextBoxCompare.Text += "\n" + lenguaje2.toString();
                }
                textBoxComparador.Focus();
                textBoxComparador.Clear();
            }
            private void textBoxComparador_KeyPress(object sender, KeyPressEventArgs e)
            {
                if (e.KeyChar == (char)(Keys.Enter))
                {
                    cargaLenguaje(textBoxComparador.Text.Trim());
                }
            }
    
            private void uniónToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(1);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void buttonIngAlfArchivoCargar_Click(object sender, EventArgs e)
            {
                String nombreFichero = "";
                openFileDialog1.Title = "Cargar Alfabeto";
                openFileDialog1.FileName = "Alfabeto";
                if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    nombreFichero = openFileDialog1.FileName;
                }
                else
                {
                    return;
                }
                MiAlfabeto = new Alfabeto();
                lenguaje1 = null;
                lenguaje2 = null;
                MiAlfabeto.cargarDeFichero(nombreFichero);
                richTextBoxAlfabeto.Clear();
                richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                textBoxIngresoAlfabeto.Clear();
                textBoxIngresoAlfabeto.Focus();
            }
    
            private void buttonIngAlfArchivoGuardar_Click(object sender, EventArgs e)
            {
                MessageBox.Show("los caracteres de tu alfabeto", "Estas por grabar en un archivo", MessageBoxButtons.OK, MessageBoxIcon.Information);
    
                if (MiAlfabeto.isEmpty())
                {
                    return;
                }
                saveFileDialog1.Title = "Guardar Alfabeto";
                saveFileDialog1.FileName = "Alfabeto";
                String nombreFichero = "";
                if (saveFileDialog1.ShowDialog() == DialogResult.OK)
                {
                    nombreFichero = saveFileDialog1.FileName;
                }
                else
                {
                    return;
                }
                MiAlfabeto.guardarAFichero(nombreFichero);
                richTextBoxAlfabeto.Clear();
                richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                textBoxIngresoAlfabeto.Clear();
                textBoxIngresoAlfabeto.Focus();
            }
    
            private void buttonBorrarAlfa_Click(object sender, EventArgs e)
            {
                MiAlfabeto = new Alfabeto();
                lenguaje1 = null;
                lenguaje2 = null;
                richTextBoxAlfabeto.Clear();
                richTextBoxAlfabeto.Text = MiAlfabeto.toString();
                textBoxIngresoAlfabeto.Clear();
                textBoxIngresoAlfabeto.Focus();
            }
    
            private void textBoxComparador_TextChanged(object sender, EventArgs e)
            {
    
            }
    
            private void labelCantPal_Click(object sender, EventArgs e)
            {
    
            }
    
            private void numericUpDownIngLeng_ValueChanged(object sender, EventArgs e)
            {
    
            }
    
            private void buttonCargarLengArchivo_Click(object sender, EventArgs e)
            {
                if (MiAlfabeto.isEmpty())
                {
                    return;
                }
                String nombreFichero = "";
                openFileDialog1.Title = "Cargar Lenguaje";
                openFileDialog1.FileName = "Lenguaje" + labelNumLeng.Text;
                if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    nombreFichero = openFileDialog1.FileName;
                }
                else
                {
                    return;
    
                }
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    lenguaje1 = new Lenguaje();
                    lenguaje1.cargarDeFichero(nombreFichero, MiAlfabeto);
                }
                else
                {
                    lenguaje2 = new Lenguaje();
                    lenguaje2.cargarDeFichero(nombreFichero, MiAlfabeto);
                }
                abrirPanelLenguaje(Convert.ToInt32(labelNumLeng.Text));
            }
    
            private void buttonGuardarLeng_Click(object sender, EventArgs e)
            {
                MessageBox.Show("las palabras de tu lenguaje", "Estas por grabar en un archivo", MessageBoxButtons.OK, MessageBoxIcon.Information);
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    if (lenguaje1.isEmpty())
                    {
                        return;
                    }
                }
                else
                {
                    if (lenguaje1.isEmpty())
                    {
                        return;
                    }
                }
    
                saveFileDialog1.Title = "Guardar Lenguaje";
                saveFileDialog1.FileName = "Lenguaje" + labelNumLeng.Text;
                String nombreFichero = "";
                if (saveFileDialog1.ShowDialog() == DialogResult.OK)
                {
                    nombreFichero = saveFileDialog1.FileName;
                }
                else
                {
                    return;
                }
                if (labelNumLeng.Text.CompareTo("1") == 0)
                {
                    lenguaje1.guardarAFichero(nombreFichero);
                }
                else
                {
                    lenguaje2.guardarAFichero(nombreFichero);
                }
                abrirPanelLenguaje(Convert.ToInt32(labelNumLeng.Text));
            }
    
            private void intersecciónToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(3);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void diferenciaToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(2);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void complementoToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(4);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void concatenaciónToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(5);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void potenciaToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(6);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void estrellaDeKleeneToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(7);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void estrellaPositivaToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(8);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void invertirToolStripMenuItem_Click(object sender, EventArgs e)
            {
                Formulario2 formuOperaciones = new Formulario2(9);
                formuOperaciones.leng1 = lenguaje1;
                formuOperaciones.leng2 = lenguaje2;
                formuOperaciones.alfab1 = MiAlfabeto;
                formuOperaciones.ShowDialog();
            }
    
            private void autorToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelAutor.Visible = true;
                panelIngAlfabeto.Visible = false;
                panelIngLenguaje.Visible = false;
               
            }
    
            private void acercaDeToolStripMenuItem_Click(object sender, EventArgs e)
            {
                panelAutor.Visible = false;
                panelIngAlfabeto.Visible = false;
                panelIngLenguaje.Visible = false;
    
            }
    
            
            private void buttonCerrarAutor_Click(object sender, EventArgs e)
            {
                panelAutor.Visible = false;
            }
    
            private void salirToolStripMenuItem1_Click(object sender, EventArgs e)
            {
                DialogResult resultado = MessageBox.Show("Deseas cerrar este sistema ?", "Pulsa una opción",
              MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
    
                if (resultado == DialogResult.Yes)
                    Close();
    
            }
    
        }
    }
    
    ///////////////////////////////////////////////////////////////
    // MODELO 111111      MANEJO DE ALFABETOS y CADENAS DE TEXTO
    //    Form2            Teoria de Lenguajes Formales
    ///////////////////////////////////////////////////////////////    
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    
    namespace Practico
    {
        public partial class Formulario2 : Form
        {
            public Formulario2()
            {
                InitializeComponent();
            }
            public Formulario2(int operacion)
            {
                InitializeComponent();
                abrirPanel(operacion);
            }
            private void abrirPanel(int nropanel)
            {
                switch (nropanel)
                {
                    case 1:
                        this.panelUnion.Visible = true;
                        break;
                    case 2:
                        this.panelDiferencia.Visible = true;
                        break;
                    case 3:
                        this.panelInters.Visible = true;
                        break;
                    case 4:
                        this.panelComplem.Visible = true;
                        break;
                    case 5:
                        this.panelConca.Visible = true;
                        break;
                    case 6:
                        this.panelPotencia.Visible = true;
                        break;
                    case 7:
                        this.panelEstrellaKleene.Visible = true;
                        break;
                    case 8:
                        this.panelEstrellaPosit.Visible = true;
                        break;
                    case 9:
                        this.panelInvertidora.Visible = true;
                        break;
                }
            }
            private void buttonUnir_Click(object sender, EventArgs e)
            {
                Lenguaje nuevo;
                nuevo = leng1.unionLeng(leng2);
                richTextBoxUnionLeng3.Text = nuevo.toString();
            }
            public Lenguaje leng1;
            public Lenguaje leng2;
            public Alfabeto alfab1;
            private void panelUnion_VisibleChanged(object sender, EventArgs e)
            {
                richTextBoxUnionLeng1.Clear();
                richTextBoxUnionLeng2.Clear();
                richTextBoxUnionLeng3.Clear();
                buttonUnir.Enabled = true;
                if (leng1 == null)
                {
                    richTextBoxUnionLeng1.Clear();
                    richTextBoxUnionLeng1.Text = "No existe el Lenguaje 1";
                    buttonUnir.Enabled = false;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        richTextBoxUnionLeng1.Clear();
                        buttonUnir.Enabled = false;
                    }
                    richTextBoxUnionLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxUnionLeng2.Text = "No existe el Lenguaje 2";
                    buttonUnir.Enabled = false;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        buttonUnir.Enabled = false;
                    }
                    richTextBoxUnionLeng2.Text = leng2.toString();
                }
            }
    
            private void panelInters_VisibleChanged(object sender, EventArgs e)
            {
                richTextBoxIntLeng1.Clear();
                richTextBoxIntLeng2.Clear();
                richTextBoxIntLeng3.Clear();
                buttonIntersectador.Enabled = true;
                if (leng1 == null)
                {
                    richTextBoxIntLeng1.Text = "No existe el Lenguaje 1";
                    buttonIntersectador.Enabled = false;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        buttonIntersectador.Enabled = false;
                    }
                    richTextBoxIntLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxIntLeng2.Text = "No existe el Lenguaje 2";
                    buttonIntersectador.Enabled = false;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        buttonIntersectador.Enabled = false;
                    }
                    richTextBoxIntLeng2.Text = leng2.toString();
                }
            }
    
            private void buttonIntersectador_Click(object sender, EventArgs e)
            {
                Lenguaje nuevo;
                nuevo = leng1.interseccionLeng(leng2);
                richTextBoxIntLeng3.Text = nuevo.toString();
            }
    
            private void panelDiferencia_VisibleChanged(object sender, EventArgs e)
            {
                richTextBoxDifLen1.Clear();
                richTextBoxDifLen2.Clear();
                richTextBoxDifLen3.Clear();
                buttonResta.Enabled = true;
                if (leng1 == null)
                {
                    richTextBoxDifLen1.Text = "No existe el Lenguaje 1";
                    buttonResta.Enabled = false;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        richTextBoxDifLen1.Clear();
                        buttonResta.Enabled = false;
                    }
                    richTextBoxDifLen1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxDifLen2.Text = "No existe el Lenguaje 2";
                    buttonResta.Enabled = false;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        buttonResta.Enabled = false;
                    }
                    richTextBoxDifLen2.Text = leng2.toString();
                }
            }
    
            private void buttonResta_Click(object sender, EventArgs e)
            {
                Lenguaje nuevo;
                nuevo = leng1.diferenciaLenguaje(leng2);
                richTextBoxDifLen3.Text = nuevo.toString();
            }
    
    
            private void panelComplem_VisibleChanged(object sender, EventArgs e)
            {
                int botonHabilitador = 0;
                richTextBoxCompLeng1.Clear();
                richTextBoxCompLeng2.Clear();
                richTextBoxCompLeng3.Clear();
                buttonComplementar.Enabled = true;
                radioButtonCompLeng1.Enabled = true;
                radioButtonCompLeng2.Enabled = true;
                numericUpDownComplemento.Value = 25;
                if (leng1 == null)
                {
                    richTextBoxCompLeng1.Text = "No existe el Lenguaje 1";
                    radioButtonCompLeng1.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        radioButtonCompLeng1.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxCompLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxCompLeng2.Text = "No existe el Lenguaje 2";
                    radioButtonCompLeng2.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        radioButtonCompLeng2.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxCompLeng2.Text = leng2.toString();
                }
                if (botonHabilitador > 1)
                {
                    buttonComplementar.Enabled = false;
                }
            }
    
            private int potencia(int num, int exponente)
            {
                int result;
                if (exponente == 1)
                    return num;
                if (exponente == 0)
                    return 1;
                exponente--;
                result = potencia(num, exponente) * num;
                return result;
            }
    
            private void buttonComplementar_Click(object sender, EventArgs e)
            {
                int cantPalaTotal = Convert.ToInt32(numericUpDownComplemento.Value);
                int cantidadDeCiclos = 0;
                int cantGene = 0;
                int cantPalAlfa = alfab1.getCarcter().Length;
                Lenguaje aux = new Lenguaje();
                if (radioButtonCompLeng1.Checked)
                {
                    aux = leng1;
                }
                else
                {
                    if (radioButtonCompLeng2.Checked)
                    {
                        aux = leng2;
                    }
                    else
                    {
                        return;
                    }
                }
                int palabrasLeng = aux.getCantPal();
                while (cantGene < (palabrasLeng + cantPalaTotal))
                {
                    cantidadDeCiclos++;
                    cantGene = 0;
                    for (int i = 0; i < cantidadDeCiclos; i++)
                        cantGene += potencia(cantPalAlfa, i);
                }
                Lenguaje nuevo;
                Lenguaje nuevo2 = new Lenguaje();
                nuevo = aux.complemento(alfab1, cantidadDeCiclos);
                nuevo2.setCantPal(cantPalaTotal);
                for (int i = 0; i < cantPalaTotal; i++)
                {
                    nuevo2.setPalabra(nuevo.getPalabras()[i]);
                }
                nuevo2.ordenarLenguajeXLongitud();
                richTextBoxCompLeng3.Text = nuevo2.toString();
            }
    
            private void panelConca_VisibleChanged(object sender, EventArgs e)
            {
                richTextBoxConLeng1.Clear();
                richTextBoxConLeng2.Clear();
                richTextBoxConLeng3.Clear();
                buttonConcatenador.Enabled = true;
                if (leng1 == null)
                {
                    richTextBoxConLeng1.Text = "No existe el Lenguaje 1";
                    buttonConcatenador.Enabled = false;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        richTextBoxConLeng1.Clear();
                        buttonConcatenador.Enabled = false;
                    }
                    richTextBoxConLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxConLeng2.Text = "No existe el Lenguaje 2";
                    buttonConcatenador.Enabled = false;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        buttonConcatenador.Enabled = false;
                    }
                    richTextBoxConLeng2.Text = leng2.toString();
                }
            }
    
            private void buttonConcatenador_Click(object sender, EventArgs e)
            {
                Lenguaje nuevo;
                nuevo = leng1.concatencacion(leng2);
                richTextBoxConLeng3.Text = nuevo.toString();
            }
    
            private void panelPotencia_VisibleChanged(object sender, EventArgs e)
            {
                int botonHabilitador = 0;
                richTextBoxPotLen1.Clear();
                richTextBoxPotLen2.Clear();
                richTextBoxPotLen3.Clear();
                buttonPotenciador.Enabled = true;
                radioButtonPotLeng1.Enabled = true;
                radioButtonPotLeng2.Enabled = true;
                numericUpDownCantPot.Value = 1;
                if (leng1 == null)
                {
                    richTextBoxPotLen1.Text = "No existe el Lenguaje 1";
                    radioButtonPotLeng1.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        radioButtonPotLeng1.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxPotLen1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxPotLen2.Text = "No existe el Lenguaje 2";
                    radioButtonPotLeng2.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        radioButtonPotLeng2.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxPotLen2.Text = leng2.toString();
                }
                if (botonHabilitador > 1)
                {
                    buttonComplementar.Enabled = false;
                }
            }
    
            private void buttonPotenciador_Click(object sender, EventArgs e)
            {
                int exponente = Convert.ToInt32(numericUpDownCantPot.Value);
                if (radioButtonPotLeng1.Checked)
                {
                    richTextBoxPotLen3.Text = leng1.potencia(exponente).toString();
                }
                else
                {
                    if (radioButtonPotLeng2.Checked)
                    {
                        richTextBoxPotLen3.Text = leng2.potencia(exponente).toString();
                    }
                }
            }
    
            private void panelEstrellaKleene_VisibleChanged(object sender, EventArgs e)
            {
                int botonHabilitador = 0;
                richTextBoxKleeneLeng1.Clear();
                richTextBoxKleeneLeng2.Clear();
                richTextBoxKleeneLeng3.Clear();
                buttonKleene.Enabled = true;
                radioButtonKleeneLeng1.Enabled = true;
                radioButtonKleeneLeng2.Enabled = true;
                numericUpDownKleene.Value = 25;
                if (leng1 == null)
                {
                    richTextBoxKleeneLeng1.Text = "No existe el Lenguaje 1";
                    radioButtonKleeneLeng1.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        radioButtonKleeneLeng1.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxKleeneLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxKleeneLeng2.Text = "No existe el Lenguaje 2";
                    radioButtonKleeneLeng2.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        radioButtonKleeneLeng2.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxKleeneLeng2.Text = leng2.toString();
                }
                if (botonHabilitador > 1)
                {
                    buttonKleene.Enabled = false;
                }
            }
    
            private void buttonKleene_Click(object sender, EventArgs e)
            {
                int cantidadPala = Convert.ToInt32(numericUpDownKleene.Value);
                int cantiPalaActual;
                Lenguaje aux = new Lenguaje();
                Lenguaje nuevo = new Lenguaje();
                if (radioButtonKleeneLeng1.Checked)
                {
                    aux = leng1;
                }
                else
                {
                    if (radioButtonKleeneLeng2.Checked)
                    {
                        aux = leng2;
                    }
                    else
                        return;
                }
                cantiPalaActual = aux.getCantPal();
                if (cantiPalaActual == 0)
                {
                    nuevo = aux.estrellaKleene(1);
                    richTextBoxKleeneLeng3.Text = nuevo.toString();
                    return;
                }
                if (cantiPalaActual == 1)
                    if (aux.getPalabras()[0].CompareTo("@") == 0)
                    {
                        nuevo = aux.estrellaKleene(1);
                        richTextBoxKleeneLeng3.Text = nuevo.toString();
                        return;
                    }
                int cant = 0;
                nuevo.setCantPal(0);
                while (nuevo.getCantPal() < cantidadPala)
                {
                    cant++;
                    nuevo = aux.estrellaKleene(cant);
                }
                Lenguaje nuevo2 = new Lenguaje();
                nuevo2.setCantPal(cantidadPala);
                for (int i = 0; i < cantidadPala; i++)
                    nuevo2.setPalabra(nuevo.getPalabras()[i]);
                nuevo2.ordenarLenguajeXLongitud();
                richTextBoxKleeneLeng3.Text = nuevo2.toString();
            }
    
            private void panelEstrellaPosit_VisibleChanged(object sender, EventArgs e)
            {
                int botonHabilitador = 0;
                richTextBoxPositLeng1.Clear();
                richTextBoxPositLeng2.Clear();
                richTextBoxPositLeng3.Clear();
                buttonPositiva.Enabled = true;
                radioButtonPosiLeng1.Enabled = true;
                radioButtonPosiLeng2.Enabled = true;
                numericUpDownCantPosi.Value = 25;
                if (leng1 == null)
                {
                    richTextBoxPositLeng1.Text = "No existe el Lenguaje 1";
                    radioButtonPosiLeng1.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        radioButtonPosiLeng1.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxPositLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxPositLeng2.Text = "No existe el Lenguaje 2";
                    radioButtonPosiLeng2.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        radioButtonPosiLeng2.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxPositLeng2.Text = leng2.toString();
                }
                if (botonHabilitador > 1)
                {
                    buttonPositiva.Enabled = false;
                }
            }
    
            private void buttonPositiva_Click(object sender, EventArgs e)
            {
                int cantidadPala = Convert.ToInt32(numericUpDownCantPosi.Value);
                int cantiPalaActual;
                Lenguaje aux = new Lenguaje();
                Lenguaje nuevo = new Lenguaje();
                if (radioButtonPosiLeng1.Checked)
                {
                    aux = leng1;
                }
                else
                {
                    if (radioButtonPosiLeng2.Checked)
                    {
                        aux = leng2;
                    }
                    else
                        return;
                }
                cantiPalaActual = aux.getCantPal();
                if (cantiPalaActual == 0)
                {
                    nuevo = aux.estrellaPositiva(1);
                    richTextBoxPositLeng3.Text = nuevo.toString();
                    return;
                }
                if (cantiPalaActual == 1)
                    if (aux.getPalabras()[0].CompareTo("@") == 0)
                    {
                        nuevo = aux.estrellaKleene(1);
                        richTextBoxPositLeng3.Text = nuevo.toString();
                        return;
                    }
                int cant = 0;
                nuevo.setCantPal(0);
                while (nuevo.getCantPal() < cantidadPala)
                {
                    cant++;
                    nuevo = aux.estrellaPositiva(cant);
                }
                Lenguaje nuevo2 = new Lenguaje();
                nuevo2.setCantPal(cantidadPala);
                for (int i = 0; i < cantidadPala; i++)
                    nuevo2.setPalabra(nuevo.getPalabras()[i]);
                nuevo2.ordenarLenguajeXLongitud();
                richTextBoxPositLeng3.Text = nuevo2.toString();
            }
    
            private void panelInvertidora_VisibleChanged(object sender, EventArgs e)
            {
                int botonHabilitador = 0;
                richTextBoxInvLeng1.Clear();
                richTextBoxInvLeng2.Clear();
                richTextBoxInvLeng3.Clear();
                buttonInvierte.Enabled = true;
                radioButtonInverLeng1.Enabled = true;
                radioButtonInverLeng2.Enabled = true;
                if (leng1 == null)
                {
                    richTextBoxInvLeng1.Text = "No existe el Lenguaje 1";
                    radioButtonInverLeng1.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng1.faltanIngresar() > 0)
                    {
                        radioButtonInverLeng1.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxInvLeng1.Text = leng1.toString();
                }
                if (leng2 == null)
                {
                    richTextBoxInvLeng2.Text = "No existe el Lenguaje 2";
                    radioButtonInverLeng2.Enabled = false;
                    botonHabilitador++;
                }
                else
                {
                    if (leng2.faltanIngresar() > 0)
                    {
                        radioButtonInverLeng2.Enabled = false;
                        botonHabilitador++;
                    }
                    richTextBoxInvLeng2.Text = leng2.toString();
                }
                if (botonHabilitador > 1)
                {
                    buttonInvierte.Enabled = false;
                }
            }
    
            private void buttonInvierte_Click(object sender, EventArgs e)
            {
                if (radioButtonInverLeng1.Checked)
                {
                    richTextBoxInvLeng3.Text = leng1.potencia(-1).toString();
                }
                else
                {
                    if (radioButtonInverLeng2.Checked)
                    {
                        richTextBoxInvLeng3.Text = leng2.potencia(-1).toString();
                    }
                }
            }
        }
    }
    
    
    

    FICHEROS:
    C y C++
    C# Sharp

    Son estructuras de datos, cuyos módulos contenedores están ubicados uno a continuación del otro, o sea están organizados linealmente y consecutivamente, de manera que para acceder a un dato hay que acceder a todos los datos precedentes. Son de dos tipos:
    1. Archivos que contienen caracteres consecutivos: Estos caracteres pueden interpretarse como datos individuales, como componentes de una cadena o como números. Pueden interpretarse definiendolos dentro de las funciones de biblioteca usadas para transferir información o por las especificaciones de formato dentro de las funciones de biblioteca.

    2. Archivos sin formato: O archivos de datos secuenciales, que organiza los datos en bloques contiguos de información, que representan estructuras de datos más complejas como array o estructuras.

    Colega algorítmico en estos links te propongo revisar los conocimientos sobre los archivos como estructuras organizadas de datos, los cuales podemos agruparlos como:
    • TEMPORARIOS: Son aquellos cuyos datos, al apagarse la máquina desaparecen.

    • PERMANENTES: Guardados en soportes físicos, permiten leer información grabada en forma permanente, guardados como archivos de datos, o secuencia de bits. Estos a su vez pueden ser de dos tipos:
      • ARCHIVOS DE DATOS SECUENCIALES: Cuyos datos están ubicados uno a continuación del otro, o sea están organizados linealmente y consecutivamente, de manera que para acceder a un dato hay que acceder a todos los datos precedentes y eso lo hace lento. Son de dos tipos:
        1. Archivos que contienen caracteres consecutivos: Estos caracteres pueden interpretarse como datos individuales, como componentes de una cadena o como números. Estos caracteres deben interpretarse como datos individuales, como componentes de una cadena o como números. La manera de interpretarlo es determinada dentro de las funciones de biblioteca usadas para transferir información o por las especificaciones de formato dentro de las funciones de biblioteca.

        2. Archivos sin formato: O archivos de datos secuenciales, que organiza los datos en bloques contiguos de información. Estos bloques representan estructuras de datos más complejas como array y estructuras. Hay un conjunto de funciones de bibliotecas para tratar este tipo de archivo. Estas funciones proveen instrucciones simples que pueden transferir array completos o estructuras a o desde un archivo de datos

        Para C el archivo es simplemente un flujo externo o una secuencia de bits almacenados en un soporte, de modo que si se abre para salida, es un flujo de archivo de salida y si el archivo se abre para entrada es un flujo de archivo para entrada.

        El lenguaje C no distingue entre archivos secuenciales y archivos de acceso directo o aleatorio. Pero existen dos tipos distintos de Archivos de datos, los llamados

        • Archivos secuenciales de datos o estándar:

        • Archivos orientados a sistemas o de bajo nivel: Están mas relacionados con el sistema operativo de la computadora que los archivos secuenciales. Su uso requiere un conjunto separado de procedimientos con sus funciones de bibliotecas correspondientes.

      • ARCHIVOS DE ACCESO DIRECTO: También llamados aleatorios, están distribuidos de manera que se puede acceder directamente conociendo su dirección.

        En C no existen archivos de acceso directo, sin embargo, existen funciones como fseek() y fgetpos() que permiten tratar los archivos como arrays, moviéndose directamente a un byte determinado del archivo abierto por fopen().

        Para el acceso de estos archivos se usa el puntero asociado con el archivo, el cual a diferencia de los punteros de C++ , es un índice que apunta a una posición dada o a la posición actual es el punto en el que comienza el siguiente acceso archivo.

    F I C H E R O S en C
    Para C el archivo es simplemente un flujo externo o una secuencia de bits almacenados en un soporte, de modo que si se abre para salida, es un flujo de archivo de salida y si el archivo se abre para entrada es un flujo de archivo para entrada.

    El lenguaje C no distingue entre archivos secuenciales y archivos de acceso directo o aleatorio. Pero existen dos tipos distintos de Archivos de datos, los llamados

    • Archivos secuenciales de datos o estándar:

    • Archivos orientados a sistemas o de bajo nivel:
      Mas relacionados con el sistema operativo de la computadora que con los archivos secuenciales. Su uso requiere un conjunto separado de procedimientos con sus funciones de bibliotecas correspondientes.

    APERTURA Y CIERRE DEL ARCHIVO SECUENCIAL: Los archivos secuenciales de datos requieren recurrir a un área de buffer para almacenar temporalmente la ionformación, mientras se está transfiriendo entre la memoria de la computadora y el archivo de datos. La sintaxis para el área de buffer es:

    
            FILE *VariablePuntero;
    

    Donde:
    - FILE es un tipo de dato estructurado que establece el área de buffer
    - VariablePuntero es la variable puntero que indica el principio de esta área.
    Previo a procesado el archivo de datos debe ser abierto, de modo de asociar el nombre de archivo con el área de buffer y especificar el modo de uso del archivo, como sólo:
    - Solo Lectura
    - Sólo para escritura
    - Para lectura / escritura.

    La sintaxis para abrir el archivo es:

    
            	VariablePuntero = fopen (NombreArchivo, ModoDeUso);
    

    Donde NombreArchivo es la cadena que identifica el nombre del archivo y ModoDeUso es la manera en la que el archivo será utilizado y debe ser una de las cadenas de la siguiente tabla.

    • "r": Abrir un archivo existente sólo para lectura.

    • "w": Abrir un nuevo archivo sólo para escritura. Si existe un archivo con el nombre-archivo especificado, será destruido y creado uno nuevo en su lugar.

    • "a": Abrir un archivo existente para añadir. Se creará un archivo nuevo si no existe un archivo con el nombre nombre-archivo especificado.

    • "r+": Abrir un archivo existente para lectura escritura.

    • "w+": Abrir un archivo nuevo para escritura y lectura. Si existe un archivo con el nombre-archivo especificado, será destruido y creado uno nuevo en su lugar.

    • "a+": Abrir un archivo existente para leer y añadir. Se creará un archivo nuevo si no existe un archivo con el nombre nombre-archivo especificado.

    La función fopen retorna un puntero al principio del área de buffer asociada con el archivo si este se puede abrir y caso contrario, retorna un valor NULL si no se puede abrir el archivo, por ejemplo si un archivo existente no ha sido encontrado.

    Para terminar el archivo debe cerrarse al final de un programa, aplicando la función de biblioteca fclose. La sintaxis para cerrar es:

    
            fclose(VariablePuntero);
    

    PROCESAMIENTO DE UN ARCHIVO: Las transacciones típicas del archivo son Altas, Bajas y Modificaciones (ABM), para lo cual se suele usar dos estrategias:

    • Para actualizar los registros dentro de un archivo de datos, se lee cada registro de un archivo, se actualiza el registro y después se escribe el registro actualizado al mismo archivo.

    • Trabajar con dos archivos diferentes: Un archivo "Fuente" y otro "Nuevo".
      Se lee cada registro del fuente, se actualiza y se escribe en el Nuevo y cuando se han actualizado todos los registros, se borra o se almacena el archivo fuente y se renombra el archivo nuevo. Así el Nuevo archivo se convierte en Fuente para el siguiente turno de modificaciones. Este proceso se aplica para efectuar bajas físicas de registros.

    ARCHIVOS SIN FORMATO: Están basadas en las funciones de biblioteca fread y fwrite o funciones de lectura y escritura sin formato, que permiten almacenar bloques de datos, consistentes en un número de bytes continuos, que representaran una estructura de datos compleja, tal como arrays simples o múltiples.

    Para estas aplicaciones es necesario leer o escribir el bloque entero del archivo de datos en vez de leer o escribir separadamente las componentes individuales de cada bloque.

    Estas funciones son operadas con cuatro argumentos:
    - un puntero al bloque de datos,
    - el tamaño del bloque de datos,
    - el número de bloques a transferir y
    - el puntero a un archivo secuencial.

    La sintaxis es:

    
         fwrite(&VariableTipoRegistro,  sizeof(Registro), 1, PunteroArchivoSecuencial);
    
    Donde VariableTipoRegistro es una variable estructura de tipo registro y PunteroArchivoSecuencial es un puntero a archivo secuencial asociado a un archivo de datos abierto para salida.

    ARCHIVOS DE ACCESO DIRECTO: También llamados aleatorios, están distribuidos de manera que se puede acceder directamente conociendo su dirección.

    En C no existen archivos de acceso directo, sin embargo, existen funciones como fseek() y fgetpos() que permiten tratar los archivos como arrays, moviéndose directamente a un byte determinado del archivo abierto por fopen().

    Para el acceso de estos archivos se usa el puntero asociado con el archivo, el cual a diferencia de los punteros de C++ , es un índice que apunta a una posición dada o a la posición actual es el punto en el que comienza el siguiente acceso archivo.
    El puntero puede ser:
    - Puntero get: que especifica la posición del archivo en el que se producirá la siguiente operación de entrada.
    - Puntero put ,
    que especifica la posición del archivo en el que se producirá la siguiente de salida.

    Cada vez que se realiza una transacción de entrada o salida, el puntero correspondiente avanza automáticamente. Pero, si se usan las funciones seekg ( ) y seekp ( ) se puede acceder al archivo de modo directo, no secuencial.

    fseek() usa tres argumentos:

    1. Puntero a FILE
      al archivo que es objeto de la búsqueda. Dicho archivo deberá haber sido abierto previamente con la función fopen().

    2. offset
      Este argumento indica la distancia a que debemos movernos desde el punto de comienzo; deberá declararse como tipo long. Puede ser positivo (movimiento hacia adelante), negativo (movimiento hacia atrás) o cero (permanece en el mismo sitio).

    3. Modo
      que identifica el punto de comienzo. El archivo cabecera stdio.h especifica las siguientes constantes explícitas para este modo:
      - SEEK_SET Comienzo del archivo
      - SEEK_CUR Posición actual
      - SEEK_END Fin del archivo

    La función fgetpos devuelve la posición actual del puntero a FILE, para ello necesita dos argumentos
    - 1: Apuntador asociado con el archivo sobre el cual queremos realizar la búsqueda.
    - 2:Variable de tipo fpos_t en donde se almacena la posición actual del apuntador al archivo.

    Volver al principio

    LECTURA DE UN ARCHIVO TEXTO: Ejemplo que lee un Archivo de texto y lo muestra en la pantalla:

    
    	#include < stdio.h>
    
    	int main()
       		 {
    

    Puntero FILE *:
    Todas las funciones de estrada/salida estándar usan este puntero para conseguir información sobre el Archivo abierto. No apunta al archivo sino a la estructura que contiene información sobre él.

    Esta estructura incluye entre otras cosas información sobre el nombre del archivo, la dirección de la zona de memoria donde se almacena el Archivo, tamaño del buffer.

    
        	FILE *Archivo;
        	char letra;
    

    Para abrir el archivo, la sintaxis de fopen:

    
               FILE *fopen(const char *nombre_Archivo, const char *modo);
    

    El nombre de Archivo se puede indicar directamente o usando una variable. Se puede abrir de diversas formas

    • r
      Abre un Archivo existente para lectura

    • w
      Crea un Archivo nuevo (o borra su contenido si existe) y lo abre para escritura.

    • a
      Abre un Archivo (si no existe lo crea) para escritura.

      El puntero se sitúa al final del archivo, así se puedan añadir datos si borrar los existentes.

      Se puede agregar: b Para abrir en modo binario, t modo texto y + modo lectura y escritura
      Ejemplo:

      • rb+ Abre el Archivo en modo binario para lectura y escritura

      • w+ Crea (o lo borra si existe) un Archivo para lectura y escritura

      • rt Abre un archivo existente en modo texto para lectura.
    
        	Archivo = fopen("origen.txt","r");
    

    Comprobar si el archivo está abierto: Después de abrir un Archivo es comprobar si realmente está abierto, para evitar fallos: el archivo puede no existir, estar dañado o no tener permisos de lectura

    Si el Archivo no se ha abierto el puntero Archivo (puntero a FILE) tendrá el valor NULL y significa que no se abrió por algún error y se debe salir del programa, usando exit( 1 ), el 1 indica al sistema operativo que se han producido errores.

    
        if (Archivo==NULL)
           {
             printf( "No se puede abrir el Archivo.\n" );
             exit( 1 );
           }
    

    Leer el archivo: La función getc, lee los caracteres uno a uno. Se puede usar también la función fgetc (son equivalentes, la diferencia es que getc está implementada como macro). Además de estas dos existen otras funciones como fgets, fread que leen más de un carácter. La sintaxis: getc (y de fgetc) es:

    
            int getc(FILE *Archivo); 
    

    Ej. letra = getc( Archivo ); Toma un carácter de Archivo, lo almacena en letra y el puntero se coloca en el siguiente carácter.

    
        	printf ( "Contenido del Archivo:\n" );
        	letra = getc ( Archivo);
    

    Fin de Archivo: Cuando entramos en el bucle while, la lectura se realiza hasta que se encuentre el final del Archivo. Para detectar el final del Archivo se pueden usar dos formas: con la función feof() o comprobando si el valor de letra es EOF.

    En el ejemplo hemos usado la función feof. Esta función es de la forma: int feof ( FILE *Archivo); Esta función comprueba si se ha llegado al final de Archivo en cuyo caso devuelve un valor distinto de 0.

    Si no se ha llegado al final de Archivo devuelve un cero.

    Por eso usamos el siguiente modo:
    while ( feof(Archivo)==0 ) o while ( !feof(Archivo) )

    La segunda forma consiste en comprobar si el carácter leído es el de fin de Archivo EOF:
    while ( letra!=EOF )
    Cuando trabajamos con Archivos de texto no hay ningún problema, pero si manejamos un Archivo binario podemos encontrarnos EOF antes del fin de Archivo.
    Por eso es mejor usar feof.

    
    		while (feof(Archivo)==0)
              {
                printf( "%c",letra );
                letra=getc(Archivo);
              }
    

    Una vez realizadas todas las operaciones deseadas sobre el Archivo hay que cerrarlo. Es importante no olvidar este paso pues el Archivo podría corromperse.

    Al cerrarlo se vacían los buffers y se guarda el Archivo en disco. Un Archivo se cierra mediante la función fclose(Archivo). Si todo va bien fclose devuelve un cero, si hay problemas devuelve otro valor.

    Estos problemas se pueden producir si el disco está lleno, por ejemplo.

    
    		if (fclose(Archivo)!=0)
    				printf( "Problemas al cerrar el Archivo\n" );
    			}
    

    LEER LINEAS COMPLETAS: La función fgets se usa para leer líneas completas desde un Archivo.

    Sintaxis:
    char *fgets(char *buffer, int longitud_max, FILE *Archivo);

    Esta función lee desde el Archivo hasta que encuentra un carácter '\n' o hasta que lee longitud_max-1 caracteres y añade '\0' al final de la cadena.

    La cadena leída la almacena en buffer. Si se encuentra EOF antes de leer ningún carácter o si se produce un error la función devuelve NULL, en caso contrario devuelve la dirección de buffer.

    
    		//////////////////////////////////////
    		//   Leer un archivo
    		// C                       WiloCarpio
    		//////////////////////////////////////
    		
    		#include 
    		
    		int main()
    			{
    			FILE *Archivo;
    			char MiTexto[100];
    		
    			Archivo=fopen("Origen.txt","r");
    			if (Archivo==NULL)
    			   {
    				 printf( "No se puede abrir el Archivo.\n" );
    				 exit( 1 );
    			   }
    			printf( "Contenido del Archivo:\n" );
    			fgets(MiTexto,100,Archivo);
    			while (feof(Archivo)==0)
    				  {
    					printf( "%s",MiTexto );
    					fgets(MiTexto,100,Archivo);
    				  }
    			if (fclose(Archivo)!=0)
    			   printf( "Problemas al cerrar el Archivo\n" );
    			}
    

    ESCRITURA EN ARCHIVOS: Abrimos un Archivo 'origen.txt' y lo copiamos en otro Archivo 'destino.txt'. Además el Archivo se muestra en pantalla.

    
    		//////////////////////////////////////
    		//   Escribir en un archivo
    		// C                       WiloCarpio
    		//////////////////////////////////////
    		#include < stdio.h>
    		
    		int main()
    			{
    		
    Como el puntero FILE es la base de la escritura/lectura de archivos, definimos dos punteros FILE:

    Puntero 'origen' para almacenar la información sobre el Archivo origen.txt

    Puntero 'destino' para guardar la información del Archivo destino.txt (el nombre del puntero no tiene por qué coincidir con el de Archivo).

    
    				FILE *origen, *destino;
    				char letra;
    
    Abrir el Archivo usando fopen. La diferencia es que ahora tenemos que abrirlo para escritura. Usamos el modo 'w' (crea el Archivo o lo vacía si existe) porque queremos crear un Archivo.

    Después de abrir un Archivo hay que comprobar si la operación se ha realizado con éxito. En este caso, como es un sencillo ejemplo, los he comprobado ambos a la vez: if (origen==NULL || destino==NULL) pero es más correcto hacerlo por separado así sabemos dónde se está produciendo el posible fallo

    
        origen=fopen("origen.txt","r");
        destino=fopen("destino.txt","w");
        if (origen==NULL || destino==NULL)
           {
           printf( "Problemas con los Archivos.\n" );
           exit( 1 );
           }
    
    Lectura del origen y escritura en destino- getc y putc

    Para la escritura usamos la función putc: int putc(int c, FILE *Archivo) ; donde c contiene el carácter que queremos escribir en el Archivo y el puntero Archivo es el Archivo sobre el que trabajamos.

    De esta forma vamos escribiendo en el Archivo destino.txt el contenido del Archivo origen.txt.

    
        letra=getc(origen);
        while (feof(origen)==0)
              {
              putc(letra,destino);
              printf( "%c",letra );
              letra=getc(origen);
              }
        if (fclose(origen)!=0)
           printf( "Problemas al cerrar el Archivo origen.txt\n" );
    
    Leemos datos de un Archivo debemos comprobar si hemos llegado al final. Sólo debemos comprobar si estamos al final del Archivo que leemos.

    No tenemos que comprobar el final del Archivo en el que escribimos puesto que lo estamos creando y aún no tiene final.

    Cerrar el Archivo – fclose

    No olvidar al trabajar con Archivos: cerrarlos. Debemos cerrar tanto los Archivos que leemos como aquellos sobre los que escribimos.

    
        if (fclose(destino)!=0)
           printf( "Problemas al cerrar el Archivo destino.txt\n" );
        }
    
    Escritura de líneas – fputs: La función fputs trabaja junto con la función fgets
    
    		int fputs(const char *cadena, FILE *Archivo);
    

    SIMPLIFICANDO LA VIDA..!!: Como las funciones getc, putc, fgets, fputs son adecuadas solo para operar con caracteres (1 byte) y cadenas. Si quisiéramos trabajar con otros tipos de datos, como almacenar variables de tipo int en el archivo, sería necesario convertir los valores a cadenas (con la función itoa), luego, para recuperar estos valores deberíamos leerlos como cadenas y pasarlos a enteros (atoi).

    Para simplificar esta tarea conviene usar las funciones fread y fwrite que nos permiten tratar con datos de cualquier tipo, incluso con estructuras.

    Fwrite: Permite escribir en un Archivo. La sintaxis es

    size_t fwrite(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);

    • buffer - variable que contiene los datos que vamos a escribir en el Archivo.

    • tamano - el tamaño del tipo de dato a escribir. Puede ser un int, un float, una estructura, ... Para conocer su tamaño usamos el operador sizeof.

    • numero - el número de datos a escribir.

    • pArchivo - El puntero al Archivo sobre el que trabajamos.
    Ejemplo:
    
    		//////////////////////////////////////
    		//   Archivo
    		// C                       WiloCarpio
    		//////////////////////////////////////
    		
    		#include 
    		
    		struct {
    				char nombre[20];
    				char apellido[20];
    				char telefono[15];
    				} registro;
    		
    		int main()
    			{
    			FILE *Archivo;
    		
    			Archivo = fopen( "nombres.txt", "a" );
    			do {
    			   printf( "Nombre: " ); fflush(stdout);
    			   gets(registro.nombre);
    			   if (strcmp(registro.nombre,""))
    				  {
    					printf( "Apellido: " ); fflush(stdout);
    					gets(registro.apellido);
    					printf( "Teléfono: " ); fflush(stdout);
    					gets(registro.telefono);
    					fwrite( ®istro, sizeof(registro), 1, Archivo );
    				  }
    			   } while (strcmp(registro.nombre,"")!=0);
    			fclose( Archivo );
    			}
    
    NOTA: El bucle termina cuando el 'nombre' se deja en blanco.

    Este programa guarda los datos personales mediante fwrite usando la estructura registro. Abrimos el Archivo en modo 'a' (append, añadir), para que los datos que introducimos se añadan al final del Archivo.

    Una vez abierto abrimos estramos en un bucle do-while mediante el cual introducimos los datos. Los datos se van almacenando en la variable registro (que es una estructura).

    Una vez tenemos todos los datos de la persona los metemos en el Archivo con fwrite:

    fwrite( ®istro, sizeof(registro), 1, Archivo );

    • ®istro - es la variable (en este caso una estructura) que contiene la información a meter al Archivo.

    • sizeof(registro) - lo utillizamos para saber cuál es el número de bytes que vamos a guardar, el tamaño en bytes que ocupa la estructura.

    • 1 - indica que sólo vamos a guardar un elemento. Cada vez que se recorre el bucle guardamos sólo un elemento.

    • Archivo - el puntero FILE al Archivo donde vamos a escribir.

    Fread: se utiliza para sacar información de un Archivo. Su formato es:

    size_t fread(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);

    Siendo buffer la variable donde se van a escribir los datos leídos del Archivo pArchivo.

    El valor que devuelve la función indica el número de elementos de tamaño 'tamano' que ha conseguido leer. Podemos pedirle a fread que lea 10 elementos (numero=10), pero si en el Archivo sólo hay 6 elementos fread devolverá el número 6.

    LOCALIZANDO REGISTROS: Siguiendo con el ejemplo anterior ahora vamos a leer los datos que habíamos introducido en "nombres.txt".

    
    		#include < stdio.h>
    		
    		struct {
    				char nombre[20];
    				char apellido[20];
    				char telefono[15];
    				} registro;
    		
    		int main()
    			{
    			FILE *Archivo;
    		
    			Archivo = fopen( "nombres.txt", "r" );
    			while ( ! feof ( Archivo ) ) 
    			 {
    			   if (fread( ®istro, sizeof ( registro ) , 1, Archivo ) ) 
    					{
    					  printf( "Nombre: %s\n", registro.nombre );
    					  printf( "Apellido: %s\n", registro.apellido);
    					  printf( "Teléfono: %s\n", registro.telefono);
    					  }
    			   }
    			fclose( Archivo );
    			}
    
    Abrimos el Archivo nombres.txt en modo lectura. Con el bucle while nos aseguramos que recorremos el Archivo hasta el final (y que no nos pasamos).

    La función fread lee un registro (numero=1) del tamaño de la estructura registro. Si realmente ha conseguido leer un registro la función devolverá un 1, en cuyo caso la condición del 'if' será verdadera y se imprimirá el registro en la pantalla.

    En caso de que no queden más registros en el Archivo, fread devolverá 0 y no se mostrará nada en la pantalla.

    Fseek:
    Permite situarnos en la posición que queramos de un Archivo abierto. Cuando leemos un Archivo hay un 'puntero' que indica en qué lugar del Archivo nos encontramos.

    Cada vez que leemos datos del Archivo este puntero se desplaza.

    Con la función fseek podemos situar este puntero en el lugar que deseemos.

    Sintaxis de fseek:
    int fseek(FILE *pArchivo, long desplazamiento, int modo);

    Como siempre pArchivo es un puntero de tipo FILE que apunta al Archivo con el que queremos trabajar. desplazamiento son las posiciones (o bytes) que queremos desplazar el puntero. Este desplazamiento puede ser de tres tipos dependiendo del valor de modo:
    - SEEK_SET: El puntero se desplaza desde el principio del Archivo.
    - SEEK_CUR: El puntero se desplaza desde la posición actual del Archivo
    - SEEK_END: El puntero se desplaza desde el final del Archivo

    Si se produce algún error al intentar posicionar el puntero, la función devuelve un valor distinto de 0. Si todo ha ido bien el valor devuelto es 0.

    Volver al principio

    LOCALIZACION ACTUAL: En el siguiente ejemplo se muestra el funcionamiento de fseek. Se trata de un programa que lee la letra que hay en la posición que especifica el usuario.

    
    		#include 
    		
    		int main()
    			{
    			FILE *Archivo;
    			long posicion;
    			int resultado;
    		
    			Archivo = fopen( "origen.txt", "r" );
    			printf( "¿Qué posición quieres leer? " ); fflush(stdout);
    			scanf( "%D", &posicion );
    			resultado = fseek( Archivo, posicion, SEEK_SET );
    			if (!resultado)
    				printf( "En la posición %D está la letra %c.\n", posicion, getc(Archivo) );
    			else
    				printf( "Problemas posicionando el cursor.\n" );
    			fclose( Archivo );
    			}
    
    ftell: Esta función es complementaria a fseek, devuelve la posición actual dentro del Archivo.

    Su formato es el siguiente: long ftell(FILE *pArchivo);
    El valor que nos da ftell puede ser usado por fseek para volver a la posición actual.

    fprintf y fscanf:
    Estas dos funciones trabajan igual que sus equivalentes printf y scanf. La única diferencia es que podemos especificar el Archivo sobre el que operar (si se desea puede ser la pantalla para fprintf o el teclado para fscanf).
    Los formatos de estas dos funciones son:

    int fprintf(FILE *pArchivo, const char *formato, ...);

    int fscanf(FILE *pArchivo, const char *formato, ...);

    F I C H E R O S en C# ( C Sharp )

    Te propongo analizar este ejemplo que te permitirá de manera simple aprender el manejo integral en C# de los archivos.

    
    		//////////////////////////////////////////////////////////////////////////////
    		// C# PROGRAMA CONSOLA MODELO BASE con ARCHIVO TEXTO 2006 Wilo Carpio
    		// CLASES, SUBCLASES y OBJETOS 230806
    		/////////////////////////////////////////////////////////////////////////////
    		using System;
    		using System.IO;
    		using System.Data.Common;
    		using System.Collections;
    		using System.ComponentModel;
    		using System.Runtime.InteropServices;
    

    PROCESAMIENTO DE UN ARCHIVO:
    Las transacciones típicas del archivo es el ABM o Altas, Bajas y Modificaciones, para lo cual se suele usar dos estrategias:

    • Para actualizar los registros dentro de un archivo de datos, se lee cada registro de un archivo, se actualiza el registro y después se escribe el registro actualizado al mismo archivo.

    • Trabajar con dos archivos diferentes: Un archivo fuente y otro Nuevo. Se lee cada registro del fuente, se actualiza y se escribe en el Nuevo y cuando se han actualizado todos los registros, se borra o se almacena el archivo fuente y se renombra el archivo nuevo. Así el Nuevo archivo se convierte en Fuente para el siguiente turno de modificaciones. Este proceso se aplica para efectuar bajas físicas de registros.
    
    		namespace ArchivoModelo
    		{ //////////////////////////////////////////////////
    		 // CLASE PRINCIPAL
    		 //////////////////////////////////////////////////
    		 class Principal
    		 {
    		 [STAThread]
    		 static void Main(string[] args)
    		 {
    		 ClaseMenu MiMenu = new ClaseMenu();
    		 MiMenu.Mostrar();
    		 }
    		 }
    
    
    		 //////////////////////////////////////////////////
    		 // CLASE MENU
    		 //////////////////////////////////////////////////
    		 public class ClaseMenu
    		 {
    		 public void Mostrar()
    		 {
    		 ClaseWilo MiClase = new ClaseWilo();
    		 SubClaseWilo MiSubClase = new SubClaseWilo();
    		 Archivo UnArchivo = new Archivo();
    		
    		 int Opcion, OpcionPrincipal;
    		 string MiFichero;
    		 do
    		 {
    		 OpcionPrincipal = MiSubClase.OpcionMenuPrincipal();
    		 switch (OpcionPrincipal)
    		 {
    		 case 1:
    		 MiFichero = UnArchivo.LeerNombreDelArchivo();
    		 do
    		 {
    		 Opcion = OpcionMenu(MiFichero);
    		 switch (Opcion)
    		 {
    		 case 1: UnArchivo.EscribirEnArchivo(); break;
    		 case 2: UnArchivo.LeerArchivo(MiFichero); break;
    		 case 3: UnArchivo.BuscarEnArchivo(MiFichero); break;
    		 case 4: UnArchivo.BorrarDatoDelArchivo(); break;
    		 case 5: break;
    		 default: MiClase.Aguarda(Opcion + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break;
    		 }
    		 }
    		 while (Opcion != 5);
    		 break;
    
    
    		 case 2: UnArchivo.CrearArchivo(); break;
    		 case 3: UnArchivo.BuscarUnArchivo(); break;
    		 case 4: UnArchivo.ElimininarUnArchivo(); break;
    		 case 5: MiClase.Aguarda("CERRARAS EL PROGRAMA..!!"); break;
    		 default: MiClase.Aguarda(OpcionPrincipal + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break;
    		 }
    		 }
    		 while (OpcionPrincipal != 5);
    		 }
    
    
    		 //////////////////////////////////////////////////
    		 // METODOS DE LA CLASE MENU
    		 //////////////////////////////////////////////////
    		
    		 static int OpcionMenu(string FicheroActivado)
    		 {
    		 ClaseWilo MiClase = new ClaseWilo();
    		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear();
    		 Console.ForegroundColor = ConsoleColor.Red;
    		 Console.Write(" ┌"); MiClase.TrazarRayaSimple(65); Console.Write("┐\n");
    		 Console.Write(" │ MENU SECUNDARIO │\n");
    		 Console.Write(" └"); MiClase.TrazarRayaSimple(65);Console.WriteLine("┘");
    		 MiClase.RotuloAzul(" Archivo: "+FicheroActivado);
    		 Console.ForegroundColor = ConsoleColor.DarkBlue;
    		 Console.WriteLine("\n 1 → ESCRIBIR EN EL ARCHIVO ");
    		 Console.WriteLine("\n 2 → VER EL CONTENIDO DEL ARCHIVO");
    		 Console.WriteLine("\n 3 → BUSCAR UN DATO EN EL ARCHIVO");
    		 Console.WriteLine("\n 4 → BORRAR UN DATO DEL ARCHIVO");
    		 Console.WriteLine("\n 5 → Volver al MENU PRINCIPAL\n");
    		 Console.Write(" ");
    		 Console.ForegroundColor = ConsoleColor.DarkGreen;
    		 MiClase.TrazarRayaSimple(78);
    		 Console.Write("\n\n\t Digita opción (Luego ENTER): ");
    		 int OpcionElegida = Convert.ToInt32(Console.ReadLine());
    		 return OpcionElegida;
    		 }
    		 }
    
    
    		 //////////////////////////////////////////////////
    		 // CLASE ARCHIVO
    		 //////////////////////////////////////////////////
    		 public class Archivo
    		 {
    		 public string FicheroActivado;
    		 public string MiCadena;
    		 ClaseWilo MiClase = new ClaseWilo();
    		 SubClaseWilo MiSubClase = new SubClaseWilo();
    		
    		 public string LeerNombreDelArchivo()
    		 {
    		 string PathLeido;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkBlue;
    		 Console.ForegroundColor = ConsoleColor.White;
    		 Console.Write(" Digita path y NOMBRE del archivo (Luego ENTER) \n");
    		 Console.BackgroundColor = ConsoleColor.Yellow;
    		 Console.ForegroundColor = ConsoleColor.DarkBlue; Console.Write("C:\\");
    		 PathLeido = ("C:\\" + Console.ReadLine());
    		 return PathLeido;
    		 }
    
    
    		 public void LeerArchivo(string FicheroActivado)
    		 {
    		 try
    		 {
    		 if (System.IO.File.Exists(FicheroActivado))
    		 {
    		 System.IO.StreamReader Fichero_aLeer = System.IO.File.OpenText(FicheroActivado);
    		 MiClase.MarcoSimpleDeTitulo("\n CONTENIDO del archivo: " + FicheroActivado); Console.Write("\n");
    		 Console.WriteLine(Fichero_aLeer.ReadToEnd());
    		 Fichero_aLeer.Close();
    		 }
    		 else
    		 {
    		 MiClase.Aguarda("El archivo " + FicheroActivado + " que deseas leer no existe");
    		 }
    		 }
    		 catch
    		 {
    		 MiClase.Aguarda("El archivo que deseas leer " + FicheroActivado + " esta siendo usado por otro proceso");
    		 }
    		 MiClase.Aguarda("");
    		 }
    
    
    		 public void BuscarEnArchivo(string FicheroActivado)
    		 {
    		 MiClase.MarcoSimpleDeTitulo(" BUSQUEDA EN EL ARCHIVO ");
    		 bool LoEncontre = false;
    		 ArrayList FicheroListado = new ArrayList();
    		 if (System.IO.File.Exists(FicheroActivado))
    		 {
    		 MiCadena = MiClase.LeerDatoDeConsola();
    		 System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado);
    		 string FicheroAuxiliar = FicheroLeido.ReadLine();
    		
    		 while (FicheroAuxiliar.CompareTo(".") != 0)
    		 {
    		 if (FicheroAuxiliar.CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToUpper().CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToLower().CompareTo(MiCadena) == 0)
    		 {
    		 LoEncontre = true;
    		 }
    		 else
    		 {
    		 FicheroListado.Add(FicheroAuxiliar);
    		 }
    		 FicheroAuxiliar = FicheroLeido.ReadLine();
    		 }
    		 if (LoEncontre) MiClase.Aguarda("EXITO: El dato " + MiCadena + " si esta grabada");
    		 else MiClase.Aguarda("LAMENTO: El dato " + MiCadena + " no fue grabada");
    		 }
    		 else
    		 {
    		 Console.WriteLine("El archivo: " + FicheroActivado + " no existe");
    		 }
    		 }
    
    
    		 public void EscribirEnArchivo()
    		 {
    		 MiClase.MarcoSimpleDeTitulo(" ALTA EN EL ARCHIVO ");
    		 FicheroActivado = LeerNombreDelArchivo();
    		 if (System.IO.File.Exists(FicheroActivado))
    		 {
    		 do
    		 {
    		 if (check())
    		 {
    		 System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado);
    		 string FicheroAuxiliar = FicheroLeido.ReadLine();
    		 ArrayList FicheroListado = new ArrayList();
    		 while (FicheroAuxiliar.CompareTo(".") != 0)
    		 {
    		 FicheroListado.Add(FicheroAuxiliar);
    		 FicheroAuxiliar = FicheroLeido.ReadLine();
    		 }
    		 FicheroListado.Add(MiCadena);
    		 FicheroListado.Add(".");
    		 FicheroLeido.Close();
    		 System.IO.StreamWriter FicheroEscrito = new System.IO.StreamWriter(FicheroActivado, false, System.Text.Encoding.ASCII);
    		 foreach (string s in FicheroListado)
    		 {
    		 FicheroEscrito.WriteLine(s);
    		 }
    		 FicheroEscrito.Close();
    		 MiSubClase.Aguarda("El dato: " + MiCadena + " se acaba de grabar..!!");
    		 }
    		 else
    		 {
    		 MiClase.Aguarda("NO SE GRABÓ: " + MiCadena + " ya existe en archivo: " + FicheroActivado);
    		 }
    		 }
    		 while (MiSubClase.OtraVez("Queres grabar otro dato en el archivo " + FicheroActivado));
    		 }
    		 else
    		 {
    		 MiClase.Aguarda("El archivo " + FicheroActivado + " no existe");
    		 }
    		 }
    
    
    		 private bool check()
    		 {
    		 MiCadena = MiClase.LeerDatoDeConsola();
    		 System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado);
    		 string FicheroAuxiliar = FicheroLeido.ReadLine();
    		 while (FicheroAuxiliar.CompareTo(".") != 0)
    		 {
    		 if (FicheroAuxiliar.CompareTo(MiCadena) == 0)
    		 {
    		 FicheroLeido.Close();
    		 return false;
    		 }
    		 else
    		 {
    		 FicheroAuxiliar = FicheroLeido.ReadLine();
    		 }
    		 }
    		 FicheroLeido.Close();
    		 return true;
    		 }
    
    
    		 public void CrearArchivo()
    		 {
    		 FicheroActivado = LeerNombreDelArchivo();
    		 if (System.IO.File.Exists(FicheroActivado))
    		 MiClase.Aguarda("El archivo " + FicheroActivado + " ya fue creado");
    		 else
    		 {
    		 using (StreamWriter FicheroEscrito = File.CreateText(FicheroActivado))
    		 {
    		 FicheroEscrito.WriteLine(".");
    		 MiClase.Aguarda("El archivo " + FicheroActivado + " fue creado");
    		 }
    		 }
    		 }
    
    
    		 public void ElimininarUnArchivo()
    		 {
    		 MiClase.MarcoSimpleDeTitulo(" ELIMINAR UN ARCHIVO ");
    		 FicheroActivado = LeerNombreDelArchivo();
    		 try
    		 {
    		 if (System.IO.File.Exists(FicheroActivado))
    		 {
    		 System.IO.File.Delete(FicheroActivado);
    		 MiClase.Aguarda("EXITO: El archivo " + FicheroActivado + " se fue al infierno..!!");
    		 }
    		 else MiClase.Aguarda("El archivo " + FicheroActivado + " NO existe..!!!");
    		 }
    		 catch
    		 {
    		 MiClase.Aguarda("El archivo " + FicheroActivado + " esta siendo usado por otro proceso");
    		 }
    		 }
    
    
    		 public void BuscarUnArchivo()
    		 {
    		 MiClase.MarcoSimpleDeTitulo(" BUSCAR SI EXISTE EL ARCHIVO ");
    		 FicheroActivado = LeerNombreDelArchivo();
    		 try
    		 {
    		 if (System.IO.File.Exists(FicheroActivado)) MiClase.Aguarda("El archvio " + FicheroActivado + " SI existe");
    		 else MiClase.Aguarda("El archivo: " + FicheroActivado + " NO existe");
    		 }
    		 catch
    		 {
    		 MiClase.Aguarda("El archivo: " + FicheroActivado + " esta siendo usado por otro proceso");
    		 }
    		 }
    
    
    		 public void BorrarDatoDelArchivo()
    		 {
    		 MiClase.MarcoSimpleDeTitulo(" BORRAR FICHA DEL ARCHIVO ");
    		 FicheroActivado = LeerNombreDelArchivo();
    		 bool LoEncontre = false;
    		 ArrayList FicheroListado = new ArrayList();
    		
    		 if (System.IO.File.Exists(FicheroActivado))
    		 {
    		 MiCadena = MiClase.LeerDatoDeConsola();
    		 System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado);
    		 string FicheroAuxiliar = FicheroLeido.ReadLine();
    		
    		 while (FicheroAuxiliar.CompareTo(".") != 0)
    		 {
    		 if (FicheroAuxiliar.CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToUpper().CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToLower().CompareTo(MiCadena) == 0)
    		 {
    		 LoEncontre = true;
    		 }
    		 else
    		 {
    		 FicheroListado.Add(FicheroAuxiliar);
    		 }
    		 FicheroAuxiliar = FicheroLeido.ReadLine();
    		 }
    		 FicheroListado.Add(".");
    		 FicheroLeido.Close();
    		 System.IO.StreamWriter FicheroEscrito = new System.IO.StreamWriter(FicheroActivado);
    		 foreach (string s in FicheroListado)
    		 {
    		 FicheroEscrito.WriteLine(s);
    		 }
    		 FicheroEscrito.Close();
    		 if (LoEncontre)
    		 {
    		 MiClase.Aguarda("EXITO: El dato " + MiCadena + " se fue al cielo..!!");
    		 }
    		 else
    		 {
    		 MiClase.Aguarda("Error: " + MiCadena + " No existe ");
    		 }
    		 }
    		 else Console.WriteLine("El archivo " + FicheroActivado + " no existe");
    		 }
    		 }
    

    Volver al principio

    
    		 ///////////////////////////////////////////////////////////////////
    		 // CLASE WILO ( herramientas )
    		 //////////////////////////////////////////////////////////////////
    		 public class ClaseWilo
    		 {
    		 public void MarcoSimpleDeTitulo(string Mensaje)
    		 {
    		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear();
    		 Console.ForegroundColor = ConsoleColor.DarkGreen;
    		 Console.Write("┌"); TrazarRayaSimple(78); Console.Write("┐");
    		 Console.Write("│ Wilo Carpio C# PROGRAMA MODELO CON ARCHIVO 2006 │");
    		 Console.Write("└"); TrazarRayaSimple(78); Console.Write("┘");
    		 Console.BackgroundColor = ConsoleColor.Red;Console.ForegroundColor = ConsoleColor.White;
    		 Console.Write(Mensaje);
    		 Console.BackgroundColor = ConsoleColor.Yellow;Console.ForegroundColor = ConsoleColor.DarkBlue;
    		 }
    		 public void TrazarRayaSimple(int TotalRayitas)
    		 {
    		 int i;
    		 Console.ForegroundColor = ConsoleColor.Red;
    		 for (i = 1; i <= TotalRayitas; i++) Console.Write("─");
    		 Console.ForegroundColor = ConsoleColor.DarkBlue;
    		 }
    		 public string LeerDatoDeConsola()
    		 {
    		 string Dato;
    		 TrazarRayaSimple(78);
    		 Console.Write("\n Digita el dato: "); Dato = Console.ReadLine();
    		 return Dato;
    		 }
    		 public void RotuloAzul(string TextoDelRotulo)
    		 {
    		 Console.ForegroundColor = ConsoleColor.White; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Blue;
    		 Console.Write(TextoDelRotulo + "\n");
    		 Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue;
    		 }
    
    
    		 public void Aguarda(string Mensaje)
    		 {
    		 Console.Write("\n ");
    		 Console.BackgroundColor = ConsoleColor.Red;Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write(" " + Mensaje + "..!!\n");
    		 Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" ");
    		 Console.BackgroundColor = ConsoleColor.Red;
    		 Console.ForegroundColor = ConsoleColor.White; Console.Write(" ENTER para seguir ");
    		 Console.BackgroundColor = ConsoleColor.Yellow;Console.ForegroundColor = ConsoleColor.DarkBlue;
    		 Console.ReadLine();
    		 }
    
    
    		 public bool OtraVez(string Pregunta)
    		 {
    		 bool Respuesta = false;
    		 string Opcion;
    		 Console.Write("\n\t" + Pregunta + "? (s/n)");
    		 Opcion = Console.ReadLine();
    		 if ((Opcion == "s") || (Opcion == "S"))
    		 Respuesta = true;
    		 return Respuesta;
    		  }
    		 }
    
    
    		 //////////////////////////////////////////////////
    		 // EJEMPLO DE UNA SUBCLASE
    		 //////////////////////////////////////////////////
    		 public class SubClaseWilo : ClaseWilo
    		 {
    		 public void MarcoDobleConTitulo(string Mensaje)
    		 {
    		 int i;
    		 Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Clear();
    		 Console.Write("\n"); Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
    		 Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗");
    		 Console.BackgroundColor = ConsoleColor.DarkGreen;Console.Write(" ");
    		 Console.BackgroundColor = ConsoleColor.DarkYellow;
    		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Green;
    		 Console.Write(" C#: MANEJO DE ARCHIVOS 2006 "); Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
    		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write(" WILUCHA 1.0 "); Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow;
    		 Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝");
    		 Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.Red;
    		 Console.WriteLine("\t\t\t\t\t\t" + Mensaje); Console.ForegroundColor = ConsoleColor.Blue;
    		 }
    
    
    		 public int OpcionMenuPrincipal()
    		 {
    		 MarcoDobleConTitulo("");
    		 int i; Console.Write(" ");
    		 Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗");
    		 Console.BackgroundColor = ConsoleColor.DarkGreen; Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.Red;
    		 Console.Write(" MENU PRINCIPAL "); Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" ");
    		 Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("╠"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╣");
    		
    		 Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.DarkRed;
    		
    		 Console.Write(" 1 → ABRIR ARCHIVO "); Separacion();
    		 Console.Write(" 2 → CREAR ARCHIVO "); Separacion();
    		 Console.Write(" 3 → VER SI HAY ARCHIVO "); Separacion();
    		 Console.Write(" 4 → BORRAR UN ARCHIVO "); Separacion();
    		 Console.Write(" "); Separacion();
    		 Console.Write(" 5 → SALIR "); Console.ForegroundColor = ConsoleColor.Yellow;
    		
    		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝");
    		 Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.White;
    		 Console.Write("\n\n\t Digita opción (Luego ENTER): ");
    		 int OpcionElegida = Convert.ToInt32(Console.ReadLine());
    		 return OpcionElegida;
    		 }
    		
    		 public void Separacion()
    		 {
    		 Console.ForegroundColor = ConsoleColor.Yellow;
    		 Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow;
    		 Console.BackgroundColor = ConsoleColor.DarkGreen;
    		 Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green;
    		 Console.Write("║"); Console.ForegroundColor = ConsoleColor.DarkRed;
    		 }
    		 }
    		 //////////////////////////////////////////////////
    		 // FIN DEL PROGRAMA
    		 //////////////////////////////////////////////////
    		}
    

    Para entrar en tema, te muestro a continuación 6 versiones de un mismo programa:

    1. Agenda 1: Maneja archivo y está códificado en consola
      
      using System;
      using System.IO;
      
      namespace Agenda
      {
          public class Clase
          {
              char resp;
              string salida = "";
      
              public Clase()
              {
              }
      
              private void menu()
              {
                  Clase C = new Clase();
      
                  do
                  {
                      salida = "NO";
                      Console.Clear();
      
                      Console.WriteLine("***** AGENDA EN CONSOLA *****");
                      Console.WriteLine("*                           *");
                      Console.WriteLine("*    1) Agregar contacto    *");
                      Console.WriteLine("*    2) Eliminar contacto   *");
                      Console.WriteLine("*    3) Listar contacto     *");
                      Console.WriteLine("*    4) Salir               *");
                      Console.WriteLine("*                           *");
                      Console.WriteLine("*****************************");
      
                      ConsoleKeyInfo info = Console.ReadKey(true);
                      resp = info.KeyChar;
                      switch (resp)
                      {
                          case '1': C.Agregar();
                              break;
      
                          case '2': C.Eliminar(0);
                              break;
      
                          case '3': C.Eliminar(1);
                              break;
      
                          case '4': salida = "SI";
                              break;
      
                          default: Console.WriteLine("\nOpción incorrecta. Elija una de las opciones que se muestran en el Menú.");
                              break;
                      }
                  } while (salida != "SI");
              }
      
              private void Agregar()
              {
                  Console.Clear();
      
                  string lectura = "";
                  string nombre = "";
                  string tel = "";
      
                  Console.WriteLine("Nombre:");
                  nombre = Console.ReadLine();
                  Console.WriteLine("Teléfono:");
                  tel = Console.ReadLine();
      
                  StreamReader lector = new StreamReader("Agenda.txt");            
                  StreamWriter escritor = new StreamWriter("AgendaBACK.txt");
      
                  while ((lectura = lector.ReadLine()) != null)
                  {
                      escritor.WriteLine(lectura);
                  }
                  lector.Close();
      
                  escritor.WriteLine(nombre);
                  escritor.WriteLine(tel);
                  escritor.Close();
      
                  File.Delete("Agenda.txt");
                  File.Copy("AgendaBACK.txt", "Agenda.txt");
                  File.Delete("AgendaBACK.txt");
              }
      
              private void Eliminar(int num)
              {
                  if (num == 0)
                  {
                      Console.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
      
                      string lectura = "";
                      string busqueda = "";
      
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          Console.WriteLine(lectura);
                          lectura = lector.ReadLine();
                          Console.WriteLine(lectura);
                          Console.WriteLine("*************************************");
                      }
                      lector.Close();
      
                      Console.WriteLine("Ingrese el nombre de la persona que desea eliminar");
                      busqueda = Console.ReadLine();
      
                      lector = new StreamReader("Agenda.txt");
                      StreamWriter escritorback = new StreamWriter("AgendaBACK.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          if (lectura == busqueda)
                          {
                              lector.ReadLine();
                          }
                          else
                          {
                              escritorback.WriteLine(lectura);
                          }
                      }
                      escritorback.Close();
                      lector.Close();
                      File.Delete("Agenda.txt");
                      File.Copy("AgendaBACK.txt", "Agenda.txt");
                      File.Delete("AgendaBACK.txt");
                  }
                  else
                  {
                      Console.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
      
                      string lectura = "";
      
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          Console.WriteLine(lectura);
                          lectura = lector.ReadLine();
                          Console.WriteLine(lectura);
                          Console.WriteLine("*************************************");
                      }
                      lector.Close();
                      Console.WriteLine("Presione 'Enter' para volver al menú principal");
                      Console.ReadLine();
                  }
              }
      
              static void Main()
              {
                  if (!File.Exists("Agenda.txt"))
                  {
                      StreamWriter escritor = new StreamWriter("Agenda.txt");
                      escritor.Close();
                  }
                  Clase C = new Clase();
                  C.menu();
              }
          }
      }
      
    2. Agenda2: Código en consola con ventanas - Maneja Archivos
      
      using System;
      using System.Drawing;
      using System.IO;
      using System.Windows.Forms;
      
      namespace Agenda
      {
          public class Clase
          {
              public Clase()
              {
              }
      
              public void DForma(Form nom, int x, int y, int w, int h, string text, FormStartPosition pos, FormBorderStyle est, bool min, bool max)
              {
                  nom.Size = new Size(w, h);
                  nom.StartPosition = pos;
                  nom.FormBorderStyle = est;
                  nom.MaximizeBox = max;
                  nom.MinimizeBox = min;
                  nom.Text = text;
              }
      
              public void DLabel(Label nom, string text, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
                  nom.Text = text;
              }
      
              public void DButton(Button nom, string text, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
                  nom.Text = text;
              }
      
              public void DTextBox(TextBox nom, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
              }
      
              public void DListBox(ListBox nom, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
              }
          }
      
          public class Form1:Form
          {
              public Form1()
              {
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  Label lb_agenda = new Label();
                  C.DLabel(lb_agenda, "AGENDA EN CONSOLA CON VENTANAS", 50, 10, 210, 20);
                  Controls.Add(lb_agenda);
      
                  Button btn_agregar = new Button();
                  C.DButton(btn_agregar, "Agregar", 100, 50, 100, 22);
                  btn_agregar.Click += new EventHandler(BotonAgregarClick);
                  Controls.Add(btn_agregar);
      
                  Button btn_eliminar = new Button();
                  C.DButton(btn_eliminar, "Eliminar", 100, 80, 100, 22);
                  btn_eliminar.Click += new EventHandler(BotonEliminarClick);
                  Controls.Add(btn_eliminar);
      
                  Button btn_listar = new Button();
                  C.DButton(btn_listar, "Listar", 100, 110, 100, 22);
                  btn_listar.Click += new EventHandler(BotonListarClick);
                  Controls.Add(btn_listar);
      
                  Button btn_salir = new Button();
                  C.DButton(btn_salir, "Salir", 100, 140, 100, 22);
                  btn_salir.Click += new EventHandler(BotonSalirClick);
                  Controls.Add(btn_salir);
              }
      
              private void BotonAgregarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form2 form2 = new Form2();
                  C.DForma(form2, 0, 0, 300, 200, "Agregar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form2.ShowDialog(this);
              }
      
              private void BotonEliminarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form3 form3 = new Form3(0);
                  C.DForma(form3, 0, 0, 300, 420, "Eliminar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form3.ShowDialog(this);
              }
      
              private void BotonListarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form3 form3 = new Form3(1);
                  C.DForma(form3, 0, 0, 300, 420, "Listar Contactos", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form3.ShowDialog(this);
              }
      
              private void BotonSalirClick(object sender, EventArgs e)
              {
                  Application.Exit();
              }
      
              static void Main()
              {
                  Clase C = new Clase();
                  Form1 form1 = new Form1();
                  C.DForma(form1, 0, 0, 300, 220, "Agenda con Ventanas", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
      
                  Application.EnableVisualStyles();
                  Application.Run(form1);
              }
          }
      
          public class Form2 : Form
          {
              TextBox txt_nom;
              TextBox txt_tel;
      
              public Form2()
              {
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  Label lb_agenda = new Label();
                  C.DLabel(lb_agenda, "AGREGAR NUEVO CONTACTO", 50, 10, 210, 20);
                  Controls.Add(lb_agenda);
      
                  Label lb_nom = new Label();
                  C.DLabel(lb_nom, "Nombre", 10, 50, 80, 20);
                  Controls.Add(lb_nom);
      
                  txt_nom = new TextBox();
                  C.DTextBox(txt_nom, 90, 50, 150, 20);
                  Controls.Add(txt_nom);
      
                  Label lb_tel = new Label();
                  C.DLabel(lb_tel, "Teléfono", 10, 80, 80, 20);
                  Controls.Add(lb_tel);
      
                  txt_tel = new TextBox();
                  C.DTextBox(txt_tel, 90, 80, 150, 20);
                  Controls.Add(txt_tel);
      
                  Button btn_aceptar = new Button();
                  C.DButton(btn_aceptar, "Aceptar", 50, 120, 100, 22);
                  btn_aceptar.Click += new EventHandler(BotonAceptarClick);
                  Controls.Add(btn_aceptar);
      
                  Button btn_cancel = new Button();
                  C.DButton(btn_cancel, "Cancelar", 160, 120, 100, 22);
                  btn_cancel.Click += new EventHandler(BotonCancelClick);
                  Controls.Add(btn_cancel);
              }
      
              private void BotonAceptarClick(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "" && txt_tel.Text != "")
                  {
                      string lectura = "";
      
                      StreamReader lector = new StreamReader("Agenda.txt");
                      StreamWriter escritor = new StreamWriter("AgendaBACK.txt");
      
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          escritor.WriteLine(lectura);
                      }
                      lector.Close();
      
                      escritor.WriteLine(txt_nom.Text);
                      escritor.WriteLine(txt_tel.Text);
                      escritor.Close();
      
                      File.Delete("Agenda.txt");
                      File.Copy("AgendaBACK.txt", "Agenda.txt");
                      File.Delete("AgendaBACK.txt");
      
                      MessageBox.Show("Contacto ingresado", "Exito",
                          MessageBoxButtons.OK, MessageBoxIcon.Information);
      
                      BotonCancelClick(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error",
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
                      txt_nom.SelectAll();
                      txt_nom.Focus();
                  }
              }
      
              private void BotonCancelClick(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      
          public class Form3 : Form
          {
              ListBox ltb_cont;
              TextBox txt_nom;
              int Num;
      
              public Form3(int num)
              {
                  Num = num;
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  if (Num == 0)
                  {
                      Label lb_agenda = new Label();
                      C.DLabel(lb_agenda, "ELIMINAR CONTACTO", 50, 10, 210, 20);
                      Controls.Add(lb_agenda);
      
                      ltb_cont = new ListBox();
                      C.DListBox(ltb_cont, 10, 50, 270, 250);
                      this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SIC);
                      Controls.Add(ltb_cont);
      
                      Label lb_nom = new Label();
                      C.DLabel(lb_nom, "Nombre", 10, 310, 80, 20);
                      Controls.Add(lb_nom);
      
                      txt_nom = new TextBox();
                      C.DTextBox(txt_nom, 90, 310, 150, 20);
                      txt_nom.ReadOnly = true;
                      Controls.Add(txt_nom);
      
                      Button btn_elim = new Button();
                      C.DButton(btn_elim, "Eliminar", 50, 350, 100, 22);
                      btn_elim.Click += new EventHandler(BotonEliminarClick);
                      Controls.Add(btn_elim);
      
                      Button btn_cancel = new Button();
                      C.DButton(btn_cancel, "Cancelar", 160, 350, 100, 22);
                      btn_cancel.Click += new EventHandler(BotonCancelClick);
                      Controls.Add(btn_cancel);
      
                      this.Load += new System.EventHandler(this.Form3_Load);
                  }
                  else
                  {
                      Label lb_agenda = new Label();
                      C.DLabel(lb_agenda, "LISTAR CONTACTOS", 50, 10, 210, 20);
                      Controls.Add(lb_agenda);
      
                      ltb_cont = new ListBox();
                      C.DListBox(ltb_cont, 10, 50, 270, 300);
                      Controls.Add(ltb_cont);
      
                      Button btn_cancel = new Button();
                      C.DButton(btn_cancel, "Cerrar", 100, 350, 100, 22);
                      btn_cancel.Click += new EventHandler(BotonCancelClick);
                      Controls.Add(btn_cancel);
      
                      this.Load += new System.EventHandler(this.Form3_Load);
                  }
              }
      
              private void Form3_Load(object sender, EventArgs e)
              {
                  if (Num == 0)
                  {
                      string lectura = "";
                      ltb_cont.Items.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          ltb_cont.Items.Add(lectura);
                          lector.ReadLine();
                      }
                      lector.Close();
                  }
                  else
                  {
                      string lectura = "";
                      ltb_cont.Items.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          ltb_cont.Items.Add(lectura + " - " + lector.ReadLine());
                      }
                      lector.Close();
                  }
              }
      
              private void ltb_cont_SIC(object sender, EventArgs e)
              {
                  txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim();
              }
      
              private void BotonEliminarClick(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "")
                  {
                      string lectura = "";
      
                      StreamReader lector = new StreamReader("Agenda.txt");
                      StreamWriter escritorback = new StreamWriter("AgendaBACK.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          if (lectura == txt_nom.Text)
                          {
                              lector.ReadLine();
                          }
                          else
                          {
                              escritorback.WriteLine(lectura);
                          }
                      }
                      escritorback.Close();
                      lector.Close();
                      File.Delete("Agenda.txt");
                      File.Copy("AgendaBACK.txt", "Agenda.txt");
                      File.Delete("AgendaBACK.txt");
      
                      MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
                      txt_nom.Clear();
                      Form3_Load(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                  }
              }
      
              private void BotonCancelClick(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
    3. Agenda3: Código en consola - Maneja Bases de Datos Access
      
      using System;
      using System.IO;
      using System.Data.OleDb;
      
      namespace Agenda
      {
          public class Clase
          {
              char resp;
              string salida = "";
      
              public Clase()
              {
              }
      
              private void menu()
              {
                  Clase C = new Clase();
      
                  do
                  {
                      salida = "NO";
                      Console.Clear();
      
                      Console.WriteLine("***** AGENDA EN CONSOLA *****");
                      Console.WriteLine("*                           *");
                      Console.WriteLine("*    1) Agregar contacto    *");
                      Console.WriteLine("*    2) Eliminar contacto   *");
                      Console.WriteLine("*    3) Listar contacto     *");
                      Console.WriteLine("*    4) Salir               *");
                      Console.WriteLine("*                           *");
                      Console.WriteLine("*****************************");
      
                      ConsoleKeyInfo info = Console.ReadKey(true);
                      resp = info.KeyChar;
                      switch (resp)
                      {
                          case '1': C.Agregar();
                              break;
      
                          case '2': C.Eliminar(0);
                              break;
      
                          case '3': C.Eliminar(1);
                              break;
      
                          case '4': salida = "SI";
                              break;
      
                          default: Console.WriteLine("\nOpción incorrecta. Elija una de las opciones que se muestran en el Menú.");
                              break;
                      }
                  } while (salida != "SI");
              }
      
              private void Agregar()
              {
                  Console.Clear();
      
                  string nombre = "";
                  string tel = "";
      
                  Console.WriteLine("Nombre:");
                  nombre = Console.ReadLine();
                  Console.WriteLine("Teléfono:");
                  tel = Console.ReadLine();
      
                  try
                  {
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + nombre + "','" + tel + "');";
                      OleDbCommand com = new OleDbCommand(insert, con);
                      com.ExecuteNonQuery();
                      con.Close();
                  }
                  catch
                  {
                      Console.WriteLine("Ocurrió un error cuando se estaba ingresando. Presione 'Enter' para volver.");
                      Console.ReadLine();
                  }
              }
      
              private void Eliminar(int num)
              {
                  if (num == 0)
                  {
                      Console.Clear();
      
                      string busqueda = "";
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
      
                      string select = "SELECT nom,tel FROM contactos ORDER BY nom";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
      
                      while (lector.Read())
                      {
                          Console.WriteLine(lector.GetValue(0).ToString().Trim());
                          Console.WriteLine(lector.GetValue(1).ToString().Trim());
                          Console.WriteLine("*************************************");
                      }
                      lector.Close();
      
                      Console.WriteLine("Ingrese el nombre de la persona que desea eliminar");
                      busqueda = Console.ReadLine();
      
                      string delete = "DELETE FROM contactos WHERE nom='" + busqueda + "'";
                      com = new OleDbCommand(delete, con);
                      com.ExecuteNonQuery();
      
                      con.Close();
                  }
                  else
                  {
                      Console.Clear();
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
      
                      string select = "SELECT nom,tel FROM contactos ORDER BY nom";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
      
                      while (lector.Read())
                      {
                          Console.WriteLine(lector.GetValue(0).ToString().Trim());
                          Console.WriteLine(lector.GetValue(1).ToString().Trim());
                          Console.WriteLine("*************************************");
                      }
                      lector.Close();
      
                      con.Close();
      
                      Console.WriteLine("Presione 'Enter' para volver al menú principal");
                      Console.ReadLine();
                  }
              }
      
              static void Main()
              {
                  if (!File.Exists("Agenda.txt"))
                  {
                      StreamWriter escritor = new StreamWriter("Agenda.txt");
                      escritor.Close();
                  }
                  Clase C = new Clase();
                  C.menu();
              }
          }
      }
      
    4. Agenda4: Código en consola con ventanas - Maneja Bases de Datos Access
      
      using System;
      using System.Drawing;
      using System.Data.OleDb;
      using System.Windows.Forms;
      
      namespace Agenda
      {
          public class Clase
          {
              public Clase()
              {
              }
      
              public void DForma(Form nom, int x, int y, int w, int h, string text, FormStartPosition pos, FormBorderStyle est, bool min, bool max)
              {
                  nom.Size = new Size(w, h);
                  nom.StartPosition = pos;
                  nom.FormBorderStyle = est;
                  nom.MaximizeBox = max;
                  nom.MinimizeBox = min;
                  nom.Text = text;
              }
      
              public void DLabel(Label nom, string text, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
                  nom.Text = text;
              }
      
              public void DButton(Button nom, string text, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
                  nom.Text = text;
              }
      
              public void DTextBox(TextBox nom, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
              }
      
              public void DListBox(ListBox nom, int x, int y, int w, int h)
              {
                  nom.Size = new Size(w, h);
                  nom.Location = new Point(x, y);
              }
          }
      
          public class Form1 : Form
          {
              public Form1()
              {
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  Label lb_agenda = new Label();
                  C.DLabel(lb_agenda, "AGENDA EN CONSOLA CON VENTANAS", 50, 10, 210, 20);
                  Controls.Add(lb_agenda);
      
                  Button btn_agregar = new Button();
                  C.DButton(btn_agregar, "Agregar", 100, 50, 100, 22);
                  btn_agregar.Click += new EventHandler(BotonAgregarClick);
                  Controls.Add(btn_agregar);
      
                  Button btn_eliminar = new Button();
                  C.DButton(btn_eliminar, "Eliminar", 100, 80, 100, 22);
                  btn_eliminar.Click += new EventHandler(BotonEliminarClick);
                  Controls.Add(btn_eliminar);
      
                  Button btn_listar = new Button();
                  C.DButton(btn_listar, "Listar", 100, 110, 100, 22);
                  btn_listar.Click += new EventHandler(BotonListarClick);
                  Controls.Add(btn_listar);
      
                  Button btn_salir = new Button();
                  C.DButton(btn_salir, "Salir", 100, 140, 100, 22);
                  btn_salir.Click += new EventHandler(BotonSalirClick);
                  Controls.Add(btn_salir);
              }
      
              private void BotonAgregarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form2 form2 = new Form2();
                  C.DForma(form2, 0, 0, 300, 200, "Agregar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form2.ShowDialog(this);
              }
      
              private void BotonEliminarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form3 form3 = new Form3(0);
                  C.DForma(form3, 0, 0, 300, 420, "Eliminar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form3.ShowDialog(this);
              }
      
              private void BotonListarClick(object sender, EventArgs e)
              {
                  Clase C = new Clase();
                  Form3 form3 = new Form3(1);
                  C.DForma(form3, 0, 0, 300, 420, "Listar Contactos", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
                  form3.ShowDialog(this);
              }
      
              private void BotonSalirClick(object sender, EventArgs e)
              {
                  Application.Exit();
              }
      
              static void Main()
              {
                  Clase C = new Clase();
                  Form1 form1 = new Form1();
                  C.DForma(form1, 0, 0, 300, 220, "Agenda con Ventanas", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false);
      
                  Application.EnableVisualStyles();
                  Application.Run(form1);
              }
          }
      
          public class Form2 : Form
          {
              TextBox txt_nom;
              TextBox txt_tel;
      
              public Form2()
              {
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  Label lb_agenda = new Label();
                  C.DLabel(lb_agenda, "AGREGAR NUEVO CONTACTO", 50, 10, 210, 20);
                  Controls.Add(lb_agenda);
      
                  Label lb_nom = new Label();
                  C.DLabel(lb_nom, "Nombre", 10, 50, 80, 20);
                  Controls.Add(lb_nom);
      
                  txt_nom = new TextBox();
                  C.DTextBox(txt_nom, 90, 50, 150, 20);
                  Controls.Add(txt_nom);
      
                  Label lb_tel = new Label();
                  C.DLabel(lb_tel, "Teléfono", 10, 80, 80, 20);
                  Controls.Add(lb_tel);
      
                  txt_tel = new TextBox();
                  C.DTextBox(txt_tel, 90, 80, 150, 20);
                  Controls.Add(txt_tel);
      
                  Button btn_aceptar = new Button();
                  C.DButton(btn_aceptar, "Aceptar", 50, 120, 100, 22);
                  btn_aceptar.Click += new EventHandler(BotonAceptarClick);
                  Controls.Add(btn_aceptar);
      
                  Button btn_cancel = new Button();
                  C.DButton(btn_cancel, "Cancelar", 160, 120, 100, 22);
                  btn_cancel.Click += new EventHandler(BotonCancelClick);
                  Controls.Add(btn_cancel);
              }
      
              private void BotonAceptarClick(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "" && txt_tel.Text != "")
                  {
                      try
                      {
                          OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                          con.Open();
                          string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');";
                          OleDbCommand com = new OleDbCommand(insert, con);
                          com.ExecuteNonQuery();
                          con.Close();
      
                          MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
      
                          BotonCancelClick(sender, e);
                      }
                      catch
                      {
                          MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                          txt_nom.SelectAll();
                          txt_nom.Focus();
                      }
                  }
                  else
                  {
                      MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error",
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
                      txt_nom.SelectAll();
                      txt_nom.Focus();
                  }
              }
      
              private void BotonCancelClick(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      
          public class Form3 : Form
          {
              ListBox ltb_cont;
              TextBox txt_nom;
              int Num;
      
              public Form3(int num)
              {
                  Num = num;
                  Diseñador();
              }
      
              private void Diseñador()
              {
                  Clase C = new Clase();
      
                  if (Num == 0)
                  {
                      Label lb_agenda = new Label();
                      C.DLabel(lb_agenda, "ELIMINAR CONTACTO", 50, 10, 210, 20);
                      Controls.Add(lb_agenda);
      
                      ltb_cont = new ListBox();
                      C.DListBox(ltb_cont, 10, 50, 270, 250);
                      this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SIC);
                      Controls.Add(ltb_cont);
      
                      Label lb_nom = new Label();
                      C.DLabel(lb_nom, "Nombre", 10, 310, 80, 20);
                      Controls.Add(lb_nom);
      
                      txt_nom = new TextBox();
                      C.DTextBox(txt_nom, 90, 310, 150, 20);
                      txt_nom.ReadOnly = true;
                      Controls.Add(txt_nom);
      
                      Button btn_elim = new Button();
                      C.DButton(btn_elim, "Eliminar", 50, 350, 100, 22);
                      btn_elim.Click += new EventHandler(BotonEliminarClick);
                      Controls.Add(btn_elim);
      
                      Button btn_cancel = new Button();
                      C.DButton(btn_cancel, "Cancelar", 160, 350, 100, 22);
                      btn_cancel.Click += new EventHandler(BotonCancelClick);
                      Controls.Add(btn_cancel);
      
                      this.Load += new System.EventHandler(this.Form3_Load);
                  }
                  else
                  {
                      Label lb_agenda = new Label();
                      C.DLabel(lb_agenda, "LISTAR CONTACTOS", 50, 10, 210, 20);
                      Controls.Add(lb_agenda);
      
                      ltb_cont = new ListBox();
                      C.DListBox(ltb_cont, 10, 50, 270, 300);
                      Controls.Add(ltb_cont);
      
                      Button btn_cancel = new Button();
                      C.DButton(btn_cancel, "Cerrar", 100, 350, 100, 22);
                      btn_cancel.Click += new EventHandler(BotonCancelClick);
                      Controls.Add(btn_cancel);
      
                      this.Load += new System.EventHandler(this.Form3_Load);
                  }
              }
      
              private void Form3_Load(object sender, EventArgs e)
              {
                  if (Num == 0)
                  {
                      ltb_cont.Items.Clear();
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string select = "SELECT nom FROM contactos ORDER BY nom;";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
                      while (lector.Read())
                      {
                          ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim());
                      }
                      con.Close();
                  }
                  else
                  {
                      ltb_cont.Items.Clear();
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string select = "SELECT nom,tel FROM contactos ORDER BY nom;";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
                      while (lector.Read())
                      {
                          ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim() + " - " + lector.GetValue(1).ToString().Trim());
                      }
                      con.Close();
                  }
              }
      
              private void ltb_cont_SIC(object sender, EventArgs e)
              {
                  txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim();
              }
      
              private void BotonEliminarClick(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "")
                  {
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string delete = "DELETE FROM contactos WHERE nom='" + txt_nom.Text + "'";
                      OleDbCommand com = new OleDbCommand(delete, con);
                      com.ExecuteNonQuery();
                      con.Close();
      
                      MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
                      txt_nom.Clear();
                      Form3_Load(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                  }
              }
      
              private void BotonCancelClick(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
    5. Agenda5: Código en diseñador con ventanas - Maneja Archivos
      
      using System;
      using System.Collections.Generic;
      using System.Windows.Forms;
      
      namespace Agenda5
      {
          static class Program
          {
              /// 
              /// Punto de entrada principal para la aplicación.
              /// 
              [STAThread]
              static void Main()
              {
                  Application.EnableVisualStyles();
                  Application.SetCompatibleTextRenderingDefault(false);
                  Application.Run(new Form1());
              }
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      
      namespace Agenda5
      {
          public partial class Form1 : Form
          {
              public Form1()
              {
                  InitializeComponent();
              }
      
              private void btn_agregar_Click(object sender, EventArgs e)
              {
                  Form2 form2 = new Form2();
                  form2.ShowDialog(this);
              }
      
              private void btn_eliminar_Click(object sender, EventArgs e)
              {
                  Form3 form3 = new Form3(0);
                  form3.ShowDialog(this);
              }
      
              private void btn_listar_Click(object sender, EventArgs e)
              {
                  Form3 form3 = new Form3(1);
                  form3.ShowDialog(this);
              }
      
              private void btn_salir_Click(object sender, EventArgs e)
              {
                  Application.Exit();
              }
          }
      }
      
      namespace Agenda5
      {
          partial class Form1
          {
              /// 
              /// Variable del diseñador requerida.
              /// 
              private System.ComponentModel.IContainer components = null;
      
              /// 
              /// Limpiar los recursos que se estén utilizando.
              /// 
              /// true si los recursos administrados se deben eliminar; false en caso contrario, false.
              protected override void Dispose(bool disposing)
              {
                  if (disposing && (components != null))
                  {
                      components.Dispose();
                  }
                  base.Dispose(disposing);
              }
      
              #region Código generado por el Diseñador de Windows Forms
      
              /// 
              /// Método necesario para admitir el Diseñador. No se puede modificar
              /// el contenido del método con el editor de código.
              /// 
              private void InitializeComponent()
              {
                  this.lb_agenda = new System.Windows.Forms.Label();
                  this.btn_agregar = new System.Windows.Forms.Button();
                  this.btn_eliminar = new System.Windows.Forms.Button();
                  this.btn_listar = new System.Windows.Forms.Button();
                  this.btn_salir = new System.Windows.Forms.Button();
                  this.SuspendLayout();
                  // 
                  // lb_agenda
                  // 
                  this.lb_agenda.AutoSize = true;
                  this.lb_agenda.Location = new System.Drawing.Point(80, 27);
                  this.lb_agenda.Name = "lb_agenda";
                  this.lb_agenda.Size = new System.Drawing.Size(135, 13);
                  this.lb_agenda.TabIndex = 0;
                  this.lb_agenda.Text = "AGENDA CON VENTANAS";
                  // 
                  // btn_agregar
                  // 
                  this.btn_agregar.Location = new System.Drawing.Point(110, 58);
                  this.btn_agregar.Name = "btn_agregar";
                  this.btn_agregar.Size = new System.Drawing.Size(75, 23);
                  this.btn_agregar.TabIndex = 1;
                  this.btn_agregar.Text = "Agregar";
                  this.btn_agregar.UseVisualStyleBackColor = true;
                  this.btn_agregar.Click += new System.EventHandler(this.btn_agregar_Click);
                  // 
                  // btn_eliminar
                  // 
                  this.btn_eliminar.Location = new System.Drawing.Point(110, 87);
                  this.btn_eliminar.Name = "btn_eliminar";
                  this.btn_eliminar.Size = new System.Drawing.Size(75, 23);
                  this.btn_eliminar.TabIndex = 2;
                  this.btn_eliminar.Text = "Eliminar";
                  this.btn_eliminar.UseVisualStyleBackColor = true;
                  this.btn_eliminar.Click += new System.EventHandler(this.btn_eliminar_Click);
                  // 
                  // btn_listar
                  // 
                  this.btn_listar.Location = new System.Drawing.Point(110, 116);
                  this.btn_listar.Name = "btn_listar";
                  this.btn_listar.Size = new System.Drawing.Size(75, 23);
                  this.btn_listar.TabIndex = 3;
                  this.btn_listar.Text = "Listar";
                  this.btn_listar.UseVisualStyleBackColor = true;
                  this.btn_listar.Click += new System.EventHandler(this.btn_listar_Click);
                  // 
                  // btn_salir
                  // 
                  this.btn_salir.Location = new System.Drawing.Point(110, 145);
                  this.btn_salir.Name = "btn_salir";
                  this.btn_salir.Size = new System.Drawing.Size(75, 23);
                  this.btn_salir.TabIndex = 4;
                  this.btn_salir.Text = "Salir";
                  this.btn_salir.UseVisualStyleBackColor = true;
                  this.btn_salir.Click += new System.EventHandler(this.btn_salir_Click);
                  // 
                  // Form1
                  // 
                  this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
                  this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                  this.ClientSize = new System.Drawing.Size(294, 188);
                  this.Controls.Add(this.btn_salir);
                  this.Controls.Add(this.btn_listar);
                  this.Controls.Add(this.btn_eliminar);
                  this.Controls.Add(this.btn_agregar);
                  this.Controls.Add(this.lb_agenda);
                  this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
                  this.MaximizeBox = false;
                  this.Name = "Form1";
                  this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
                  this.Text = "Agenda con Ventanas";
                  this.ResumeLayout(false);
                  this.PerformLayout();
      
              }
      
              #endregion
      
              private System.Windows.Forms.Label lb_agenda;
              private System.Windows.Forms.Button btn_agregar;
              private System.Windows.Forms.Button btn_eliminar;
              private System.Windows.Forms.Button btn_listar;
              private System.Windows.Forms.Button btn_salir;
          }
      }
      
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      using System.IO;
      
      namespace Agenda5
      {
          public partial class Form2 : Form
          {
              public Form2()
              {
                  InitializeComponent();
              }
      
              private void btn_aceptar_Click(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "" && txt_tel.Text != "")
                  {
                      string lectura = "";
      
                      StreamReader lector = new StreamReader("Agenda.txt");
                      StreamWriter escritor = new StreamWriter("AgendaBACK.txt");
      
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          escritor.WriteLine(lectura);
                      }
                      lector.Close();
      
                      escritor.WriteLine(txt_nom.Text);
                      escritor.WriteLine(txt_tel.Text);
                      escritor.Close();
      
                      File.Delete("Agenda.txt");
                      File.Copy("AgendaBACK.txt", "Agenda.txt");
                      File.Delete("AgendaBACK.txt");
      
                      MessageBox.Show("Contacto ingresado", "Exito",
                          MessageBoxButtons.OK, MessageBoxIcon.Information);
      
                      btn_cancel_Click(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error",
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
                      txt_nom.SelectAll();
                      txt_nom.Focus();
                  }
              }
      
              private void btn_cancel_Click(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
      namespace Agenda5
      {
          partial class Form2
          {
              /// 
              /// Variable del diseñador requerida.
              /// 
              private System.ComponentModel.IContainer components = null;
      
              /// 
              /// Limpiar los recursos que se estén utilizando.
              /// 
              /// true si los recursos administrados se deben eliminar; false en caso contrario, false.
              protected override void Dispose(bool disposing)
              {
                  if (disposing && (components != null))
                  {
                      components.Dispose();
                  }
                  base.Dispose(disposing);
              }
      
              #region Código generado por el Diseñador de Windows Forms
      
              /// 
              /// Método necesario para admitir el Diseñador. No se puede modificar
              /// el contenido del método con el editor de código.
              /// 
              private void InitializeComponent()
              {
                  this.lb_agenda = new System.Windows.Forms.Label();
                  this.lb_nom = new System.Windows.Forms.Label();
                  this.lb_tel = new System.Windows.Forms.Label();
                  this.txt_nom = new System.Windows.Forms.TextBox();
                  this.txt_tel = new System.Windows.Forms.TextBox();
                  this.btn_aceptar = new System.Windows.Forms.Button();
                  this.btn_cancel = new System.Windows.Forms.Button();
                  this.SuspendLayout();
                  // 
                  // lb_agenda
                  // 
                  this.lb_agenda.AutoSize = true;
                  this.lb_agenda.Location = new System.Drawing.Point(67, 28);
                  this.lb_agenda.Name = "lb_agenda";
                  this.lb_agenda.Size = new System.Drawing.Size(158, 13);
                  this.lb_agenda.TabIndex = 0;
                  this.lb_agenda.Text = "AGREGAR NUEVO CONTACTO";
                  // 
                  // lb_nom
                  // 
                  this.lb_nom.AutoSize = true;
                  this.lb_nom.Location = new System.Drawing.Point(12, 60);
                  this.lb_nom.Name = "lb_nom";
                  this.lb_nom.Size = new System.Drawing.Size(48, 13);
                  this.lb_nom.TabIndex = 1;
                  this.lb_nom.Text = "Nombre";
                  // 
                  // lb_tel
                  // 
                  this.lb_tel.AutoSize = true;
                  this.lb_tel.Location = new System.Drawing.Point(12, 94);
                  this.lb_tel.Name = "lb_tel";
                  this.lb_tel.Size = new System.Drawing.Size(52, 13);
                  this.lb_tel.TabIndex = 2;
                  this.lb_tel.Text = "Teléfono";
                  // 
                  // txt_nom
                  // 
                  this.txt_nom.Location = new System.Drawing.Point(82, 57);
                  this.txt_nom.Name = "txt_nom";
                  this.txt_nom.Size = new System.Drawing.Size(181, 22);
                  this.txt_nom.TabIndex = 3;
                  // 
                  // txt_tel
                  // 
                  this.txt_tel.Location = new System.Drawing.Point(82, 91);
                  this.txt_tel.Name = "txt_tel";
                  this.txt_tel.Size = new System.Drawing.Size(181, 22);
                  this.txt_tel.TabIndex = 4;
                  // 
                  // btn_aceptar
                  // 
                  this.btn_aceptar.Location = new System.Drawing.Point(56, 131);
                  this.btn_aceptar.Name = "btn_aceptar";
                  this.btn_aceptar.Size = new System.Drawing.Size(75, 23);
                  this.btn_aceptar.TabIndex = 5;
                  this.btn_aceptar.Text = "Aceptar";
                  this.btn_aceptar.UseVisualStyleBackColor = true;
                  this.btn_aceptar.Click += new System.EventHandler(this.btn_aceptar_Click);
                  // 
                  // btn_cancel
                  // 
                  this.btn_cancel.Location = new System.Drawing.Point(161, 131);
                  this.btn_cancel.Name = "btn_cancel";
                  this.btn_cancel.Size = new System.Drawing.Size(75, 23);
                  this.btn_cancel.TabIndex = 6;
                  this.btn_cancel.Text = "Cancelar";
                  this.btn_cancel.UseVisualStyleBackColor = true;
                  this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click);
                  // 
                  // Form2
                  // 
                  this.ClientSize = new System.Drawing.Size(292, 166);
                  this.Controls.Add(this.btn_cancel);
                  this.Controls.Add(this.btn_aceptar);
                  this.Controls.Add(this.txt_tel);
                  this.Controls.Add(this.txt_nom);
                  this.Controls.Add(this.lb_tel);
                  this.Controls.Add(this.lb_nom);
                  this.Controls.Add(this.lb_agenda);
                  this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
                  this.MaximizeBox = false;
                  this.Name = "Form2";
                  this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
                  this.Text = "Agregar Contacto";
                  this.ResumeLayout(false);
                  this.PerformLayout();
      
              }
      
              #endregion
      
              private System.Windows.Forms.Label lb_agenda;
              private System.Windows.Forms.Label lb_nom;
              private System.Windows.Forms.Label lb_tel;
              private System.Windows.Forms.TextBox txt_nom;
              private System.Windows.Forms.TextBox txt_tel;
              private System.Windows.Forms.Button btn_aceptar;
              private System.Windows.Forms.Button btn_cancel;
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      using System.IO;
      
      namespace Agenda5
      {
          public partial class Form3 : Form
          {
              int Num;
      
              public Form3(int num)
              {
                  InitializeComponent();
                  Num = num;
              }
      
              private void Form3_Load(object sender, EventArgs e)
              {
                  if (Num == 0)
                  {
                      string lectura = "";
                      ltb_cont.Items.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          ltb_cont.Items.Add(lectura);
                          lector.ReadLine();
                      }
                      lector.Close();
                  }
                  else
                  {
                      this.Text = "Listar Contactos";
                      lb_agenda.Text = "LISTAR CONTACTOS";
                      lb_nom.Visible = false;
                      txt_nom.Visible = false;
                      ltb_cont.Size = new Size(268, 310);
                      btn_elim.Visible = false;
                      btn_cancel.Location = new Point(110, 351);
                      btn_cancel.Text = "Cerrar";
      
                      string lectura = "";
                      ltb_cont.Items.Clear();
                      StreamReader lector = new StreamReader("Agenda.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          ltb_cont.Items.Add(lectura + " - " + lector.ReadLine());
                      }
                      lector.Close();
                  }
              }
      
              private void ltb_cont_SelectedIndexChanged(object sender, EventArgs e)
              {
                  txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim();
              }
      
              private void btn_eliminar_Click(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "")
                  {
                      string lectura = "";
      
                      StreamReader lector = new StreamReader("Agenda.txt");
                      StreamWriter escritorback = new StreamWriter("AgendaBACK.txt");
                      while ((lectura = lector.ReadLine()) != null)
                      {
                          if (lectura == txt_nom.Text)
                          {
                              lector.ReadLine();
                          }
                          else
                          {
                              escritorback.WriteLine(lectura);
                          }
                      }
                      escritorback.Close();
                      lector.Close();
                      File.Delete("Agenda.txt");
                      File.Copy("AgendaBACK.txt", "Agenda.txt");
                      File.Delete("AgendaBACK.txt");
      
                      MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
                      txt_nom.Clear();
                      Form3_Load(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                  }
              }
      
              private void btn_cancel_Click(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
      namespace Agenda5
      {
          partial class Form3
          {
              /// 
              /// Variable del diseñador requerida.
              /// 
              private System.ComponentModel.IContainer components = null;
      
              /// 
              /// Limpiar los recursos que se estén utilizando.
              /// 
              /// true si los recursos administrados se deben eliminar; false en caso contrario, false.
              protected override void Dispose(bool disposing)
              {
                  if (disposing && (components != null))
                  {
                      components.Dispose();
                  }
                  base.Dispose(disposing);
              }
      
              #region Código generado por el Diseñador de Windows Forms
      
              /// 
              /// Método necesario para admitir el Diseñador. No se puede modificar
              /// el contenido del método con el editor de código.
              /// 
              private void InitializeComponent()
              {
                  this.ltb_cont = new System.Windows.Forms.ListBox();
                  this.lb_agenda = new System.Windows.Forms.Label();
                  this.btn_cancel = new System.Windows.Forms.Button();
                  this.btn_elim = new System.Windows.Forms.Button();
                  this.txt_nom = new System.Windows.Forms.TextBox();
                  this.lb_nom = new System.Windows.Forms.Label();
                  this.SuspendLayout();
                  // 
                  // ltb_cont
                  // 
                  this.ltb_cont.FormattingEnabled = true;
                  this.ltb_cont.Location = new System.Drawing.Point(12, 44);
                  this.ltb_cont.Name = "ltb_cont";
                  this.ltb_cont.Size = new System.Drawing.Size(268, 264);
                  this.ltb_cont.TabIndex = 0;
                  this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SelectedIndexChanged);
                  // 
                  // lb_agenda
                  // 
                  this.lb_agenda.AutoSize = true;
                  this.lb_agenda.Location = new System.Drawing.Point(88, 19);
                  this.lb_agenda.Name = "lb_agenda";
                  this.lb_agenda.Size = new System.Drawing.Size(116, 13);
                  this.lb_agenda.TabIndex = 1;
                  this.lb_agenda.Text = "ELIMINAR CONTACTO";
                  // 
                  // btn_cancel
                  // 
                  this.btn_cancel.Location = new System.Drawing.Point(161, 351);
                  this.btn_cancel.Name = "btn_cancel";
                  this.btn_cancel.Size = new System.Drawing.Size(75, 23);
                  this.btn_cancel.TabIndex = 12;
                  this.btn_cancel.Text = "Cancelar";
                  this.btn_cancel.UseVisualStyleBackColor = true;
                  this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click);
                  // 
                  // btn_elim
                  // 
                  this.btn_elim.Location = new System.Drawing.Point(56, 351);
                  this.btn_elim.Name = "btn_elim";
                  this.btn_elim.Size = new System.Drawing.Size(75, 23);
                  this.btn_elim.TabIndex = 11;
                  this.btn_elim.Text = "Eliminar";
                  this.btn_elim.UseVisualStyleBackColor = true;
                  this.btn_elim.Click += new System.EventHandler(this.btn_eliminar_Click);
                  // 
                  // txt_nom
                  // 
                  this.txt_nom.Location = new System.Drawing.Point(91, 314);
                  this.txt_nom.Name = "txt_nom";
                  this.txt_nom.ReadOnly = true;
                  this.txt_nom.Size = new System.Drawing.Size(181, 22);
                  this.txt_nom.TabIndex = 9;
                  // 
                  // lb_nom
                  // 
                  this.lb_nom.AutoSize = true;
                  this.lb_nom.Location = new System.Drawing.Point(21, 317);
                  this.lb_nom.Name = "lb_nom";
                  this.lb_nom.Size = new System.Drawing.Size(48, 13);
                  this.lb_nom.TabIndex = 7;
                  this.lb_nom.Text = "Nombre";
                  // 
                  // Form3
                  // 
                  this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
                  this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                  this.ClientSize = new System.Drawing.Size(292, 386);
                  this.Controls.Add(this.btn_cancel);
                  this.Controls.Add(this.btn_elim);
                  this.Controls.Add(this.txt_nom);
                  this.Controls.Add(this.lb_nom);
                  this.Controls.Add(this.lb_agenda);
                  this.Controls.Add(this.ltb_cont);
                  this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
                  this.MaximizeBox = false;
                  this.Name = "Form3";
                  this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
                  this.Text = "Eliminar Contacto";
                  this.Load += new System.EventHandler(this.Form3_Load);
                  this.ResumeLayout(false);
                  this.PerformLayout();
      
              }
      
              #endregion
      
              private System.Windows.Forms.ListBox ltb_cont;
              private System.Windows.Forms.Label lb_agenda;
              private System.Windows.Forms.Button btn_cancel;
              private System.Windows.Forms.Button btn_elim;
              private System.Windows.Forms.TextBox txt_nom;
              private System.Windows.Forms.Label lb_nom;
          }
      }
      
    6. Agenda6: Código en diseñador con ventanas - Maneja Bases de Datos Access
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      
      namespace Agenda6
      {
          public partial class Form1 : Form
          {
              public Form1()
              {
                  InitializeComponent();
              }
      
              private void btn_agregar_Click(object sender, EventArgs e)
              {
                  Form2 form2 = new Form2();
                  form2.ShowDialog(this);
              }
      
              private void btn_eliminar_Click(object sender, EventArgs e)
              {
                  Form3 form3 = new Form3(0);
                  form3.ShowDialog(this);
              }
      
              private void btn_listar_Click(object sender, EventArgs e)
              {
                  Form3 form3 = new Form3(1);
                  form3.ShowDialog(this);
              }
      
              private void btn_salir_Click(object sender, EventArgs e)
              {
                  Application.Exit();
              }
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      using System.Data.OleDb;
      
      namespace Agenda6
      {
          public partial class Form2 : Form
          {
              public Form2()
              {
                  InitializeComponent();
              }
      
              private void btn_aceptar_Click(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "" && txt_tel.Text != "")
                  {
                      try
                      {
                          OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                          con.Open();
                          string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');";
                          OleDbCommand com = new OleDbCommand(insert, con);
                          com.ExecuteNonQuery();
                          con.Close();
      
                          MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
      
                          btn_cancel_Click(sender, e);
                      }
                      catch
                      {
                          MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                          txt_nom.SelectAll();
                          txt_nom.Focus();
                      }
                  }
                  else
                  {
                      MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error",
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
                      txt_nom.SelectAll();
                      txt_nom.Focus();
                  }
              }
      
              private void btn_cancel_Click(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      using System.Data.OleDb;
      
      namespace Agenda6
      {
          public partial class Form3 : Form
          {
              int Num;
      
              public Form3(int num)
              {
                  InitializeComponent();
                  Num = num;
              }
      
              private void Form3_Load(object sender, EventArgs e)
              {
                  if (Num == 0)
                  {
                      ltb_cont.Items.Clear();
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string select = "SELECT nom FROM contactos ORDER BY nom;";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
                      while (lector.Read())
                      {
                          ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim());
                      }
                      con.Close();
                  }
                  else
                  {
                      this.Text = "Listar Contactos";
                      lb_agenda.Text = "LISTAR CONTACTOS";
                      lb_nom.Visible = false;
                      txt_nom.Visible = false;
                      ltb_cont.Size = new Size(268, 310);
                      btn_elim.Visible = false;
                      btn_cancel.Location = new Point(110, 351);
                      btn_cancel.Text = "Cerrar";
      
                      ltb_cont.Items.Clear();
      
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string select = "SELECT nom,tel FROM contactos ORDER BY nom;";
                      OleDbCommand com = new OleDbCommand(select, con);
                      OleDbDataReader lector = com.ExecuteReader();
                      while (lector.Read())
                      {
                          ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim() + " - " + lector.GetValue(1).ToString().Trim());
                      }
                      con.Close();
                  }
              }
      
              private void ltb_cont_SelectedIndexChanged(object sender, EventArgs e)
              {
                  txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim();
              }
      
              private void btn_elim_Click(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "")
                  {
                      OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                      con.Open();
                      string delete = "DELETE FROM contactos WHERE nom='" + txt_nom.Text + "'";
                      OleDbCommand com = new OleDbCommand(delete, con);
                      com.ExecuteNonQuery();
                      con.Close();
      
                      MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
                      txt_nom.Clear();
                      Form3_Load(sender, e);
                  }
                  else
                  {
                      MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                  }
              }
      
              private void btn_cancel_Click(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.Windows.Forms;
      
      namespace Agenda6
      {
          static class Program
          {
              /// 
              /// Punto de entrada principal para la aplicación.
              /// 
              [STAThread]
              static void Main()
              {
                  Application.EnableVisualStyles();
                  Application.SetCompatibleTextRenderingDefault(false);
                  Application.Run(new Form1());
              }
          }
      }
      
      namespace Agenda6
      {
          partial class Form1
          {
              /// 
              /// Variable del diseñador requerida.
              /// 
              private System.ComponentModel.IContainer components = null;
      
              /// 
              /// Limpiar los recursos que se estén utilizando.
              /// 
              /// true si los recursos administrados se deben eliminar; false en caso contrario, false.
              protected override void Dispose(bool disposing)
              {
                  if (disposing && (components != null))
                  {
                      components.Dispose();
                  }
                  base.Dispose(disposing);
              }
      
              #region Código generado por el Diseñador de Windows Forms
      
              /// 
              /// Método necesario para admitir el Diseñador. No se puede modificar
              /// el contenido del método con el editor de código.
              /// 
              private void InitializeComponent()
              {
                  this.btn_salir = new System.Windows.Forms.Button();
                  this.btn_listar = new System.Windows.Forms.Button();
                  this.btn_eliminar = new System.Windows.Forms.Button();
                  this.btn_agregar = new System.Windows.Forms.Button();
                  this.lb_agenda = new System.Windows.Forms.Label();
                  this.SuspendLayout();
                  // 
                  // btn_salir
                  // 
                  this.btn_salir.Location = new System.Drawing.Point(108, 138);
                  this.btn_salir.Name = "btn_salir";
                  this.btn_salir.Size = new System.Drawing.Size(75, 23);
                  this.btn_salir.TabIndex = 9;
                  this.btn_salir.Text = "Salir";
                  this.btn_salir.UseVisualStyleBackColor = true;
                  this.btn_salir.Click += new System.EventHandler(this.btn_salir_Click);
                  // 
                  // btn_listar
                  // 
                  this.btn_listar.Location = new System.Drawing.Point(108, 109);
                  this.btn_listar.Name = "btn_listar";
                  this.btn_listar.Size = new System.Drawing.Size(75, 23);
                  this.btn_listar.TabIndex = 8;
                  this.btn_listar.Text = "Listar";
                  this.btn_listar.UseVisualStyleBackColor = true;
                  this.btn_listar.Click += new System.EventHandler(this.btn_listar_Click);
                  // 
                  // btn_eliminar
                  // 
                  this.btn_eliminar.Location = new System.Drawing.Point(108, 80);
                  this.btn_eliminar.Name = "btn_eliminar";
                  this.btn_eliminar.Size = new System.Drawing.Size(75, 23);
                  this.btn_eliminar.TabIndex = 7;
                  this.btn_eliminar.Text = "Eliminar";
                  this.btn_eliminar.UseVisualStyleBackColor = true;
                  this.btn_eliminar.Click += new System.EventHandler(this.btn_eliminar_Click);
                  // 
                  // btn_agregar
                  // 
                  this.btn_agregar.Location = new System.Drawing.Point(108, 51);
                  this.btn_agregar.Name = "btn_agregar";
                  this.btn_agregar.Size = new System.Drawing.Size(75, 23);
                  this.btn_agregar.TabIndex = 6;
                  this.btn_agregar.Text = "Agregar";
                  this.btn_agregar.UseVisualStyleBackColor = true;
                  this.btn_agregar.Click += new System.EventHandler(this.btn_agregar_Click);
                  // 
                  // lb_agenda
                  // 
                  this.lb_agenda.AutoSize = true;
                  this.lb_agenda.Location = new System.Drawing.Point(79, 20);
                  this.lb_agenda.Name = "lb_agenda";
                  this.lb_agenda.Size = new System.Drawing.Size(135, 13);
                  this.lb_agenda.TabIndex = 5;
                  this.lb_agenda.Text = "AGENDA CON VENTANAS";
                  // 
                  // Form1
                  // 
                  this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
                  this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                  this.ClientSize = new System.Drawing.Size(292, 186);
                  this.Controls.Add(this.btn_salir);
                  this.Controls.Add(this.btn_listar);
                  this.Controls.Add(this.btn_eliminar);
                  this.Controls.Add(this.btn_agregar);
                  this.Controls.Add(this.lb_agenda);
                  this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
                  this.MaximizeBox = false;
                  this.Name = "Form1";
                  this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
                  this.Text = "Agenda con Ventanas";
                  this.ResumeLayout(false);
                  this.PerformLayout();
      
              }
      
              #endregion
      
              private System.Windows.Forms.Button btn_salir;
              private System.Windows.Forms.Button btn_listar;
              private System.Windows.Forms.Button btn_eliminar;
              private System.Windows.Forms.Button btn_agregar;
              private System.Windows.Forms.Label lb_agenda;
          }
      }
      
      using System;
      using System.Collections.Generic;
      using System.ComponentModel;
      using System.Data;
      using System.Drawing;
      using System.Text;
      using System.Windows.Forms;
      using System.Data.OleDb;
      
      namespace Agenda6
      {
          public partial class Form2 : Form
          {
              public Form2()
              {
                  InitializeComponent();
              }
      
              private void btn_aceptar_Click(object sender, EventArgs e)
              {
                  if (txt_nom.Text != "" && txt_tel.Text != "")
                  {
                      try
                      {
                          OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;");
                          con.Open();
                          string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');";
                          OleDbCommand com = new OleDbCommand(insert, con);
                          com.ExecuteNonQuery();
                          con.Close();
      
                          MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information);
      
                          btn_cancel_Click(sender, e);
                      }
                      catch
                      {
                          MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                          txt_nom.SelectAll();
                          txt_nom.Focus();
                      }
                  }
                  else
                  {
                      MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error",
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
                      txt_nom.SelectAll();
                      txt_nom.Focus();
                  }
              }
      
              private void btn_cancel_Click(object sender, EventArgs e)
              {
                  this.Close();
              }
          }
      }
      
      namespace Agenda6
      {
          partial class Form3
          {
              /// 
              /// Variable del diseñador requerida.
              /// 
              private System.ComponentModel.IContainer components = null;
      
              /// 
              /// Limpiar los recursos que se estén utilizando.
              /// 
              /// true si los recursos administrados se deben eliminar; false en caso contrario, false.
              protected override void Dispose(bool disposing)
              {
                  if (disposing && (components != null))
                  {
                      components.Dispose();
                  }
                  base.Dispose(disposing);
              }
      
              #region Código generado por el Diseñador de Windows Forms
      
              /// 
              /// Método necesario para admitir el Diseñador. No se puede modificar
              /// el contenido del método con el editor de código.
              /// 
              private void InitializeComponent()
              {
                  this.btn_cancel = new System.Windows.Forms.Button();
                  this.btn_elim = new System.Windows.Forms.Button();
                  this.txt_nom = new System.Windows.Forms.TextBox();
                  this.lb_nom = new System.Windows.Forms.Label();
                  this.lb_agenda = new System.Windows.Forms.Label();
                  this.ltb_cont = new System.Windows.Forms.ListBox();
                  this.SuspendLayout();
                  // 
                  // btn_cancel
                  // 
                  this.btn_cancel.Location = new System.Drawing.Point(161, 348);
                  this.btn_cancel.Name = "btn_cancel";
                  this.btn_cancel.Size = new System.Drawing.Size(75, 23);
                  this.btn_cancel.TabIndex = 18;
                  this.btn_cancel.Text = "Cancelar";
                  this.btn_cancel.UseVisualStyleBackColor = true;
                  this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click);
                  // 
                  // btn_elim
                  // 
                  this.btn_elim.Location = new System.Drawing.Point(56, 348);
                  this.btn_elim.Name = "btn_elim";
                  this.btn_elim.Size = new System.Drawing.Size(75, 23);
                  this.btn_elim.TabIndex = 17;
                  this.btn_elim.Text = "Eliminar";
                  this.btn_elim.UseVisualStyleBackColor = true;
                  this.btn_elim.Click += new System.EventHandler(this.btn_elim_Click);
                  // 
                  // txt_nom
                  // 
                  this.txt_nom.Location = new System.Drawing.Point(91, 311);
                  this.txt_nom.Name = "txt_nom";
                  this.txt_nom.ReadOnly = true;
                  this.txt_nom.Size = new System.Drawing.Size(181, 22);
                  this.txt_nom.TabIndex = 16;
                  // 
                  // lb_nom
                  // 
                  this.lb_nom.AutoSize = true;
                  this.lb_nom.Location = new System.Drawing.Point(21, 314);
                  this.lb_nom.Name = "lb_nom";
                  this.lb_nom.Size = new System.Drawing.Size(48, 13);
                  this.lb_nom.TabIndex = 15;
                  this.lb_nom.Text = "Nombre";
                  // 
                  // lb_agenda
                  // 
                  this.lb_agenda.AutoSize = true;
                  this.lb_agenda.Location = new System.Drawing.Point(88, 16);
                  this.lb_agenda.Name = "lb_agenda";
                  this.lb_agenda.Size = new System.Drawing.Size(116, 13);
                  this.lb_agenda.TabIndex = 14;
                  this.lb_agenda.Text = "ELIMINAR CONTACTO";
                  // 
                  // ltb_cont
                  // 
                  this.ltb_cont.FormattingEnabled = true;
                  this.ltb_cont.Location = new System.Drawing.Point(12, 41);
                  this.ltb_cont.Name = "ltb_cont";
                  this.ltb_cont.Size = new System.Drawing.Size(268, 264);
                  this.ltb_cont.TabIndex = 13;
                  this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SelectedIndexChanged);
                  // 
                  // Form3
                  // 
                  this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
                  this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                  this.ClientSize = new System.Drawing.Size(292, 386);
                  this.Controls.Add(this.btn_cancel);
                  this.Controls.Add(this.btn_elim);
                  this.Controls.Add(this.txt_nom);
                  this.Controls.Add(this.lb_nom);
                  this.Controls.Add(this.lb_agenda);
                  this.Controls.Add(this.ltb_cont);
                  this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
                  this.MaximizeBox = false;
                  this.Name = "Form3";
                  this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
                  this.Text = "Eliminar Contacto";
                  this.Load += new System.EventHandler(this.Form3_Load);
                  this.ResumeLayout(false);
                  this.PerformLayout();
      
              }
      
              #endregion
      
              private System.Windows.Forms.Button btn_cancel;
              private System.Windows.Forms.Button btn_elim;
              private System.Windows.Forms.TextBox txt_nom;
              private System.Windows.Forms.Label lb_nom;
              private System.Windows.Forms.Label lb_agenda;
              private System.Windows.Forms.ListBox ltb_cont;
          }
      }
      

    Te cuento que mucha de la información que leerás en esta page, la aprendi con el auxilio de la siguiente bibliografia:

    
      	LIBRO                   	AUTOR                    EDITORIAL       AÑO
    	Programación C++      		- Luis Joyanes              - Mc Graw Hill    	1999
    	C++  Cómo programar   		- Deitel y Deitel           - Prentice Hall   	1999
    	Visual C++ 6          		- Kate gregory              - Prentice Hall   	2000
    	Visual C++ 6          		- Cris H. Pappas            - Mc Graw - Hill  	2000
    	Visual C++6 Manual    		- Beck Zaratian             - Mc Graw Hill    	1999
    	Visual C++6           		- Holzner                   - Mc Graw Hill    	1999
    	Manual C / C++        		- Wiliam H. Murray          - Mc Graw Hill    	1997
    	Visual C++6           		- María Cascon Sánchez      - Prentice Hall   	1999
    	Visual C++            		- Ori y Nathan Gurenwich    - SAMS Publishing 	1998
    	C++ Builder 5         		- Fransisco Charte          - Anaya           	2000
    	Visual C#                 	- Erika Alarcon             - Megabyte        	2004
    	Visual C#.NET 2008        	- Cristina Sanchez          - Edit MACRO      	2008
    	Entornos y Metodologias 
    	de Programación          	- Alonso Amo                - Paraninfo       	2000
    	Lenguajes de Programación 	- Ravi Sethi                - Addison-Wesley  	2000
    	Lenguajes de Programación 	- Mauricio Strauchler
    	Orientación a Objetos     	- Carlos Fontela            - Nueva Librería  	2008
    

    Lenguaje de Programación
    HTML
    C, C++, C#
    Basic
    Delphi
    Fox
    Builder
    Haskell
    Java
    A S P
    PHP
    Small
    UML
    Lisp
    Prolog
    C S S

    BONUS: En este ámbito paradigmático ademas te ofrezco:

    PARADIGMAS IMPRESOS:
    Lenguajes Gramáticas
    Autómatas Series
    Laplace Ecuación
    Operador Compilador

    PARADIGMA
    Cultivo una rosa blanca
    ..en julio, como en enero
    para el amigo sincero
    que me da su mano franca..!!

    Y para el cruel que me arranca
    el corazón con que vivo,
    cardo ni ortiga cultivo;
    ..cultivo una rosa blanca..!
    José Martí

    Te espero en: wilucha@gmail.com

    Esta page está en: www.wilocarpio.com

    18/10/2010

    Volver al principio