Unidad 1. Desarrollo de Objetos en La Plataforma .NET

Programacin .NET II Unidad 1. Desarrollo de objetos en la plataforma .NET

Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software

Ingeniera en Desarrollo de Software

8 cuatrimestre

Programa de la asignatura:

Programacin .NET II

Unidad 1. Desarrollo de objetos en la plataforma .NET

Clave:

150930934

Universidad Abierta y a Distancia de Mxico

UnADM


Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 1

ndice

Presentacin de la Unidad ................................................................................................. 2

Propsitos .......................................................................................................................... 2

Competencia especfica ..................................................................................................... 2

1.1. Encapsulacin ............................................................................................................ 3

1.1.1. Mtodos miembro ................................................................................................. 6

1.1.2. Propiedades ....................................................................................................... 10

Actividad 1. Encapsulamiento .......................................................................................... 14

Actividad 2. Encapsulacin de datos mediante CSharp ................................................... 14

1.2. Construccin y destruccin en CSharp ..................................................................... 16

1.2.1. Constructores ..................................................................................................... 17

1.2.2. Destructores ....................................................................................................... 20

1.3. Sobrecarga ............................................................................................................... 22

1.3.1. Sobrecarga de constructores .............................................................................. 23

1.3.2. Sobrecarga de mtodos ..................................................................................... 24

1.3.3. Sobrecarga de operadores ................................................................................. 27

Actividad 3. Construccin, destruccin y sobrecarga ....................................................... 30

Actividad 4. Sobrecarga ................................................................................................... 31

Autoevaluacin ................................................................................................................ 32

Evidencia de aprendizaje. Desarrollo de objetos en .NET ................................................ 32

Autorreflexiones ............................................................................................................... 33

Cierre de la unidad .......................................................................................................... 34

Para saber ms ............................................................................................................... 34

Fuentes de consulta ........................................................................................................ 35



Presentacin de la Unidad

Bienvenido(a) a la primera unidad de la asignatura Programacin .Net II. Es una materia

seriada, y en este sentido ser necesario que apliques los conocimientos adquiridos en

Programacin .Net I del sptimo cuatrimestre. Ahora sabes que en la programacin .Net

uno de los lenguajes utilizados es CSharp, y se aplica en la solucin de problemas

orientados a objetos.

Con esta unidad se inicia tu aprendizaje de los conceptos de programacin orientada a

objetos utilizando la tecnologa de .Net, especficamente el lenguaje CSharp. Para ello,

recordars conceptos como propiedades, mtodos miembros, constructores, destructores

y sobrecarga, todos ellos desde el punto de vista de Microsoft y .Net.

Aprenders nuevos conceptos tales como los que se refieren a colecciones, arreglos y

manejo de errores. Elementos que son empleados en diversos lenguajes orientados a

objetos, y de gran utilidad en el desarrollo de aplicaciones en el sector productivo.

Propsitos

Al trmino de esta unidad logrars:

Entender el concepto de encapsulacin. Comprender la

utilidad que para este fin tienen los mtodos junto con los datos

miembros de una clase, y su forma de construir clases

encapsuladas.

Identificar en qu consiste la encapsulacin, la utilidad de los

mtodos y datos miembro de una clase.

Manejar los constructores y destructores dentro de una clase, as como los

diferentes tiempos en los que estos mtodos son utilizados.

Comprender y utilizar la sobrecarga de un objeto, aplicarla en el desarrollo de ste,

y a la vez entender los beneficios de la sobrecarga de mtodos, constructores y

operadores.

Competencia especfica

Utiliza el lenguaje CSharp de la plataforma .NET para

construir objetos de software, con el propsito de entender el manejo

de encapsulamiento, construccin y sobrecarga.



1.1. Encapsulacin

La historia de la programacin ha sido marcada por una serie de propuestas que estn

pensadas en guiar al desarrollador para que ste desempee su trabajo siguiendo dos

principios:

Primero: reutilizar el trabajo ya realizado. En otras reas de la ingeniera no se parte de

cero para la construccin del siguiente paso de la tecnologa, normalmente se toma como

punto de inicio lo ya creado. En el rea de sistemas este concepto anteriormente era casi

desconocido, la programacin orientada a objetos intenta agregar este proceso a la forma

de desarrollar objetos de software.

Segundo: el mundo real puede ser interpretado, de manera ms fcil, si todo se

representa como objetos y con la manera en que stos se congregan para formar

entidades ms complejas. La programacin orientada a objetos sigue este pensamiento,

mientras busca que el desarrollo sea un proceso acumulativo de objetos computacionales

basados en los anteriores.

La programacin orientada a objetos se basa en conceptos considerados fundamentales

de esta metodologa de programacin, tales como encapsulacin, herencia y polimorfismo

(Sharp, 2010). Para iniciar el estudio de la unidad se presenta en este tema la definicin y

caractersticas del concepto de encapsulacin.

La encapsulacin es un mecanismo que consiste en organizar datos y mtodos de una

estructura para evitar que ellos sean consultados y modificados por un medio distinto a los

especificados. Por lo tanto, la encapsulacin permite garantizar la integridad de los datos

que contiene un objeto (Ferguson et al., 2010). Recuerda que la integridad de los datos

es un concepto fundamental dentro de la programacin orientada a objetos, por lo que

debes asegurarte de que una clase sea la nica responsable del acceso a sus mtodos y

atributos. Esto est definido as en la programacin orientada a objetos.

Adems de envolver datos y mtodos en una sola unidad, la encapsulacin tambin

oculta los detalles internos de datos y el comportamiento de un objeto (Michaells, 2010).

El usuario de una clase en particular no necesita saber cmo estn estructurados los

datos dentro de ese objeto, es decir, un usuario no necesita saber la forma en que fueron

programados. Mediante la encapsulacin los datos se ocultan, se encapsulan dentro de

una clase, y la clase implementa un diseo que permite que otras partes del cdigo

accedan de esos datos de forma eficiente. Imagina la encapsulacin como un envoltorio

protector que rodea a los datos de las clases de C# (Ferguson et al., 2010).



De acuerdo con lo anterior, es posible comparar la clase con una cpsula, puesto que

cada objeto es una estructura en cuyo interior hay datos y un cdigo que los manipula,

todos ellos relacionados entre s, como si estuvieran encerrados en una cpsula, de ah el

trmino de encapsulacin.

Representacin metafrica de encapsulacin. Tomada de 123RF.com.

Encapsulacin significa que un grupo de propiedades relacionadas, mtodos y otros

miembros, se tratan como una sola unidad u objeto (MSDN, 2013). Se conocen 4

alcances (MSDN, 2013):

