Una especie de ToDo List

Seguramente conocen a “Remember The Milk” Ps… yo lo instalé y no me avisó de nada x.X
Tal vez no lo supe ocupar😯 Y si bien es una buena idea, quise crear algo igual, pero sin tanta cuática😉

Es por eso que en esta entrada, veremos el la primera parte de “Y para hoy?”
Es una aplicación en C#, que lee y escribe datos en XML. En un principio, pensé hacerlo con MySQL… pero en realidad era una tontera xDDD

Click en + para ver la parte 1, escribir (o guardar) una actividad😉

Como dije, es un WPF en C# y es bastante simple.
Screenshot - 23_05_2010 , 12_47_14
No quise hacerlo con tiempo, solamente por día. El motivo ps… El programa se abre al prender la LapTop, mira si tenemos alguna actividad para hoy. Si tenemos algo (leyendo en el XML) muestra un aviso. Si no, ps se cierra😉

Como pueden ver, tenemos:

  • 2 TextBox. Uno para el nombre de la actividad. Y el otro(multi-línea x.X) para el detalle de la actividad.
  • 3 RadioButtons. Esto es para el grado de la actividad. Mientras mayor grado, más molesto el aviso xDDD
  • Un Calendario para la fecha. Para la fecha…😯
  • Un botón para enviar los datos🙂

Vamos al código😉

Tengo 2 variables de clase, que guardan el grado y la fecha

Int16 grado;
String date;

El grado, puede ser: 0,1,2. Siendo 0 el mayor.

En el evento “SelectedDatesChanged” del calendario, tengo lo siguiente:

DateTime dt = calendar1.SelectedDate.Value;
Thread.CurrentThread.CurrentCulture = new CultureInfo("es-ES");
this.date = dt.ToString("d");

En dt guardo la fecha. Después, formateo el hilo como en España (con CL no me funciona…). Y por último la guardo en “date”. Para usar el “CultureInfo” necesitan el NameSpace “System.Globalization”

Cada RadioButton tiene … es obvio no?

this.grado = x;

Donde x depende del grado que ustedes asignen😉

El botón, crea el objeto algo (si, muchas de mis variables se llaman “algo”, “cosa”, “esto”, etc😯 ) de la clase GuardaXML, y después mandamos las cosas por el método “setCosas”.

String nombre=textBox1.Text, detalle=textBox2.Text;
GuardaXML algo = new GuardaXML();
algo.setCosas(nombre, detalle, this.date, this.grado);

Por último (y esto es algo opcional) en el evento “Initialized” de la ventana tengo esto:

if (Environment.GetCommandLineArgs().Length > 1)
  {
     String s = Environment.GetCommandLineArgs()[1];
     switch (s)
        {
           case "leer": /*Leemos las actividades desde el XML*/ break;
           default: /*guardamos en el XML*/ break;
        }
  }
  else
    {
       //Si no tenemos ningún parámetro, guardamos en XML
    }

Sirve para, por ejemplo, leer o escribir dependiendo del ejecutable. Si tenemos un “programa.exe leer” ps entonces leemos. Más adelante quedará más claro😉

Eso sería todo por la clase MainWindow. Ahora, vemos la clase GuardaXML


Vamos a usar el NameSpace “System.Xml” ps lo agregan😉

Esta clase tiene 3 funciones, ya vieron a setCosas. Ella envía las cosas (😯 ) a ScribeXML.
Entonces simplemente tendríamos esto:

public void setCosas(String nombre, String detalle,
     String Fecha, Int16 grado)
        {
            this.ScribeXML(nombre, detalle, Fecha, grado);
        }

ScribeXML, por su parte, realiza 2 tareas.
Primero, revisa que el archivo XML con las Actividades exista. Si no existe, lo crea.
Luego, escribe lo que mandemos.

Como es largo, vamos por parte😉
1)

