Introducción a la Programación en Microsoft Visual Studio C# 2010 · 2014. 2. 7. ·...

Introducción a la Programación en Microsoft Visual Studio C# 2010

Elaborado por: Jesús Fernando Sierra Pastrana

Introducción a la Programación

1. Introducción a la plataforma.

.NET Framework

Primero debemos entender que es un Framework, un Framework es una palabra

utiliza para definir un conjunto estandarizado de conceptos, prácticas y criterios para enfocar un

tipo de problemática particular que sirve como referencia, para enfrentar y resolver nuevos

problemas de índole similar.

Extendiendo esto al ámbito del desarrollo de Software es una estructura conceptual y tecnológica

de soporte definido, normalmente con artefactos o módulos de software concretos, con base a la

cual otro proyecto de software puede ser más fácilmente organizado y desarrollado.

Típicamente, puede incluir soporte de programas, bibliotecas, y un lenguaje interpretado, entre

otras herramientas, para así ayudar a desarrollar y unir los diferentes componentes de un

proyecto.

Una vez entendido lo que es un framework veremos que .NET es u

hace un énfasis en la transparencia de redes, con independencia de plataforma de hardware y que

permita un rápido desarrollo de aplicaciones.

Además es una infraestructura sobre la que se reúne todo un conjunto de lenguajes y

que simplifican enormemente el desarrollo de aplicaciones. Mediante esta herramienta se ofrece

un entorno de ejecución altamente distribuido, que permite crear aplicaciones robustas y

escalables.

Al ser un Framework de desarrollo de Software con

desarrollo, contando con muchas herramientas auxiliares al desarrollo, en cada versión liberada se

han ido agregando nuevas secciones de estas librerías y herramientas, hasta llegar al momento a

la versión 4.0. Dentro de todo este conjunto de recursos se pueden

divisiones que componen a todo el entorno




Introducción a la plataforma.

debemos entender que es un Framework, un Framework es una palabra



mbito del desarrollo de Software es una estructura conceptual y tecnológica



picamente, puede incluir soporte de programas, bibliotecas, y un lenguaje interpretado, entre


Una vez entendido lo que es un framework veremos que .NET es un framework de Microsoft que


permita un rápido desarrollo de aplicaciones.

Además es una infraestructura sobre la que se reúne todo un conjunto de lenguajes y



Al ser un Framework de desarrollo de Software contiene elementos tales como librerías de



o de todo este conjunto de recursos se pueden representar en

que componen a todo el entorno:

Julio 2012

1

en Microsoft Visual Studio C# 2010

debemos entender que es un Framework, un Framework es una palabra inglesa que se



mbito del desarrollo de Software es una estructura conceptual y tecnológica



picamente, puede incluir soporte de programas, bibliotecas, y un lenguaje interpretado, entre


n framework de Microsoft que


Además es una infraestructura sobre la que se reúne todo un conjunto de lenguajes y servicios



tiene elementos tales como librerías de



en tres grandes



• Lenguajes de compilación

• Biblioteca de clases de .Net

• CLR (Common Language Runtime)

Todos estos componentes son abarcados por la IDE de d

Studio en su versión más reciente

versión de .NET Framework, que estarán listas junto con el lanzamiento del nuevo Sistema

Operativo Windows 8.

Common Language Runtime (CLR)

El CLR es el verdadero núcleo del framework de .NET, entorno de ejecución en el que se cargan las

aplicaciones desarrolladas en los distintos lenguajes, ampliando el conjunto de servicios del

sistema operativo (W2k y W2003). Permite

por la plataforma .Net, como C++, Visual Basic, C#, entre otros.



Lenguajes de compilación

Biblioteca de clases de .Net

CLR (Common Language Runtime)

Todos estos componentes son abarcados por la IDE de desarrollo de Microsoft llamada

en su versión más reciente 2010, y estando en desarrollo la versión 2012 junto con la nueva


Language Runtime (CLR)



sistema operativo (W2k y W2003). Permite integrar proyectos en distintos lenguajes soportados

por la plataforma .Net, como C++, Visual Basic, C#, entre otros.

Julio 2012

2

esarrollo de Microsoft llamada Visual

, y estando en desarrollo la versión 2012 junto con la nueva




integrar proyectos en distintos lenguajes soportados

Introducción a la Programación en Microsoft Visual Studio C# 2010 Julio 2012

Elaborado por: Jesús Fernando Sierra Pastrana 3

Además el CLR cuenta con un recolector de basura (Garbage Collector), similar al que tiene Java

que funciona muy parecido, ya que se encarga de eliminar o liberar la Memoria de objetos

obsoletos o sin uso de forma automática o llamándolo para liberar un objeto en específico que

nosotros le indiquemos.

Una de las características más llamativas es el Motor de depuración que permite llevar un

seguimiento de la ejecución del proyecto sin importar el lenguaje que sea así como la intercalación

de estos, permitiendo tener una mejor productividad en el desarrollo y la detección de puntos

críticos o bugs.

Microsoft Intermediate Language (MSIL)

La herramienta de desarrollo compila el código fuente de cualquiera de los lenguajes soportados

por .NET en un código intermedio, el CIL (Common Intermediate Language) antes conocido como

MSIL (Microsoft Intermediate Language), similar al BYTECODE de Java. Para generarlo, el

compilador se basa en la especificación CLS (Common Language Specification) que determina las

reglas necesarias para crear el código MSIL compatible con el CLR.



