martes, 16 de octubre de 2012

[004] _screen, Ventana Principal

La ventana principal I

Para los los foxpreros nada que decir sobre la ventana principal de nuestras aplicaciones, para todos los demás sólo les puedo comentar que la ventana principal es aquella que (en muchas de nuestras aplicaciones orientadas a datos) representa la aplicación entera. Es la que contendrá todos los formularios de nuestros programas. Tendrá un menú configurable, una barra de tareas y una barra de estado.

La principal ventaja de nuestra ventana principal es que no vamos a tener ninguna limitación en el momento de trabajar con ella. Esto lo entenderán perfectamente los que venimos del Foxpro.



Bien, aquí es donde las cosas cambian un poco para mejor. En Foxpro si queríamos gobernar un formulario desde el código debíamos crearlo en un prg. Esto nos implicaba no poder trabajar en modo gráfico con el mismo. Aunque nuestros formularios fuesen heredados de otros formulario a modo de plantilla, siempre nos tocaba poner el código (la lógica del programa) junto al diseño de los formualrio, y esto complicaba la lectura del código, ya que lo teníamos muy esparcido.

La mejor opción que nos ofrece C Sharp es poder separar la parte de la lógica de negocio de nuestra aplicación de la parte gráfica. Esto nos permitirá progamar de una forma específica y abordar sin gran esfuerzo proyectos con Windows Form y proyectos ASP .NET.

La ventaja más interesante de los formularios de C Sharp es que están contenidos en ficheros de texto con la extensión .cs. Se terminaron los problemas de los SCX a nivel de corrupción, etc. (Todos sabemos que un scx y un sct no son ni más ni menos que un dbf y un fpt).

Para trabajar de esta manera, comentada anteriormente, tendremos toda la parte gráfica de los formularios en los própios forms de c sharp, y el 90% del código para gestionar los forms en un fichero .cs que llamaremos TForms.cs, el cual contendrá una clase llamada TForms.cs que instanciaremos en el método main de nuestro programa. Mostramos un ejemplo:

NOTA: Cuando muestre un código que empieza con tres puntos y termina con tres puntos deberás ver el código completo basándote en los ejemplos anteriores.

...
 static class Prg
 { 
      public static bool TestMode = false;
      public static string LastText = "";
      public static string CurDir = "";
      public static string TForms oForms = null;

      [STAThread]
      static void Main()
      {
          CurDir = Application.ExecutablePath.Substring(0,                              Application.ExecutablePath.LastIndexOf("\\"));

          if ( File.Exists( CurDir + "\\Logger.Txt" ))  
               File.Delete( CurDir + "\\Logger.Txt" );

         TestMode = ( File . Exists ( CurDir + "\\Test.ON" )  ); 
     
         Application.EnableVisualStyles();
         Application.SetCompatibleTextRenderingDefault(false);
         
         oForms = new TForms();
         oForms._ScreenShow();

         Application.Run();
         Application.DoEvents();   
       }
...

Así es pues como quedaría nuestro método Main, al realizar la llamada al formulario principal de nuestra aplicación. Aún no es el código definitivo, ya que nos faltan temas relacionados con ficheros de configuración de nuestro programa, etc.

En posteriores capítulos seguiremos hablando de la ventana principal de nuestras aplicaciones, y os podréis descargar el código fuente del proyecto base para cualquiert tipo de aplicación.

Una de las curiosidades que supongo que has detectado es el hecho de llamar a la clase de los formularios TForms. En el próximo capitulo hablaremos de la nomenclatura de las variables, para ello nos basaremos en el VisualFoxpro, pero también en otros lenguajes como Delphi.

NEWS [ Mono: C# para Android ]

Proyecto Mono

Última versión estable:   2.10.8 del 19 de diciembre, 2011   Multiplataforma

Mono es el nombre de un proyecto de código abierto iniciado por Ximian y actualmente impulsado por Novell (tras la adquisición de Ximian) para crear un grupo de herramientas libres, basadas en GNU/Linux y compatibles con .NET según lo especificado por el ECMA.

Es un proyecto independiente de la plataforma. Actualmente Mono funciona en GNU/Linux, OpenBSD, FreeBSD, UNIX, Mac OS X, Solaris y plataformas Windows.

Existe un proyecto similar, llamado Portable.NET, es parte del proyecto dotGNU.




Xamarin es una companía establecida en mayo de 2011 por los ingenieros que crearon Mono, una implementación libre de la plataforma de desarrollo .NET para dispositivos Android, iOS y GNU/Linux.


En junio de 2000, Microsoft anunció por primera vez su .NET Framework. Miguel de Icaza, de Ximian, comenzó a investigar si una versión para Linux era factible. Posteriormente, el proyecto Mono fue lanzado el 19 de junio de 2001. Ximian fue adquirida por Novell el 4 de agosto de 2003.

Después de la subsecuente adquisición de Novell por parte de Attachmate en abril de 2011, Attachmate anunció el despido de cientos de trabajadores de Novell, incluyendo a desarrolladores de Mono,2 poniendo así el futuro del proyecto en cuestión.

El 16 de mayo, Miguel de Icaza anunció en su blog que Mono será desarrollado y soportado por Xamarin, empresa que planea lanzar una serie de productos para dispositivos móviles. De acuerdo con de Icaza, al menos una parte del equipo original de Mono se ha movido a la nueva compañía.

De este modo se abre una puerta para todos los desarrolladores de aplicaciones de Windows puedan traer sus creaciones a Android eso sí, pagando su licencia profesional de 280 euros al año o una licencia Enterprise por 700 euros al año. Unos precios que quizá echen bastante para atrás a los desarrolladores nóveles aunque Mono da la posibilidad de descargar una versión de prueba gratuita.

Mono para Android viene con su runtime propio, vinculaciones para las APIS nativas de Android, un plugin para Visual Studio 2010 y un SDK con las herramientas necesarias para poder programas aplicaciones, depurarlas y empaquetarlas.

Ahora habrá que ver cuántos desarrolladores de C# y .NET deciden dar el paso, además de pagar la respectiva licencia, y traer su talento y aplicaciones a Android. Una buena noticia que abre el abanico un poco más a todos los interesados en programar para dispositivos móviles.

Por otra parte Si usted sigue las noticias aunque sea un poco, sabrá que Google está teniendo problemas con Oracle sobre el uso de cierta parte de código de Java en Android. Por lo tanto, un grupo de desarrolladores se les ocurrió una solución muy simple: ¿qué pasaría si Android no se basara en Java?  ¿Y si, en cambio, Android se tradujera con C # ? Resulta, que podría no ser una idea tan terrible. Por lo menos, podría hacer que Android fuese aún más rápido de lo que es ahora.

El equipo de Xamarin sabe un poco acerca de todo esto de C # y NET., Que se ha utilizado para ayudar a crear una plataforma de desarrollo llamado Mono, que permite la creación de aplicaciones iOS Android escritas en C # en lugar de Objective C para iOS o Java para Android. Las aplicaciones creadas se pueden traducir fácilmente para su uso en cualquier Android, iOS o Windows Phone, y se pueden escribir con el apoyo total de Visual Studio. Y, el equipo afirma que las aplicaciones creadas con la plataforma funcionan mejor y consumen menos batería que otras aplicaciones escritas de forma nativa.

Android está traduciendo a C #

Teniendo en cuenta estos antecedentes, sería sólo un pequeño salto para que el equipo trasladase todo el sistema Android a C #. Así fue como construyeron una herramienta llamada Sharpen, que ha estado traduciendo Android con el código que se encuentra en el repositorio AOSP. Xamarin se inició con la traducción del código 2.x el año pasado, y comenzó a trabajar en Android 4.0 este año. El equipo dice que Android Mono (C # máquina virtual) es más rápido que Dalvik (Java VM), y muestra algunos gráficos de barras que parecen corroborar esa historia.

La traducción de Android por Xamarin  ha sido nombrada XobotOS, y se ha hecho disponible en github, por lo que los desarrolladores pueden entrar y jugar un rato con ella. El trabajo todavía es joven, pero ha estado funcionando bien en las pruebas con un escritorio Linux. Estamos interesados ​​en ver como se ejecuta  en un dispositivo móvil real.

viernes, 5 de octubre de 2012

[003] Inicio, La clase Prg




Vamos a ver como podemos empezar nuestros proyectos de C Sharp si perder de vista la forma de programar que utilizábamos en VisualFoxpro. 

En este artículo vamos a tratar sobre el .NET FRAMEWORK con el que tenemos que trabajar ( Sí un determinado proyecto no nos lo impide) y sobre el Prg de inicio, en este caso el fichero que contiene el método Main en Visual Studio, llamado  [ program.cs ].


Actualmente deberíamos programa con el .NET FRAMEWORK 2.0, y a continuación os argumentaré el porqué de esta decisión. Las razones podrían ser la siguientes, aunque puedes decidir trabajar con otros .NET FRAMEWORK, ya que en el código del fichero principal  [ program.cs ] no hay nada que impida esta decisión:

  • Si excluimos XP, Windows 7 (32 y 64) y posteriores incorporan por defecto como mínimo el .NET FRAMEWORK 2.0.
  • Su peso para XP no supera los 40 Megas, en el momento de la instalación.
  • Esta muy documentado en internet y depurado por Microsoft.
Para mi son suficientes, no se para vosotros. Veamos ahora el código a incorporar en el fichero [ program.cs ]:

01. using System;
02. using System.Collections.Generic;
03. using System.Windows.Forms;
04. using System . IO;
06. 
07. namespace NuestrpPrograma
08.{
09.  static class Prg
10.  { 
11.       public static bool TestMode = false;
12.       public static string LastText = "";
13.       public static string CurDir = "";
14. 
15.       [STAThread]
16.       static void Main()
17.       {
18.          CurDir = Application.ExecutablePath.Substring(0, Application.ExecutablePath.LastIndexOf("\\"));
19. 
20.          ifFile.Exists( CurDir + "\\Logger.Txt" ))  File.Delete( CurDir + "\\Logger.Txt" );
21.          TestMode = ( File . Exists ( CurDir + "\\Test.ON" )  ); 
22.     
23.         Application.EnableVisualStyles();
24.         Application.SetCompatibleTextRenderingDefault(false);
25.         Application.Run(new _screen());
26.       
27.       }
28. 
29.       public static bool Log( string cIn, string cTx )
30.      {
31.         if!TestMode )                          { return false; }
32.         if ( cIn + cTx == Prg.LastText )  { return true; }
33.  
34.         try
35.        {
36.
37.        StreamWriter oWriter = File.AppendText(ExecPath + "\\Logger.Txt");
38.        oWriter.WriteLine( "[" + DateTime.Now.Millisecond.ToString("0000") + "] " + cIn + " [ " + cTx + " ]" 39.);
40.        oWriter.Close();
41.
42.        }
43.        catch { return false; }
44.     
45.        Prg.LastText = cIn + cTx;
46.       return true;
47.
48.      }
49.
50.      public static bool Log( string cIn, string cTx, string cFile )
51.     {
52.         if!TestMode )                         { return false; }
53.         if ( cIn + cTx == Prg.LastText ) { return true; }
54.  
55.        try
56.       {
57.
58.       StreamWriter oWriter = File.AppendText(ExecPath + "\\" + cFile.Trim() + ".txt");
59.       oWriter.WriteLine( "[" + DateTime.Now.Millisecond.ToString("0000") + "] <" + cIn + " [ " + cTx + " ]" 60.);
61.       oWriter.Close();
62.
63.       }
64.       catch { return false; }
65.  
66.      Prg.LastText = cIn + cTx;
67.      return true;
68.
69.     }
70.  }
71.}

Ok, vamos a desgranar el código expuesto anteriormente...

Lo primero es declarar 3 variables públicas (a parte de todas las que interesen en nuestra aplicación). 
  • [Línea 11] La primera es la que yo llamo TestMode, y como el nombre dice nos indicará si estamos en Modo Test. La variable se pondrá a true si existe un fichero al al lado del ejecutable llamado [ Test.ON ], vacío o con contenido, es irrelevante.
  • [Línea 12] La segunda LastText contendrá el último texto enviado al fichero [ Logger.Txt ], para evitar que se repitan las entradas en este fichero y facilitar así la lectura del mismo.
  • [Línea 13] La tercera es CurDir y contendrá la ruta de nuestro ejecutable la cual nos servirá, de seguro, en múltiples ocasiones.
Ahora vamos a ver lo mínimo y necesario para el contenido del método Main, a la búsqueda de nuestra filosofía Foxpro.

  • [Línea 18] Lo primero es cargar la variable CurDir con su correspondiente ruta, la del ejecutable una vez compilado.
  • [Línea 20] En esta línea comprobamos si ya existe el fichero [ Logger.Txt ], si es así lo eliminamos para empezar siempre a cargarlo con datos de nuevo.
  • [Línea 21] Aquí ponemos la variable TestMode a true si comprobamos que existe, al lado del ejecutable, el fichero [ Test.ON ].
  • [Línea 23] y [Línea 24] y [Línea 25] Ejecutamos el formulario _screen, para los programadores de Foxpro esta será la ventana principal de Foxpro y de nuestras Aplicaciones.
Después del método Main tenemos dos métodos más, en realidad uno sobrecargado ( Esto en Fox no se podía realizar ) el método se llama Log, y cuando lo utilicemos en la aplicación lo podemos hacer de dos maneras diferentes.

En la primera cargaremos datos en el fichero [ Logger.Txt ] y en la segunda cargaremos datos en el fichero que queramos. Vamos a ver varios ejemplos:

namespace Application
{
  static class Prg
  {
  public static string CurDir = "";
  public static string LastText = "";
  public static string CurDir = "";

  [STAThread]
  static void Main()
  {
  
  CurDir = Application.ExecutablePath.Substring(0, Application.ExecutablePath.LastIndexOf("\\"));
  Log( "Prg.Main()", + "Path: " CurDir  );

  if ( File.Exists( CurDir + "\\Logger.Txt" ))  File.Delete( CurDir + "\\Logger.Txt" );
  TestMode = ( File . Exists ( CurDir + "\\Test.ON" )  ); 

 Log( "Prg.Main()", + "Run :screen" );
     
  Application.EnableVisualStyles();
  Application.SetCompatibleTextRenderingDefault(false);
  Application.Run(new _screen());

  }
 }
}

En este caso utilizamos el Log para documentar puntos del arranque de la aplicación. Ten en cuenta que si utilizas el método Log fuera de la clase Prg deberás hacerlo de esta manera:

Prg.Log( "Clase.Metodo()", + "Parametros..." );

La otra forma de utilizar el método Log es indicarle en un parámetro más el nombre del fichero particular donde queremos separar parte de los datos, por ejemplo todo el código relacionado con un determinado formulario (Lo veremos más adelante).



NOTA: No aconsejo, para nada, cargar la clase Prg con más métodos que los que he definido en la misma. 

NEWS [ Futuro de C# ]

Reflexionando sobre el futuro

Futuras y presentes reflexiones para un programador .NET


Microsoft lleva de calle a todos los "informáticos" que trabajan sobre sus tecnologías. No para de sacar novedades continuas e importantes en todos sus productos, especialmente a los programamdores. Ya que, no solamente la evolución ha sido constante en lo que a las herramientas se refiere, sino que aún han sido más vertiginosas en las posibilidades y capacidades de los diferentes lenguajes de programación que incorpora la plataforma .NET.


Hagamos una reflexión sobre el incierto pero apasionado futuro laboral para los programadores que estamos haciendo aplicaciones informáticas en nuestro trabajo, o como hobby.

Realmente, No importa qué lenguaje aprendas hoy en día. La programación es sobre la implementación de algoritmos. Por lo tanto esa es la habilidad que hay que desarrollar. Así que sólo debes elegir el lenguaje que más te acomode, aprender a usarlo y obtener experiencia en la realización de programas cada vez más complejos.

C# vs el resto de los lenguajes


Aunque nadie lo quiera reconocer, C# empieza a ser la niña bonita en los lenguajes de .NET. Por otr parte no se quiere reconocer que C# es un Java. Eso sí, ya nació genéticamente mejorado en relación a su padre putativo. El paso del tiempo lo ha convertido en un lenguaje mucho más robusto, flexible y que no deja de crecer.

.NET es una plataforma de programación con un horizonte muy lejano y mantiene un ritmo incansable de evolución. Aumentando el nivel de productividad que lo hace muy rentable para ser utilizado en desarrollos profesionales.

Pero no solamente de C# vive .NET y, en una política excelente, se ha implementado en la plataforma más de 50 lenguajes de programación diferentes. Y entre ellos destacar Pyhton, Ruby, Pascal, PHP, etc.

Además sólo hay que seguir el indice TIOBE para comprobar como, de una manera muy estable, va acaparando el mercado de la programación.

Ventajas de utilizar C#

Su facilidad de uso y considerable capacidad para acelerar el tiempo de desarrollo . Por ejemplo, si usted fuera a codificar una calculadora para Windows con una interfaz gráfica totalmente funcional, es posible que tardase varias horas durante un día con C + +, sin embargo, si usted utiliza C # para codificar el mismo programa sólo necesitaría unos 30 minutos. Ese es el poder de C #.
Otra razón de para la utilización de C # son sus IDE, la mayoría vienen con un editor gráfico integrado. Esto le permite editar fácilmente la interfaz gráfica de usuario para programarla en poco tiempo.

Desventajas de utilizar C#

Puesto que C # tiene que cargar su CLR (Common Language Infrastructure) y el Framework. NET cada vez que se ejecuta un programa en C # la carga del mismo es considerablemente mayor que la carga de un programa equivalente en C ++. Por lo tanto, si es vital la velocidad del programa   entonces estarás mucho mejor programado con C o C + +.
Otro gran problema que C # tiene es el hecho de que estás irremediablemente obligado a usar el Framework .NET de Microsoft. Esto significa que es mucho más difícil de transferir su programa de Windows a otro sistema operativo. Sin embargo, la llegada del Proyecto Mono ha hecho esta mucho más fácil de lo que era antes, ahora se puede portar casi cualquier programa en C # que desea tanto Linux y Mac OS.
C # no permite el acceso directo al hardware de la computadora, esto se podría considerar a la vez como bueno y malo. Bueno, porque significa que hay menos de que preocuparse, no tienes que preocuparte de la gestión de memoria y no tienes que preocuparte de los accidentes. Es malo porque tienes mucha menos flexibilidad con tus programas y no los puedes optimizar para el hardware.



[002] Variables Públicas


Como tengo la intención de ofrecer mis conocimientos compartidos entre Foxpro y C Sharp para todo aquel que considere interesantes mis ideas ( especialmente los que, como yo, vienen de Foxpro) hablaré para los unos y los otros.

Sabido es que C Sharp es totalmente orientado a objetos ( su paradigma es el de la programación orientada a objetos POO ), en el caso de Foxpro se comparte la programación secuencial ( paradigma de otros tiempos ) y la POO. Esto proporciona cierta libertad a los programadores, algo muy parecido a lo que les sucede a los programadores de C++.

En este artículo os voy a proporcionar una forma de tener variables públicas o globales en una aplicación de C Sharp, sin perder su paradigma de lenguaje orientado a objetos.

Empezaremos por desgranar un poco el funcionamiento de arranque de C Sharp el cual es muy peculiar, ya que en el caso de Foxpro el punto de entrada del programa es un fichero (prg, form, etc.), en el caso de C Sharp es un método que por la obligatoriedad del paradigma orientado a objetos, este debe de estar en una clase. Vamos a ver un ejemplo:


namespace Nombre_del_Programa
{
    class Prg
    {
        static void Main(string[] args)
        {
            // Esta es la primera línea de código...
            Console.WriteLine("Hola Mundo!");
        }
    }
}

Lo primero que comprobamos es que el método Main es estático. Esto me hace pensar que poco podemos hacer con la clase Prg... ¿ La instanciamos, y creamos objetos de ella ? .- No tiene mucho sentido...


Por lo tanto no considero una locura hacer que la clase Prg sea también una clase estática, y que incluso las variables de la clase Prg sean variables estáticas. Veamos este ejemplo en el que creamos una variable para almacenar la ruta de ejecutable de la aplicación que estamos creando.

namespace NuestroPrograma
{
    static class Prg
    {
        public static string CurDir = "";
       // Otra variable pública para toda la aplicación...
      // Otra variable pública para toda la aplicación...
      // Otra variable pública para toda la aplicación...
      // Otra variable pública para toda la aplicación...

        static void Main(string[] args)
        {
            // Esta es la primera línea de código...
            CurDir = Application.StartupPath + "\\";
            Console.WriteLine("Hola Mundo!");
        }
    }
}

En este caso en cualquier parte de nuestro programa podremos acceder a la variable CurDir y utilizarla o cambiar su contenido. Todas la variables públicas / Globales de nuestra aplicación las podemos insertar en la clase Prg y así podremos utilizarlas donde queramos ( siempre que estemos dentro del ámbito del namespace NuestroPrograma ) sólo tendremos que llamarlas con la siguiente sintaxis:

namespace NuestroPrograma
{
    static class FuncionesGenerales
    {
        public string CurDirectory()
        {
            return Prg.CurDir;
        }
    }
}

Mi único consejo en este caso es que las variables declaradas en la clase Prg estén inicializadas con algún valor por defecto.