try
  {
      String filename = "cosasAhacer.xml";
      XmlDocument xmlDoc = new XmlDocument();

      try
        {
           xmlDoc.Load(filename);
        }

Tiramos un Try (uno nunca sabe) pongámole try1.
Primero creamos un String con el nombre del archivo. En mi caso es “cosasAhacer.xml” , después el objeto xmlDoc.
Ahora un nuevo try (try2) que se encarga solamente de abrir el archivo. Si no existiera, cargamos el Catch (catch2) que se encarga de “crear” el archivo XML:

catch (System.IO.FileNotFoundException)
     {
          XmlTextWriter scribe = new XmlTextWriter(filename,
               System.Text.Encoding.UTF8);
          scribe.Formatting = Formatting.Indented;
          scribe.WriteProcessingInstruction("xml",
              "version='1.0' encoding='UTF-8'");
          scribe.WriteStartElement("Cosiacos");
          scribe.Close();
          xmlDoc.Load(filename);
     }

Se crea “scribe” que ‘Escribe” en el XML.  Lo importante sería… el tag del Root. En mi caso es “Cosiacos”. Lo cambian, lo dejan, da lo mismo :p
Y con esto terminamos el try2. Y volvemos al try1. Con lo siguiente:

XmlNode root = xmlDoc.DocumentElement;
XmlElement Actividad = xmlDoc.CreateElement("Actividad");
XmlElement Nombre = xmlDoc.CreateElement("Nombre");
XmlElement Date = xmlDoc.CreateElement("Fecha");
XmlElement Grado = xmlDoc.CreateElement("Grado");
XmlElement Estado = xmlDoc.CreateElement("Estado");
XmlElement Detalle = xmlDoc.CreateElement("Detalle");
XmlText txtNom=xmlDoc.CreateTextNode(nombre),
 txtFecha=xmlDoc.CreateTextNode(Fecha),
 txtGrado=xmlDoc.CreateTextNode(grado.ToString()),
 txtEst=xmlDoc.CreateTextNode("Por Cumplir"),
 txtDate = xmlDoc.CreateTextNode(detalle);

Creamos la variable root, que en nuestro caso carga “Cosiacos”.
Después, creamos los diferentes Tags que vamos a usar. Por el momento son Tags sin jerarquía, más adelante se ordenan🙂
Por último, creamos las hojitas del XML. Las iniciamos con los parámetros que recibimos
Ahora, escribimos en el XML:

   root.AppendChild(Actividad);

   Actividad.AppendChild(Nombre);
   Nombre.AppendChild(txtNom);

   Actividad.AppendChild(Date);
   Date.AppendChild(txtFecha);

   Actividad.AppendChild(Grado);
   Grado.AppendChild(txtGrado);

   Actividad.AppendChild(Estado);
   Estado.AppendChild(txtEst);

   Actividad.AppendChild(Detalle);
   Detalle.AppendChild(txtDate);

   xmlDoc.Save(filename);
}

En este punto, ordenamos los Tags.
El tag “Actividad” se convierte en ‘hijo’ de ‘Cosiacos’
Después, “Nombre” se convierte en el hijo de Actividad, quien a su vez, tiene a txtNom como hijito🙂
Lo mismo se hace con cada Tag, y cuando llegamos al final, guardamos el archivo ‘físicamente’
Cerramos al try1 y entramos al catch1, en caso de que salte algún error:

catch (Exception ex)
     {
        MandaError(ex.ToString());
      }

Enviamos el error a la función MandaError. Su código es:

private void MandaError(string str)
        {
            MessageBox.Show("" + str + "");
        }

Y listo😀
Con esto terminamos la primera parte de la aplicación “Escribir”. En la siguiente, terminamos con “leer y avisar”.

Pueden ver el código completo de Window.xaml, MainWindow.cs y GuardaXML.cs en caso de que se pierdan😉

Acerca de MaritoCares

Ingeniero Informático. Con tendencias a la programación en [C#, VB].NET, Java(Web principalmente...), PHP, JavaScript, algo mínimo de [ruby, python], y el clásico C.
Esta entrada fue publicada en Aplicación, Windows y etiquetada . Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s