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


 


Tema destacado: Sigue las noticias más importantes de seguridad informática en el ttwitter! de elhacker.NET


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  Introducir y seleccionar lengua en modo consola
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Introducir y seleccionar lengua en modo consola  (Leído 563 veces)
Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Introducir y seleccionar lengua en modo consola
« en: 25 Febrero 2019, 05:51 »

Hola:

Teniendo un menú hecho por defecto en español en este caso. (Cuando todo esté acabado tiene que estar en Inglés por defecto).

Quiero crear menús que sea capaz de elegir el idioma, en al cual hoy en día no hay problema porque está este traductor para escapar.

Mi idea para tener un orden de cada idioma a introducir, por ejemplo, español, inglés, alemán, francés, italiano y portugués.

En este ejemplo hay 6 lenguas. No se si la mejor opción es crear una carpeta de idiomas y ahí meto cada lengua en el cual es llamado.



Código de ejemplo para.
Código
  1. using System;
  2.  
  3. namespace Idiomas_consola_01_cs
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            // Título de la ventana.
  10.            Console.Title = "Menú - C# 2017";
  11.  
  12.            // Tamaño ventana consola.
  13.            // X anchura.
  14.            Console.WindowWidth = 80;
  15.  
  16.            // Y altura.
  17.            Console.WindowHeight = 40;
  18.  
  19.            // Oculto el cursor.
  20.            Console.CursorVisible = false;
  21.  
  22.            // Almacena la tecla pulsada en la variable.
  23.            ConsoleKey teclaInicial;
  24.  
  25.            // Fondo verde.
  26.            Console.BackgroundColor = ConsoleColor.Green;
  27.  
  28.            // Letras negras.
  29.            Console.ForegroundColor = ConsoleColor.Black;
  30.  
  31.            do
  32.            {
  33.                // Limpiar pantalla.
  34.                Console.Clear();
  35.  
  36.                // Formato numérico dd/MM/yyyy.
  37.                Console.WriteLine(DateTime.Now.ToString("ddd dd MMM"));
  38.  
  39.                // Almacena en la variable una tecla pulsada.
  40.                teclaInicial = Console.ReadKey(true).Key;
  41.  
  42.                // ¿Haz pulsado la tecla Enter?
  43.                if (teclaInicial == ConsoleKey.Enter)
  44.                {
  45.                    // Sí. Se ejecuta esta función.
  46.                    menuPrincipal();
  47.                }
  48.            } while (teclaInicial != ConsoleKey.Escape);
  49.        }
  50.  
  51.        #region Menú Principal.
  52.        public static void menuPrincipal()
  53.        {
  54.  
  55.            // Contador de teclas y navegador.
  56.            int opcion = 0;
  57.            bool salir = false;
  58.            // Capturar tecla para luego validar.
  59.            ConsoleKey tecla;
  60.  
  61.            do
  62.            {
  63.                // Limpiar pantalla.
  64.                Console.Clear();
  65.  
  66.                switch (opcion)
  67.                {
  68.                    case 0:
  69.                        Console.SetCursorPosition(0, 0);
  70.                        Console.Write("Language");
  71.                        break;
  72.                    case 1:
  73.                        Console.SetCursorPosition(0, 0);
  74.                        Console.WriteLine("Opción 1.");
  75.                        break;
  76.                    case 2:
  77.                        Console.SetCursorPosition(0, 0);
  78.                        Console.WriteLine("Opción 2.");
  79.                        break;
  80.                    case 3:
  81.                        Console.SetCursorPosition(0, 0);
  82.                        Console.WriteLine("Opción 3.");
  83.                        break;
  84.                    case 4:
  85.                        Console.SetCursorPosition(0, 0);
  86.                        Console.WriteLine("Opción 4.");
  87.                        break;
  88.                    case 5:
  89.                        Console.SetCursorPosition(0, 0);
  90.                        Console.WriteLine("Opción 5.");
  91.                        break;
  92.                    case 6:
  93.                        Console.SetCursorPosition(0, 0);
  94.                        Console.WriteLine("Opción 6.");
  95.                        break;
  96.                    case 7:
  97.                        Console.SetCursorPosition(0, 0);
  98.                        Console.WriteLine("Salir menú");
  99.                        break;
  100.                    default:
  101.                        break;
  102.                }
  103.  
  104.                // Fin de pintar el menú.
  105.                //******************************************************************
  106.  
  107.                // Leer tecla ingresada por el usuario.
  108.                tecla = Console.ReadKey(true).Key;
  109.  
  110.                // Validar el tipo de tecla.
  111.                if (tecla == ConsoleKey.Enter)
  112.                {
  113.                    switch (opcion)
  114.                    {
  115.                        case 1:
  116.                            // Instrucciones.
  117.                            break;
  118.                        case 2:
  119.                            // Instrucciones.
  120.                            break;
  121.                        case 3:
  122.                            // Instrucciones.
  123.                            break;
  124.                        case 4:
  125.                            // Instrucciones.
  126.                            break;
  127.                        case 6:
  128.                            // Instrucciones.
  129.                            break;
  130.                        case 7:
  131.                            salir = true;
  132.                            break;
  133.                        default:
  134.                            break;
  135.                    }
  136.                }
  137.  
  138.                if (tecla == ConsoleKey.DownArrow)
  139.                {
  140.                    opcion += 1; // Equivalente ++.
  141.                }
  142.  
  143.                if (tecla == ConsoleKey.UpArrow)
  144.                {
  145.                    opcion -= 1; // --.
  146.                }
  147.  
  148.                // Si está en la última opción, salta a la primera.
  149.                if (opcion > 7)
  150.                {
  151.                    opcion = 0;
  152.                }
  153.  
  154.                // Si está en la primera posición, salta a la última.
  155.                if (opcion < 0)
  156.                {
  157.                    opcion = 7;
  158.                }
  159.  
  160.                // Uso la tecla escape como salida.
  161.            } while (salir == false);
  162.        }
  163.        #endregion
  164.    }
  165. }