Para ejecutarse se necesita un segundo paso, un compilador JIT (Just

código máquina real que se ejecuta en la plataforma del cliente. De esta forma se consigue con

.NET independencia de la plataforma de hardware. La compilación JIT la realiza el CLR a medida

que el programa invoca métodos. El códig

del ordenador, siendo recompilado de nuevo sólo en el caso de producirse algún cambio en el

código fuente.

De esta forma tendremos programas mucho más eficientes ya que al momento de ejecutarse por

primera vez o en su instalación, se generara código máquina eficiente y nativo con el que el

rendimiento se ve mejorado y optimizado.

NameSpaces

Cuando se está programando una aplicación muchas veces se necesitan realizar acciones como

manipulación de archivos, acceso a datos, conocer el estado del sistema, implementar seguridad,

etc. El Framework organiza toda la funcionalidad del sistema operativo en un espacio de nombres

(NameSpaces) jerárquico de forma que a la hora de programar resulta bastante sencillo en

lo que se necesita.

Para ello, el Framework posee un sistema de tipos universal, denominado Common Type System

(CTS). Este sistema permite que el programador pueda interactuar los tipos que se incluyen en el

propio Framework (biblioteca de clases

forma se aprovechan las ventajas propias de la programación orientada a objetos, como la

herencia de clases predefinidas para crear nuevas clases, o el polimorfismo de clases para

modificar o ampliar funcionalidades de clases ya existentes.



Para ejecutarse se necesita un segundo paso, un compilador JIT (Just-In-Time) es el que genera el



que el programa invoca métodos. El código ejecutable obtenido se almacena en la memoria caché



era vez o en su instalación, se generara código máquina eficiente y nativo con el que el

rendimiento se ve mejorado y optimizado.


, acceso a datos, conocer el estado del sistema, implementar seguridad,


(NameSpaces) jerárquico de forma que a la hora de programar resulta bastante sencillo en



propio Framework (biblioteca de clases de .Net) con los creados por él mismo (clases). De esta



funcionalidades de clases ya existentes.

Julio 2012

4

Time) es el que genera el



o ejecutable obtenido se almacena en la memoria caché



era vez o en su instalación, se generara código máquina eficiente y nativo con el que el


, acceso a datos, conocer el estado del sistema, implementar seguridad,


(NameSpaces) jerárquico de forma que a la hora de programar resulta bastante sencillo encontrar



de .Net) con los creados por él mismo (clases). De esta





La biblioteca de clases de .Net Framework incluye, entre otros, tres componentes clave:

• ASP.NET para construir aplicaciones y servicios Web.

• Windows Forms para desarrollar interfaces de usuario.

• ADO.NET para conectar las aplicaciones a bases de datos.

La forma de organizar la biblioteca de clases de .Net dentro del código es a través de los espacios

de nombres (namespaces), donde cada clase está organizada en espacios de nombres según su

funcionalidad. Por ejemplo, para manejar ficheros se utiliza el espacio de nombres System.IO y si

lo que se quiere es obtener información de una fuente de datos se utilizará el espacio de nombres

System.Data.

La principal ventaja de los espacios de nombres de .Net es que de esta forma se tiene toda la

biblioteca de clases de .Net centralizada bajo el mismo espacio de nombres (System). Además,

desde cualquier lenguaje se usa la misma sintaxis de invocación, ya que a todos los lenguajes se

aplica la misma biblioteca de clases.



Descripción del entorno de desarrollo IDE

Empezaremos a conocer la IDE Visual Studio 2010, iniciándola y viendo que tendremos una

pantalla principal en la que nos dará opciones de inicio rápido, así como poder ver los proyectos

recientemente usados si es que los hubiera.

Explorador de soluciones

Veremos que al tener un proyecto abierto podremos ver sus características y componentes en el

lado superior derecho.



Panel de propiedades

El panel de propiedades es una parte fundamental de Visual Studio, ya que desde aquí podemos

controlar las características de los elementos del Framework que vayamos agregando a nuestro

programa.

Otros paneles del IDE Visual Studio

Veremos que Visual Studio tiene una multitud de diferentes paneles y barras, todos útiles

dependiendo del tipo de aplicación que vayamos a desarrollar.



2. Desarrollo del primer Programa.

¿Qué es un proyecto?

Un proyecto es un grupo de archivos de diferentes tipos que trabajan en conjunto para realizar

una tarea específica o brindar una solución a un problema. Visual Studio trae por defecto

instaladas diferentes platillas o tipos de Proyectos listos para ser utilizados.

Tipos de proyectos

Algunos de los tipos destacados de proyectos con los que cuenta Visual Studio son:

• Aplicación de Windows Forms

• Aplicación de Consola

• Aplicación Web ASP.NET

• Aplicación de Crystal Reports

• Aplicación de Silverlight Cada uno de estos diferentes tipos de proyecto cuenta con diferentes características, así como

diferentes tipos de recursos que nos ofrece el framework, como por ejemplo una aplicación de

Windows Forms nos ofrece el desarrollo de una aplicación con interfaz gráfica de usuario nativa de

los sistemas Windows, así como una aplicación en consola no tendrá está característica disponible.

Crear un nuevo proyecto

Para crear nuestro primer proyecto dentro de Visual Studio daremos clic al Menú Archivo ->

Nuevo -> Proyecto o presionando las teclas Ctrl + Shift + N.

Seleccionaremos Aplicación de Consola, le daremos el nombre de “Primer Proyecto” y pondremos

el proyecto en la ubicación que deseemos.



El entorno de trabajo

El entorno de trabajo estará conformado principalmente por la ventada de edición de texto, el

explorador de soluciones, el panel de propiedades y el panel de salida/Lista de errores.

Un vistazo rápido al código generado automáticamente

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Primer_Proyecto {

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

}

} }

Aquí vemos que hacemos referencia a librerías del framework de .NET mediante la palabra

reservada using, esto se hace para acortar las llamadas a las clases, objetos y métodos, pudiendo

de esta forma solo hacer la llamada a estos solo escribiendo el nombre directamente sin tener que

escribir la ruta jerárquica que parte desde System hasta el elemento deseado. Su equivalente en

java de esta instrucción es el import que realiza una acción similar a la mencionada anteriormente.



Después veremos que usamos otra palabra reservada: namespace seguida del nombre de nuestro

proyecto, esto es porque estamos agregando al namespace nuestro proyecto, junto con todos las

clases y métodos, para poder hacer uso de estos en otros códigos o clases del mismo proyecto.

Algunos aspectos importantes del lenguaje

Podemos ver que hay varios pares de llaves en el código generado, estas llaves se utilizan dentro

de C# para indicar el alcance o Scope de bloques de código, como por ejemplo podemos ver que

en el namespace abrimos una llave y la llave de cerrado se encuentra hasta al final, esto nos indica

que lo que alcanza a ver o englobar el namespace que es todo el código, así como vemos que

tenemos una clase que identificamos con la palabra reservada class seguida del nombre de

nuestra clase: Program y de igual forma tenemos una llave de apertura y otra de cerrado más

abajo que indican el inicio y el final de la clase.

Dentro de nuestra clase creada automáticamente tendremos un método, pero no cualquier

método, este método es el Main, este método es el que se ejecuta siempre que se inicia un

programa, por lo tanto es OBLIGATORIO colocarlo dentro de nuestro código pero solo una vez ya

que este método debe de ser único en todo nuestro proyecto, así como debe de guardar una

sintaxis de esta forma:

static void Main (string[] args){…}

Siendo el string[] args totalmente opcional, pudiendo dejar sin argumentos el método Main.

Nuestros programas se ejecutarán desde el método Main y todo el código que se encuentre

dentro del bloque contenido entre las llaves será el que se ejecutará.

Escribiendo nuestra primera sentencia

Para escribir nuestra primera sentencia recurriremos al primer ejemplo en todos los cursos de

programación poniendo un “Hola mundo”, en la pantalla de consola, para esto debemos de

colocar la siguiente línea dentro del método Main:

System.Console.WriteLine("Hola mundo!!!");

La primer cosa que debemos tener en cuenta es que toda sentencia de C# se termina con un “;”,

con algunas excepciones que veremos más adelante. Lo segundo es que la frase Hola mundo!!! Se

encuentra contenida dentro de comillas esto es para indicarle al compilador que eso es una

cadena de caracteres. Por último vemos que el método WriteLine debe de ser precedido por toda

la ruta de acceso desde System dado que no hemos colocado a System.Console dentro de nuestro

proyecto mediante la sentencia using.

Aquí podemos ver que partimos de nuestro namespace origen o raíz System, procedido del

operador “.” Que nos permite acceder a los elementos y/o propiedades de los elementos del

lenguaje, en este caso le indicamos que estamos dirigiéndonos a un objeto llamado Console, que

no es otro que la consola de nuestro Sistema Operativo; Y solo nos resta indicarle que queremos



invocar al método WriteLine, que lo que hace es escribir una línea en la consola con lo que

nosotros le dijimos que mostrara mediante el argumento de la función.

Ejecución del programa

Hemos escrito lo que queríamos para nuestro primer programa, ahora necesitamos verlo como se

ejecuta, para esto tenemos tres formas:

1. Seleccionando el menú Depurar y dar clic en la opción Iniciar Depuración. 2. Presionar el botón con en las barras de menú.

3. Presionando la tecla F5.

Ejecutamos y… no sucedió nada!

Realmente si sucedió solo que demasiado rápido para verlo, lo que ocurrió es que hizo justamente

lo que le pedimos que hiciera: Iniciara el programa en consola, para esto se lanza

automáticamente la consola de Windows, después escribimos una línea y después al no haber más

instrucciones y llegar al final del bloque simplemente el programa lo entiende como que debe de

finalizarse el programa y eso hace, solo que esto ocurre demasiado rápido para verlo.

Para solucionar este problema, solo deberemos agregar dos líneas más al código:

System.Console.WriteLine("Presione una tecla para continuar...");

System.Console.ReadKey();



La primera línea ya sabemos qué hace, mientras que la segunda es una desconocida total, lo que

hace como lo dice su nombre es Leer una tecla, pero esa tecla la lee por medio de la entrada

estándar, que no es otro que el Teclado.

Siendo así nos disponemos a ejecutar el programa y veremos algo similar a esto:

Y al presionar cualquier tecla veremos que finaliza el programa sin ningún problema.

3. Tipos de Datos y Trabajo con Variables.

Tipos de datos básicos

Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en la escritura de

aplicaciones que en C# se ha incluido una sintaxis especial para tratarlos. Por ejemplo, para

representar números enteros de 32 bits con signo se utiliza el tipo de dato System.Int32 definido

en la BCL, aunque a la hora de crear un objeto a de este tipo que represente el valor 2 se usa la

siguiente sintaxis:

System.Int32 a = 2;

Como se ve, no se utiliza el operador new para crear objeto System.Int32, sino que directamente

se indica el literal que representa el valor a crear, con lo que la sintaxis necesaria para crear entero

de este tipo se reduce considerablemente. Es más, dado lo frecuente que es el uso de este tipo

también se ha predefinido en C# el alias int para el mismo, por lo que la definición de variable

anterior queda así de compacta:



int a = 2;

System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de nombres System se

han incluido todos estos:

Tipo Descripción Bits Rango de valores Alias

SByte Bytes con signo 8 [-128, 127] sbyte

Byte Bytes sin signo 8 [0, 255] byte

Int16 Enteros cortos con signo 16 [-32.768, 32.767] short

UInt16 Enteros cortos sin signo 16 [0, 65.535] ushort

Int32 Enteros normales 32 [-2.147.483.648, 2.147.483.647]

int

UInt32 Enteros normales sin signo 32 [0, 4.294.967.295] uint

Int64 Enteros largos 64

[-9.223.372.036.854.775.808,

9.223.372.036.854.775.807]

long

UInt64 Enteros largos sin signo 64 [0-18.446.744.073.709.551.615]

ulong

Single Reales con 7 dígitos de precisión 32 [1,5×10-45 - 3,4×1038] float

Double Reales de 15-16 dígitos de precisión

64 [5,0×10-324 - 1,7×10308] double

Decimal Reales de 28-29 dígitos de precisión

128 [1,0×10-28 - 7,9×1028] decimal

Boolean Valores lógicos 32 true, false bool

Char Caracteres Unicode 16 [‘\u0000’, ‘\uFFFF’] char

String Cadenas de caracteres Variable El permitido por la memoria string

Object Cualquier objeto Variable Cualquier objeto object

Las variables en C#

Una variable puede verse simplemente como un hueco en el que se puede almacenar un objeto de

un determinado tipo al que se le da un cierto nombre.

Declaración de una variable

Para poderla utilizar sólo hay que definirla indicando cuál era su nombre y cuál será el tipo de

datos que podrá almacenar, lo que se hace siguiendo la siguiente sintaxis:

<tipoVariable> <nombreVariable>;

Después de declarar una variable podemos asignarle un valor que corresponda con el tipo de dato

que declaramos en la variable.

int y;

y = 20;



Sin embargo, C# también proporciona una sintaxis más sencilla con la que podremos asignar un

valor a una variable en el mismo momento que se define. Para ello se la ha de definir usando esta

otra notación:

<tipoVariable> <nombreVariable> = <valorInicial>;

Tomando el ejemplo anterior aplicando el mismo valor a la variable pero con la nueva sintaxis:

int y = 20;

Alcance de las variables

El alcance de las variables, va directamente ligado con el Scope de métodos, clases, controles de

flujo y bucles de repetición que se verán más adelante, si una variable es declarada dentro de un

bloque, esta variable solo podrá ser utilizable/visible dentro de este bloque, si salimos de este

bloque e intentamos utilizar esta variable nos marcara un error de compilación.

Literales

Un literal es la representación explícita de los valores que pueden tomar los tipos básicos del

lenguaje. A continuación se explica cuál es la sintaxis con que se escriben los literales en C#

desglosándolos según el tipo de valores que representan:

• Literales enteros: Un número entero se puede representar en C# tanto en formato decimal como hexadecimal. En el primer caso basta escribir los dígitos decimales (0-9) del número unos tras otros, mientras que en el segundo hay que preceder los dígitos hexadecimales (0-9, a-f, A-F) con el prefijo 0x. En ambos casos es posible preceder el número de los operadores + ó – para indicar si es positivo o negativo, aunque si no se pone nada se considerará que es positivo. Ejemplos de literales enteros son 0, 5, +15, -23, 0x1A, -0x1a, etc.

• Literales reales: Los números reales se escriben de forma similar a los enteros, aunque sólo se pueden escribir en forma decimal y para separar la parte entera de la real usan el tradicional punto decimal. También es posible representar los reales en formato científico, usándose para indicar el exponente los caracteres e ó E. Ejemplos de literales reales son 0.0, 5.1, -5.1, +15.21, 3.02e10, 2.02e-2, 98.8E+1, etc.

• Literales lógicos: Los únicos literales lógicos válidos son true y false, que respectivamente representan los valores lógicos cierto y falso.

• Literales de carácter: Prácticamente cualquier carácter se puede representar encerrándolo entre comillas simples. Por ejemplo, 'a' (letra a), ' ' (carácter de espacio), '?' (símbolo de interrogación), etc. Las únicas excepciones a esto son los caracteres que se muestran en la Tabla, que han de representarse con secuencias de escape que indiquen su valor como código Unicode o mediante un formato especial tal y como se indica a continuación:

Carácter Código de escape Unicode Código de escape

especial

Comilla simple \u0027 \'

Comilla doble \u0022 \"



Carácter nulo \u0000 \0

Alarma \u0007 \a

Retroceso \u0008 \b

Salto de página \u000C \f

Nueva línea \u000A \n

Retorno de carro \u000D \r

Tabulación horizontal \u0009 \t

Tabulación vertical \u000B \v

Barra invertida \u005C \\

Operadores y expresiones

Un operador en C# es un símbolo formado por uno o más caracteres que permite realizar una

determinada operación entre uno o más datos y produce un resultado.

A continuación se describen cuáles son los operadores incluidos en el lenguaje clasificados según

el tipo de operaciones que permiten realizar:

• Operaciones aritméticas: Los operadores aritméticos incluidos en C# son los típicos de suma (+), resta (-), producto (*), división (/) y módulo (%). También se incluyen operadores de incremento y decremento (++ y --).

• Operaciones lógicas: Se incluyen operadores que permiten realizar las operaciones lógicas típicas: “and” (&& y &), “or” (|| y |), “not” (!) y “xor” (^).

• Operaciones relacionales: Se han incluido los tradicionales operadores de igualdad (==), desigualdad (!=), “mayor que” (>), “menor que” (<), “mayor o igual que” (>=) y “menor o igual que” (<=).

• Operaciones de manipulación de bits: Se han incluido operadores que permiten realizar a nivel de bits operaciones “and” (&), “or” (|), “not” (~), “xor” (^), desplazamiento a izquierda (<<) y desplazamiento a derecha (>>) El operador << desplaza a izquierda rellenando con ceros, mientras que el tipo de relleno realizado por >> depende del tipo de dato sobre el que se aplica: si es un dato con signo mantiene el signo, y en caso contrario rellena con ceros.

• Operaciones de asignación: Para realizar asignaciones se usa en C# el operador =, operador que además de realizar la asignación que se le solicita devuelve el valor asignado. Por ejemplo, la expresión a = b asigna a la variable a el valor de la variable b y devuelve dicho valor, mientras que la expresión c = a = b asigna a las variables c y a el valor de b (el operador = es asociativo por la derecha).

Por otra parte una expresión es considerada así cuando cuenta con uno o más operadores y operandos. Los operandos pueden ser literales, variables o contantes.

X = 20 * s + 25;

Constantes

Una constante es una variable pero que una vez declarada e inicializada no se puede modificar su

valor a diferencia de una variable normal. Las constantes se definen como variables normales pero



precediendo el nombre de su tipo del modificador const y dándoles siempre un valor inicial al

declararlas.

const int a = 123;

Arrays: Introducción

Un Array es un arreglo o colección de datos consecutivos guardados en memoria, siendo todos

estos de un mismo tipo de dato, y pudiendo ser lineales que comúnmente son llamados

“vectores”, así como los puede haber multidimensionales, siendo los más comunes los de 2

dimensiones denominados por muchos como “tablas”.

La forma de declarar un array es muy parecida a la de una variable, solo con la diferencia que

después del tipo de dato debemos colocar corchetes ([ ]) para indicar que estamos declarando un

array.

int[] tabla;

También podemos al igual que con una variable inicializar el array en su misma declaración o darle

valor más adelante.

int[] tabla = new int[100];

En este ejemplo estamos declarando un arreglo con capacidad de 100 elementos enteros, cabe

destacar que un array no es redimensionable, una vez que se ha declarado su tamaño este se

mantendrá fijo para esa instancia del objeto.

Además de declarar y crear en memoria el array, también podemos darle valores a los espacios de

memoria explícitamente de varias formas:

int[] tabla = new int[] {5,1,4,0};

int[] tabla = {5,1,4,0};

Trabajando con arrays

Lo primero que se debe de tener en cuanta al trabajar con arrays es el como accesar a los

miembros de este, esto se hace escribiendo en nombre del array procedido de corchetes y entre

estos el índex o índice donde se encuentra alojado el valor que nos interesa.

tabla[2]= 5;

Una vez que sabemos que podemos obtener o modificar un valor almacenado dentro de un array,

solo resta saber cómo se manejan estos índices, primero que nada nosotros definimos un tamaño

especifico de datos que puede almacenar, este tamaño es el que nos dará el rango de índices que

puede manejar, siempre el primer índice es el 0 y el último será el tamaño que definimos -1, dado

que la cuenta inicia en 0, esto es algo que se debe de tener siempre en cuenta ya que provoca

muchos dolores de cabeza mientras se desarrollan aplicaciones que utilicen arrays.



4. Estructuras de Control.

Sentencias de control: ¿Para qué sirven?

Hasta este punto somos capaces de realizar programas sencillos que puedan realizar operaciones

aritméticas y de otros tipos, y nos muestren su resultado en pantalla, pero para poder realizar

aplicaciones verdaderamente potentes nos debemos de fijar en la parte de que los programas

necesitaran poder tomar decisiones con respecto a la información ingresada al sistema así como

poder cambiar su comportamiento con respecto a estas decisiones, para este tipo de operaciones

son las Estructuras de Control de Flujo

Condiciones. Operaciones de comparación

Para poder hacer uso de estructuras de control necesitaremos una condición que cumplir o una

decisión que tomar basada en información contenida en variables y/o literales.

Para esto tenemos los operadores relacionales que al realizar una comparación nos devuelven

valores booleanos (true o false). Entre estos se encuentran el <, <=, ==, ¡=, => y >, todos estos

operan de forma similar poniendo de ambos extremos un elemento a comparar, recalcando que

para poder realizar una comparación deben de ser de mismo tipo los operandos, en caso contrario

y de ser posible el compilador hará el casting correspondiente para poder realizar la operación.

Variable1 >= Variable2

Variable1 ¡= 7

Condiciones complejas. Operadores booleanos

Para poder hacer más potentes las comparaciones podemos valernos de los operadores

booleanos, para de esta forma poder combinar más de una sentencia de comparación, así

logrando tomar decisiones más complejas, pero a su vez más útiles para lograr mejores resultados.

Estos operadores son AND, OR y XOR, y estás trabajan de acuerdo a su tabla de verdad, siendo así

que para poder utilizarlos necesitamos que los operandos sean de un tipo booleano, o en un caso

más específico de ser una sentencia de comparación retorne un valor booleano como es el caso de

los operadores relacionales.

(Variable1 >= Variable2) || (5 == 3)

(Variable1 ¡= Variable2) && (5 < 3)

Sentencia If

La sentencia más sencilla pero no por menos útil es el If, que sirve para indicar que se ejecutará un

bloque de código en caso de cumplirse una condición, su sintaxis es:



if (<condición>){

<instruccionesIf>}

En caso de que la condición nos diera como resultado true pasará a ejecutar el código contenido

entre llaves, en caso contrario simplemente ignorará el bloque y seguirá con su ejecución normal.

if (numero >= 0){

System.Console.WriteLine(“Es positivo”);

}

System.Console.WriteLine(“Es negativo”);

En este ejemplo si número tuviera un valor mayor a 0 la condición nos lanzaría un true como

resultado y por tanto mostrándonos el mensaje de que el número es positivo y en caso contrario

que es negativo el número.

Sentencias If más complejas

¿Pero qué pasa si necesitamos además de lo visto, realizar alguna operación en caso de no

cumplirse la condición antes de seguir con las demás instrucciones?

Para esto se complementa el If con el Else, dando como resultado una estructura más completa

pero sin aumentar mucho su complejidad, solo basta con agregar la sentencia else después del

bloque de instrucciones del If, y abriendo la llave de bloque y colocando las operaciones que

necesitemos realizar dentro y cerrando el bloque con la llave.

if (numero >= 0){

System.Console.WriteLine(“Es positivo”);

}

else{

numero *= -1;

System.Console.WriteLine(“Era negativo”);

}

En este ejemplo que es una extensión de la anterior, mediante el else hemos podido detectar que

el número ingresado es un número negativo y lo hemos tratado para hacerlo positivo, y de esta

forma al seguir con la ejecución estamos asegurando que el número que recibirán las expresiones

siguientes serán siempre positivos.

Sentencia switch

Un caso común es cuando no podemos manejar una condición simple ni compleja ya que

esperamos diferentes valores, dependiendo del que se reciba se hará una acción diferente, esto

puede ser resuelto mediante la encadenación de varios ifs, pero esta solución provoca mucho

código y es fácil perderse en nuestro propio código y además puede acarrear problemas de lógica

muy difíciles de detectar, para esto existe la sentencia Switch.

switch (nombre){

case “Luis”:

System.Console.WriteLine(“Dueño”);

break;

case “Mario”:



System.Console.WriteLine(“Gerente”);

break;

default:

System.Console.WriteLine(“Empleado”);

break;

}

En el ejemplo podemos ver que podemos escoger entre 3 casos, el encontrarnos que el nombre es

el del Dueño, el del Gerente o el de un empleado, todo esto manejado por “casos”, no debemos

de olvidar terminar mediante la sentencia break que lo que hace es romper la ejecución del

bloque del switch, ya que de no colocarlo seguiría con el código que esta inmediatamente abajo,

provocando un comportamiento que no deseamos.

5. Estructuras de Repetición (Bucles).

Bucles: ¿Para qué sirven?

Los bucles tienen una gran utilidad dentro del desarrollo de aplicaciones de todo tipo ya que nos

ofrecen un mecanismo de repetición de sentencias o de un bloque de sentencias hasta que se

cumpla una condición de paro.

Sentencia for

La primera sentencia de este tipo es el denominado for, que cuenta con 4 elementos en su

sintaxis, la o las sentencias de inicialización, la condición de paro, la sentencia de modificación y el

conjunto de instrucciones que realizará.

for (<inicialización>; <condición>; <modificación>){

<instrucciones>

}

Sentencia for en acción

Un uso muy común que se le da a los for’s es para modificar valores de arrays sin mucha

complicación ya que por medio de la repetición constante de las instrucciones y manejando un

índice que se va modificando cada vuelta del ciclo, podemos ir accesando uno a uno a los

elementos del array.

for (int i = 0; i < array.Length; i++){

array[i] *= array[i];

}

En este caso podemos ver que el for se está encargando de elevar al cuadrado todos los elementos

pertenecientes al array, otro punto importante es el ver que utilizamos una variable entera

denominada i, esta variable solo es visible o accesible dentro del Scope del bloque for.

Sentencia foreach

La instrucción foreach es una variante del for pensada especialmente para compactar la escritura

de códigos donde se realice algún tratamiento a todos los elementos de una colección, que suele

un uso muy habitual de for en los lenguajes de programación que lo incluyen. La sintaxis que se

sigue a la hora de escribir esta instrucción foreach es:



foreach (<tipoElemento> <elemento> in <colección>){

<instrucciones>

}

El significado de esta instrucción es muy sencillo: se ejecutan <instrucciones> para cada uno de los

elementos de la <colección> indicada. <elemento> es una variable de sólo lectura de tipo

<tipoElemento> que almacenará en cada momento el elemento de la colección que se esté

procesando y que podrá ser accedida desde <instrucciones>.

Colecciones de datos y uso de foreach

Una matriz y el vector son simplemente unas de las muchas opciones para almacenar conjuntos de

datos utilizando C#. La opción que seleccione depende de varios factores, tales como la forma en

que se piensa manipular o tener acceso a los elementos. Por ejemplo, utilizar una lista suele ser

más rápido que utilizar una matriz si debe insertar elementos al principio o en medio de la

colección. Otros tipos de clases de colección incluyen mapa, árbol y pila.

System.Collections.Generic.List<string> sandwich = new System.Collections.Generic.List<string>(); sandwich.Add("jamón");

sandwich.Add("tomate"); sandwich.Insert(1, "lechuga"); foreach (string ingredient in sandwich){ System.Console.WriteLine(ingredient); }

En este código vemos que utilizamos una colección llamada List, que contendrá elementos de

tipos string, la Lista es una colección de tipo FIFO (First In First Out), además contamos con

métodos ya definidos para agregar elementos a la lista y otro que aquí se muestra que es el de

Insert, que lo que hace es ingresar el elemento en la posición que le digamos, desplazando a los

demás elementos.

En l aparte del foreach vemos que contiene todos los elementos de la sintaxis, y lo que hace es

mostrar los elementos en el orden que se encuentran en la lista de una forma sencilla y en pocas

líneas de código.

Sentencia while

La instrucción while permite ejecutar un bloque de instrucciones mientras se de una cierta

instrucción. Su sintaxis de uso es:

while (<condición>){

<instrucciones>

}

Su significado es el siguiente: Se evalúa la <condición> indicada, que ha de producir un valor

lógico. Si es cierta (valor lógico true) se ejecutan las <instrucciones> y se repite el proceso de

evaluación de <condición> y ejecución de <instrucciones> hasta que deje de serlo. Cuando sea

falsa (false) se pasará a ejecutar la instrucción siguiente al while. En realidad <instrucciones>

puede ser una única instrucción o un bloque de instrucciones.

while (actual < 21){



Console.WriteLine(actual);

actual++;

}

6. Programación Orientada a Objetos.

Clases y objetos: Introducción

C# es un lenguaje orientado a objetos puro, lo que significa que todo con lo que vamos a trabajar

en este lenguaje son objetos.

Un objeto es un agregado de datos y de métodos que permiten manipular dichos datos, y un

programa en C# no es más que un conjunto de objetos que interaccionan unos con otros a través

de sus métodos.

Una clase es la definición de las características concretas de un determinado tipo de objetos. Es

decir, de cuáles son los datos y los métodos de los que van a disponer todos los objetos de ese

tipo. Por esta razón, se suele decir que el tipo de dato de un objeto es la clase que define las

características del mismo.

En resumen un objeto es una instancia de una clase específica, así compartiendo características y

métodos de otros objetos pertenecientes a la misma clase.

Declaración de una clase

La sintaxis básica para definir una clase es la que a continuación se muestra:

class <nombreClase>{

<miembros>

}

El nombre de la clase puede ser cualquiera que deseemos, pero limitados por las mismas reglas

que se utilizan para dar nombres a variables.

class A{}

Propiedades o atributos de una clase

Una clase así declarada no dispondrá de ningún miembro a excepción de los implícitamente

definidos de manera común para todos los objetos que creemos en C#. Estos miembros los

veremos dentro de poco en este mismo tema bajo el epígrafe La clase primegina: System.Object.

Un campo, propiedad o atributo es un dato común a todos los objetos de una determinada clase.

Para definir cuáles son los campos de los que una clase dispone se usa la siguiente sintaxis dentro

de la zona señalada como <miembros> en la definición de la misma:

<tipoCampo> <nombreCampo>;



Los campos de un objeto son a su vez objetos, y en <tipoCampo> hemos de indicar cuál es el tipo

de dato del objeto que vamos a crear. Éste tipo puede corresponderse con cualquiera que los

predefinidos en la BCL o con cualquier otro que nosotros hayamos definido siguiendo la sintaxis

arriba mostrada. A continuación se muestra un ejemplo de definición de una clase de nombre

Persona que dispone de tres campos:

class Persona{

string Nombre;// Campo de cada objeto Persona que almacena su nombre

string Apellido;// Campo de cada objeto Persona que almacena su apellido

int Edad;// Campo de cada objeto Persona que almacena su edad

}

Según esta definición, todos los objetos de clase Persona incorporarán campos que almacenarán

cuál es el nombre de la persona que cada objeto representa y cuál es su edad.

Métodos de una clase

Un método es un conjunto de instrucciones a las que se les asocia un nombre de modo que si se

desea ejecutarlas basta referenciarlas a través de dicho nombre en vez de tener que escribirlas.

Dentro de estas instrucciones es posible acceder con total libertad a la información almacenada en

los campos pertenecientes a la clase dentro de la que el método se ha definido, por lo que como al

principio del tema se indicó, los métodos permiten manipular los datos almacenados en los

objetos.

La sintaxis que se usa en C# para definir los métodos es la siguiente:

<tipoDevuelto> <nombreMétodo> (<parametros>){

<instrucciones>

}

Todo método puede devolver un objeto como resultado de la ejecución de las instrucciones que lo

forman, y el tipo de dato al que pertenece este objeto es lo que se indica en <tipoDevuelto>. Si no

devuelve nada se indica void, y si devuelve algo es obligatorio finalizar la ejecución de sus

instrucciones con alguna instrucción return <objeto>; que indique qué objeto ha de devolverse.

Opcionalmente todo método puede recibir en cada llamada una lista de objetos a los que podrá

acceder durante la ejecución de sus instrucciones. En <parametros> se indica es cuáles son los

tipos de dato de estos objetos y cuál es el nombre con el que harán referencia las instrucciones del

método a cada uno de ellos. Aunque los objetos que puede recibir el método pueden ser

diferentes cada vez que se solicite su ejecución, siempre han de ser de los mismos tipos y han de

seguir el orden establecido en <parametros>.

Un ejemplo de cómo declarar un método de nombre Cumpleaños es la siguiente modificación de

la definición de la clase Persona usada antes como ejemplo:

class Persona{



int Edad; // Campo de cada objeto Persona que almacena su edad



void Cumple(int n){

Edad += n;

}

}

Utilización de las clases. Clases instanciadas y no

Para poder hacer uso de una clase, se hace mediante una instancia de esta que es conocida como

Objeto, esta se instancia o se crea en memoria para poder hacer uso de sus atributos y sus

métodos. Si no hiciéramos esto sus atributos y métodos que definimos no serán utilizables.

Constructores y destructores

Para poder instanciar objetos utilizaremos el operados new con la siguiente sintaxis:

new <nombreTipo>(<parametros>)

Este operador crea un nuevo objeto del tipo cuyo nombre se le indica y llama durante su proceso

de creación al constructor del mismo apropiado según los valores que se le pasen en

<parametros>, devolviendo una referencia al objeto recién creado. Hay que resaltar el hecho de

que new no devuelve el propio objeto creado, sino una referencia a la dirección de memoria

dinámica donde en realidad se ha creado.

Para poder hacer uso del operador new tendremos que utilizar un método especial llamado

Constructor, que es el encargado de decirnos como se crea e inicializa el objeto de dicha clase.

Existe el constructor por defecto que se encarga de construir por default el objeto con valores de 0

en sus atributos o su equivalente a este, este constructor solo se carga si nosotros no definimos un

constructor propio.

Persona = new Persona()

En el caso que nosotros definamos un constructor se hará de la misma manera que definimos un

método, solo con la variación que no debemos colocar tipo de retorno, ya que este será

automáticamente una referencia al objeto recién creado en memoria.

class Persona{




Persona(string n, string a, int e){

Nombre = n;

Apellido = a;

Edad = e;

}

void Cumple(int n){

Edad += n;

}

}

