En todos los libros que he leído, la primera aplicación que se desarrolla es la típica en “Hello world!!” o un “Hola Mundo!!” en la que se imprime o se obtiene en pantalla el mismo texto y tiene su historia; la más antigua de ellas y que yo conozca es la de un tejedor (“muuuu espabilao”) llamado Joseph Marie Jacquard que allá por 1801, le daba instrucciones a un telar mediante tarjetas perforadas y consiguió escribir “hello word” en uno de sus tapices, después dicen que Bill Gates inició Windows 1 con la misma frase, o un libro de C por los años 70 que imprimía lo mismo y … hasta hoy que se sigue usando por todos los begginers o principiantes . Pero para cambiar y siendo este un blog “andalú”, nuestra primera aplicación va a escribir un mensaje que diga “ereeh la caña illo!!!” (Traducido a eres la caña chiquillo, cosas de los andaluces!), ¿ok?, bueno, vamos allá.Antes de nada, quiero decir que toda aplicación tiene un método llamado Main tanto para C# como VB.NET. Da igual en que clase lo pongamos que el compilador se encargará de buscarlo e iniciar todo desde ahí, desde Main. Este método tiene además dos modificadores, uno public y otro static. El modificador público es para acceder a la aplicación desde el exterior y el static lo explico ahora mismo.
Cuando creamos un clase y la instanciamos, se genera un nuevo objeto, si instanciamos esta clase mil veces, tendremos 1000 objetos, pero si una clase o un miembro de clase es static, lo primero es que no hace falta instanciarla y lo segundo, que solo se crea una solo objeto.
Ejemplo. Si tenemos un clase vehículo estática y queremos que arranque el vehículo, no haría falta crear un nuevo vehículo, sino que escribiríamos el nombre de la clase seguido de punto y el método a usar, Vehículo.Arrancar, pero con el inconveniente de que solo habrá un solo objeto. Pasemos a un ejemplo:
C#
/* ************************************************
* © WAKI 2014
* PROYECTO: Aprender a Programar.
* Archivo: Program.cs
* Descripción: Clase Main y Vehículo
* Historial:
* Comentarios:
*
****************************************************/
using System;
namespace MyNameSpace
{
class MyApp
{
static void Main(string[] args)
{
Vehiculo miVehiculo = new Vehiculo();
miVehiculo.Arrancar();
ClaseEstatica.MetodoEstatico();
}
}
static class ClaseEstatica
{
static public ClaseEstatica()
{
}
static public void MetodoEstatico()
{
// código cuando se accede al método estático
}
}
class Vehiculo
{
public Vehiculo()
{
// código utilizado al instanciar la clase
}
public void Arrancar()
{
// código necesario para arrancar
}
}
}
VB.NET
' ************************************************
'* © WAKI 2014
'* PROYECTO: Aprender a Programar.
'* Archivo: Program.vb
'* Descripción: Clase Main y Vehículo
'* Historial:
'* Comentarios:
'*
'***************************************************
Namespace MyNameSpace
Class MyApp
Private Shared Sub Main(args As String())
Dim miVehiculo As New Vehiculo()
miVehiculo.Arrancar()
ClaseEstatica.MetodoEstatico()
End Sub
End Class
NotInheritable Class ClaseEstatica
Private Sub New()
End Sub
Public Shared Sub MetodoEstatico()
' código cuando se accede al método estático
End Sub
End Class
Class Vehiculo
' código utilizado al instanciar la clase
Public Sub New()
End Sub
Public Sub Arrancar()
' código necesario para arrancar
End Sub
End Class
End Namespace
Analicemos el código; tenemos un espacio de nombres llamado MyNameSpace con tres clases, una pública y estática MyApp que contiene el método Main, otra Vehiculo y otra pública y estática llamada ClaseEstatica. La primera es desde donde accederemos desde Windows, (donde pone string[] args, son parámetros enviados como argumentos y los veremos con más detalle) y en su método Main hacemos lo siguiente:
Creamos un objeto Vehículo al que llamamos miVehiculo (el nombre es elección del usuario, podría haberle llamado coche, micoche, etc) e instanciamos uno nuevo (new Vehiculo). A partir de este momento, cada vez que nos referimos a miVehiculo nos referimos a el que hemos creado y ahora que ya tenemos un objeto, invocamos el método Arrancar desde este mismo objeto. Ahora nos referimos a la clase estática pero sin hacer referencia a new ClaseEstatica , directamente escribiendo la clase y seguido del método estático. Fácil, ¿no?
En VB.NET las clases se instancia primero con Dim, luego el nombre y posteriormente As New nombre de la clase
Volviendo a nuestra primera aplicación y centrándonos en ella. Abrimos el Bloc de Notas o Notepad++, creamos un nuevo archivo de texto y escribimos (aconsejo escribir) o copiamos y pegamos el código de nuestra primera Aplicación. Guardamos donde queramos el archivo, eso si, guardando con extensión .cs para C# o .vb para VB.NET. Si no vemos las extensiones, hay que habilitar su visualización.
(En W7, desde una ventana del explorador de Windows, Organizar, Opciones de carpeta y búsqueda, Pestaña Ver y casi al final de la lista desmarcamos Ocultar las Extensiones de Archivos …)
C#
/* ************************************************
* © WAKI 2014
* PROYECTO: Aprender a Programar.
* Archivo: Program.cs
* Descripción: Clase Main y Vehículo
* Historial:
* Comentarios:
*
****************************************************/
using System;
namespace MyConsoleApplication
{
class MyApp
{
static void Main(string[] args)
{
Console.WriteLine ("ereeh la caña illo!!!");
Console.WriteLine("Pulse una tecla para cerrar");
Console.ReadLine();
}
}
}
VB.NET
'* ************************************************
'* © WAKI 2014
'* PROYECTO: Aprender a Programar.
'* Archivo: Module1.vb
'* Descripción: Clase Main y Vehículo
'* Historial:
'* Comentarios:
'*
'****************************************************
Module Module1
Class MyApp
Public Shared Sub Main(args As String())
Console.WriteLine("ereeh la caña illo!!!")
Console.WriteLine("Pulse Intro para cerrar")
Console.ReadLine()
End Sub
End Class
End Module
Nota: (Una instrucción Module define un tipo de referencia disponible en su espacio de nombres. Un módulo es similar a una clase pero con algunas distinciones importantes. Cada módulo tiene exactamente una instancia y no necesita ser creado ni asignado a una variable. Los módulos no admiten la herencia ni implementan interfaces. No es una clase y no puede declarar.)
Analicemos este nuevo código. Vemos que hemos escrito la clase Console que procede del espacio de nombre System que lo tenemos importado, esta clase tiene múltiples métodos, pero hemos escogido WriteLine y ReadLine. El primero escribe una línea en la consola (pantalla negra) y el segundo espera una entrada del teclado y una vez recibida cierra el programa. La parte que va incluida entre los paréntesis de los métodos se llama argumento y tiene un tipo, es decir si el método dice que solo puede recibir un texto, no podemos pasarle un número (aunque ya veremos que también se puede), pero en definitiva, el método decide que recibir.
Una vez que recibe el argumento tipo string (texto), se visualiza en pantalla.
Ahora vamos a crear el programa. Dijimos que necesitábamos un compilador que lo encontraremos en C:\Windows\Microsoft.NET\Framework\(Versión de .NET) yo en mi caso voy a compilar con la versión .NET Framework 4.0 por tanto yo tengo el compilador en C:\Windows\Microsoft.NET\Framework\v4.0.30319.
En W7, abro el símbolo del sistema como administrador (Inicio-Todos los Programas-Accesorios- Símbolo del Sistema y le damos con el botón derecho “Ejecutar como Administrador”.
Una vez en la pantalla oscura, escribimos cd\ e INTRO de modo que el símbolo del sistema se irá a C: \>, en esta ruta se creará nuestro programa y después de esto, escribo la ruta donde se encuentra el compilador seguido del archivo que queremos compilar, en mi caso C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe C:\Desarrollo\ConsoleApplication1\Program.cs, pulsamos INTRO y et voilá, compilado, ya tenemos nuevo programa!, en C:\ tendremos un ejecutable llamado program.exe. Lo ejecutamos y … ahí lo llevas
Saludos “der Waki”
wakicode 