En el menú Languaje, si pulsas Enter, tiene que verse en Inglés, todos los idiomas que vayamos incorporando. El usuario elige el idioma y se queda seleccionado.

¿Alguna idea?

Saludos.


En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
NEBIRE


Desconectado Desconectado

Mensajes: 2.337


Ver Perfil
Re: Introducir y seleccionar lengua en modo consola
« Respuesta #1 en: 25 Febrero 2019, 14:45 »

La manera más sencilla y rápida, sobretodos para cosas muy escuetas es usar un array.
Y la forma más sencilla al cargar el programa es leerlo de un ficherito de texto:
Debe quedar claro que podrías separar cada idioma de otro por una etiqueta del tipo:
<idioma>

Así lees el fichero de una tacada y haces un split por la cadena <idioma>, entonces todos los textos de un idioma quedan alojados en el array como una cadena...
Si el inglés ha de ser el idioma por defecto, sugiero que sea el primero de la lista, así se alojaría en el índice 0 del array, este podría ser la forma de componer el menú para inglés y español:
Citar
<idioma> English
<menu>
File
....Open ...
....Save
....Save As ...
....Close
....-
....Recent Files:
........1
........2
........3
........4
........5
....Exit
<menu>
Edit
....Copy
....Paste
....Delete
....-
....Select All
....Invert Select
<menu>
Options
....Display ...
....Language
........0 English
........1 Spanish
<menu>
Help
....Manual ...
....About ...
<idioma> Español
<menu>
Fichero
....Abrir ...
....Guardar
....Salvar como ...
....Cerrar
....-
....Ficheros Recientes:
........1
........2
........3
........4
........5
....Salir
<menu>
Editar
....Copiar
....Pegar
....Borrar
....-
....Seleccionar todo
....Invertir Seleccion
<menu>
Optiones
....Display ...
....Idioma
........0 Inglés
........1 Español
<menu>
Ayuda
....Manual ...
....Creditos ...
<idioma> Deutsche

etc...

Como se puede apreciar, el texto se puede guardar fácilmente en un único fichero de texto, (no son menús infinitos), tampoco pasa nada si se guardan en un fichero distinto cada uno... observa como en las opcones al elegir idioma cada uno se asocia a un número, si al final fueran más de diez, será preferible prescindir de números y usar letras A,B,C,D, si fueran más de 26 idiomas, prescindir también de las letras. cada ítem de un menú lleva implícito un índice como ítem de una colección, siempre puede usarse dicho valor para elegir el fichero adecuado, aunque un único fichero conteniéndolos todos puede bastar, se carn todos al cargar el programa y se mantienen en memoria todo el tiempo hasta que el programa se cierra. Así evitas también toda la operatoria de abrir distintos ficheros de idioma cargarlos y tal, con posibilidades de fallos... si los menús fuerna a ser gigantescos (es decir no es un único menú de una ventana si no de todo un programa con sus diferentes ventanas, entonces sí es cuando conviene que cada uno esté en su propio fichero, en tales casos además suelen usarse una clase que aplica los cambios sobre un fichero de idioma. También suele usarse dlls por cada idioma que implementan una interfaz.

...pero vamos para tu caso y experimentar, es suficiente con un ficherito en texto que aloge todos.
Adicionalmente a la función de carga del fichero, debe haber otra función que desglose la cadena que recoge el menú completo de un idioma, y lo deposite en cada ítem del menú. Por lo tanto debe haber una correspondencia, entre ítems del menú y cada ítem del texto en el fichero.
Así a la entrada de la función haces nuevamente un split, que corta por cada <menu>, formando así un array, donde cada indice aloja un ítem del menú principal....
Así si se eligió español:
Código:
array string Menus = split(ReadAllFile, "<idioma>")
funcion DesglosarMenuIdioma(string Menu ) = Menus(1) // toma el menú español
    array string MenuTxt = Split(Menu, "<menu>")

...el menú princiapl 1, será pués: 'Editar', y de momento su contenido será éste:
Citar
MenuTxt(1) = "Editar
....Copiar
....Pegar
....Borrar
....-
....Seleccionar todo
....Invertir Seleccion"

Nuevamente un split, ahora por cada línea, revela cada subítem de dicho menú...
La jerarquía se compone de "....", es decir con cada aparición de esos 4 puntitos, implica que son hijos del ítem padre. En general una función recursiva resuelve el caso, inclsuo sin los "<menu>", y acabas teniendo un árbol que luego recorres desde la raíz para asignarlo al menú. Nota que si la asignación la vas haciendo sobre la marcha (sin necesidad de guardar nada), no es preciso recrear siquiera un árbol, tan solo (mediante la recursión y splits), vas recorriendo la estructura subyacente del mismo modo que si fuera un árbol pero sin necesidad real de que debas tener, crear ni mantener un árbol...

p.d.: Nota que cosas como 'ficheros recientes' son independientes del idioma, ese contenido deberá rellenarse desde otra parte, seguramente desde algún ficherito que guarde la configuración del programa, eso se hace también al cargar el programa tras meter el idioma elegido.

El menú del idioma podría ubicar también un ítem para reflejar el elegido, tal que así:
Citar
....Idioma
........Español
........-
........0 Inglés
........1 Español
Esto es, aparece el seleccionado, luego un separador y detrás la lista elegible.
Finalmente, cuando un usuario elija un idioma, asgúrate que si es el mismo que el ya cargado, debe ignorarse toda acción posterior. El idioma por defecto es el 0, y si el usuario decide "guardar opciones al salir ...", en el fichero de configuración se guardaría 1 (i por ejemplo el actual cargado es el español), y tras una nueva carga tomando el idioma elegido por el usuario, encontrará el 1, y cargará así el español.


« Última modificación: 25 Febrero 2019, 14:53 por NEBIRE » En línea

Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Introducir y seleccionar lengua en modo consola
« Respuesta #2 en: 25 Febrero 2019, 23:20 »

Buen aporte, a leer, interpretar y actuar.

Muchas gracias por la ayuda. ;)
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Eleкtro
Ex-Staff
*
Desconectado Desconectado

Mensajes: 9.709



Ver Perfil
Re: Introducir y seleccionar lengua en modo consola
« Respuesta #3 en: 26 Febrero 2019, 01:26 »

Visual Studio ya provee herramientas de localización de idioma mediante los archivos de recurso (resources.resx) embedidos en la aplicación, por lo tanto no hay necesidad de reinventar la rueda ni tampoco usar metodologías rudimentarias como pudiera ser un Array de cadenas de texto, aunque, y ya puestos, antes que usar un string con formato Xml y andarse con substrings y splits para obtener un Array de strings, lo cual resulta tedioso o engorroso de hacer, sería mucho más simple y conveniente declarar una variable de tipo XElement y ahí especificar el contenido del documento Xml, y entonces tratarlo como tal mediante las funcionalidades built-in de .NET Framework para el tratamiento de documentos Xml, y con ello aportar mayor estabilidad y simplificación al análisis de datos (o parsing) si lo comparásemos con la manipulación de un string con formato Xml al que hacerle un String.Split().
Dicho de otra forma, la propuesta sería más o menos lo mismo que te ha explicado el compañero @NEBIRE, pero enfocado al uso del tipo XElement en lugar de String, y sin la carga de archivos locales (eso ya sería como prefieras hacerlo).

Un ejemplo muy, muy básico para declarar una cadena de texto Xml con cadenas de texto para distintos idiomas, obtener el idioma por defecto del thread en ejecución (esto se haría al inicío de tu aplicación), establecer un nuevo idioma, y escribir las cadenas de texto del idioma actual establecido:

Código
  1. using System;
  2. using System.Globalization;
  3. using System.Threading;
  4. using System.Xml.Linq;
  5.  
  6. namespace ConsoleApp1 {
  7.  
  8.    class Program {
  9.  
  10.        private static readonly XElement languages =
  11.            XElement.Parse(@"<languages>
  12.                                 <en-US>
  13.                                     <Options>
  14.                                         <Option1>Option 1</Option1>
  15.                                         <Option2>Option 2</Option2>
  16.                                         <Option3>Option 3</Option3>
  17.                                     </Options>
  18.                                     <ExitMessage>Press any key to exit...</ExitMessage>
  19.                                 </en-US>
  20.                                 <es-ES>
  21.                                     <Options>
  22.                                         <Option1>Opción 1</Option1>
  23.                                         <Option2>Opción 2</Option2>
  24.                                         <Option3>Opción 3</Option3>
  25.                                     </Options>
  26.                                     <ExitMessage>Pulse cualquier tecla para salir...</ExitMessage>
  27.                                 </es-ES>
  28.                             </languages>");
  29.  
  30.        static void Main(string[] args) {      
  31.  
  32.            // Obtener configuración de idioma actual.
  33.            CultureInfo currentCi = Thread.CurrentThread.CurrentUICulture;
  34.            XElement currenLangXml = languages.Element(currentCi.Name);
  35.            // Si no se encuentra un elemento Xml para el idioma actual, establecer idioma favorito por defecto (Inglés).
  36.            if (currenLangXml == null) {
  37.                currenLangXml = languages.Element("en-US");
  38.            }
  39.  
  40.            // --------------------------------------------------------------
  41.  
  42.            // Establecer nueva configuración de idioma.
  43.            CultureInfo newCi = new CultureInfo("es-ES");
  44.            XElement newLangXml = languages.Element(newCi.Name);
  45.  
  46.            // --------------------------------------------------------------
  47.  
  48.            // Obtener los campos de opciones del idioma actual establecido.
  49.            string option1 = newLangXml.Element("Options").Element("Option1").Value;
  50.            string option2 = newLangXml.Element("Options").Element("Option2").Value;
  51.            string option3 = newLangXml.Element("Options").Element("Option3").Value;
  52.            string exitMsg = newLangXml.Element("ExitMessage").Value;
  53.  
  54.            // --------------------------------------------------------------
  55.  
  56.            // Escribir las opciones en el idioma actual establecido.
  57.            Console.WriteLine(option1);
  58.            Console.WriteLine(option2);
  59.            Console.WriteLine(option3);
  60.            Console.WriteLine();
  61.            Console.WriteLine(exitMsg);
  62.  
  63.            Console.ReadKey(intercept: true);
  64.        }
  65.    }
  66. }

Logicamente puedes escribir los nodos Xml que desees con cuantos elementos desees y elementos hijos cada uno.

Por cierto, cabría destacar que una de las ventajas o comodidades de VB.NET es simplificar (por no decir perfeccionar) al máximo el tratamiento de Xml en tiempo de diseño gracias a la inclusión directa de código Xml mediante la funcionalidad LINQ to XML incluyendo la declaración de literales Xml, por lo que el equivalente al código de arriba en C# sería más reducido e "interactivo", quedando así:

Código
  1. Imports System
  2. Imports System.Globalization
  3. Imports System.Linq
  4. Imports System.Threading
  5. Imports System.Xml.Linq
  6.  
  7. Public Module Module1
  8.  
  9.    Private ReadOnly languages As XElement =
  10.        <languages>
  11.            <en-US>
  12.                <Options>
  13.                    <Option1>Option 1</Option1>
  14.                    <Option2>Option 2</Option2>
  15.                    <Option3>Option 3</Option3>
  16.                </Options>
  17.                <ExitMessage>Press any key to exit...</ExitMessage>
  18.            </en-US>
  19.            <es-ES>
  20.                <Options>
  21.                    <Option1>Opción 1</Option1>
  22.                    <Option2>Opción 2</Option2>
  23.                    <Option3>Opción 3</Option3>
  24.                </Options>
  25.                <ExitMessage>Pulse cualquier tecla para salir...</ExitMessage>
  26.            </es-ES>
  27.        </languages>
  28.  
  29.    Public Sub Main()
  30.  
  31.        ' Obtener configuración de idioma actual.
  32.        Dim currentCi As CultureInfo = Thread.CurrentThread.CurrentUICulture
  33.        Dim currenLangXml As XElement = languages.Element(currentCi.Name)
  34.        ' Si no se encuentra un elemento Xml para el idioma actual, establecer idioma favorito por defecto (Inglés).
  35.        If currenLangXml Is Nothing Then
  36.            currenLangXml = languages.<en-US>.Single()
  37.        End If
  38.  
  39.        ' --------------------------------------------------------------
  40.  
  41.        ' Establecer nueva configuración de idioma.
  42.        Dim newCi As New CultureInfo("es-ES")
  43.        Dim newLangXml As XElement = languages.Element(newCi.Name)
  44.  
  45.        ' --------------------------------------------------------------
  46.  
  47.        ' Obtener los campos de opciones del idioma actual establecido.
  48.        Dim option1 As String = newLangXml.<Options>.<Option1>.Value
  49.        Dim option2 As String = newLangXml.<Options>.<Option2>.Value
  50.        Dim option3 As String = newLangXml.<Options>.<Option3>.Value
  51.        Dim exitMsg As String = newLangXml.<ExitMessage>.Value
  52.  
  53.        ' --------------------------------------------------------------
  54.  
  55.        ' Escribir las opciones en el idioma actual establecido.
  56.        Console.WriteLine(option1)
  57.        Console.WriteLine(option2)
  58.        Console.WriteLine(option3)
  59.        Console.WriteLine()
  60.        Console.WriteLine(exitMsg)
  61.  
  62.        Console.ReadKey(intercept:=True)
  63.    End Sub
  64.  
  65. End Module





Pero esta solución del Xml solo sería si lo quieres hacer de forma muy rudimentaria, por que como ya he mencionado antes Visual Studio ya provee herramientas de localización de idioma, y eso es lo que deberías usar si buscas una solución sofisticada, no rudimentaria como el uso de un Xml / String.

Aquí lo tienes todo explicado de la A a la Z:

Si quieres un resumen o mejor dicho un tutorial en C#, lee esto:

Y por cierto, también puedes utilizar la extensión Jollans Multi-Language for Visual Studio para Visual Studio. Es una joya que ahorra mucho tiempo y ayuda a mantener un seguimiento de los idiomas, eso si, es un producto de pago (para quien no sepa encontrar la respectiva "medicina"). Supongo que habrá extensiones gratuitas igualmente especializadas en la localización de idiomas de aplicaciones .NET, pero tampoco lo voy a buscar yo todo por ti...

Saludos.
« Última modificación: 26 Febrero 2019, 08:54 por Eleкtro » En línea


Meta


Desconectado Desconectado

Mensajes: 3.203



Ver Perfil WWW
Re: Introducir y seleccionar lengua en modo consola
« Respuesta #4 en: 27 Febrero 2019, 20:55 »

Buenas:

Buen trabajo, esa técnica no lo sabía. Si, se que viene lo del idioma ya preparao, ni siquiera usar XML debo hacerlo, solo desde la edad de pìedra. Hay gente que lo hacen desde un archivo txt también se hace, en mi caso, lo quiero hacer solo a códigos.

Saludos y buen trabajo. ;)
En línea

Tutoriales Electrónica y PIC: http://electronica-pic.blogspot.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines