elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  Guardar un dato y recuperarlo de un archivo
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Guardar un dato y recuperarlo de un archivo  (Leído 1,916 veces)
Meta


Desconectado Desconectado

Mensajes: 3.438



Ver Perfil WWW
Guardar un dato y recuperarlo de un archivo
« en: 4 Julio 2020, 00:39 am »

Buenas:

En este ejemplo de código gracias al equipo de este foro. Los datos de selección de un radioButton en consola C#, se guarda en la RAM o en una variable.

Quiero saber el archivo recomendado para guardar dicho dato y luego recuperarlo nada más arrancar el programa. Por supuesto, si selecciono con Enter la "> (*) Opción E", se guarda automáticamente este dato en un archivo.

¿Qué tipo de archivo aconsejable para guardar datos y recuperarlo?

Me comenta que en binario, porque es lo que trabaja las computadoras, más rápido y eficientes para ella. Para nosotros pensé en un archivo de texto txt. Para otros prefieren el XML, otros el editor de registro en el cual ahora dicen mejor no manejarlo para no saturarlo.

Alguien sabrá.

El código es este de abajo.
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace radioButton_consola_03_cs
  8. {
  9.    class Program
  10.    {
  11.        #region Variables.
  12.        private static readonly string[] TEXTO = new string[]
  13.        {
  14.            "( ) Opción A        ",
  15.            "( ) Opción B        ",
  16.            "( ) Opción C        ",
  17.            "( ) Opción D        ",
  18.            "( ) Opción E        ",
  19.            "( ) Opción F        ",
  20.            "( ) Opción G        ",
  21.            "    SALIR"
  22.        };
  23.  
  24.        private static int itemSeñalado;
  25.  
  26.        private static int itemSeleccionado;
  27.        #endregion
  28.  
  29.        static void Main(string[] args)
  30.        {
  31.            // Título de la ventana.
  32.            Console.Title = "RadioButton";
  33.  
  34.            // Tamaño de la ventana.
  35.            Console.SetWindowSize(20, 5);
  36.  
  37.            // Fondo azul.
  38.            Console.BackgroundColor = ConsoleColor.Blue;
  39.  
  40.            // Letras blanco.
  41.            Console.ForegroundColor = ConsoleColor.White;
  42.  
  43.            // Oculto el cursor.
  44.            Console.CursorVisible = false;
  45.  
  46.            // Almacena la tecla pulsada en la variable.
  47.            ConsoleKey teclaInicial;
  48.  
  49.            do
  50.            {
  51.                // Limpiar pantalla.
  52.                Console.Clear();
  53.  
  54.                // Posición del cursor del título del MENÚ PRINCIPAL.
  55.                Console.SetCursorPosition(0, 0);
  56.  
  57.                // Título.
  58.                Console.Write("   MENÚ PRINCIPAL   ");
  59.  
  60.                // Pocisión de la hora.
  61.                Console.SetCursorPosition(4, 2);
  62.  
  63.                // Formato numérico dd/MM/yyyy.
  64.                Console.Write(DateTime.Now.ToString("ddd dd MMM"));
  65.  
  66.                // Almacena en la variable una tecla pulsada.
  67.                teclaInicial = Console.ReadKey(true).Key;
  68.  
  69.                // ¿Haz pulsado la tecla Enter?
  70.                if (teclaInicial == ConsoleKey.Enter)
  71.                {
  72.                    // Sí. Se ejecuta esta función.
  73.                    MenuPrincipal();
  74.                }
  75.            } while (teclaInicial != ConsoleKey.Escape);
  76.        }
  77.  
  78.        #region Menú Principal.
  79.        private static void MenuPrincipal()
  80.        {
  81.            bool salir = false;
  82.  
  83.            // En itemSelecionado:
  84.            // -1 = Sin seleccionar con * ninguna opción.
  85.            // 0 = Seleccionar con * la Opción A.
  86.            // 1 = Seleccionar con * la Opción B.
  87.            // 2 = Seleccionar con * la opción C.
  88.            // 3 = Seleccionar con * la opción D.
  89.            // 4 = Seleccionar con * la opción E.
  90.            // 5 = Seleccionar con * la opción F.
  91.            // 6 = Seleccionar con * la opción G.
  92.  
  93.            // Capturar tecla para luego validar.
  94.            ConsoleKey tecla;
  95.  
  96.            // Cada vez que se vuelva al menú, está señalizado con el *.
  97.            itemSeñalado = 0;
  98.            int pagina;
  99.            do
  100.            {
  101.                //******************************************************************
  102.                // Dibujo el menú principal.
  103.  
  104.                // Limpiar pantalla.
  105.                Console.Clear();
  106.  
  107.                pagina = 0;
  108.                if (itemSeñalado >= 4)
  109.                {
  110.                    pagina = 4;
  111.                }
  112.  
  113.                // Recorre la lista de las opciones.
  114.                for (int k = 0; k < 4; k++)
  115.                {
  116.                    Console.SetCursorPosition(0, k);
  117.                    Console.Write(itemSeñalado == k + pagina ? "> " : "  ");
  118.                    Console.Write(TEXTO[k + pagina]);
  119.                    Console.SetCursorPosition(3, k);
  120.                    Console.Write(itemSeleccionado == k + pagina ? "*" : " ");
  121.                }
  122.  
  123.                // Fin de pintar el menú principal.
  124.                //******************************************************************
  125.  
  126.                // Leer tecla ingresada por el usuario.
  127.                tecla = Console.ReadKey(true).Key;
  128.  
  129.                switch (tecla)
  130.                {
  131.                    // Al pulsar Enter, marcas un radioButton con *.
  132.                    case ConsoleKey.Enter:
  133.                        if (itemSeñalado < 7)
  134.                        {
  135.                            itemSeleccionado = itemSeñalado;
  136.                        }
  137.                        salir = (itemSeñalado == TEXTO.Length - 1);
  138.                        break;
  139.  
  140.                    // Pulsar flecha abajo del teclado.
  141.                    case ConsoleKey.DownArrow:
  142.                        if (++itemSeñalado >= TEXTO.Length)
  143.                        {
  144.                            itemSeñalado = 0;
  145.                            Console.Clear();
  146.                        }
  147.                        else if (itemSeñalado == 4)
  148.                        {
  149.                            Console.Clear();
  150.                        }
  151.                        break;
  152.  
  153.                    // Pulsar flecha arriba del teclado.
  154.                    case ConsoleKey.UpArrow:
  155.                        if (--itemSeñalado < 0)
  156.                        {
  157.                            itemSeñalado = TEXTO.Length - 1;
  158.                            Console.Clear();
  159.                        }
  160.                        else if (itemSeñalado == 3)
  161.                        {
  162.                            Console.Clear();
  163.                        }
  164.                        break;
  165.                }
  166.                // Uso la tecla escape como salida.
  167.            } while (!salir);
  168.        }
  169.        #endregion
  170.    }
  171. }

Por supuesto. Se guarda los datos desde que se pulse Enter. Tengo entendido que el archivo a guardar si no hay ninguno o no lo detecta por ejemplo a este nombre, por ejemplo Archivo.txt. Lo crea. Si está creado, solo lo lee y guarda datos.

Desde que pulse Enter en > Salir se guarda los datos. Si pulsas la X con el ratón (mouse) de la ventana del programa, también se asegura que se cierra el archivo y tenga todo guardado por si acaso, no quiero tener error de archivos.

Saludos.


En línea

FFernandez

Desconectado Desconectado

Mensajes: 128



Ver Perfil
Re: Guardar un dato y recuperarlo de un archivo
« Respuesta #1 en: 27 Julio 2020, 23:25 pm »

Creo que es indiferente el tipo de archivo, sino el tipo de dato guardado.


En línea

Meta


Desconectado Desconectado

Mensajes: 3.438



Ver Perfil WWW
Re: Guardar un dato y recuperarlo de un archivo
« Respuesta #2 en: 28 Julio 2020, 02:21 am »

Hecho, ya crea Archivo.txt, que puede ser cualquiera.

Si me pongo como dices, el tipo de dato, se puede hacer hasta en binario.

Código
  1. using System;
  2. using System.IO;
  3.  
  4. namespace radioButton_consola_03_cs
  5. {
  6.    class Program
  7.    {
  8.        #region Variables.
  9.        private static readonly string[] TEXTO = new string[]
  10.        {
  11.            "( ) Opción A        ",
  12.            "( ) Opción B        ",
  13.            "( ) Opción C        ",
  14.            "( ) Opción D        ",
  15.            "( ) Opción E        ",
  16.            "( ) Opción F        ",
  17.            "( ) Opción G        ",
  18.            "    SALIR"
  19.        };
  20.  
  21.        private static int itemSeñalado;
  22.  
  23.        private static int itemSeleccionado;
  24.        #endregion
  25.  
  26.        static void Main(string[] args)
  27.        {
  28.            // Título de la ventana.
  29.            Console.Title = "RadioButton";
  30.  
  31.            // Tamaño de la ventana.
  32.            Console.SetWindowSize(20, 5);
  33.  
  34.            // Fondo azul.
  35.            Console.BackgroundColor = ConsoleColor.Blue;
  36.  
  37.            // Letras blanco.
  38.            Console.ForegroundColor = ConsoleColor.White;
  39.  
  40.            // Oculto el cursor.
  41.            Console.CursorVisible = false;
  42.  
  43.            // Almacena la tecla pulsada en la variable.
  44.            ConsoleKey teclaInicial;
  45.  
  46.            do
  47.            {
  48.                // Limpiar pantalla.
  49.                Console.Clear();
  50.  
  51.                // Posición del cursor del título del MENÚ PRINCIPAL.
  52.                Console.SetCursorPosition(0, 0);
  53.  
  54.                // Título.
  55.                Console.Write("   MENÚ PRINCIPAL   ");
  56.  
  57.                // Pocisión de la hora.
  58.                Console.SetCursorPosition(4, 2);
  59.  
  60.                // Formato numérico dd/MM/yyyy.
  61.                Console.Write(DateTime.Now.ToString("ddd dd MMM"));
  62.  
  63.                // Almacena en la variable una tecla pulsada.
  64.                teclaInicial = Console.ReadKey(true).Key;
  65.  
  66.                // ¿Haz pulsado la tecla Enter?
  67.                if (teclaInicial == ConsoleKey.Enter)
  68.                {
  69.                    // Sí. Se ejecuta esta función.
  70.                    MenuPrincipal();
  71.                }
  72.            } while (teclaInicial != ConsoleKey.Escape);
  73.        }
  74.  
  75.        #region Menú Principal.
  76.        private static void MenuPrincipal()
  77.        {
  78.            bool salir = false;
  79.  
  80.            // En itemSelecionado:
  81.            // -1 = Sin seleccionar con * ninguna opción.
  82.            // 0 = Seleccionar con * la Opción A.
  83.            // 1 = Seleccionar con * la Opción B.
  84.            // 2 = Seleccionar con * la opción C.
  85.            // 3 = Seleccionar con * la opción D.
  86.            // 4 = Seleccionar con * la opción E.
  87.            // 5 = Seleccionar con * la opción F.
  88.            // 6 = Seleccionar con * la opción G.
  89.  
  90.            // Capturar tecla para luego validar.
  91.            ConsoleKey tecla;
  92.  
  93.            // Cada vez que se vuelva al menú, está señalizado con el *.
  94.            itemSeñalado = 0;
  95.            int pagina;
  96.  
  97.            // Crear archivo y guarda el * seleccioinado en él.
  98.            if (File.Exists("Archivo.txt"))
  99.            {
  100.                string data = File.ReadAllText("Archivo.txt");
  101.                itemSeleccionado = Convert.ToInt32(data);
  102.                //itemSeñalado = itemSeleccionado;
  103.            }
  104.  
  105.            do
  106.            {
  107.                //******************************************************************
  108.                // Dibujo el menú principal.
  109.  
  110.                // Limpiar pantalla.
  111.                Console.Clear();
  112.  
  113.                pagina = 0;
  114.                if (itemSeñalado >= 4)
  115.                {
  116.                    pagina = 4;
  117.                }
  118.  
  119.                // Recorre la lista de las opciones.
  120.                for (int k = 0; k < 4; k++)
  121.                {
  122.                    Console.SetCursorPosition(0, k);
  123.                    Console.Write(itemSeñalado == k + pagina ? "> " : "  ");
  124.                    Console.Write(TEXTO[k + pagina]);
  125.                    Console.SetCursorPosition(3, k);
  126.                    Console.Write(itemSeleccionado == k + pagina ? "*" : " ");
  127.                }
  128.  
  129.                // Fin de pintar el menú principal.
  130.                //******************************************************************
  131.  
  132.                // Leer tecla ingresada por el usuario.
  133.                tecla = Console.ReadKey(true).Key;
  134.  
  135.                switch (tecla)
  136.                {
  137.                    // Al pulsar Enter, marcas un radioButton con *.
  138.                    case ConsoleKey.Enter:
  139.                        if (itemSeñalado < 7)
  140.                        {
  141.                            itemSeleccionado = itemSeñalado;
  142.                        }
  143.                        salir = (itemSeñalado == TEXTO.Length - 1);
  144.  
  145.                        // Si sales del programa, escribes en el archivo.
  146.                        //if (salir == true)
  147.  
  148.                        // Si pulsa Enter, escribes en el archivo.
  149.                        if (tecla == ConsoleKey.Enter)
  150.                        {
  151.                            File.WriteAllText("Archivo.txt", itemSeleccionado.ToString());
  152.                        }
  153.  
  154.                        break;
  155.  
  156.                    // Pulsar flecha abajo del teclado.
  157.                    case ConsoleKey.DownArrow:
  158.                        if (++itemSeñalado >= TEXTO.Length)
  159.                        {
  160.                            itemSeñalado = 0;
  161.                            Console.Clear();
  162.                        }
  163.                        else if (itemSeñalado == 4)
  164.                        {
  165.                            Console.Clear();
  166.                        }
  167.                        break;
  168.  
  169.                    // Pulsar flecha arriba del teclado.
  170.                    case ConsoleKey.UpArrow:
  171.                        if (--itemSeñalado < 0)
  172.                        {
  173.                            itemSeñalado = TEXTO.Length - 1;
  174.                            Console.Clear();
  175.                        }
  176.                        else if (itemSeñalado == 3)
  177.                        {
  178.                            Console.Clear();
  179.                        }
  180.                        break;
  181.                }
  182.                // Uso la tecla escape como salida.
  183.            } while (!salir);
  184.        }
  185.        #endregion
  186.    }
  187. }
  188.  

Saludos.
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Como Guardar ID y Dato en un Combo
Programación Visual Basic
TheGhost(Z) 5 3,343 Último mensaje 9 Marzo 2008, 17:08 pm
por ((( SPAWN )))
Cual es el mejor campo o tipo de dato para guardar url's en mysql?
Bases de Datos
kinos 5 12,382 Último mensaje 16 Agosto 2010, 20:09 pm
por kinos
[?] leer binario y guardar en struct dato AYUDA « 1 2 »
Programación C/C++
nolosabe 17 9,121 Último mensaje 29 Octubre 2011, 15:44 pm
por nolosabe
ayuda a guardar dato en php
PHP
General Dmitry Vergadoski 2 1,804 Último mensaje 24 Diciembre 2013, 22:43 pm
por #Aitor
GUARDAR DATO DATAGRIDVIEW C#
.NET (C#, VB.NET, ASP)
PETTETE 0 2,748 Último mensaje 12 Enero 2018, 13:52 pm
por PETTETE
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines