PDF de programación - Curso 2014 1

Introducción
Nuestro objetivo a la hora de crear estas prácticas es ver cómo usar los servicios y
mecanismos que nos ofrece un Middleware mediante una sucesión de ejemplos,
quizás algo sencillos al principio pero que ganarán en riqueza a lo largo del curso. El
entorno de desarrollo que os recomendamos es Visual Studio en cualquiera de sus
versiones recientes.

Curso de Middleware. Práctica 1.

1 de 14

Primer ejemplo: una aplicación local
Al principio vamos a construir una pequeña aplicación que nos permitirá
familiarizarnos con C# y con el entorno de desarrollo. Vamos a utilizar un ejemplo
muy usual en este tipo de cursos: una calculadora. Esta aplicación será inicialmente
local (no remota) y posteriormente la vamos a transformar en una aplicación
distribuida.
El primer paso pues será definir la clase de la calculadora. Os proponemos un código
de ejemplo, pero os aconsejamos que intentéis crear uno vosotros mismos.

// Calculadora.cs
using System;
namespace Calculo
{
public class Calculadora
{
public double Suma(double izq, double dch)
{

return izq+dch;

}

}
}
}

public double Producto(double izq, double dch)
{

return izq*dch;

Para usar este código vamos a construir un programa principal que hará llamadas a
dicha clase. Un ejemplo sería:

Curso de Middleware. Práctica 1.

2 de 14

// Program.cs
using System;
using Calculo;

namespace practica1
{
public class Program
{
public static void Main(string[] args)
{

Console.WriteLine("Esto es una prueba");

Calculadora calc = new Calculadora();

Console.WriteLine("Suma 5+3=" + calc.Suma(5, 3));
Console.WriteLine("Producto 5*3=" + calc.Producto(5,


3));

Console.WriteLine("Pulsa enter para terminar");
Console.ReadLine();
}
}
}

Editar y compilar estos programas es relativamente fácil si utilizamos Visual Studio,
basta crear el proyecto correspondiente, añadir los ficheros de código y compilar.
Veamos cómo crear este programa.

El primer paso será crear un proyecto desde Visual Studio. En nuestro ejemplo, hemos
elegido una aplicación de consola y le hemos puesto el nombre de “practica1”:

Curso de Middleware. Práctica 1.

3 de 14

Al terminar deberíamos tener algo similar a:

A continuación, añadimos la clase Calculadora:

Curso de Middleware. Práctica 1.

4 de 14

Tendríamos que ver algo similar a:

y añadimos el código anterior:

Curso de Middleware. Práctica 1.

5 de 14

Ahora, añadimos el código del programa principal:



Si pulsamos sobre el botón de ejecutar deberíamos ver lo siguiente:

Curso de Middleware. Práctica 1.

6 de 14

Cuando veas este símbolo, nos gustaría llamar tu atención sobre
algún aspecto de la práctica. Es un buen momento para que tu
profesor os cuente conceptos de teoría. No avances en la
práctica hasta asegurarte que has entendido correctamente
los objetivos de la misma!!!!.

En este punto, queremos llamar la atención principalmente sobre conceptos
de programación tradicional que serán relevantes cuando hagamos
aplicaciones distribuidas. Incluso en un ejemplo tan simple como en el
anterior, podemos encontrar dudas. En concreto, nos gustaría comentar los
siguientes puntos:

•

• Conoces y puedes explicar las palabras reservadas del código, en
particular conoces la diferencia entre paquete (o namespace) y clase.
¿Sabes lo que significa la cláusula “using” (es el equivalente de
“import” de java)?
Entiendes la diferencia entre paquete y librería (tanto estática como
dinámica).
¿Sabrías hacer el mismo ejemplo sin necesidad de separar la clase del
programa principal? ¿Tendría sentido? ¿Puedes explicar alguna
ventaja o inconveniente de hacer de una forma u otra?
Puedes explicar la diferencia de paso de parámetros por valor y por
referencia.

•

•

• Cuando una clase se encuentra dentro de un namespace a uno o varios
niveles, ¿Sabes cómo se nombra?. ¿Entiendes la diferencia entre
“Calculo.Calculadora” y “Calculadora”?

Curso de Middleware. Práctica 1.

7 de 14

•

• C# no dispone de un operador o instrucción para la destrucción o
liberación de objectos (p.e. “delete” o “free”). ¿Entiendes las
implicaciones de este concepto? Puedes decir cuando vive un objeto y
cuando muere en el ejemplo anterior. ¿Qué es un recolector de
memoria (“garbage collector”)?.
¿Sabes la diferencia entre un miembro de clase y un miembro de
instancia?. ¿Cómo los distingues?
¿Sabes la diferencia entre ámbito de una variable y vida de una
instancia? ¿Es lo mismo? ¿Tenemos que preocuparnos de ello?
¿Dónde se almacenan la variable “calc” del programa principal?. ¿En
la pila (stack)? ¿En el montón (heap)? ¿Y los argumentos de los
métodos que tenemos en la calculadora?
¿Sabrías decir si alguna de las preguntas anteriores te parecen
importantes para los sistemas distribuidos? ¿Cuáles? Intenta razonar tu
respuesta.

•

•

•

Curso de Middleware. Práctica 1.

8 de 14

Ejercicios adicionales

Sobre el código anterior, vamos a realizar algunos cambios que nos ayuden a
comprender otros conceptos relevantes.
En nuestro primer ejemplo nos harían falta otras operaciones tales como dividir o
restar. Lo dejamos para que lo hagáis vosotros mismos como ejercicio. Por
ejemplo, añade código similar a:

public double Resta(double izq, double dch)
{

return izq - dch;

}

Otra mejora que necesitaremos en breve es disponer de trazas. Os recomiendo que
insertéis alguna traza en las funciones de la clase calculadora; de esta forma
podremos observar dónde se está ejecutando el objeto cuando pasemos al modelo
distribuido. Como ejemplo, te ofrecemos el siguiente fragmento de código:

public double Resta(double izq, double dch)
{

Console.WriteLine(“Estoy en el método Resta”);
return izq - dch;

}

Otro aspecto muy necesario en breve es la generación de una librería que tenga la
calculadora. Vamos a separar el código de la calculadora y del programa principal.
Decimos que ésto será necesario ya que cuando pasemos al modelo distribuido, la
lógica de la calculadora estará en el servidor, mientras que nuestro programa
principal se convertirá en el cliente. Os contamos paso a paso cómo hacer este
cambio. Primero debemos añadir un nuevo proyecto a la solución. Este nuevo
proyecto debe ser de tipo librería. La siguiente pantalla representa este paso.



Curso de Middleware. Práctica 1.

9 de 14

Hemos llamado a nuestro proyecto Calculo. Tras la creación de este proyecto lo
que veremos en el Visual Studio será algo similar a:

Observa que se nos ha creado una clase por defecto en el proyecto (llamada
“Class1.cs”). Podemos borrarla y en su lugar vamos a poner la clase calculadora
que teníamos anteriormente. Es suficiente con arrastrar el fichero “Calculadora.cs”.
El resultado final debería ser lo siguiente:

Curso de Middleware. Práctica 1.

10 de 14

Si ahora compilamos, veremos que se generan errores de compilación. Antes de
continuar, os animamos a que lo compruebe. El problema surge debido a que el
proyecto practica1 no sabe localizar la clase Calculadora. Por ello es necesario
incluir una referencia al proyecto que contiene ese código. Esta acción se realiza
pulsando con el botón derecho encima del proyecto “practica1”. Elegimos añadir
referencia.

Y elegimos el proyecto que contiene la librería:

Curso de Middleware. Práctica 1.

11 de 14

Ahora debería compilar y ejecutar sin problema.
Os animamos a que probéis a seguir probando las diferentes opciones que nos
ofrece el entorno de trabajo. Un aspecto interesante para probar es la depuración.
Intentad depurar y seguir paso a paso la ejecución del programa.

Es un buen momento para que tu profesor os cuente
conceptos de teoría.
No avances en la práctica hasta
asegurarte que has entendido correctamente los objetivos de
la misma!!!!.

Hemos añadido algunos conceptos nuevos que debemos meditar. Por favor,
intenta explicar los siguientes puntos:

•

•

En nuestro ejemplo, tenemos una librería llamada “Calculo.dll” y un
ejecutable “practica1.exe”. ¿Entiendes la diferencia?
¿Tiene sentido separar el código en dos assemblies (librería y
ejecutable)? ¿Puedes explicar alguna ventaja o inconveniente de hacer
de una forma u otra?

• Cuando hemos separado el código de la calculadora para hacer una
librería, ¿Ha sido necesario cambiar el nombre del namespace?
¿Hemos modificado la sentencia que hacía “using”? ¿Tiene sentido
hacer esos cambios cuando construimos una librería?
¿Para qué sirve añadir una referencia al proyecto? ¿Ha sido necesario
añadir otra referencia a la inversa? ¿Qué pasaría? ¿Tiene sentido?
En un programa distribuido ¿es importante dividir la funcionalidad en
varias librerías? ¿No complica la programación innecesariamente?

•

•

Curso de Middleware. Práctica 1.

12 de 14

Resumen
A lo largo de esta práctica hemos aprendido a construir nuestra primera aplicación en
C#. Por ahora, es una aplicación local, pero nos ha permitido una primera toma de
contacto con C# y con Visual Studio. Este primer ejemplo nos ha permitido repasar
conceptos de programación a los que tendremos que replantear cuando veamos
sistemas distribuidos.

Curso de Middleware. Práctica 1.

13 de 14

Conceptos introducidos
En esta práctica hemos introducido/repasado los siguientes conceptos:

• Aplicación local
• Clase
•
• Métodos de instancia y de clase
• Namespace
•
•
• Máquina virtual
• Recolector de basura
•
• Constructor

Tipo de datos

Instancia

Ejecutable y Librería
Paso de parámetros por valor y por referencia

Curso de Middleware. Práctica 1.

14 de 14