01 c sharp basico

8/3/2019 01 C Sharp Basico

1/65

Curso: C# Bsico

C# Bsico

Manual del Participante


2/65

Curso: C# Bsico

Tabla de Contenido

1 Historia: .......................................................................................................................... 42 Introduccin:...................................................................................................................5

2.1 .NET ....................................................................................................................... 52.2 Resumen Introductorio ........................................................................................... 52.3 C# vs JAVA............................................................................................................ 62.4 C# vs C++............................................................................................................... 62.5 Por que C#?........................................................................................................... 7

3 Primeros Conceptos........................................................................................................ 83.1 No otro Hola Mundo! ........................................................................................ 8

3.2 Comentarios............................................................................................................83.2.1 Comentarios de una Lnea.............................................................................. 83.2.2 Comentarios Multilinea.................................................................................. 83.2.3 Comentarios de documentacin XML............................................................ 8

3.3 Clases, Objetos y Tipos .......................................................................................... 93.4 Metodos ................................................................................................................ 103.5 Namespaces .......................................................................................................... 103.6 La palabra reservada using................................................................................ 113.7 Case Sensitive....................................................................................................... 11

4 Fundamentos del lenguaje............................................................................................ 124.1 Tipos.....................................................................................................................12

4.1.1 Importancia de los Tipos de datos ................................................................ 124.1.2 Tipos de datos en C# .................................................................................... 124.1.3 Tipos bsicos o nativos................................................................................. 134.1.4 Conversin de Tipos..................................................................................... 16

4.2 Arreglos ................................................................................................................ 184.3 Identificadores, Variables, Constantes y Enumeraciones..................................... 20

4.3.1 Identificadores .............................................................................................. 204.3.2 Variables.......................................................................................................204.3.3 Constantes.....................................................................................................214.3.4 Enumeraciones ............................................................................................. 22

4.4 Operadores............................................................................................................23

4.4.1 Operadores aritmticos ................................................................................. 234.4.2 Operadores Lgicos...................................................................................... 234.4.3 Operadores Relacinales .............................................................................. 234.4.4 Operadores de manipulacin de bits............................................................. 234.4.5 Operadores de asignacin............................................................................. 244.4.6 Operador condicional o ternario................................................................... 24

5 Estructuras de Control .................................................................................................. 255.1 goto.......................................................................................................................255.2 if............................................................................................................................265.3 switch....................................................................................................................275.4 for ......................................................................................................................... 28


3/65

Curso: C# Bsico

5.5 while ..................................................................................................................... 28

5.6 do-while................................................................................................................295.7 foreach .................................................................................................................. 305.8 continue y break ................................................................................................... 31

6 Introduccin a las clases............................................................................................... 336.1 Clases....................................................................................................................336.2 Mtodos ................................................................................................................ 34

6.2.1 Sobrecarga de Mtodos ................................................................................ 356.3 Parmetros ............................................................................................................ 37

6.3.1 Parmetros por valor..................................................................................... 376.3.2 Parmetros por referencia............................................................................. 386.3.3 Parmetros de salida..................................................................................... 39

6.3.4 Parmetros variables..................................................................................... 406.3.5 Consideraciones de parmetros de valor y de referencia ............................. 416.4 Miembros de clase vs Miembros de instancia...................................................... 436.5 Constructores........................................................................................................446.6 this ........................................................................................................................ 476.7 Propiedades...........................................................................................................486.8 Indexadores...........................................................................................................516.9 Modificadores de acceso ...................................................................................... 52

7 Herencia y Polimorfismo.............................................................................................. 537.1 Herencia................................................................................................................537.2 Polimorfismo ........................................................................................................ 56

7.3 Modificadores de Herencia................................................................................... 597.4 Clases abstractas ................................................................................................... 597.5 is ........................................................................................................................... 607.6 Conversin de tipos y as....................................................................................... 62

8 Estructuras .................................................................................................................... 639 Interfaces ...................................................................................................................... 6310 Excepciones..............................................................................................................64


4/65

Curso: C# Bsico

1 Historia:

Se inicia a desarrollar en 1998 Nombre de proyecto, COOL En el 2000, se libera la especificacin de C# Lanzamiento del SDK de .NET beta, incluyendo un compilador de C# Diseado por Anders Hejlsberg (Creador de Turbo Pascal y arquitecto de

Delphi), Scott Wiltamuth y Peter Golde Simple, Moderno, Orientado a Objetos, Tipos Seguros, herencia de

C/C++


5/65

Curso: C# Bsico

2 Introduccin:

2.1 .NET

Plataforma de desarrollo de software con especial nfasis en eldesarrollo rpido, independencia de lenguaje y transparencia atravs de redes.

Componentes de .NETo Lenguajes de programacin (C#, J#, JScript, Manager

C++, VB.NET, etc.)o Herramientas de desarrollo (VS.NET)o Una Class Library Comno MSIL (Microsoft Intermediate Language)o CLR (Common Language Runtime)

Independencia de Lenguaje Multiplataforma (Gracias al proyecto Mono) Estandarizacin por ECMA internacional2.2 Resumen Introductorio

Sencillo Sigue el patrn de los lenguajes modernos Soporte de estructuras, componentes, POO, excepciones, GC Herencia sencilla Punteros


6/65

Curso: C# Bsico

2.3 C# vs JAVA

"I felt a great disturbance in the Force, as if a million java coders cried out in torment and

were silenced at once"

Similitudeso Basados en C/C++o POOo GCo ILo Generics (Recin salidos del horno en JAVA)

Diferenciaso C# mas parecido a C++o Enumeracioneso Punteros (Unsecure Code)o Propiedadeso Delegadoso Mtodos Annimoso Iteradoreso Foreacho Etc.

2.4 C# vs C++

VM (Runtime) C# es mas POO (Todos los tipos heredan de Object) C# solo tiene herencia sencilla C# tiene propiedades Chequeo de limites de memoria Se acceden a los miembros con . en vez de ::


7/65

Curso: C# Bsico

2.5 Por que C#?

Nermle, Fortan, Java, Python, Managed C++, BOO, VB.NET,etc.

C# fue diseado para .NET y por lo tanto lo aprovecha al100%

Hincapi en la sencillez


8/65

Curso: C# Bsico

3 Primeros Conceptos

3.1 No otro Hola Mundo!

using System;

namespace NoOtroHolaMundo

{

class FooBar

{

//Metodo principalstaticvoid Main(string[] args)

{

/*

* Estos son comentarions de multilineas

* Al mas puro estilo de C/C++

*

*/

Console.WriteLine ("No otro hola mundo!");

}

}

}

3.2 Comentarios

3.2.1 Comentarios de una Lnea

Los comentarios de una sola lnea se introducen con //

3.2.2 Comentarios Multilnea

Los comentarios multilnea inician con /* y terminan con */

3.2.3 Comentarios de documentacin XML

Estos se introducen con ///, son de una sola lnea y son tiles paraherramientas de auto documentacin XML.


9/65

Curso: C# Bsico

3.3 Clases, Objetos y Tipos

El mecanismo con el cual se trabaja con la POO es la creacin de nuevostipos. Un tipo es una representacin de un concepto. Un concepto es unaentidad que cumple con una funcin, tiene propiedades y mtodos. Porejemplo un concepto puede ser un automvil. Podemos tener muchosautomviles, todos ellos se comportan y tienes propiedades similares. Porejemplo un automvil se puede encender, apagar, cambiar de velocidad;tambin puede tener un color, nmero de velocidades, marca, modelo, etc. Losatributos (valores de las propiedades) son las que nos permiten distinguir entredos autos distintos (el suyo y el del vecino).

Una clase es un concepto, esto es, la definicin de un conjunto de objetos. Unobjeto es una entidad real, es decir, su auto o el de su compaero. Y la clase esel concepto que representan todos los automviles, es donde se define como secomportarn todos los automviles y que propiedades tendrn (Imagine unplano o un molde). Una instancia es una entidad que representa una clase, porejemplo, su auto es una instancia de la clase Automvil. El termino objeto einstancia se usara indistintamente.

La idea de la POO es crear nuevos tipos (conceptos o clases) que puedan serrehusados. As no se necesita programar varios componentes con funcionessimilares, nicamente, se programa el concepto (clase) con sus mtodos ypropiedades y posteriormente se crean instancias de estas para ser usadas.

En C# una clase es llamada class, en C# hay ciertos tipos de clases especialescomo las enumeraciones, estructuras y delegados que sern estudiadas mastarde.

Como se vio en el ejemplo previo (3.1), se inicia una clase con la palabra

reservada class seguido del nombre de la clase, con todos los mtodos ypropiedades encerradas entre { y }.


10/65

Curso: C# Bsico

3.4 Mtodos

Los mtodos definen el comportamiento de los objetos, la sintaxis paradeclarar un mtodo es:

[mod acceso] ([tipo1 identificador1, ..]) {

[return ]

}

Segn el ejemplo: Modificadores de acceso: static Tipo: void Identificador: Main Implementacin: Console.WriteLine ();

Cuando un mtodo no retorna ninguna valor se usa el tipo de retorno void. Elmodificador static ser discutido mas adelante. C# toma como punto dearranque el mtodo con nombre Main.

3.5 Namespaces

Los namespaces (espacios de nombres) existen para la organizacin logica delas clases, es un concepto parecido a los packages de java (en UML esconocido tambin con este nombre), con la diferencia que C# no fuerza que laestructura lgica de los namespaces sea la misma que la estructura fsica de losfuentes.

Un uso comn de los espacios de nombre es para la distincin entre cdigo dela entidad que desarrollo la clase, el proyecto o programa al que pertenece y

sus capas o componentes, por ejemplo EmpresaFoo.ProyectoBar.Dominio,donde se almacenaran las clases del Dominio del proyecto Bar de la empresaFoo.

Para poner una clase en un espacio de nombre basta con poner:

namespace EspacioDeNombresFOO


11/65

Curso: C# Bsico

Y encerrar entre llaves las clases que se contendrn en los espacios de nombre.

Se pueden poner espacios de nombres dentro de espacios de nombre, porejemplo NamespaceFOO.NamespaceBAR.NamespaceFOOBAR.

3.6 La palabra reservada using

La palabra reservada using nos sirve para facilitar el trabajo con los espaciosde nombres, por ejemplo, si tenemos la clase BAR en el espacio de nombresFOO, tendramos que usar FOO.BAR para accederla, para esto existe usingque es el equivalente de import de java (con la diferencia de que se importa

todo el espacio de nombres, no solo una clase).

En el ejemplo anterior (3.1), se tiene using System; debido a que Console esuna clase que se encuentra en el espacio de nombres System. Siomitiramos esa lnea tendramos que llamar a la clase Console de la siguientemanera:

3.7 Case Sensitive

C#, al igual que C/C++, java y muchos lenguajes mas, es Case Sensitive,esto significa que tiene la inteligencia suficiente para distinguir entremaysculas y minsculas, Por lo tanto la clase Foo es distinta a la clase FOO ola clase FoO.


12/65

Curso: C# Bsico

4 Fundamentos del lenguaje

4.1 Tipos

4.1.1 Importancia de los Tipos de datos

Los tipos son la base de cualquier programa. Un tipo no es ms que un espacioen el que se almacena una informacin, ya sean nmeros, palabras o tu fechade nacimiento.

4.1.2 Tipos de datos en C#

C# es un lenguaje de fuertemente tipado, lo cual quiere decir que elprogramador debe definir a que tipo pertenece cada pedazo de informacin ocada objeto que se crea. De esta forma podemos crear objetos de tipo nmeroentero, de tipo cadenas de texto, de tipo ventana, de tipo botones, entre otros.Haciendo esto, C# nos ayudar a mantener nuestro cdigo seguro en dondecada tipo cumple con su funcin. En todas las operaciones el compilador

comprueba los tipos para ver su compatibilidad. Las operaciones no vlidaslanzan errores en tiempo de compilacin. De esta forma se evitan muchoserrores y se consigue una mayor fiabilidad. Esto tambin permite a C#anticipar de antemano la cantidad de recursos del sistema que nuestroprograma utilizar haciendo nuestro cdigo seguro y eficiente.

Los tipos en C# al igual que C++ y Java se clasifican en dos secciones: Tiposbsicos o internos y tipos creados por el usuario.

Los tipos bsicos no son ms que alias para tipos predefinidos en la librerabase de la plataforma .NET. As, el tipo nmero entero (que se lo representacon la palabra clave int), no es ms que una forma rpida de escribirSystem.Int32.

Dentro de stas dos secciones los tipos del lenguaje C# tambin son divididosen dos grandes categoras: tipos por valor y tipos por referencia. Existe unatercera categora de tipos, disponible solo cuando se usa cdigo no seguro: lospunteros, que quedan fuera del alcance de este curso.


13/65

Curso: C# Bsico

Los tipos por valor difieren de los tipos por referencia en que las variables de

los tipos por valor contienen directamente su valor, mientras que las variablesde los tipos por referencia almacenan la direccin donde se encuentran losobjetos (un puntero), es por eso que se las llaman referencias. Ms adelantedescribiremos como funcionan cada una de estas categoras.

4.1.3 Tipos bsicos o nativos

Los tipos nativos son los tipos que conoce nativamente C#, a continuacin latpica tabla de tipos, informacin que pueden contener, tamao, y rango de

valores que aceptan.

Tipo Nombre realConsigno?

Tamao Valores que soporta

bool System.Boolean No 1 true,false

byte System.Byte No 1 0 - 255

sbyte System.SByte Si 1 -128 - 127

short System.Int16 Si 2 -32,768 32,767

ushort System.Uint16 No 2 0 65,535

int System.Int32 Si 4 -2,147,483,648 2,147,483,647uint System.Uint32 No 4 0 4,394,967,395

long System.Int64 Si 8-9,223,372,036,854,775,808 -9,223,372,036,854,775,807

ulong System.Uint64 No 8 0 18,446,744,073,709,551,615

float System.Single Si 4Aproximadamente 1.5E-45 hasta 3.4E38con 7 cifras significativas

double System.Double Si 8Aproximadamente 5.0E-324 hasta1.7E308 con 7 cifras significativas

decimal System.Decimal Si 12 Aproximadamente 1.0E-28 hasta 7.9E28con 28 29 cifras significativas

char System.Char 2 Cualquier carcter Unicode (16 bits)

string System.String Cualquier cadena de caracteres Unicode


14/65

Curso: C# Bsico

4.1.3.1 Enteros

Los tipos que sirven para almacenar nmeros enteros son: byte, sbyte. short,ushort, int, uint, long y ulong. Como se aprecia en la tabla, C# defineversiones con y sin signo para tipos con los mismos bytes utilizados. Cada tipose distingue por la capacidad de almacenaje.

4.1.3.2 Tipos de punto flotante

Los tipos de punto flotante sirven para representar a nmeros con partefraccionaria. La representacin por supuesto puede no ser exacta, bien porerrores de la mquina, bien porque el nmero de decimales que se puede alojares finito.Existen dos clases de tipos de punto flotante, float, double y decimal. De losdos, el ms usado es double, pues es el valor que devuelven la mayora de lasfunciones matemticas de la librera base.

4.1.3.3 Tipo decimal

El tipo decimal es un tipo "nuevo" en el sentido de que no tiene equivalente en

C/C++. Es muy parecido a los tipo de coma flotante float y double.En la aritmtica de los tipos de coma flotante ordinarios, se pueden producirleves errores de redondeo. El tipo decimal elimina estos errores y puederepresentar correctamente hasta 28 lugares decimales. Esta capacidad pararepresentar valores decimales sin errores de redondeo lo hace especialmenteeficaz para clculos monetarios.

4.1.3.4 Tipo bool

El tipo bool sirve para expresar los valores verdadero/falso, que en C# se

muestran con las palabras reservadas true y false.


15/65


16/65

Curso: C# Bsico

4.1.4 Conversin de Tipos

Normalmente, es muy necesario convertir los tipos de los objetos que se hancreado. En C# esto se puede hacer implcita y explcitamente. Una conversinde tipos implcita sucede automticamente, es decir, el compilador se encargade realizar la conversin. Una conversin explicita, se llevara a cavosolamente si se especifica la conversin. Hay que aclarar que no siempre esposible convertir un tipo a otro.

Las conversiones implcitas ocurren cuando se desea cambiar de un tipo demenor capacidad a uno de mayor capacidad del mismo tipo. Por ejemplo de unshort a un int.

Como regla general las conversiones implcitas se llevan a cabo cuando sedesea cambiar un tipo de menor capacidad hacia un tipo de mayor capacidadde la misma especie. Por ejemplo si deseamos crear 2 tipos enteros (mismaclase) el uno que lleve el tipo short (menor capacidad) y el otro que lleve eltipo int (mayor capacidad) una conversin implcita de short a int se lleva acabo en el siguiente ejemplo:

short corto = 3;int entero = corto; //compilar sin ningn problema

En el caso que queramos hacer de forma inversa, es decir asignar un valor inta una variable short, estaramos violando la regla de asignar un tipo de mayorcapacidad a una variable de tipo de menor capacidad aunque sean de la mismaclase (enteros). As el siguiente ejemplo no compilar dndonos un error:

int entero = 300;

short corto = entero;//nos dar un error de compilacin

En estos casos es cuando podremos hacer una conversin explcita. Debido aque la informacin almacenada en la variable entero de tipo int est tambinen el rango de capacidad del tipo short y los dos tipos son de la misma clase(enteros), podremos hacer una conversin explicita designando entreparntesis a que tipo queremos convertir de la siguiente manera:

int entero = 300;

short corto = (short) entero; //Compila bien


17/65

Curso: C# Bsico

Esta operacin es llamada casting. A continuacin una tabla con los tipos

nativos y que tipo de conversin necesitan entre ellos:

Conversin Implcita (I) Conversin Explcita (E)

Desde/hacia byte sbyte short ushort int uint long ulong float double decimal

byte I E I I I I I I I I I

sbyte E I I E I E I E I I I

short E E I E I E I E I I I

ushort E E E I I I I I I I Iint E E E E I E I E I I I

uint E E E E E I I I I I I

long E E E E E E I E I I I

ulong E E E E E E E I I I I

float E E E E E E E E I I E

double E E E E E E E E E I E

decimal E E E E E E E E E E I


18/65

Curso: C# Bsico

4.2 Arreglos

En C# se pueden construir arreglos de cualquier tipo de dato. As, podemosconstruir arreglos de objetos, de cadenas de texto, arreglos de enteros e inclusoarreglos de arreglos

using System;

class Arreglo

{

publicstaticvoid Main()

{

int[] arr = newint[3];

arr[0] = 1;

arr[1] = 2;

arr[2] = 3;

Console.WriteLine (arr[1]);

}

}

Para crear un arreglo debemos especificar de que tipo deseamos crear elarreglo seguido por corchetes [ ] que es el distintivo del arreglo (en nuestroejemplo usamos int[]), seguido por la palabra clave new y el tipo y la cantidadde parmetros que tendr nuestro arreglo. En el ejemplo anterior, por ejemplo,

se cre un arreglo arr unidimensional con capacidad para 3 enteros(especificado por new int[3]), y luego se le asign a cada parmetro un enterodistinto (ntese que se comienza a contar a partir de 0 y el nmero delparmetro se encuentran entre corchetes).

Existe una forma ms corta para declarar el arreglo y asignarle los valores:

int[] arr = {1,2,3}; //es exactamente lo mismo que el ejemplo anterior

Tambin se pueden crear arreglos bidimensionales (y de la misma forma para

n dimensiones). En ese caso la sintaxis para declarar un arreglo bidimensionalde enteros ser

int[,] FooArray = newint[2,2];

FooArray[0,0] = 1;

FooArray[1,0] = 3;

FooArray[0,1] = 5;

FooArray[1,1] = 7;


19/65

Curso: C# Bsico

O la versin corta:

int[,] FooArray = {{1,3},{5,7}}; //Lo mismo que las lineas anteriores


20/65

Curso: C# Bsico

4.3 Identificadores, Variables, Constantes y Enumeraciones.

4.3.1 Identificadores

En una aplicacin siempre se deben crear variables, constantes, mtodos,objetos, etc. Para poder crearlos debemos asignar nombres o identificadores.Estos identificadores deben seguir ciertas reglas:

Un identificador debe empezar con una letra o un signo _(underscore). Un identificador no puede tener espacios en blanco. Un identificador no puede llevar el mismo nombre que una palabra

clave.

Despus de que el identificador empiece con una letra o un smbolo _, elidentificador puede tener cualquier cantidad de letras, lneas o nmeros.

4.3.2 Variables

Para crear una variable debemos especificar a que tipo pertenece antes delnombre que le vamos a dar. Por ejemplo si deseamos crear una variable que sellame var y que sea del tipo entero (int) procederemos de la siguiente manera:

int var;

Una vez creada la variable podemos almacenar la informacin que deseamos.Para hacerlo utilizamos el operador = despus del nombre de la variable.

var = 10;

Hay que tener presente que la variable como su nombre lo indica podr tomarotros valores. Por ejemplo si deseamos que nuestra variable cambie de valor a5 hacemos lo que habamos hecho en el ejemplo anterior pero con el nuevovalor:

var = 5;


21/65

Curso: C# Bsico

De ahora en adelante la variable var pasa a tener el valor de 5.

Para simplificar el proceso de creacin y asignacin de valor de una variablepodemos especificar estos dos procesos en una misma lnea.

int var = 10;

La primera vez que una variable recibe un valor se llama inicializacin de lavariable. En C# todas las variables que van a ser utilizadas deben serinicializadas para que vuestro programa pueda funcionar.

En caso anterior hemos creado la variable var e inicializado la variable con elvalor 10. Hay que tener cuidado que la creacin de una variable se la hace unasola vez y la asignacin de diferentes valores se puede hacer cuantas vecesqueramos.

4.3.3 Constantes

Las constantes como su nombre lo indica son variables cuyo valor no puedeser alterado. stas se utilizan para definir valores que no cambian con eltiempo. Por ejemplo podemos definir una constante para especificar cuantos

segundos hay en una hora de la siguiente forma:constint SecondsPerHour = 3600;

sta constante no podr ser cambiada a lo largo de nuestro programa. En elcaso de que querremos asignarle otro valor, obtendremos un error en tiempode compilacin.

Las constantes deben ser inicializadas en el momento de su creacin.


22/65

Curso: C# Bsico

4.3.4 Enumeraciones

Supongan que estn diseando una aplicacin, y necesitan crear una variableque contendr los distintos tipos de aprobacin de un documento, dichos tipossern:

Aprobado Rechazado En espera de aprobacin En revisin

Que tipo de variable utilizaran para especificar los estados?

Una forma elegante seria utilizando las enumeraciones.

enum ApprovalState

{

Approved,

Rejected,

RevitionQueue,

BeingApproved

}

Y la usaramos de la siguiente forma:

ApprovalState estadoAprovacion = ApprovalState.Approved;

Otro ejemplo de enumeracin seria:

enum FooEnum : long

{

Foo = 123456789,Bar = 13571113,

FooBar = 11235813

}


23/65

Curso: C# Bsico

4.4 Operadores

4.4.1 Operadores aritmticos

Operador Nombre

+ Suma- Resta* Multiplicacin / Divisin \ Divisin entera% Modulo

4.4.2 Operadores Lgicos

Operador Nombre

&& AND en cortocircuito|| OR en cortocircuito NOT (Negacin)^ XOR (OR Exclusivo)& AND| OR

4.4.3 Operadores Relacinales

Operador Nombre

== Idntico!= Diferente> Mayor que< Menor que

>= Mayor igual Corrimiento Der


24/65

Curso: C# Bsico

4.4.5 Operadores de asignacin

Operador Nombre

= Asignacin+= Mas igual-= Menos igual*= Por igual /= Sobre igual&= AND igual|= OR Igual^= XOR Igual

= Desp der igual++ Incremento-- Decremento

4.4.6 Operador condicional o ternario

Operador Nombre

? Operador ternario

El operador ternario sirve para la asignacin de un valor dependiendo de unacondicin.

Por ejemplo, el siguiente cdigo:

if (num1 > num2)

numayor = num1;

else

nummayor = num2;

Podra ser sustituido por este otro:

nummayor = (num1 > num2) ? num1 : num2;


25/65

Curso: C# Bsico

5 Estructuras de Control

5.1 goto

No se ran, a mi me gusta el espagueti!

Si bien, la infamemente famosa sentencia goto, tiene muy mala reputacin, C#la incluye, como recomendacin evite usarla siempre que sea posible.

Para usar goto, primeramente se define una etiqueta, con un nombre seguidode dos puntos :. Posteriormente se usa goto Etiqueta; para saltar a dichaubicacin.

using System;

namespace GOTO

{

class GOTO

{

staticvoid Main(string[] args)

{

int numero = 0;

PRINT:

Console.WriteLine (numero);

numero++;

if (numero


26/65

Curso: C# Bsico

5.2 if

Esta sentencia sirve para ejecutar unas instrucciones en caso de que se cumpladeterminada condicin. La forma completa de la instruccin if es:

if (condicin) {

instruccin1;

instruccin2;

...

} else {

instruccin1;

instruccin2;...

}

La clusula else es opcional. Si la condicin es verdadera, se ejecutarn lasinstrucciones dentro del bloque if, mientras que si es falsa, se ejecutar elbloque else. El valor que controla la sentencia if debe ser de tipo bool.


27/65

Curso: C# Bsico

5.3 switch

La instruccin switch es muy parecida a la estructura if-else-if, slo quepermite seleccionar entre varias alternativas de una manera ms cmoda.Funciona de la siguiente manera: el valor de una expresin se pruebasucesivamente con una lista de constantes. Cuando se encuentra unacoincidencia, se ejecuta la secuencia de instrucciones asociada con esacoincidencia. La forma general de la instruccin switch es la siguiente:

switch (expresion)

{

case constante1 :

instruccion1;instruccion2;

..

break;

case constante2:

instrucciones;

break;

...

default:

instrucciones;

break;

}

La sentencia default se ejecutar slo si ninguna constante de las que siguen acase coincide con expresin. Es algo similar al else final de la instruccin if-else-if.

Como habr notado, al final de todo case siempre hay una sentencia break.Esto no es obligatorio, puede haber en su lugar otra sentencia de salto comoun goto inclusive en el caso default.


28/65


29/65

Curso: C# Bsico

5.6 do-while

El do-while es sumamente parecido al while, la diferencia es que en el ciclowhile no se evala la expresin en la primera iteracin, su sintaxis es:

Se trata de una ligera variante del bucle anterior, con la diferencia de queahora primero se ejecutan las instrucciones y luego se evala la condicin, deforma que tiene una estructura:

do {

instrucciones;

} while (condicin);


30/65

Curso: C# Bsico

5.7 foreach

El foreach es un ciclo sumamente til, que sirve para iterar por cada elementode una coleccin. Esto puede ser arreglos o colecciones definidas por elusuario. Su sintaxis es:

foreach (Tipo identificador in Coleccion) {

instrucciones;

}

Donde identificador tomara el valor del elemento actual de la coleccin porcada una de las iteraciones, a continuacin un ejemplo de foreach conarreglos, en el curso C# Avanzado se aprender a crear colecciones quepuedan ser iteradas por medio de un foreach:

using System;

namespace FOREACH

{

class FOREACH

{


{

int[] FooBar = newint[10];

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

FooBar[i] = i;

foreach (int valAct in FooBar)

Console.WriteLine (valAct);

}

}

}

Algo a considerar es que la variable que apunta al elemento actual no puedeser modificada dentro del foreach.


31/65

Curso: C# Bsico

5.8 continue y break

El continue y break sirven para cambiar la forma en que opera un ciclo.

El break, termina el ciclo inmediatamente, independientemente si se cumple ono su condicin de control. Ejemplo:

using System;

namespace BREAK

{

class BREAK

{


{

int i = 0;

for (;;) {

Console.WriteLine (i);

if (i == 10)

break;

i++;

}

}

}

}

El continue ignora cualquier otra instruccin que se encuentre despus de el ycontinua en la siguiente iteracin, esto respetando las reglas del ciclo encuestin (por ejemplo, si es un for, realiza el incremento y la verificacin de lacondicin de control). Ejemplo:


32/65

Curso: C# Bsico

using System;

namespace CONTINUE

{

class CONTINUE

{


{

for (int i = 0; i < 11; i++) {

Console.WriteLine (i);

if (i >= 5)

continue;

Console.WriteLine ("Aun no llegamos al 5");}

}

}

}


33/65

Curso: C# Bsico

6 Introduccin a las clases

Como hemos dicho, C# es un lenguaje orientado objetos. A diferencia delenguajes como C++ o Python en los que la orientacin a objetos es opcional,en C# y al igual que en Java, la orientacin a objetos es ineludible, de hechocualquier mtodo o variable est contenida dentro de un objeto. Y el conceptofundamental en torno a la orientacin a objetos es la clase.

6.1 Clases

Una clase es como una plantilla que describe cmo deben ser las instancias dedicha clase, de forma que cuando creamos una instancia, sta tendrexactamente los mismos mtodos y variables que los que tiene la clase. Losdatos y mtodos contenidos en una clase se llaman miembros de la clase y losque son contenidos dentro de una instancia son llamados miembros deinstancia, la diferencia entre estos ser discutida mas adelante. Para acceder alos miembros de clase o instancia se usa el operador ".". A continuacin unejemplo de la definicin de una clase y su instanciacion.


34/65

Curso: C# Bsico

using System;

namespace CLASES1

{

class Automovil

{

publicint MaximaVelocidad;

publicstring Marca;


{

Automovil micarro = new Automovil ();

micarro.MaximaVelocidad = 100;micarro.Marca = "GeekMovil";

Automovil otrocarro = new Automovil ();

otrocarro.MaximaVelocidad = 150;

otrocarro.Marca = "FOOneral Motors";

Console.WriteLine ("MI CARRO: MV={0}, Marca={1}",

micarro.MaximaVelocidad, micarro.Marca);

Console.WriteLine ("OTRO CARRO: MV={0}, Marca={1}",

otrocarro.MaximaVelocidad, otrocarro.Marca);

}

}

}

La palabra reservada public antes de los tipos de datos, es un modificador deacceso y son necesarios para que puedan ser accedidos desde otra clase, masadelante veremos a mas detalle los modificadores de acceso. Las clasestambin pueden contener mtodos.

Podemos hacer ms cosas con las clases, como heredar otras clases oimplementar interfaces, pero esto ser discutido mas adelante.

6.2 Mtodos

Los mtodos, son trozos de cdigo que reciben datos, hacen algo con esosdatos, y a veces devuelven algn valor. En C#, todos los mtodos seencuentran contenidas dentro de un objeto o una clase.

Cuando queramos llamar a un mtodo, debemos simplemente poner el nombredel mtodo y sus argumentos dentro de un parntesis separados por comas.


35/65

Curso: C# Bsico

Un ejemplo de mtodo:

using System;

namespace Metodos

{

class MATH

{

publicdouble Divide (double a, double b)

{

return a / b;

}


{

MATH miMath = new MATH ();

double res = miMath.Divide (10, 2);

Console.WriteLine ("10 / 2 = {0}", res);

}

}

}

6.2.1 Sobrecarga de Mtodos

Al igual que en C/C++, Java y muchos otros lenguajes, C# permite lasobrecarga de mtodos. La sobrecarga de mtodos consiste en la posibilidadde tener ms de un mtodo con el mismo nombre.

Si hay ms de un mtodo con el mismo nombre, Cmo se pueden diferenciarentre ellos?

La manera de diferenciarlos es la firma del mtodo. Para lograr la sobrecarga

los mtodos deben de tener distintas firmas.Que define la firma de un mtodo?

Nombre Cantidad de parmetros Tipos de parmetros Orden de los parmetros


36/65

Curso: C# Bsico

Por lo tanto es posible realizar lo siguiente:

using System;

namespace SobrecargaMetodos

{

class Class1

{


{

Class1 c1 = new Class1 ();

c1.Print ();

c1.Print ("FOO");

c1.Print (10);

}

publicvoid Print ()

{

Print ("Hola");

}

publicvoid Print (string valor)

{

Console.WriteLine (valor);

}

publicvoid Print (int numero)

{

Print ("El numero " + numero);

}

}

}


37/65

Curso: C# Bsico

6.3 Parmetros

6.3.1 Parmetros por valor

Cuando se pasan parmetros por valor, se manda una copia del valor original,por lo que cualquier modificacin que se le haga al valor dentro del mtodo notiene efecto en la variable original.

using System;

namespace ParametrosValor

{

class Foo

{

publicvoid Bar (int numero)

{

numero = 10;

}


{

Foo foo = new Foo ();

int val = 6;

foo.Bar (val);Console.WriteLine (val);

}

}

}


38/65

Curso: C# Bsico

6.3.2 Parmetros por referencia

Cuando se pasan parmetros por valor, en vez de mandar una copia del valororiginal, se manda una referencia a este, por lo que cualquier modificacin alos valores afectara a las variables originales. Para indicar un paso deparmetro por referencia se debe de usar la palabra reservada ref tanto en aldefinicin del mtodo, como desde donde se llama.

using System;

namespace ParametrosReferencia

{

class Foo

{

publicvoid Swap (refint Val1, refint Val2)

{

Val1 ^= Val2;

Val2 ^= Val1;

Val1 ^= Val2;

}


{int a = 10;

int b = 15;

Foo foo = new Foo ();

foo.Swap (ref a, ref b);

Console.WriteLine ("a={0}, b={1}", a, b);

}

}

}


39/65

Curso: C# Bsico

6.3.3 Parmetros de salida

En C#, no se puede usar una variable si esta no es inicializada, de tal maneraque es imposible mandar una variable sin inicializar a un mtodo. Si el valorinicial de la variable no es importante, este inconveniente se puede solucionarcon los parmetros de salida. Si esto se hace as, el mtodo es el responsablede inicializar la variable, y este no la puede usar antes de inicializarla, almenos que la envi como parmetro a otro mtodo que tome un parmetro desalida. Para sealar que un parmetro es de salida se debe de agregar lapalabra clave out tanto en la definicin del mtodo como desde donde semande llamar. Ejemplo:

using System;

namespace ParametrosSalida

{

class OtroFoo

{

publicvoid GetString (outstring val)

{val = Console.ReadLine ();

}


{

string cadena;

OtroFoo bar = new OtroFoo ();

bar.GetString (out cadena);

Console.WriteLine (cadena);

}

}

}


40/65

Curso: C# Bsico

6.3.4 Parmetros variables

Hay situaciones en las que un mtodo puede aceptar una cantidad variable deparmetros, y la cantidad es desconocida, en estos casos son tiles losparmetros variables. Solo puede existir un parmetro variable por mtodo yeste debe de estar definido hasta el ltimo. Se especifica un parmetro variabledefinindolo como un parmetro tipo arreglo pero con la palabra reservadaparams. Ejemplo:

using System;

namespace ParametrosVariables

{

class ParametrosVar

{

publicvoid PrintMuchos (paramsstring[] parametros)

{

foreach (string item in parametros)

Console.WriteLine (item);

}

publicvoid PrintMuchos2 (string[] parametros)

{

foreach (string item in parametros)

Console.WriteLine (item);

}


{

ParametrosVar par = new ParametrosVar ();

par.PrintMuchos ("uno", "dos", "tres", "mil",

"muchos");

par.PrintMuchos2 (newstring[] {"uno", "dos", "tres","mil", "muchos"});

}

}

}


41/65

Curso: C# Bsico

6.3.5 Consideraciones de parmetros de valor y de referencia

Cuando se trabajan con tipos de referencia, trabajar con parmetros de valor yreferencia puede ser un poco confuso al principio.

Considere esto:

using System;

namespace ParametrosValorTiposReferencia

{

class Persona

{

publicstring Nombre;

}

class Init

{

staticvoid Main(string[] args){

Persona per = new Persona ();

per.Nombre = "Pancho";

CambiaNombre (per, "Lencho");

Console.WriteLine (per.Nombre);

}

publicstaticvoid CambiaNombre (Persona persona,

string Nombre)

{

persona.Nombre = Nombre;

}

}

}

Que imprime el cdigo anterior?, el mtodo CambiaNombre debera decambiar el nombre, pero se esta mandado a la persona como valor, entonces sedebera de mandar una copia, y la persona original no debera de ser afectada.Pero si se afecta, Qu sucedi?


42/65

Curso: C# Bsico

Todos los objetos son tipos por referencia, por lo tanto se guarda una

referencia al objeto, no el objeto en si. Cuando se manda un objeto por valor,lo que se copia es la referencia, por lo tanto se puede modificar el objetooriginal.

Entonces, Qu sucede cuando mandamos un tipo de referencia porreferencia?

Veamos el siguiente cdigo:

using System;

namespace ParametrosReferenciaTipoReferencia

{

class Persona

{


}

class Init

{


{

Persona per = new Persona ();per.Nombre = "Foo";

Persona personaOriginal = per;

CambiaPersona (ref per);

Console.WriteLine (per.Nombre + " - " +

personaOriginal.Nombre);

Console.WriteLine ((per == personaOriginal) ?

"Son la misma persona" :

"no son la misma persona");

}

publicstaticvoid CambiaPersona (ref Persona persona)

{

string nom = persona.Nombre;persona = new Persona ();

persona.Nombre = nom;

}

}

}

Cuando usamos el operador == con dos tipos de referencia lo que secompara son sus referencias y no los objetos en si (las direcciones de memoriadel objeto a que apunta). Cuando mandamos como parmetro de referencia un


43/65

Curso: C# Bsico

tipo de referencia, se enva una referencia a la referencia, por lo que podemos

hacer que la referencia original apunte a cualquier otro objeto. Es por esto queel cdigo anterior imprime que no son la misma persona, ya que apuntan a dosobjetos distintos.

6.4 Miembros de clase vs Miembros de instancia

Anteriormente mencionamos que existan miembros de instancia y miembrosde clase. La diferencia entre ambos es que unos pertenecen a la clase y otros ala instancia. De esta manera, no se necesita instanciar un objeto para llamar unmtodo de clase, solamente se accede del modo..

Los miembros de clase son tiles para mantener informacin que soncompartidas por todas las instancias de ese tipo o exponer mtodos los cualesno necesitan mantener ninguna informacin de estado (como servicios), estousualmente se ve como asociaciones de dependencia en UML.

Los miembros de clases son conocidos como miembros estticos, y se definen

anteponiendo el modificador de acceso static antes del miembro.Un ejemplo de un miembro esttico es el mtodo WriteLine de la claseConsole, recordaran que nunca instancia la clase Console para llamar a sumtodo WriteLine.

Otro ejemplo claro, son todos los mtodos de la clase System.Math.


44/65

Curso: C# Bsico

6.5 Constructores

Como hemos visto, las instancias de una clase se crean con la sintaxis

= new ([]);

Una vez creada una clase, sus miembros se inicializan a sus valorespredeterminados.

Esto se realiza por un constructor por default que crea el compilador, un

constructor es un mtodo especial el cual es llamado al momento de crear unainstancia.

Si se desea realizar alguna otra tarea de inicializacin aparte de las que realizael constructor por default podemos definir nuestros propios constructores, yestos incluso pueden recibir parmetros.

La forma de definir un constructor es muy parecido a la definicin de unmtodo, las peculiaridades que tiene este es que debe de ser del nombre de laclase y no tiene ningn tipo de retorno (ni siquiera void). En el siguiente

ejemplo una clase que define su propio constructor que manda un mensaje porpantalla cuando se crea una instancia:

using System;

namespace Constructores1

{

class Class1

{

public Class1 ()

{

Console.WriteLine ("Se ha creado una instancia");

}


{

new Class1 ();

new Class1 ();

}

}

}


45/65

Curso: C# Bsico

Como se dijo tambin es posible definir parmetros en los constructores,ejemplo:

using System;


{

class Persona

{

publicstring nombre;

public Persona (string Nombre)

{

nombre = Nombre;

}


{

Persona per = new Persona ("YO");

Console.WriteLine (per.nombre);

}

}

}

Si se define un constructor, el compilador dejara de generar el constructor pordefault (aunque seguir inicializando los valores), as que si no se define estemanualmente y el constructor definido acepta parmetros, no se podr crearuna instancia sin especificar los parmetros al constructor.

Se pueden sobrecargar los constructores, siguiendo las mismas reglas de lasobrecarga de mtodos que fue explicada anteriormente.

Por ultimo, un constructor puede llamar a otro constructor como se ve acontinuacin:


46/65

Curso: C# Bsico

using System;


{

class Persona

{

publicstring nombre;

public Persona () : this ("Default")

{

}


{nombre = Nombre;

}


{

Persona p1 = new Persona ();

Persona p2 = new Persona ("YO");

Console.WriteLine (p1.nombre);

Console.WriteLine (p2.nombre);

}

}

}

Cuando se llama al constructor sin parmetros, este automticamente llama alotro constructor con un valor de Default al parmetro Nombre.

El significado de la palabra this ser explicado mas adelante.


47/65

Curso: C# Bsico

6.6 this

La palabra reservada this, es una referencia a la misma instancia donde seencuentra, es til para acceder a miembros inaccesibles por que algnparmetro lo ah ocultado, o para denotar la llamada a un constructor dentro deun constructor como se vio en el ejemplo anterior. Ejemplo:

using System;

namespace THIS

{

class Persona

{



{

/*

* El miembro Nombre es inaccesible por que el

* parametro Nombre lo oculta

* Por eso nesesitamos el this

**/

this.Nombre = Nombre;

}


{

Persona p = new Persona ("Pancho Zacates");

Console.WriteLine (p.Nombre);

}

}

}


48/65

Curso: C# Bsico

6.7 Propiedades

C# tiene un concepto llamado propiedades, que ayuda a una mejorencapsulacion, un fundamento principal de la POO.

Para ver por que son importantes, veamos cdigo en Java que es usadohabitualmente para exponer un miembro pblicamente sin comprometer suencapsulamiento.

class Persona{

privateint edad;

publicvoid setEdad (int Edad)

{

edad = Edad;

}

publicint getEdad ()

{

return edad;

}

}

Todo parece bien, hasta el momento de tratar de usar este cdigo, que pasa siuna Persona cumple aos?

persona.setEdad (persona.getEdad () + 1);

Este cdigo no es natural, es difcil de entenderlo a primera vista. Claro, unose termina acostumbrando, pero sigue siendo anti-natura. Una mejor opcinseria:

persona.Edad = persona.Edad + 1;

o:

persona.Edad += 1;

o incluso:


49/65

Curso: C# Bsico

persona.Edad++;

Pero para hacer esto en Java, tendramos que olvidarnos de la encapsulacion.

Las propiedades en C# solucionan esto, las propiedades son un tipo especificode mtodos, que vistos desde el exterior parecen como si fueran miembrosnormales. Su sintaxis es:

{

[get {

codigo;

}]

[set {

codigo;

}]

}

El cdigo en la seccin get es ejecutado cuando se quiere obtener el valor de lapropiedad, y el cdigo en la seccin set es usado cuando se le asigna un valor.En la seccin get debe de tener un return , que es el que obtendr elcdigo que llame a la propiedad. En la seccin set se obtiene el nuevo valor dela propiedad con la palabra reservada value.

Ambas secciones son opcionales, por lo que se pueden obtener propiedades desolo lectura, solo escritura y lectura y escritura.

Un ejemplo de su uso:


50/65

Curso: C# Bsico

using System;

namespace Propiedades

{

class Persona

{

int edad;

publicint Edad

{

get

{

return edad;}

set

{

if (value >= 0)

edad = value;

}

}


{

Persona p = new Persona ();

p.Edad = 10;p.Edad++;

p.Edad--;

p.Edad = -1; //Este no tiene efecto

Console.WriteLine (p.Edad);

}

}

}


51/65

Curso: C# Bsico

6.8 Indexadores

Los indexadotes son un tipo especial de propiedad, los cuales permiten usar aun objeto como si este fuera un array. La sintaxis de su definicin es:

this [[Parametros]] {

[get

{

codigo;

}]

[set

{codigo;

}]

}

Los indicadores se acceden con:

[[Parmetros]]

Los indexadotes son tiles cuando define sus propias colecciones.

Ejemplo:


52/65

Curso: C# Bsico

using System;

namespace Indexadores

{

class Numeros

{

int[] array = newint[100];

publicintthis [int index]

{

get

{return array[index];

}

set

{

array[index] = value;

}

}


{

Numeros nums = new Numeros ();

nums[0] = 10;

nums[14] = 11;

Console.WriteLine (nums[0] + "-" + nums[14]);

}

}

}

6.9 Modificadores de acceso

Modificador Visibilidad

private Solo la misma clasepublic Todas las clases

protected La misma clase o tipos derivadosinternal Clases del mismo assemblyprotected internal Clases del mismo assembly o tipos derivados


53/65

Curso: C# Bsico

7 Herencia y Polimorfismo

7.1 Herencia

La herencia es un concepto fundamental de la POO. Cuando se dice que unacierta clase A hereda otra clase B significa que la clase A contiene todos losmiembros de la clase B ms algunos que opcionalmente puede implementarella misma. Usualmente vemos una relacin de herencia cuando hay unarelacin de is-a.

Las clases en C# soportan herencia simple, de forma que una clase puedederivar de otra, pero no de varias (como si era posible en C++). De hecho, enC# todas las clases derivan implcitamente de la clase object.

La sintaxis que se utiliza es la siguiente:

class :

{

//miembros

}


54/65

Curso: C# Bsico

Ahora veamos un pequeo ejemplo de herencia:

using System;

namespace Herencia1

{

class Vehiculo

{

publicint VelocidadMaxima ()

{

return 100;

}

}

class Bicicleta : Vehiculo

{

publicint NumeroVelocidades ()

{

return 5;

}


{

Bicicleta bici = new Bicicleta ();

//Metodo heredado

Console.WriteLine (bici.VelocidadMaxima ());

//Meotodo propioConsole.WriteLine (bici.NumeroVelocidades ());

}

}

}

Cuando se crea una instancia de una clase, automticamente se crea unainstancia de la clase base, como se puede ver en el siguiente ejemplo:


55/65

Curso: C# Bsico

using System;

namespace Herencia2

{

class Foo

{

public Foo ()

{

Console.WriteLine ("Construllendo FOO");

}

}

class Bar : Foo

{

public Bar (){

Console.WriteLine ("Construllendo BAR");

}


{

new Bar ();

}

}

}

Si deseamos elegir que constructor de la clase base se debera de llamar,utilizamos la misma sintaxis que cuando un constructor llama a otro, aexcepcin de que usamos la palabra reservada base a la vez de this. Ladiferencia entre base y this, es que base es una referencia a la clase base.Ejemplo:


56/65


57/65

Curso: C# Bsico

using System;

namespace Polimorfismo

{

class Vehiculo

{

publicvirtualvoid Acelerar ()

{

Console.WriteLine ("El vehiculo acelera de forma

misteriosa");

}

}

class Bicicleta : Vehiculo{

publicoverridevoid Acelerar ()

{

Console.WriteLine ("El conductor pedalea rapidamente

para acelerar");

}

}

class Class1

{


{ Vehiculo v = new Vehiculo ();

v.Acelerar ();


bici.Acelerar ();

Vehiculo vehiculoBici = bici;

vehiculoBici.Acelerar ();

}

}

}

Aqu vemos como la bicicleta cambia su comportamiento, pero esto no seria

muy til sin poder hacer lo que vemos en la lnea:Vehiculo vehiculoBici = bici;

Esto puede ser extrao al principio, pero tiene su explicacin lgica.Habamos mencionado que usualmente se tiene una relacin de herenciacuando vemos una relacin del tipo is-a. Por ejemplo, la bicicleta is-avehculo. Esto nos permite guardar en una variable de tipo X, una referencia acualquier objeto que herede en algn momento de este tipo X. Si hacemos


58/65

Curso: C# Bsico

esto, no podemos acceder a los mtodos nuevos que defini el nuevo tipo,

pero si accedemos a los mtodos comunes del tipo X, estos se comportarancomo el nuevo tipo, no como estaban previamente definidos para X.

Si deseamos evitar esto, deberemos usar new en ves de override, comoveremos a continuacin:

using System;

namespace Polimorfismo

{

class Vehiculo

{

publicvirtualvoid Acelerar ()

{

Console.WriteLine ("El vehiculo acelera de forma

misteriosa");

}

}

class Bicicleta : Vehiculo

{

publicnewvoid Acelerar ()

{

Console.WriteLine ("El conductor pedalea rapidamente

para acelerar");}

}

class Class1

{


{

Vehiculo v = new Vehiculo ();

v.Acelerar ();


bici.Acelerar ();

Vehiculo vehiculoBici = bici;

vehiculoBici.Acelerar ();

}

}

}

En este caso no ejecuta el nuevo mtodo, sino que ejecuta el mtodo definidooriginalmente.


59/65

Curso: C# Bsico

7.3 Modificadores de Herencia

Modificador Significado

abstract El mtodo no esta implementadonew Oculta la implementacin original

override Especifica que se esta redefiniendo un mtodo heredadosealed La clase no puede ser heredada, o el mtodo no puede ser redefinido

(junto con override)virtual Permite que los mtodos puedan ser redefinidos

7.4 Clases abstractas

Hay ocasiones en las que se desea especificar la implementacin de soloalgunos mtodos, y dejar la responsabilidad de la implementacin de losdems mtodos a las clases que hereden de esta. En este caso se le asigna elmodificador abstract a los mtodos que no sern implementados. Si una clasetiene por lo menos un mtodo abstracto, la clase entera debe de ser marcadaabstracta.

Una clase abstracta no puede ser instanciada, si una clase hereda de una claseabstracta, y no implementa algn mtodo abstracto heredado, esta clase debede ser tambin marcada como abstracta.

Ejemplo:


60/65

Curso: C# Bsico

using System;

namespace ClaseAbstracta

{

abstractclass Foo

{

publicabstractvoid DoFoo ();

}

abstractclass Bar : Foo

{

//Debe de ser abstracta por que no implementa DoFoo

}

class FooBar : Bar{

publicoverridevoid DoFoo ()

{

Console.WriteLine ("Doing Foo");

}

}

class Class1

{


{

FooBar foobar = new FooBar ();

foobar.DoFoo ();

Bar b = foobar;

b.DoFoo ();

Foo f = foobar;

f.DoFoo ();

}

}

}

Si intentramos instancias Foo o Bar obtendramos un error en tiempo decompilacin debido a que las clases son abstractas.

7.5 is

El operador is nos sirve para identificar si algn objeto es de algn tipo enespecifico, su sintaxis es:

is


61/65

Curso: C# Bsico

Este operador nos devuelve true si el objeto es de la clase especificada o si

hereda en algn momento de ella.

Ejemplo:

using System;

namespace IS

{

class Foo

{

}

class Bar : Foo

{

}

class FooBar : Bar

{

}

class Class1

{


{Foo foo = new Foo ();

Bar bar = new Bar ();

FooBar foobar = new FooBar ();

CheckIs (foo);

CheckIs (bar);

CheckIs (foobar);

bar = foobar;

CheckIs (bar);

foo = bar;

CheckIs (foo);

}

staticvoid CheckIs (object o){

if (o is Foo)

Console.WriteLine ("Object is Foo");

if (o is Bar)

Console.WriteLine ("Object is Bar");

if (o is FooBar)

Console.WriteLine ("Object is FooBar");

}

}

}


62/65

Curso: C# Bsico

7.6 Conversin de tipos y as

Hemos visto anteriormente como le asignamos una instancia de una clase X auna variable de tipo Y siempre que X herede de Y. Esta conversin esimplcita, sin embargo, si deseamos hacer lo contrario (convertir de Y a X),debemos de hacer una conversin explicita, esto es debido a que si Y nuncafue X, no puede ser asignado a X, es por esto que el compilador pide esto,para evitar posibles errores, la sintaxis es idntica como la conversin entretipos de valor:

()

Si la conversin no es valida obtendremos un error en tiempo de ejecucin.Otra manera de realizar esta operacin es con la palabra reservada as y esusado as:

as

Cuando se realicen estas operaciones es importante usarlo en conjunto con eloperador is, para evitar posibles errores, una regla general es:

Tipo foo;

if (instancia is Tipo)

foo = (Tipo) instancia

o bien:

Tipo foo;

if (instancia is Tipo)

foo = instancia as Tipo


63/65

Curso: C# Bsico

8 Estructuras

Las clases son muy parecidas a las clases, la diferencia radica que lasestructuras no pueden heredar, y estas son tipos de valor. Para definirlas solousamos la palabra reservada struct en ves de class. Como las estructuras sontipos por valor, estas se almacenan en el stack, al contrario de los tipos dereferencia que se almacenan en el managed heap. Esto implicaconsideraciones de rendimiento, por ejemplo es mas rpido acceder a unaestructura dentro de un mismo mtodo, pero puede ser muy lento enviarlas

como parmetro (necesitan ser copiadas).Considere muy bien a la hora de elegir entre una clase o una estructura.

9 Interfaces

Las interfaces son una especie de contratos, las cuales definen mtodos ypropiedades mas no las implementan, las clases pueden implementar muchasinterfases, pero solo pueden heredar de una clase. Si una clase implementa una

interfase, esta debe de implementar todos los miembros que estas definen, sino lo hace, esta deber de ser marcada como abstracta. Las interfases puedenimplementar interfases ellas mismas.

Las interfases no pueden definir constructores y no puede especificar lavisibilidad de sus miembros.

Las interfases se definen del mismo modo que las clases, solo que estas usanla palabra reservada interfase al contrario de class, adems no puedeimplementar ningn mtodo, un ejemplo de interfase:

publicinterface Foo

{

void DoFoo ();

bool DoBar ();

int FooBar

{

get;

set;

}

}


64/65

Curso: C# Bsico

10 Excepciones

El manejo de excepciones es un mecanismo que se encuentra incorporado en.NET para detectar y manejar errores en tiempo de ejecucin. .NET contienemuchsimas excepciones estndares, pero uno puede definir las suyas propias.Las excepciones son anomalas que ocurren durante la ejecucin de unprograma. Si el desarrollador no provee un mtodo de manejar excepcionesestas causan la terminacin del programa.

Todas las excepcionas heredan en algn momento de System.Exception, C#maneja las excepciones con try, match y finally.

Cuando una porcin de cdigo puede ocasionar una excepcin, este seencierra en un bloque try, posteriormente debe de haber un conjunto debloques catch, los cuales especifican que acciones tomar si algn tipo deexcepcin es lanzada dentro del bloque try.

Opcionalmente se puede tener un bloque finally, donde su cdigo se ejecutarasiempre, haya o no haya sido lanzada una excepcin, usualmente es til para

liberar recursos no manejados (archivos, conexiones, etc.).Para definir sus propias excepciones debe de crear una clase que herede deSystem.Exception o cualquier otra clase que haya heredado de esta ultima.

Podemos lanzar excepciones manualmente con la sentencia throw, de laforma:

throw

Esta es la estructura de try, catch y finally:


65/65

try

{

//Codigo que puede lanzar una excepcion

}

catch ( [])

{

//Codigo para el manejo de la excepcion

}

catch ( [])

{

//Codigo para el manejo de la excepcion

}

..

finally

{

//Esto siempre se ejecuta}

Cuando una excepcin es lanzada dentro del try, el runtime empieza a buscarbloque por bloque de catch, si la excepcin es del tipo del bloque actual, si loes, ese bloque toma el control, si no lo es continua la bsqueda. Si ningncatch es del tipo de la excepcin esta se propaga al mtodo que mando llamaral mtodo actual. Si la excepcin no es atrapada en ningn catch, la aplicacintermina.

Cuando el runtime encuentra el catch apropiado, deja de buscar, dndose unefecto de coladera, as que es importante el orden de los bloques catch, porejemplo si se pone primero un catch (Exception) este atrapara todas lasexcepciones, y no verificara los bloques posteriores.

01 c sharp basico

Documents