Persona = new Persona(“Julio”,”Juarez”,15);



Al igual que es posible definir métodos constructores que incluyan código que gestione la creación

de objetos de un tipo de dato, también es posible definir un destructor que gestione cómo se

destruyen los objetos de ese tipo de dato. Este método suele ser útil para liberar recursos tales

como los ficheros o las conexiones de redes abiertas que el objeto a destruir estuviese acaparando

en el momento en que se fuese a destruir.

La destrucción de un objeto es realizada por el recolector de basura cuando realiza una

recolección de basura y detecta que no existen referencias a ese objeto ni en pila, ni en registros

ni desde otros objetos sí referenciados. Las recolecciones se inician automáticamente cuando el

recolector detecta que queda poca memoria libre o que se va a finalizar la ejecución de la

aplicación, aunque también puede forzarse llamando al método Collect() de la clase System.GC

La sintaxis que se usa para definir un destructor es la siguiente:

~<nombreTipo>(){

<código>

}

Herencia

El mecanismo de herencia es uno de los pilares fundamentales en los que se basa la programación

orientada a objetos. Es un mecanismo que permite definir nuevas clases a partir de otras ya

definidas de modo que si en la definición de una clase indicamos que ésta deriva de otra, entonces

la primera (a la que se le suele llamar clase hija) será tratada por el compilador automáticamente

como si su definición incluyese la definición de la segunda (a la que se le suele llamar clase padre o

clase base). Las clases que derivan de otras se definen usando la siguiente sintaxis:

class <nombreHija>:<nombrePadre>{

<miembrosHija>

}

A los miembros definidos en <miembrosHijas> se les añadirán los que hubiésemos definido en la

clase padre. Por ejemplo, a partir de la clase Persona puede crearse una clase Trabajador así:

class Trabajador:Persona{

int Sueldo;

Trabajador (string nombre, string apellido, string edad, int

sueldo):base(nombre, apellido, edad){

Sueldo = sueldo;

}

}

Los objetos de esta clase Trabajador contarán con los mismos miembros que los objetos Persona y

además incorporarán un nuevo campo llamado Sueldo que almacenará el dinero que cada

trabajador gane. Nótese además que a la hora de escribir el constructor de esta clase ha sido

necesario escribirlo con una sintaxis especial consistente en preceder la llave de apertura del

cuerpo del método de una estructura de la forma:



: base(<parametrosBase>)

A esta estructura se le llama inicializador base y se utiliza para indicar cómo deseamos inicializar

los campos heredados de la clase padre. No es más que una llamada al constructor de la misma

con los parámetros adecuados, y si no se incluye el compilador consideraría por defecto que vale

:base(), lo que sería incorrecto en este ejemplo debido a que Persona carece de constructor sin

parámetros.

Ya hemos visto que es posible definir tipos cuyos métodos se hereden de definiciones de otros

tipos. Lo que ahora vamos a ver es que además es posible cambiar dicha definición en la clase hija,

para lo que habría que haber precedido con la palabra reservada virtual la definición de dicho

método en la clase padre. A este tipo de métodos se les llama métodos virtuales, y la sintaxis que

se usa para definirlos es la siguiente:

virtual <tipoDevuelto> <nombreMétodo>(<parámetros>){

<código>

}

Si en alguna clase hija quisiésemos dar una nueva definición del método, simplemente lo

volveríamos a definir en la misma pero sustituyendo en su definición la palabra reservada virtual

por override. Es decir, usaríamos esta sintaxis:

override <tipoDevuelto> <nombreMétodo>(<parámetros>){

<nuevoCódigo>

}

Nótese que esta posibilidad de cambiar el código de un método en su clase hija sólo se da si en la

clase padre el método fue definido como virtual. En caso contrario, el compilador considerará un

error intentar redefinirlo.

Polimorfismo

El polimorfismo es otro de los pilares fundamentales de la programación orientada a objetos. Es la

capacidad de almacenar objetos de un determinado tipo en variables de tipos antecesores del

primero a costa, claro está, de sólo poderse acceder a través de dicha variable a los miembros

comunes a ambos tipos. Sin embargo, las versiones de los métodos virtuales a las que se llamaría a

través de esas variables no serían las definidas como miembros del tipo de dichas variables, sino

las definidas en el verdadero tipo de los objetos que almacenan.

A continuación se muestra un ejemplo de cómo una variable de tipo Persona puede usarse para

almacenar objetos de tipo Trabajador. En esos casos el campo Sueldo del objeto referenciado por

la variable no será accesible, y la versión del método Cumple() a la que se podría llamar a través de

la variable de tipo Persona sería la definida en la clase Trabajador, y no la definida en Persona:

class Persona{






Persona(string n, string a, int e){

Nombre = n;

Apellido = a;

Edad = e;

}

void Cumple(int n){

Edad += n;

}

}

class Trabajador:Persona{

int Sueldo;

Trabajador (string nombre, string apellido, string edad, int

sueldo):base(nombre, apellido, edad){

Sueldo = sueldo;

}

virtual Cumple(){

Edad++;

System.Console.WriteLine(“Cumple Trabajador”);

}

static void Main(){

Persona p = new Trabajador(“Juan”,”Gutierrez”,21,50000);

p.Cumple();

}

}

Si ejecutamos este código encontraremos a la salida que nos lanzará el mensaje de “Cumple

Trabajador”, demostrando que la clase se comporta de otra forma a pesar de ser de otro tipo.

Introducción a la Programación en Microsoft Visual Studio C# 2010 · 2014. 2. 7. ·...

Documents

Transcript of Introducción a la Programación en Microsoft Visual Studio C# 2010 · 2014. 2. 7. ·...