1. Pblico: en el que cualquier funcin de cualquier objeto puede acceder a los datos

o mtodos de una clase que se define con este nivel de acceso. Este es el nivel de

proteccin de datos ms bajo.

2. Internal: el acceso a los datos slo est permitido al proyecto actual, es decir, a la

clase que se est compilando.

3. Protegido: es un acceso a los datos restringido, se hereda pero no se puede

manipular desde afuera.

4. Privado: el acceso a los datos est restringido, slo pueden ser modificados por

los mtodos de la clase que se est compilando. Este es el alcance ms alto de

proteccin de datos.

El siguiente ejemplo te aclarar el tema de los diferentes alcances.

Imagina que te solicitan crear la clase Entrada que representa en la vida real la entrada

a una casa, a un edificio, etctera. Todas las entradas deben tener las siguientes

caractersticas: alto, ancho y una propiedad que indique si est abierta o cerrada. Estos



datos (alto y ancho) puede ser representados por una variable de tipo double, y la

propiedad que indique si est cerrada o abierta de tipo boolean, true si est abierta y

false si est cerrada. Estas propiedades debern ser de los siguientes tipos segn el

escenario que se presente:

Internal Los datos miembro slo sern manipulados por el mismo objeto, y ste slo ser manipulado por la misma clase que lo define. El objeto no tendr una jerarqua de herencia. En el ejemplo los datos miembro tendrn la siguiente descripcin:

Privado Los datos miembro slo sern manipulados por el mismo objeto, y ste ser

manipulado por otras clases pero no deben tener acceso a los datos miembro. El objeto no tendr una jerarqua de herencia. En el ejemplo los datos miembro tendrn la siguiente descripcin:

Protegido Los datos miembro slo sern manipulados por el mismo objeto, y ste ser

manipulado por otras clases pero no deben tener acceso a los datos miembro. El objeto tendr una jerarqua de herencia. Por ejemplo:

Pblico Los datos miembro sern manipulados por el mismo objeto, y otras clases

deben tener acceso a dichos datos. El objeto puede o no tener una jerarqua de herencia (puede o no tener hijos). Por ejemplo:

En los siguientes subtemas abordars los mtodos miembro, que son una de las

funciones que permiten dar integridad a los datos miembro. Cabe mencionar que los

mtodos miembro aseguran el proceso de encapsulacin al ser las nicas funciones

vlidas que pueden manipular los datos.



1.1.1. Mtodos miembro

Los mtodos miembro son funciones que pertenecen a un objeto (son miembros de la

clase, de ah su nombre). En este subtema se explicar de una manera ms profunda

cmo se definen y sus propiedades.

Un mtodo miembro es una funcin asociada a un objeto. Desde el punto de vista del

comportamiento del objeto, es lo que el objeto puede hacer. Por ejemplo, si se tiene una

clase llamada CuentaBancariaDeDebito y uno de sus datos es saldo, el comportamiento

de esa clase es el de revisar que su saldo no sobrepase a un valor negativo; es decir,

evitar, informar o estar pendiente de que no se retire ms de lo que se tenga de saldo.

Como dice Marck Michaells en el libro Essential C# (2010) un mtodo es un medio de

agrupacin de una secuencia de instrucciones que realizan una determinada accin o

calculan un resultado determinado, esto proporciona mayor estructura y organizacin de

las normas que conforman el programa (p. 220).

Todas las clases tendrn cuando menos un mtodo, como ya pudiste constatarlo en la

asignatura Programacin .Net I. En esta plataforma se cuenta con el mtodo llamado

Main(), que es el punto de entrada de la clase. Pero una clase tambin se compone de

muchos otros mtodos que, segn lo propuesto por Deitel (2007), pueden clasificarse en:

Constructores

Destructores

Setters y getters, tambin llamados propiedades

Mtodos de uso general

A continuacin se explica la forma en que se aplican los mtodos de uso general.

Cuando un mtodo es invocado (ejecutado), es conceptualmente lo mismo que enviar un

mensaje a una clase, por ello algunos autores les llaman interfaces; porque son el medio

de comunicar al objeto con su ambiente exterior.

Existen dos funcionalidades bsicas de un mtodo:

1. Manipular los datos miembro del mismo objeto.

2. Comunicarse con otros objetos, que son los llamados interfaces, porque tienen la

capacidad de enviar y recibir mensajes de otros objetos.

Un mtodo se define de acuerdo a la siguiente nomenclatura:



Basado en MSDN, 2013.

En la que se puede apreciar que:

[alcance]: se refiere al grado de encapsulacin, que como sabes puede ser pblico,

internal, protegido y privado. El estar entre corchetes [ ] significa que lo que est adentro

no es necesario, es opcional, y, si no se pusieran, ser de tipo internal.

Tipo: tipo del valor de retorno. Un mtodo puede devolver un valor a quien lo llama o no

devolver nada. El valor devuelto por un mtodo puede ser de un tipo primitivo de datos o

una referencia, pero nunca puede devolver ms de un valor. Si el mtodo no devuelve

nada, el tipo devuelto por el mtodo es el tipo void y debe indicarse utilizando esa

palabra.

nombreDelMetodo: existe un acuerdo propuesto por Microsoft de que los nombres de los

mtodos comienzan con minscula. Si el nombre de ese mtodo es un nombre

compuesto cada nueva palabra empieza con maysculas, para los nombres de los

mtodos tambin se ha propuesto que inicien con un verbo.

Ejemplo: sumarNumeros, calcularPerimetro, pintar, terminar.

Posible lista de parmetros: la lista de parmetros es opcional porque la funcin podra

no tenerlos, en caso de que los tenga se trata de variables locales (slo accesibles y

visibles por el propio mtodo), se separa por comas en las que se debe de especificar el

tipo y nombre de cada uno, se inicializan en la llamada recibiendo los valores

especificados por los argumentos de la llamada. Si la funcin no lleva parmetros hay que

colocar los parntesis (Pelez, 2005).

Lo contenido entre las llaves { } se conoce como el cuerpo del mtodo, y est

conformado por la siguiente informacin:



Definicin de variables locales: dentro de los mtodos se pueden definir variables,

estas slo son accesibles dentro del mtodo en donde se han definido. Este tipo de

variables no se inicializan por defecto, si no se inicializan en el momento de la definicin,

se deben de inicializar con un valor antes de utilizarlas, de lo contrario el compilador

detectar un error (Pelez, 2005).

Sentencias: son las instrucciones necesarias para realizar una tarea.

La instruccin return devuelve el control de la ejecucin al paso que hizo la llamada. Si se

tiene un mtodo no devuelve nada y se elimina la sentencia return, la funcin termina con

la llave final, tambin llamada llave de cierre de la funcin. Es en estos casos cuando el

mtodo devuelve un tipo void. En los casos en los que el mtodo retorna un valor, la

funcin no puede ser de este tipo y la sentencia return, adems de producir la salida de la

funcin, especificar el valor de retorno al punto donde se hizo la llamada. En un mtodo

de una funcin puede haber ms de una sentencia return, pero slo se ejecuta una a un

tiempo (Pelez, 2005).

A continuacin se presentan estos conceptos en un ejemplo:

En el mundo real existen los libros. De entre sus muchas caractersticas un libro tiene

ttulo, autores, editorial y ao de edicin. Si se quisiera llevar este concepto de libro a un

objeto en CSharp, se tendra una clase llamada Libro, con los datos miembro: titulo,

autores, editorial y edicion. Los tres primeros datos de tipo string y el ltimo de tipo

entero. El listado de esta idea se muestra a continuacin:

Si se requiere agregar un mtodo llamado nuevoLibro que reciba como parmetros

elTitulo, losAutores, laEditorial y laEdicion de tipo string en los tres primeros casos y

la ltima de tipo entero, estos parmetros se pasan al objeto como se observa a

continuacin:



Supn que se necesita un mtodo llamado antiguedadDelLibro que recibe el ao actual

como un nmero entero y devuelve el nmero de aos que tiene de impreso el libro. La

funcin relacionada se muestra a continuacin:

A fin de no generar nuevas variables, CSharp permite repetir el nombre de los parmetros

y el nombre de los datos miembro, la forma de diferenciarlos es utilizando la palabra

reservada this para los datos miembro. Observa esto con un ejemplo:

Supn que se necesita una funcin llamada cambiarTitulo que permita precisamente

cambiar el ttulo del libro. Una forma de hacer esto se muestra a continuacin:

En el ejemplo se est guardando el parmetro dentro del objeto.



Finalmente recuerda que si el mtodo es pblico podr ser utilizado por cualquier

programa. Observa el uso de este objeto:

Cuando se ejecuta este programa se obtiene el siguiente resultado:

El libro tiene tres aos de antigedad.

Ten en cuenta que los mtodos miembro trabajan en conjunto, a ello se le nombra

propiedades, y es lo que se abordar en el siguiente subtema.

1.1.2. Propiedades

Las propiedades son mtodos miembros que ofrecen un mecanismo flexible para leer,

escribir o calcular los valores de campos privados. Se pueden utilizar las propiedades

como si fuesen miembros de datos pblicos, aunque en realidad son mtodos especiales

denominados descriptores de acceso. De este modo, se puede tener acceso a los datos

con facilidad, a la vez que proporcionan la seguridad y flexibilidad de los mtodos (MSDN,

2013).

Para ejemplificar lo que son las propiedades, considera el caso en que se requiera

construir un objeto llamado Reloj, con tres datos miembro: horas, minutos y segundos.

Recuerda que CSharp te permite utilizar variables y nombres de mtodos con

caracteres latinos como int aoActual, pero no es recomendable porque te pueden

ocasionar problemas si cambias de computadora y sta tiene definido en Windows el

idioma ingls u otro. Por ello, es preferible int antiguedad a int antigedad.

System.Console.ReadLine(), para que se detenga y haya tiempo de ver el resultado

de la ejecucin.



Todos ellos de tipo int y privados para que el concepto de encapsulamiento se aplique,

es decir, que slo sean accesados por los mismos miembros del objeto. Esto en CSharp

se desarrollara como se muestra en el siguiente listado:

En este ejemplo se han encapsulado los datos para que no puedan ser modificados

desde el exterior, por lo que para poder lograr que sean manejados desde el exterior se

utiliza el concepto de propiedad que proporciona CSharp.

El formato para declarar una propiedad en CSharp es el siguiente:

Dentro de esa propuesta de desarrollo, los estndares de Microsoft (MSDN, 2013)

plantean que el nombre de las propiedades inicie con una letra Mayscula, teniendo el

mismo nombre que la propiedad a la cual van a servir de interfaz. Siguiendo ese

delineamiento la propiedad para horas tendra el siguiente cdigo:



Como se observa, se ha implementado una interfaz para horas. En el mtodo get, que

devuelve el contenido de la variable horas, slo se utiliza la palabra reservada return.

En el mtodo set, que permite guardar valores dentro de la variable horas, utiliza el

parmetro value que representa el valor que se est recibiendo y se guarda dentro de

una variable. Un ejemplo del uso del objeto es el siguiente:

De esta manera se logra el acceso a datos privados mediante el concepto de

propiedades. Como puedes observar, el dato horas al ser privado slo se puede acceder

a travs de la propiedad Horas.

Ahora, imagina que necesitas una propiedad de slo lectura llamada Hora_Actual.

Una propiedad de slo lectura significa que no es posible asignar un valor, slo ser

posible ver su contenido.

Considera necesario que cuando se imprima el contenido de Hora_Actual se muestre

horas:minutos:segundos. Una respuesta vlida sera 10:30:22.

No sera correcto hacer algo como esto: reloj.Hora_Actual=10:30:22; porque se est

utilizando a la propiedad para escribir un valor y en la propuesta no se permite. Slo se

requiere ver el contenido, es decir, una propiedad de slo lectura.

El cdigo para nicamente ver su contenido, es decir, de slo lectura se muestra a

continuacin:



En el cdigo puedes observar tres cosas:

1) No es necesario que una propiedad encapsule un valor dentro de la clase. En este

caso slo existe la propiedad Hora_Actual pero no est ligada a un dato

especfico dentro de la clase.

2) No existen instrucciones para el mtodo set, por lo tanto la propiedad no puede

recibir valores; ser de slo lectura. Si faltara el cdigo de las instrucciones para

get y existiera uno para la instruccin set, la propiedad sera de slo escritura

pero no se podra recuperar un valor de la variable.

3) No es forzoso el uso de slo retornar o tomar valores como parte de las

propiedades, es posible hacer cualquier operacin dentro de ellas.

System.Convert.ToString convierte el dato horas, que es de tipo entero, a un

dato de tipo string.

De acuerdo con lo anterior, se puede resumir que la encapsulacin es un mecanismo que

permite a los programadores determinar qu datos y mtodos miembro sern utilizados

por la misma clase y por las otras que compondrn el desarrollo, al mismo tiempo que

proporciona una serie de herramientas para lograrlo.

Las principales ventajas de la encapsulacin consisten en que

- Facilita a los desarrolladores el ocultar detalles de la implementacin interna y slo

deja visibles aquellos que son seguros de usar.

- Cuando se modifica, permite que los cambios posteriores de los objetos no afecten

la funcionalidad de las clases derivadas, porque los programadores al no poder

acceder no pueden alterarlos.

En los siguientes temas continuars viendo las ventajas de los otros pilares de la

programacin orientada a objetos.



Actividad 1. Encapsulamiento

Como ahora sabes, la encapsulacin se logra mediante el manejo de los cuatro alcances

o niveles de encapsulamiento de CSharp: public, private, protected, internal, y cada

uno permite que el encapsulamiento se concrete de forma ordenada. En esta actividad

identificars el uso y los alcances de cada uno. Para ello:

1. Elabora un cuadro comparativo donde expongas el uso de cada uno de los

niveles de acceso o alcances, acompalos con ejemplos donde se muestre el

alcance de cada uno.

1. Guarda tu actividad con la nomenclatura DPRN2_U1_A1_XXYZ. Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por tu segundo apellido.

2. Sube tu archivo a la base de datos.

3. Consulta el documento Criterios de evaluacin de actividades U1 para ver la

rbrica de la actividad y conocer los parmetros de evaluacin.

4. Posteriormente, comenta el cuadro comparativo y los ejemplos de, al menos, dos

de tus compaeros(as), respecto a la definicin de cada uno de los niveles de

encapsulamiento, usos y alcances; as como respecto a la pertinencia de los

ejemplos que incluyan. Realiza tus comentarios con respeto y de forma

constructiva.

Actividad 2. Encapsulacin de datos mediante CSharp

En esta actividad aplicars tus conocimientos para solucionar un problema donde se

encapsulen datos utilizando las instrucciones de CSharp. Para comenzar:

1. Construye un objeto a partir de las indicaciones que te haga llegar tu

Facilitador(a).

2. A partir de las indicaciones que recibas, convierte en propiedad los datos

miembros.

3. Escribe el cdigo en la plataforma de C#. Net modo consola, en el que se debe

mostrar la clase y dentro de sta los mtodos (funciones).



4. Ejecuta tu cdigo de forma que muestre los resultados deseados y que no

contenga errores.

5. Elabora una explicacin de la funcionalidad del objeto desarrollado e intgrala en

un documento de texto junto con las capturas de pantalla de la ejecucin de tu

programa.

6. Consulta el documento Criterios de evaluacin de actividades U1 para conocer

los criterios de evaluacin de la actividad.

7. Al concluir tu programa, guarda todo tu proyecto en un archivo .zip con el nombre

DPRN2_U1_A2_XXYZ. Sustituye las XX por las dos primeras letras de tu primer

nombre, la Y por tu primer apellido y la Z por tu segundo apellido.

8. Posteriormente, enva el archivo a tu Facilitador(a) para recibir retroalimentacin.



1.2. Construccin y destruccin en CSharp

Una de las mejores definiciones de constructores y destructores se puede encontrar en

el libro La biblia de CSharp de Ferguson et l. (2005) donde se menciona que:

Los constructores y los destructores son mtodos especiales, el primero de ellos sirve

para inicializar un objeto a un estado conocido que sea necesario para poder utilizarlo.

Por el contrario un destructor es un mtodo especial que se ejecuta cuando el CLR (el

entorno comn de ejecucin) destruye los objetos de la clase. Permite liberar recursos

(memoria, valores, dispositivos) para que otros objetos dispongan de ellos (p. 423).

Este es un concepto de la programacin orientada a objetos, es decir, cualquier

lenguaje que soporte este modelo de desarrollo debe proveer herramientas para

implementar los mtodos especiales.

As mismo, en la mayora de los lenguajes, si en el momento de desarrollar un objeto no

se declara constructor o destructor, el compilador agregar de forma automtica uno de

ellos con caractersticas especiales.

Ten en cuenta que todos los objetos tienen cuatro fases importantes en su ciclo de vida:

1. Creacin: reserva de espacio en memoria para un nuevo objeto.

2. Construccin: establecimiento de las condiciones iniciales necesarias para

manipular un objeto. Se revisar en el subtema 1.2.1. Constructores.

3. Operacin: es la parte donde el objeto realiza las actividades que se le encargan,

mediante la programacin de sus mtodos. Todo el proceso de desarrollo de las

aplicaciones se manejan en este punto.

4. Destruccin: establecimiento de las condiciones necesarias para que un objeto

pueda desaparecer (entre ellas, la liberacin del espacio de memoria). Esto se

revisar con detalle en el subtema 1.2.2. Constructores.

Lo correspondiente a la creacin fue revisado de manera indirecta con anterioridad, y lo

recordars al crear una instancia de libro. Para ello, considera el ejemplo revisado

durante el primer tema de esta unidad:



En el siguiente subtema se expondr lo correspondiente a la segunda y cuarta etapa del

ciclo de vida de un objeto; es decir, la etapa de construccin y destruccin, dentro de la

programacin en lenguaje CSharp. Tambin se explicarn los mtodos utilizados en cada

una de las etapas mencionadas.

1.2.1. Constructores

En relacin al ciclo de vida de un objeto, para este subtema comenzars con la revisin

de la segunda etapa que, como sabes, se refiere al uso de los constructores en CSharp.

Los constructores son mtodos de clase que se ejecutan cuando se crea un objeto de

un tipo determinado, en CSharp tienen el mismo nombre que la clase y, normalmente,

inicializan los miembros de datos del nuevo objeto (MSDN, 2013).

Retomando el ejemplo del inicio de la unidad, si se tiene una clase llamada Libro su

constructor ser un mtodo tambin llamado Libro.

Un constructor que no toma ningn parmetro se denomina constructor predeterminado

y si no se escribe uno, el compilador define uno con esas caractersticas (sin ningn

parmetro).

Cuando se utiliza la instruccin new se est invocando al constructor de la clase.

Un constructor tendr el siguiente formato:




En donde:

Modificadores: los constructores slo pueden ser pblicos o privados. Para fines

prcticos de esta asignatura, todos los constructores sern pblicos. Los constructores

privados tienen un uso muy especial que revisars ms adelante.

NombreDeLaClase: todos los constructores deben llamarse como se llama la clase.

Exactamente igual en letra y tipo de ellas (maysculas y minsculas).

Posible lista de parmetros. La lista de parmetros formales es opcional, el constructor

podra no tener, cuando los tiene se tratan como variables locales, slo accesibles desde

el interior del constructor. Estos parmetros se separan por comas, llevan el tipo y el

nombre. Se inicializan en la llamada recibiendo los valores. Si el constructor no tiene

parmetros hay que poner los parntesis.

El cuerpo del constructor tendr el siguiente formato:

Definicin de variables locales: dentro de los constructores se pueden definir variables

que slo son accesibles dentro de ellos. Este tipo de variables no se inicializan por

defecto, por lo tanto se deben inicializar en el momento de su definicin o deben de

inicializar antes de utilizarlas, pues de lo contrario el compilador detecta un error.

Sentencias: son las instrucciones necesarias para realizar determinada tarea.

Es necesario observar dos puntos importantes:

1. Un constructor no devuelve ningn tipo de dato. Incluso no debe devolver un

tipo void. Por lo tanto no se pone ninguna palabra en tipo.

2. Como consecuencia de lo anterior, no es vlido utilizar la palabra return en

ningn caso.



Retomando el objeto del reloj, se agregar un constructor que reciba los parmetros de

horas, minutos, segundos, y los guarde dentro de los datos miembro del objeto. El

cdigo quedara como se muestra a continuacin:

Los elementos que inician con el operador this, se refieren a los datos del propio objeto y

los elementos que no inician con esa palabra son los parmetros del constructor.

Un objeto puede tener varios constructores, si supones que se necesita un constructor

que no reciba parmetros y por lo tanto inicialice todos los datos miembro en cero. En ese

caso el constructor tendra la siguiente apariencia:

El compilador distingue que son dos constructores diferentes por el nmero de

parmetros de cada uno. Cuando se invocan en el programa principal se puede ver cmo

se construyen dos instancias.

Importante: es altamente recomendado por Microsoft que se utilice el

operador this para evitar la creacin de una gran cantidad de variables

en el momento de la definicin de un mtodo o constructor. Esta

tcnica de programacin es muy utilizada en el desarrollo de

aplicaciones reales.



En el primer caso reloj1, sus valores internos de horas, minutos y segundos en 0.

En el segundo caso reloj2, sus valores internos de horas son de 10, el de minutos de 32 y

el de segundos de 43.

Esto lo podemos ver en los datos que se imprimen:

0:0:0

10:32:43

Ten en cuenta que los constructores pueden realizar cualquier actividad, la nica

condicin es que no pueden devolver un valor. En el siguiente subtema se explicar lo

correspondiente a los destructores.

1.2.2. Destructores

En este subtema se abordarn los mtodos opuestos a los constructores, es decir, los

destructores. Si un constructor inicializa datos cuando el objeto es construido, un

destructor (como su nombre lo indica) destruye los datos que el constructor inicializ.

Los destructores se utilizan para destruir instancias de clases. Como dice el libro de

Microsoft, C# Language Specification (2010): es posible comparar un destructor como lo

opuesto a un constructor (p. 484). Un destructor en programacin orientada a objetos es

una funcin miembro especial que es invocada automticamente cuando el objeto se

deja de referenciar (termina de ejecutarse). Segn Eckel Bruce (2010), sus principales

actividades son:

1. Liberar los recursos computacionales que el objeto haya adquirido en el tiempo de

ejecucin al terminar de residir en memoria.

2. Eliminar todas las referencias que tenga de otros recursos u objetos.



De acuerdo con MSDN (2013), al contrario de un constructor:

a. Una clase slo puede tener un destructor.

b. No se puede llamar a los destructores. Se invocan automticamente.

c. Un destructor no permite modificadores de acceso ni tiene parmetros.

La sintaxis de un destructor es la siguiente:


Directamente en el portal de Microsof de CSharp (2013), se dice que El programador no

tiene control sobre cundo se llama al destructor porque esto est determinado por el

recolector de basura, pero cuando este se llame ejecutar el cdigo que se implemente.

Un ejemplo simple de un recolector de basura es el que se muestra a continuacin,

retomando el ejemplo de la clase reloj.

Importante: al smbolo ~ se le conoce como tilde en los pases latinos.

Importante: el Garbage Collector o Recolector de basura es el

responsable de liberar memoria, eliminando todos aquellos objetos que

ya no se estn utilizando. Es un proceso automtico y el usuario no

tiene control.



Las actividades en este destructor son simples. Se limpian las variables del objeto. Esto

de manera general no es necesario, pero ejemplifica muy bien una labor final.

Los destructores tienen pocos usos, pero el ms comn es el cerrado de bases de

datos guardando informacin a fin de evitar inestabilidades en ellas.

1.3. Sobrecarga

Para continuar con el estudio de la programacin orientada a objetos en CSharp es

momento de que identifiques el uso de la sobrecarga. Para ello necesitas tener en cuenta

la firma de un mtodo, concepto que se refiere a la combinacin del dato que regresa, el

nombre del mismo y los argumentos que recibe (Deitel, 2007).

A partir del concepto anterior es posible afirmar que la sobrecarga de mtodos es la

creacin de varios mtodos con el mismo nombre, pero con firmas diferentes. En

programacin orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos

o ms funciones con el mismo nombre pero con funcionalidad diferente, basada en

el tipo de parmetros que recibe (Deitel, 2007).

Por ejemplo, si se tiene dos mtodos llamados leerDatos, pero uno recibe dos enteros y

el otro recibe dos nmeros flotantes, se dice que el mtodo leerDatos est sobrecargado

dos veces. Es posible sobrecargar constructores y mtodos (como se explic en el

subtema 1.2.1. Constructores, son similares pero pensados para situaciones distintas).

Los operadores por default estn sobrecargados. Por ejemplo, el operador + puede

sumar enteros, flotantes o combinaciones de ellos; lo que representa es la suma de dos

valores.

Toma en cuenta que la sobrecarga es una de las caractersticas ms importantes de la

programacin orientada a objetos. Esta caracterstica permite implementar algoritmos que

cumplen la misma funcin, pero que tienen parmetros diferentes.



1.3.1. Sobrecarga de constructores

Al ser el constructor un mtodo, tambin es posible sobrecargarlo, lo cual resulta de gran

utilidad cuando se necesita instanciar varios objetos de una forma diferente al momento

de crearlos. Un ejemplo podra ser el siguiente:

Se cuenta con un objeto llamado Persona, que puede recibir datos en el momento de

instanciarse. Una instancia se forma conociendo el nombre de la persona; otra,

conociendo su nombre y su tarjeta de trabajo, pero tambin es posible instanciar un objeto

Persona conociendo su tarjeta, nombre, edad y sexo.

En el ejemplo anterior se cuenta con un constructor sobrecargado tres veces.

Para profundizar al respecto recuerda el ejemplo del reloj, considera que necesitas un

constructor que reciba la hora en forma de una cadena que reciba el siguiente formato:

HH:MM:SS, pero tambin necesitas un constructor que reciba la hora en forma de nmero

de segundos y lo convierta a horas, minutos y segundos (esto te puede parecer raro, pero

es la forma en la que la mayora de las aplicaciones como Excel o sistemas operativos

como Windows o Linux manejan el tiempo). El ejemplo se puede implementar como se

muestra a continuacin:



Al analizar el cdigo se puede decir que el constructor est sobrecargado porque los dos

reciben el mismo nmero de parmetros (slo uno), pero son de diferente tipo y cada uno

de ellos tiene un procedimiento diferente para calcular el nmero de horas, minutos y

segundos que tendr el objeto.

El programa principal instanciar (recuerda que todo programa en CSharp debe

instanciarse para poder ejecutarse) a cada uno de los objetos dependiendo del argumento

que se le indique, esto se puede observar en el siguiente listado:

La primera instancia del reloj1 recibe como parmetro una cadena, la instancia del reloj2

recibe un nmero que representa una hora en segundos. El compilador sabe qu

constructor usar en funcin del parmetro que se est enviando. Esto se puede

comprobar en la salida del programa, que ser la siguiente:

10:20:30

3:24:5

Un objeto puede tener tantos constructores como sean necesarios, slo es necesario

recordar que el tipo de parmetros que recibe debe cambiar.

1.3.2. Sobrecarga de mtodos

Segn MSDN (2013), la sobrecarga consiste en crear ms de un mtodo en una clase

con el mismo nombre y distintos tipos de argumentos. Esto es muy prctico, pues no

tienes que renombrar cada funcin segn el tipo de valor que acepta.

En el ejemplo del objeto reloj, en caso de que se presenten dos requerimientos, el

primero sera un mtodo llamado avanza, el cual recibira un valor en horas, minutos y

segundos; el segundo mtodo debera estar sobrecargado, uno de ellos recibira tres

enteros y el otro tres cadenas que contendran horas, minutos y segundos.



Primer requerimiento: un mtodo que se llame avanza y reciba un valor en horas,

minutos y segundos. Se debe aumentar estos valores al reloj, pero recuerda que al

sumar los segundos o minutos del parmetro a de la clase, no pueden ser mayor que 59

porque al ser 60 aumenta un minuto o una hora ms, dependiendo del parmetro que se

trate. Tambin debes cuidar que las horas, al sumarse las del parmetro con las del

objeto, no sean mayor que 23. El reloj deber de iniciarse a 0.

Segundo requerimiento: el mtodo debe estar sobrecargado, uno de ellos recibir tres

enteros y otro recibir tres cadenas que contendrn las horas, los minutos y los segundos.

Es posible ver esto en el siguiente listado:

Puede concluirse que cada mtodo sobrecargado es capaz tener su propio cdigo. En el

ejemplo anterior tambin se observa cmo un mtodo puede llamar a otro, siempre y

cuando utilice los parmetros adecuados.



Como puede observarse en el programa principal Main, el uso de los constructores y

mtodos sobrecargados puede ser de manera libre de acuerdo a ciertas necesidades. El

compilador C# .NET sabr cul utilizar de acuerdo al tipo de parmetros (para fines

prcticos de esta asignatura, compilador de C Sharp, C#, Visual CSharp, C# .NET o

CSharp .NET son sinnimos). La siguiente lista muestra ejemplos de mtodos

sobrecargados vlidos:

Las tres firmas son vlidas porque tienen distinto tipo de parmetros que reciben. En el

caso de la firma tres, no es trascendente que devuelva un entero ni que los parmetros

tengan otro nombre, lo importante es el nmero de parmetros y su tipo.

Ejemplo de firmas no vlidas:

En la firma 4 se observa un error. No importa que cambie el nombre de los parmetros, su

tipo es igual al ejemplo de la firma 1.



En la firma 5 se observa un error. No importa que el valor de retorno cambie, el tipo y

nmero de parmetros es igual al ejemplo de la firma 1.

Se concluye que la sobrecarga es una herramienta til en el desarrollo de las

aplicaciones, al dar un nombre nico a procesos que esencialmente son iguales y en los

que slo se cambian los valores con los que se trabaja. El caso ms notorio antes de que

el polimorfismo existiera es el del lenguaje C, donde existan los mtodos llamados itoa,

ftoa y ltoa, todos ellos devuelven una cadena, pero la primera recibe un entero, la

segunda un float y la tercera un long. Con el polimorfismo esto se puede evitar al dar un

solo nombre al mtodo y los parmetros le dirn al compilador qu operacin debe hacer.

1.3.3. Sobrecarga de operadores

Como se mencion en el Tema 1.3. Sobrecarga, un operador es naturalmente

sobrecargado porque el mismo operador permite hacer diversas operaciones con

parmetros diferentes. Por ejemplo: el operador +

Float + Float realiza la suma sobre dos flotantes.

Integer + Integer realiza una suma sobre dos enteros.

String + String realiza la concatenacin sobre dos cadenas.

Y puede probarse cualquier combinacin de parmetros.

CSharp es uno de los pocos lenguajes que permite reescribir (sobrecargar) un operador,

agregndole nuevas funcionalidades. Para ello, segn el MSDN (2013), se deben seguir

las siguientes reglas:

1. No se debe realizar sobrecarga a operadores de forma que realicen operaciones

no naturales. Por ejemplo sobrecargar el operador + para que realice una

multiplicacin.

2. Algunos operadores deben sobrecargarse en pares, por ejemplo, al sobrecargarse

el operador de igualdad ==, tambin se debe modificar el de desigualdad !=,

junto con > tambin debe modificarse >=.

La siguiente tabla muestra la posibilidad de sobrecarga de los operadores (MSDN, 2013):

Operadores Posibilidad de sobrecarga

+, -, !, ~, ++, --, true, false Estos operadores unarios s pueden sobrecargarse.



+, -, *, /, %, &, |, ^, Estos operadores binarios s pueden sobrecargarse.

==, !=, , = Los operadores de comparacin pueden sobrecargarse, pero deben ser en pares

&&, || Los operadores lgicos condicionales no pueden sobrecargarse, pero se evalan mediante & y |, los cuales s pueden sobrecargarse.

+=, -=, *=, /=, %=, &=, |=, ^=, = Los operadores de asignacin no pueden sobrecargarse, pero +=, por ejemplo, se evala con +, el cual s puede sobrecargarse.

=, ., ?:, ->, new, is, sizeof, typeof Estos operadores no pueden sobrecargarse.

Tabla 1. Posibilidad de sobrecarga de operadores (MSDN, 2013)

La sintaxis para sobrecargar un operador es la siguiente:


Las palabras en cursivas son palabras reservadas obligatorias, donde:

ValorDeRetorno: es el tipo de dato que retornar el operador.

OperadorASobreCargar: alguno de la tabla anterior.

Tipo: valores que recibir el operador.

Ahora un ejemplo.

Recordars que toda fraccin se representa de la siguiente forma:

Y que la suma de dos fracciones se realiza de la siguiente manera:

public static ValorDeRetorno operator OperadorASobreCarger(Tipo c1, Tipo c2) { Procedimiento }



+

=

+

Con los anteriores conceptos se desarrollar un objeto que se llamar fraccin. Tendr

dos datos miembros de tipo entero llamados Numerador y Denominador. Estos se

recibirn en el constructor. Se tendr un mtodo llamado imprime que devolver la

fraccin en el formato Numerador/Denominador.

Se sobrecargar el operador +que permita sumar dos fracciones. El cdigo del

enunciado se muestra a continuacin:

El uso de esta clase se muestra a continuacin:



Fraccin 1: 1/2

Fraccin 2: 1/3

Fraccin Suma: 5/6

Como se aprecia en el ejemplo, el operador + se ha sobrecargado y en este programa

tambin se permite sumar fracciones.

Hasta aqu se concluye el desarrollo de los Temas 1.2. Construccin y destruccin en

CSharp, y 1.3. Sobrecarga. Es momento de que realices algunas actividades de

aprendizaje.

Actividad 3. Construccin, destruccin y sobrecarga

En esta actividad dars solucin a un problema donde se construya y destruya, adems

de que se sobrecarguen funciones en un objeto utilizando las instrucciones de CSharp.

Para comenzar, realiza lo siguiente:

1. Retoma el objeto que realizaste en la actividad 2, agrgale un constructor

polimrfico bajo las siguientes reglas:

Un constructor que reciba uno, dos y los tres datos (desarrollars 3

constructores).

El constructor que reciba un dato miembro inicializar en null o cero, los

otros dos, el constructor que reciba 2 datos miembro inicializar el restante

en null o cero.

2. Adems, agrega un destructor cuya nica funcionalidad sea limpiar las variables

miembro.



3. Agrega dos mtodos sobrecargados, esto con apoyo de las indicaciones de tu

Facilitador(a) sobre sus caractersticas.

4. Escribe el cdigo en la plataforma de C#. Net modo consola, en el que debe

mostrarse la clase y dentro de sta los mtodos (funciones).

5. Ejecuta tu cdigo de forma que muestre los resultados deseados y no contenga

errores.

6. Agrega en un documento de texto una breve descripcin de los pasos realizados

y explica la funcionalidad del programa, agrega la captura de las pantallas de tu

programa en ejecucin.

7. Consulta el documento Criterios de evaluacin de actividades U1 para conocer

los criterios de evaluacin de la actividad.

8. Al concluir tu programa, empaca todo tu proyecto en un archivo .zip con el

nombre: DPRN2_U1_A3_XXYZ. Sustituye las XX por las dos primeras letras de

tu primer nombre, la Y por tu primer apellido y la Z por tu segundo apellido.

9. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.

Actividad 4. Sobrecarga

En esta actividad analizars algunos ejemplos del uso de sobrecarga de mtodos. La

actividad es colaborativa, por lo que tu Facilitador(a) te asignar un nmero de equipo

para trabajar.

Con la ayuda de tu equipo de trabajo:

1. Identifica algunos problemas relacionados con la sobrecarga de mtodos,

particularmente que sean observables en aplicaciones reales o en problemas

propuestos por ustedes, donde pueda plantearse como solucin una

sobrecarga.

2. Consulta la Rbrica de participacin en foros que se encuentra disponible en

la seccin Material de apoyo.

Al ingresar al foro:



3. Comenta un ejemplo que hayas investigado al interior del equipo.

4. Designa un representante del equipo que comparta el ejemplo que consideres

aporta mayores elementos respecto al tema de sobrecarga y sus aportaciones

en la solucin de problemas. Deber exponerse el problema, y por qu

consideras que es un ejemplo representativo.

5. Una vez que concluida la aportacin de equipo, revisa y comenta la

participacin de al menos dos compaeros(as) respecto a la pertinencia de los

ejemplos, as como la aportacin que te dejan sus participaciones en el foro.

Haz lo mismo con tus propias experiencias y conocimientos.

6. Con base en las aportaciones de tus compaeros(as), elabora conclusiones

individuales y deja tu evidencia en el foro.

Autoevaluacin

Antes de desarrollar la evidencia de aprendizaje, realiza la autoevaluacin con el fin de

llevar a cabo un repaso general de la unidad, as como detectar aquellos temas que no

has comprendido en su totalidad y que requieras revisar nuevamente. Consulta a tus

compaeros(as) y Facilitador(a).

Evidencia de aprendizaje. Desarrollo de objetos en .NET

En el transcurso de la asignatura realizaste diversas actividades para practicar los

principales conceptos desarrollados en cada uno de los temas, ahora es momento de

preparar tu evidencia de aprendizaje. Para ello, sigue estos pasos:

1. Identifica un problema hipottico o de la vida real (mbito personal, profesional,

educativo o familiar) en el que sea posible integrar las soluciones que te ofrecen

las herramientas de .NET: encapsulacin, construccin, destruccin, sobrecarga

en lenguaje CSharp. Describe en un archivo de texto cul sera el desarrollo de

tu objeto.

2. Desarrolla el proyecto de tu objeto en .NET para resolver el problema que hayas

planteado en el punto anterior. Al realizarlo, guarda las capturas de pantalla de



cada uno de los pasos para que muestres la funcionalidad y la adecuada

ejecucin del programa.

3. Al concluir, realiza un empacado de tu proyecto. Recuerda que cuando se

desarrolla un programa en Visual Studio se genera todo un directorio con

diferentes subdirectorios que guardan toda la estructura de un proyecto, para el

caso de la plataforma .NET se conocen con el nombre genrico de Solucin.

4. Posteriormente, redacta en un documento de texto los siguientes datos:

Tu nombre completo.

La versin de Visual Studio en la que desarrollaste tu programa. Recuerda

que la ltima versin disponible es la 2012, pero en cualquier versin

desde la 2008 y la 2010 lo puedes desarrollar. Todas ellas tienen una

versin Express que Microsoft considera libre y en la que puedes

desarrollar sin licencia.

Descripcin del procedimiento que empleaste hasta llegar al empacado de

tu objeto, esto mediante un archivo de texto con las capturas de pantalla

de todo el proceso (desarrollo de todos los pasos de tu evidencia 1, 2 y 3).

5. Consulta la Rbrica de evaluacin para conocer los criterios de evaluacin de tu

evidencia.

6. Guarda la actividad en un archivo .zip con el nombre DPRN2_U1_EA_XXYZ.

Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por tu

primer apellido y la Z por tu segundo apellido.

7. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.

*Recuerda partir de los comentarios que recibas, y en caso de ser necesario,

debers enviar una segunda versin de tu evidencia.

Autorreflexiones

Adems de enviar tu trabajo de la Evidencia de aprendizaje, ingresa al foro Preguntas de

Autorreflexin y consulta las preguntas que tu Facilitador(a) presente; a partir de ellas

elabora tu autorreflexin en un archivo de texto llamado DPRN2_U1_ATR_XXYZ.

Posteriormente enva tu archivo mediante la herramienta Autorreflexiones.



Cierre de la unidad

Durante el desarrollo de esta unidad abordaste los temas de encapsulacin,

construccin, destruccin y sobrecarga, los cuales te muestran cmo se pueden

desarrollar en CSharp los conceptos de programacin orientada a objetos.

Ten en cuenta que el tema de encapsulacin es pilar fundamental de la programacin

orientada a objetos, pues significa reunir todos los elementos que pueden considerarse

pertenecientes a una misma entidad, al mismo nivel de abstraccin. Esto permite

aumentar la cohesin de los componentes del sistema (MSDN, 2013). Como viste en los

ejemplos, sus propiedades te dan control completo del interior del objeto y cierra el

contenido a manejos indebidos.

La construccin y la destruccin son mtodos utilizados en estas dos etapas (cuando

el objeto es instanciado y cuando deja de ser referenciado), muy importantes dentro de la

vida de un objeto, cuando se construye y cuando se destruye.

En lenguajes orientados a objetos, todo objeto tiene un ciclo de vida (nace cuando se

instancia, vive cuando ejecuta sus mtodos de trabajo, muere cuando se deja de hacer

referencia a l); en la primera etapa se utiliza un constructor y en la segunda un

destructor. Estos mtodos son de suma importancia porque hacen nfasis en estos dos

momentos en la vida de un objeto: la construccin y la destruccin. En las unidades

subsecuentes vers otros mtodos que se encargan de otros momentos en dicho ciclo.

Ten siempre en cuenta que el ciclo de vida de un objeto empieza por su declaracin,

instanciacin y uso en un programa CSharp, hasta que desaparece.

Finalmente, la sobrecarga se refiere al uso del mismo identificador y sus parmetros,

pero en distintos contextos (distinto tipo). En la siguiente unidad vers que este concepto

es el inicio de algo an ms complejo y til llamado polimorfismo, donde la sobrecarga

pasa al siguiente nivel, no slo cambia el tipo de parmetros sino tambin el nmero de

ellos.

Te espera una unidad muy interesante, donde aprenders nuevos conceptos de

programacin orientada a objetos mediante CSharp, en la plataforma .NET.

Para saber ms

Importante: recuerda que todos los objetos tienen un ciclo de vida.



En esta seccin se presentan algunos recursos que es recomendable que consultes para

profundizar en el estudio de los principales temas revisados en la unidad.

La primer recomendacin es la base de conocimientos que se encuentra en el

portal oficial de CSharp en espaol, propuesto por Microsoft; ah encontrars la

explicacin y varios ejemplos de encapsulacin, construccin, destruccin y

sobrecarga. Esta pgina est desarrollada para la versin de CSharp 2012, pero

es vlida para cualquier versin, desde 2008 hasta 2010. Se encuentra disponible

en

http://msdn.microsoft.com/es-MX/library/dd460654.aspx

http://msdn.microsoft.com/es-es/library/a5adyhe9.aspx

El libro de Jos Antonio Gonzlez Seco, El lenguaje de programacin C#. Es un

desarrollo libre y, aunque es una versin muy anterior, los conceptos

fundamentales no han cambiado. Se encuentra disponible en la seccin Material

de apoyo y tambin lo puedes obtener de

http://dis.um.es/~bmoros/privado/bibliografia/LibroCsharp.pdf

En el siguiente portal hallars varios videos de algunos conceptos importantes de

CSharp. Se encuentra en ingls, pero puedes apoyarte en alguna de las diversas

herramientas de traduccin para poder acceder a la informacin y observar los

videos. Este sitio tambin es parte de la base de conocimientos de CSharp y estn

disponible en http://msdn.microsoft.com/en-us/vstudio//bb798022.aspx

Fuentes de consulta

Bsicas

Archer, T. (2010). A fondo C#. Madrid: McGraw-Hill.

Deitel, M. (2004). Cmo programar en CShar y Java, 4a. ed. Espaa: Pearson.

_______. (2007). Cmo programar en CSharp, 2da. ed. Espaa: Pearson.



Eckel, B. y OBrien, L. (2010). Thinking in C#. Estados Unidos: Prentice Hall.

Ferguson J. et al. (2005). La biblia de CSharp. Madrid: Anaya.

Gonzlez, J. (ao). Lenguaje de programacin en C#. Recuperado de

http://dis.um.es/~bmoros/privado/bibliografia/LibroCsharp.pdf

Michaellis, M. (2010). Essential C# 4.0. Estados Unidos: Addison Wesley.

Microsoft Corporation. (1999-2007). C# Language Specification Version 3.0.

Estados Unidos: Microsoft Corporation.

MSDN. Microsoft Developer Network. (2013). Operadores sobrecargables (Gua

de programacin de C#). Recuperado de http://msdn.microsoft.com/es-

mx/library/8edha89s%28v=vs.80%29.aspx.

_____________________________. (2013). Programacin orientada a objetos C#

y Visual Basic. Recuperado de

http://msdn.microsoft.com/es-MX/library/dd460654.aspx.

_____________________________. (2013). Sobrecarga de operadores (C# y

Java). Recuperado de

http://msdn.microsoft.com/es-mx/library/ms228498%28v=vs.80%29.aspx.

Pelez, M. (2005). Java: Conceptos bsicos de P.O.O, curso desarrollo de

aplicaciones informticas. I.E.S. Galileo de Valladolid. Recuperado de

http://centros5.pntic.mec.es/ies.galileo/pilar/metodos.html#Paso_de_parametros

Romn, C. Temas especiales de computacin. Programacin con Java.

Recuperado de http://profesores.fi-b.unam.mx/carlos/java/indice.html

Sharp, J. (2010). Microsoft Visual C# 2010. Estados Unidos: Microsoft Press.

Troelsen, A. (2010). Pro C# 2010 and the .NET 4 Platform. Estados Unidos:

Apress.

Unidad 1. Desarrollo de Objetos en La Plataforma .NET

Documents

Transcript of Unidad 1. Desarrollo de Objetos en La Plataforma .NET