Ahora que ya sabemos cómo crear una clase, vamos a intentar
crear nuestra primera aplicación.
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 MyAppPrivate 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áticoEnd Sub
End Class
Class Vehiculo
' código utilizado al instanciar la clasePublic 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 MyAppPublic 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”
No hay comentarios:
Publicar un comentario