Vamos a realizar un primer programa en C# y luego lo iremos ampliando con una de las características básicas de un programa de programación orientada a objetos: las propiedades.
Para comenzar este programa abrimos Visual Studio y pulsamos en nuevo -> proyecto.
Esto nos abre una pantalla donde elegiremos el tipo de proyecto, vamos a elegir una Aplicación de Windows Forms que es lo más habitual para un proyecto de C#.net
En las casillas de abajo indicamos la ubicación del proyecto y el nombre, en este caso HolaMundo.
Hecho esto, nos abre la pantalla principal del proyecto, lo primero que tenemos que hacer, es añadirle un botón y una etiqueta (label). Para ello, sobre el panel derecho pulsamos en Cuadro de herramientas para desplegar las herramientas y elegimos Button, hecho esto lo arrastramos sobre nuestro formulario.
Colocamos sobre el formulario el botón y la etiqueta (tomada también del cuadro de herramientas).
Si ahora hacemos doble click sobre el botón, se nos abrirá el editor de código en el que el código inicial ya está escrito y sólo tendremos que añadir una línea de código para asignar ¡Hola Mundo! A la etiqueta en el evento click del botón. De este modo al pulsar el botón se mostrará el mensaje y tendremos nuestra primera funcionalidad al pulsar un botón (evento).
Aquí el código completo.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
label1.Text = "¡HOLA MUNDO!";
}
}
}
No hay que preocuparse por las primeras líneas, pues las pone automáticamente el compilador.
Ahora pulsamos el botón iniciar del área de trabajo, tal y como se muestra en la figura superior, y esto nos abre el formulario. Al pulsar sobre nuestro botón, podemos ver el mensaje que hemos escrito para la etiqueta.
Propiedades
En la programación orientada a objetos, el código se encapsula en trozos de código que una vez probados no deben cambiarse. Esto garantiza un funcionamiento correcto y separado del resto del programa. Estos trozos de código se llaman clases y para evitar tocar el código para manejar las variables internas de cada clase tenemos las propiedades.
A continuación una definición básica de las propiedades en C#.
En primer lugar definimos un espacio de nombres, que es una separación lógica dentro de nuestro código
namespace Espacio_de_Nombres
{
}
Dentro de nuestro espacio de nombres podemos definir diferentes clases. Si deseamos acceder a una de ellas desde un espacio de nombres diferente debemos anteponer el nombre del espacio de nombres separado por un punto.
namespace Espacio_de_Nombres
{
public class Nombre_Clase
{
}
}
En el caso de arriba si deseamos acceder a la clase Nombre_clase desde un espacio de nombres diferente de Espacio_de_Nombres debemos escribir
Espacio_de_Nombres.Nombre_Clase
Dentro de la clase es conveniente definir siempre las variables como privadas para que no se puedan acceder desde fuera, y tanto en para escribir en ellas desde el exterior como para leerlas conviene definir propiedades y trabajar desde fuera con las propiedades. Si no hacemos esto no estamos siguiendo el principio de encapsulamiento de la programación orientada a objetos y estaremos haciendo una chapuza.
El código de lo que digo es así de sencillo.
public class MiClase
{
private string m_titulo = ""; // variable interna de la clase siempre
privada
public string propiedad_titulo // propiedad para leer y escribir los
datos de la varable privada de la clase
{
get
{
return m_titulo; //propiedad de lectura Get
(devuelve al exterior el valor de la variable interna m_titulo)
}
set
{
m_titulo = value; // propiedad de escritura Set (escribe la variable interna con el valor
introducido en el parámetro value)
}
}
}
Cuando queremos escribir sobre la variable privada de la clase desde una parte de código externa a la clase, debemos crear un objeto perteneciente a la clase y utilizar la propiedad propiedad_titulo para escribir sobre la variable m_titulo de la clase. Añadimos otro botón llamado btnEscribir_titulo y hacemos doble click sobre él. Ponemos este código en su interior.
Dentro de la clase del formulario pero fuera del evento del botón definimos una variable local
private string variable_local;
Y ahora escribimos el código para el evento del segundo botón al que llamaremos btnEscribir_titulo.
private void btnEscribir_titulo_Click(object sender, EventArgs e)
{
Espacio_de_Nombres.Nombre_clase ObjetoClase; //definición de un objeto de la clase
ObjetoClase = new Espacio_de_Nombres.Nombre_clase(); //creacion del objeto en memoria
ObjetoClase.propiedad_titulo = "Texto título"; //Utilización de la propiedad de la clase para escribir sobre ella
label1.Text = ObjetoClase.propiedad_titulo; //Utilización de la propiedad de la clase para leer su valor
variable_local =
ObjetoClase.propiedad_titulo; //Utilización de la propiedad de la clase para leer su valor
}
Ahora al pulsar el botón Escribir título escribimos “texto título” en la variable privada de la clase, y lo muestra en la etiqueta, además asigna ese valor a la variable local creada.
Las propiedades no sólo sirven para transferir datos de entrada y salida, una funcionalidad muy utilizada es la de validar los datos. Así por ejemplo si introducimos una cadena de caracteres pero necesitamos que sea una fecha, podemos utilizar la definición de la propiedad para validar que los datos introducidos sean correctos.
Así por ejemplo, podemos definir una propiedad tipo int que verifique que sólo se introduzcan valores entre 1 y 10. Añadimos una caja de texto al formulario e introducimos el siguiente código en el evento de un tercer botón llamado validar número.
Añadimos a la clase el siguiente código:
private int m_numero;
public int
propiedad_numero // propiedad para leer y escribir los
datos de la varable privada de la clase
{
get
{
return m_numero; //propiedad de lectura Get
(devuelve al exterior el valor de la variable interna m_numero)
}
set
{
m_numero = value; // propiedad de escritura Set (escribe la variable interna con el valor
introducido en el parámetro value)
}
}
Después, en el evento click del tercer botón añadimos este código:
private void
btnValidarNumero_Click(object sender, EventArgs e)
{
Espacio_de_Nombres.Nombre_clase ObjetoClase; //definición de un objeto de la clase
ObjetoClase = new Espacio_de_Nombres.Nombre_clase(); //creacion del objeto en memoria
int j;
if (Int32.TryParse(txtNumero.Text, out j))
MessageBox.Show("Numero
obtenido correctamente.");
else
MessageBox.Show("No
se puede convertir a entero la cadena
introducida.");
ObjetoClase.propiedad_numero = j; //Lee el número introduciodo en el control texto
}
Si ahora queremos validar que el valor de número introducido esté entre 1 y 10 el código lo podemos poner en la propiedad en vez de en el evento del botón.
public int propiedad_numero // propiedad para leer y escribir los datos de la varable
privada de la clase
{
get
{
return m_numero; //propiedad
de lectura Get (devuelve al exterior el valor de la variable interna m_numero)
}
set
{
m_numero = value; // propiedad de escritura Set (escribe la variable interna
con el valor introducido en el parámetro value)
if (m_numero < 11 && m_numero > 0)
m_numero = value;
else
MessageBox.Show("El número debe estar entre 1 y 10");
}
}
Si ahora introducimos un texto sucede lo siguiente:
Y si elegimos un número superior a 10 o inferior a 1 dice esto
Si introducimos un número entre los parámetros requeridos, entonces se asigna a la variable m_numero de la clase y lo confirma con este mensaje.
Este tipo de comportamiento específico de una clase debe ser reportado de la forma más detallada posible en la cabecera de la clase, especificando bien lo que hace cada propiedad y cada método de la clase.
Propiedades de sólo lectura o sólo escritura
Para finalizar, comentar que también puede haber propiedades de sólo lectura. Si a la propiedad sólo le definimos la parte get, o de sólo escritura si le definimos únicamente la parte set. De este modo los datos quedan aún más encapsulados y podemos impedir que ningún programador modifique los valores internos de nuestra clase.
a continuación pongo algunos ejemplos:
a continuación pongo algunos ejemplos:
//*****************************************************************
//Definición
de propiedades
//propiedad
de sólo lectura
//Devuelve
la ruta completa del fichero fuente
//Esta líneas
de abajo se muestran en IntelliSense
/// <summary>
/// Esta propiedad es de sólo lectura y devuelve una cadena
con la ruta completa donde se encuentra el archivo de código fuente
/// </summary>
public string RutaCompleta
{
get { return m_RutaCompleta; }
}
///<summary>
///Esta propiedad es de sólo lectura y devuelve el Nombre del
archivo sin la ruta del archivo fuente
///</summary>
public string NombreArchivo
{
get
{
int ultimaBarra = m_RutaCompleta.LastIndexOf("\\");
return m_RutaCompleta.Substring(ultimaBarra + 1);
}
}
///<summary>
///Esta propiedad es de sólo escritura, le introducimos desde el programa un valor a la variable privada de la clase
///</summary>
public int DefineNumClases
{
set { m_ContadorClases= value; }
}
//Fin
Definición de propiedades
//*******************************************
No hay comentarios:
Publicar un comentario