Program Ac i on Final2
50
Programación Orientada a Objetos
-
Upload
soledad-solis -
Category
Documents
-
view
13 -
download
0
description
trabajo escolar
Transcript of Program Ac i on Final2
Programación Orientada a Objetos
ContenidoObjetivos Generales....................................................................................51.1 Introducción histórica y contextual.............................................................51.2 Entorno de desarrollo...............................................................................61.2.1. ¿Qué es Framework .Net?..................................................................61.2.2. CIL y JIT..............................................................................................6.....................................................................................................................61.2.3 Ensamblados.......................................................................................71.2.4. Código administrado (Managed Code)...............................................71.2.5. Recolección De Basura (Garbage Collection).....................................71.2.7. Versiones de C# y de IDE..................................................................81.3. Variables, tipos de datos y conversión entre tipos..............................................91.3.1. Variables............................................................................................91.3.2 Constante............................................................................................91.3.3 Tipos de datos.....................................................................................91.3.4 Clasificación de tipos valor...............................................................101.3.5 Tipos Enteros....................................................................................111.3.6 Tipos en coma flotante.....................................................................111.3.7 Tipo decimal.....................................................................................121.3.9 Tipo char...........................................................................................121.3.10 Tipos enum.....................................................................................121.3.11 Tipos struct.....................................................................................121.3.12 Tipos referencia..............................................................................131.3.13 Tipo class........................................................................................131.3.14 Tipo object......................................................................................131.3.15 Tipo string.......................................................................................131.3.16 Tipo interface..................................................................................131.3.17 Tipo Array.......................................................................................131.3.18 Tipo Delegate..................................................................................141.3.20 Tipo de conversión..........................................................................141.3.21 Conversiones implícitas..................................................................14
1
1.3.22 Conversiones explícitas..................................................................151.4 Operadores y expresiones...........................................................................161.4.1 Operadores matemáticos..................................................................161.4.1.1 Operadores de Incrementos y decrementos................................161.4.1.2 Operaciones de asignación (=)......................................................171.4.1.3 Operadores Relacionales...............................................................171.4.1.2 Operadores Lógicos.......................................................................171.4.2 Procedencia de Operadores..............................................................181.5 Estructuras de control................................................................................191.5.1 El operador ternario..........................................................................191.5.2. La sentencia if..................................................................................191.5.3 Alternativa múltiple..........................................................................201.5.3.1 La sentencia switch........................................................................201.5.4 Loops................................................................................................201.5.4.1 Bucles for.......................................................................................211.5.4.2 Bucles foreach..............................................................................211.5.4.3 Bucles while y do...while................................................................211.5.4.4 Bucle While....................................................................................211.5.4.5 Bucle Do…while.............................................................................211. 6 Paquetes o librerías............................................................................221.6 Espacios de nombres...........................................................................221.6.1 Common Type System (CTS)............................................................222.1 Clases y objetos.....................................................................................232.1.1 Objeto...............................................................................................232.1.2 Creación y uso de objetos.................................................................232.1.3 Acceder a un objeto..........................................................................242.1.4 Clase.................................................................................................242.1.5 Contenido de una clase.....................................................................242.1.6. Modificadores de acceso..................................................................252.1.7 Metodos............................................................................................252.2 Herencia..................................................................................................27
2
2.2.1 Tipos de herencia..............................................................................272.2.2 Herencia simple................................................................................272.3 Encapsulamiento.......................................................................................282.3.1 Declaracion de encapsulado.............................................................282.4 Polimorfismo............................................................................................282.4.1 Métodos virtuales..............................................................................292.5 Sobrecarga...............................................................................................302.6 Clases abstractas.......................................................................................302.7 Interfaces.................................................................................................31...................................................................................................................312.7.1 Declaración de una interfaz..............................................................31Una interfaz se declara de la siguiente manera:........................................312.7.2.1 Implementacion ...........................................................................32Acontinuacion se observa como se declara e implementa una interfaz en C#..............................................................................................................322.7.3 Interfaces en C#..............................................................................32Las interfaces en C# se enlistan a continuacion :....................................32Colecciones................................................................................................323. 1 Arreglos.................................................................................................33Definición de un array y acceso a los datos.......................................................333.2 Listas enlazadas simples......................................................................343.2.1 La clase genérica List........................................................................343.2.2 Metodos y propiedades de la clase genérica List..............................343.3 Colas (Queue)......................................................................................354.1 Excepciones.........................................................................................364.1.2 Tipos de excepciones........................................................................364.2 La clase para controlar una excepción................................................374.3 Capturar excepciones.........................................................................374.4 Creación de excepciones personalizadas............................................385.1 Componentes para la interfaz gráfica........................................................385.1.1 Controles...........................................................................................385.1.2 Propiedades......................................................................................39
3
5.2 Manejo de eventos.................................................................................395.2.1 Eventos.............................................................................................395.3 Creación de aplicaciones gráficas.............................................................406.1 Introducción y elementos necesarios para una aplicación web........................416.2 Servidores y protocolos...........................................................................416.3 Acceso a bases de datos mediante programas que corran del lado servidor.......426.3.1 Proveedores de datos.......................................................................427.1 Definición de Archivos de texto y archivos binarios......................................457.1.1 Streams.............................................................................................457.1.2 Archivos de texto..............................................................................457.1.3 Archivos binarios...............................................................................467.2 Operaciones básicas en archivos texto y binario..........................................477.2.1 Nombres de rutas y rutas relativas...................................................477.2. 2 Archivos de Texto con Flujos de Caracteres...................................477.2.3 Lectura..............................................................................................487.3 Manejo de excepciones en archivos...........................................................50Bibliografía................................................................................................52Referencias electrónicas...........................................................................52
4
Objetivos Generales.
El alumno comprenda el modelado de datos utilizando la metodologia de programación Orientada a Objetos.
El alumno aprendera a maniplular archivos, para el procesamiento de datos. El alumno sera capaz de realizar aplicaciones utilizando la programacion Orientada a Objetos, asi
mismo manejando conexcion a base de datos, utilizando las librerias correspondientes.
I. FUNDAMENTOS DE PROGRAMACIÓN1.1 Introducción histórica y contextual.
El leguaje C tiene sus antecedentes desde 1970, a continuación se muestra un diagrama donde se muestra su evolución:
Finalmente C# es definido como lenguaje de programación de alto nivel orientado a objetos, evolucionado de C y C++ que es ejecutado por el CLR , creado por Scott y Anders Hejlsberg en el año 2000.
5
1 9 7 0 , K e n T h o m p s o n c re a
B .
1 9 8 0 , B ja rn e S tro u s tru p c re a
C + + .
1 9 7 2 , D e n is e R itc h ie la n z a C , c re a d o a p a rt ir
d e B .
1 9 9 8 , S e e s ta n d a r iz a C +
+ .
2 0 0 0 , A n d e rs H e jls b e rg y
S c o tt W ilta m u th c re a n
C # ,a d e m a s s e p re s e n ta la
p la ta fo rm a .n e t .
C# tiene las siguientes características:
Tiene una sintaxis muy expresiva y fácil aparentemente similar a la de Java1 y C++. Es un lenguaje Orientado a Objetos. Es un lenguaje estructurado de bloques, que se delimitan con llaves ({x}). Es un lenguaje fuertemente tipado. Es el único lenguaje principal utilizado en las versiones de .net.
1.2 Entorno de desarrollo.
El entorno de desarrollo integrado (IDE) es un conjunto de herramientas para desarrollar aplicaciones a través de una GUI2 común. Microsoft Visual Studio permite desarrollar y compilar aplicaciones que soporten la plataforma .Net y aplicaciones Windows Forms en los siguientes lenguajes:
Microsoft Visual Studio, es entorno un preparado para desarrollar aplicaciones que contiene leguajes como por ejemplo C# es uno de los lenguajes principales a detallar en este curso, seguidamente el diagrama muestra la evolución este IDE en conjunto con las versiones de C#.
1 Java es un lenguaje de programación creado en 1995 por Sun microsystems es un lenguaje derivado de C# y C++.2 Interfaz Gráfica de Usuario.
6
Lenguajes que soporta Microsoft Visual Studio.C#.Visual Basic.net.Visual Basic. C#.net.C++.
2002
Visual Studio 2002.C# 1.0Codigo Administrado.
2005
Visual Studio 2005C# 2.0GenericosMetodos AnonimosTipos nulables. 20
08
Visual Studio 2008C# 3.0Expresiones Lambada.Tipos anonimosLinqTipos implicitos (var)
2010
Visual Studio 2010C#4.0Programación DinamicaArgumentos con nombre.Parametros Opcionales.
2012
Visual Studio 2012C#5.0Atributos de información de llamadas asicronas.
2013
Visual Studio 2013C#5.0Correcion de errores Compilador "Roslyn". 20
15
Visual Studio 2015 C#6.0Versión actual
7
1.2.1. Framework .Net.
El Framework.net fue lanzado por Microsoft en el año 2001 en conjunto con la primera versión de C# (1.0), con la finalidad de ser utilizado por los lenguajes de programacion de C# y C++, Visual Basic, etc.
Según el portal web de Microsoft MSDN “.NET puede ser instalado en cualquier sistema operativo de la familia Windows superior a Windows 98. “; Actualmente los Sistemas Operativos de Windows ya lo tienen instalado.
El siguiente esquema explica algunos puntos importantes de dicho Framework.
La arquitectura de .Net Framework es muy extensa enseguida en el siguiente esquema se observan sus componentes.
8
¿Qué es el
Framework.net?
El .NET Framework es un API de .net creada por Microsoft en 2001 que en conjunto con C# son usadas para la compilación y desarrollo de aplicaciones .Net.
Caracteristicas
Esta basado completamente Orientado a objetos.Es multi-lenguaje.Provee un único modelo de programación para todo tipo de aplicaciones.
Versiones
.Net Framework 1.0 .
.Net Framework 2.0
.Net Framework 3.0.
.Net Framework 3.5 .
.Net Framework 4.0.
.Net Framework 4.5.
.Net Framework 4.6.
Lenguajes de compilación y herramientas de desarrollo.
Biblioteca de clases .net.
Entorno de ejecución de aplicaciones(CLR).
1.2.2. Entorno de ejecución de Aplicaciones.
Además de otros componentes el .NET Framework contiene el Common Language Runtime (CLR) es un entorno de ejecución que se suministra la ejecución de todas las aplicaciones desarrolladas usando la biblioteca de .NET. Posteriormente la imagen muestra la Common Language Runtime (CLR).
El CLR es característico por su estilo de administración de ejecución de aplicaciones: Compila Justo a tiempo.
Primeramente el código es traducido o compilado a lenguaje maquina mediante Common Intermediate Languaje (CIL) en conjunto de un Just-in-time (JIT).
Mientras el código esta en tiempo de ejecución, el CLR se encarga de la gestión de memoria y depuración del lenguaje a esto se le conoce como “Código administrado”.
Suministra Memoria de SO.Mediante el Recolector de Basura (Garbage Collection), se asegura de liberar memoria sondeando periódicamente el ordenador eliminando basura.
Administra la ejecución de aplicaciones mediante ensamblados.Finalmente el CIL crea código en ensamblados. Los ensamblados son archivos de aplicación que a su vez pueden ser ejecutados desde el sistema Operativo sin la necesidad de otros programas con extensión .exe y bibliotecas con extensión .Dll.
9
Common Language Runtime (CLR)
I.3. Variables, tipos de datos y conversión entre tipos.
I.3.1. Variables.
De acuerdo al libro Iniciación a la programación en C#: un enfoque práctico, los autores definen una variable de la siguiente manera “Una variable representa un espacio de memoria para almacenar un valor de un determinado tipo “.
Sintaxis:
<Tipo de dato > < Nombre de la variable>
Ejemplo:
int answer = 42;string greeting = "Hello, World”;
I.3.2. Tipos de datos.
C# es una lenguaje de programación tipado, que se deriva de Sistema Tipo Común (CTS) proporcionado por el .NET Framework.
En seguida se define que es un tipo de datos en el diagrama (observar el diagrama de engranes).
10
Definición.
Un tipo de datos es una serie de valores que se relacionan con operaciones de manipulacion sobre ellos.Los tipos de datos en C# se heredan de la clase System.Object.
Se Clasifican
Tipos de valor Tipos simplesTipos de referencia.
A continuación la siguiente tabla muestra la descripción de los tipos de datos más usados en la programación.
1.3.3 Tipo de conversión.
Las conversiones se definen como operadores con el nombre del tipo al cual convierten3.
C# tiene dos tipos de conversión:
La conversión implícita.
La conversión explícita.
1.3.4 Conversiones implícitas.
Este tipo de conversión también es conocida como asignación o declaración de valores a una variable sin tipo de dato.
Ejemplo:
i = 1;i=X;
La siguiente tabla muestra las conversiones numéricas que el compilador puede realizar de forma implícita
3 https://msdn.microsoft.com/es-es/library/vstudio/09479473(v=vs.110).aspx
11
Tipos de datos mas utilizados en C#.
1.3.5 Conversiones explícitas.
Las conversiones explicitas o también llamado como conversiones de tipo, este casting le indica explícitamente al compilador que se va a convertir un tipo de dato a otro.
La sintaxis de conversión explicita simple es la siguiente:
<(destinationType)sourceVar>
Ejemplo:
// Cast double to int. a = (int) x;
También se pueden realizar conversiones de tipo utilizando clases. Este tipo de casting se realiza entre tipos de datos que no son compatibles como enteros, objetos,
Las clases para realizar estos casting con:
System. Convert. System. DateTime. System. BitConverter.
Y los metodos Parse.
1.4 Operadores y expresiones.¿Qué es una expresión?
12
Tabla de conversiones implicitas.
[4] Una expresión es una secuencia de uno o más operandos y cero o más operadores que se pueden evaluar como un valor, objeto, método o espacio de nombres único. Las expresiones pueden constar de un valor literal, una invocación de método, un operador y sus operandos o un nombre simple. Los nombres simples pueden ser el nombre de una variable, miembro de tipo, parámetro de método, espacio de nombres o tipo.
Según Microsoft MSDN un operador en C# es definido de la siguiente manera: “Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción.”
A la combinación de variables con operadores y variables literales se le llama como “operandos”.
El siguiente diagrama ilustra las categorías de Operadores:
1.4.1 Operadores matemáticos.En la siguiente tabla se visualizan los operadores matemáticos utilizados en C#.
4 https://msdn.microsoft.com/es-es/library/ms173144(v=vs.120).aspx
13
Categoria de Operadores
Ternarios: se asocian a
tres operandos. Sólo existe
un operador ternario, (?:)
Binarios: Se asocian a dos operandos.
Unarios: Se asocian a un
solo operando.
1.4.1.1 Operadores de Incrementos y decrementos.
Se utilizan para incrementar o decrecer un valor mayor a 1; Estos operadores se pueden fijar antes o después, enlistados en la siguiente tabla:
1.4.1.2 Operaciones de asignación (=).
El lado derecho de una expresión de asignación siempre evalúa antes que se lleve a cabo la asignación.La siguiente tabla describe los operadores:
14
Descripción de Operandores matematicos.
Operandores de incrementos y decrementos.
1.4.1.3 Operadores Relacionales.Los operadores relacionales son comparaciones booleanas es decir al evaluar devuelven un resultado true o false.
La siguiente tabla describe los operadores:
1.4.1.2 Operadores Lógicos.
Son conocidos como Operadores logicos condicionales estos son: OR , AND y NOT. La siguiente tabla describe los operadores:
15
Operadores de asignación
Operadores Relacionales.
El operador NOT (!).
Este operador pertenece a la categoría Unaria y evalúa dos expresiones falsas a verdaderas
1.4.2 Procedencia de Operadores.
La precedencia de operadores determina el orden en el cual las expresiones se evalúan, lo cual, en algunos casos, puede determinar el valor general de expresión:
Por ejemplo:
Y= (6+4)/2
Dependiendo de qué expresión se evalué primero el valor de y puede terminar siendo 5 u 8. La procedencia del operador determina el orden en el cual las expresiones se evalúan, la procedencia de operador se realizan de izquierda a derecha,
Según las normas de precedencia de operadores, se evalúan en el siguiente orden: (), -, +, *, =. [5].
Pasos para realizar la Operación.
1. Evaluar la expresión encerrada por paréntesis (6+4).2. El resultado es 10 como no hay operador de resta se realiza la suma.3. Se realiza la división y el resultado es 5.4. Finalmente el valor asignado para Y es 5.
La tabla siguiente muestra una lista de los operadores, en orden de precedencia de mayor a menor.
5 https://msdn.microsoft.com/es-es/library/vstudio/fatf1t6a(v=vs.100).aspx
16
Operadores Logicos.
1.5 Estructuras de control.
Las estructuras de control intervienen en el flujo de un programa basada en una decisión de una instrucción booleana.
Las estructuras de control se clasifican en dos:
17
Precedencia de Operadores.
Est
ruct
uras
de
cont
rol
Seleccion
simple
doble.
multiple.
Iteracion Repetitiva.
For
while
do while
1.5.2. Las sentencias selectivas (if).
Las sentencias selectivas o de decisión se clasifican en los siguientes tipos:
Alternativa simple:
Esta selección permite evaluar un conjunto de instrucciones dentro de un bloque de código, estas instrucciones evalúan una condición verdadera.
Alternativa doble:
La estructura selectiva doble permite que el flujo de control de un programa tenga alternativamente dos posibilidades verdaderas o falsas.
Por ejemplo:
1.5.3 Alternativa múltiple.La sentencia switch.
Esta sentencia evalúa múltiples casos con una variable entera.En caso de haber una repuesta falsa se termina evaluación con Break.
18
Ejemplo de seleccion simple.
Ejemplo de seleccion doble.
La estructura básica de una sentencia switch es como sigue:
1.5.4 Bucles.
Son estructuras que ejecutan un programa n número de veces hasta cumplir una condición.
1.5.4.1 Bucles for.
Ejecuta una instrucción que es incrementada y finaliza hasta que una condición sea evaluada como falsa.
Sintaxis:
19
Sentencia Switch.
Estructura del ciclo For.
1.5.4.3 Bucle While.
Ejecuta una instrucción n número de veces mientras que se evalúa una condición.
Sintaxis:
1.5.4.5 Bucle Do…while.
Realiza la ejecución un bloque de instrucciones una vez, mientras repite la ejecución del bucle hasta que la evaluación de una expresión de condición devuelva False.
Sintaxis:
20
Estructura del ciclo while.
1. 6 Paquetes o librerías.
MSDN Library define lo siguiente: “La biblioteca de clases .NET Framework define un conjunto de tipos numéricos integrados y tipos más complejos que representan una amplia variedad de construcciones lógicas, como el sistema de archivos, conexiones de red, colecciones y matrices de objetos y fechas. Un programa típico de C# usa los tipos de la biblioteca de clases, así como tipos definidos por el usuario que modelan los conceptos específicos del dominio problemático del programa.”
El Framework .net contiene la librería Common Type System (CTS). Esta librería permite acceder a todos los tipos de datos de la clase System. Object.
A continuación se muestra la estructura de dicha librería:
La biblioteca de clases de .Net Framework incluye, entre otros, tres componentes clave:
ASP.NET. Windows Forms. ADO.NET.
Dicha biblioteca está organizada dentro de espacio de nombres (namespaces) según su funcionalidad.
21
Estructura del ciclo do...while.
Estructura de CTS.
Cuestionario.
o ¿Qué es C#?o ¿Qué es .net?o Explica el proceso de compilación de .net.o ¿Qué es un IDE?o Nombra cada una de las versiones Visual Studio.
Conclusiones.
C# es una leguaje de programacion tipado para la mejor compilacion.C# es un lenguaje de programación preparado para el consumo de recursos de memoria a la hora de ejecución, al igual que java, tiene 3 elementos:
Compilador Máquina virtual Una biblioteca de clases.
II .Programacion Orientada a Objetos.Es una metodologia de programacion creada con la finalidad de reutilizar código de manera organizada.
2.1 Clases y objetos.
2.1.1 Objeto.
Un objeto es la copia de una clase que contiene sus propias caracteristicas (atributos) y comportamientos (metodos).
Para crear la instancia de una clase se realiza lo siguiente:
Sintaxis:
<Nombre de la clase> <operador de asignación (=)> <palabra reservada New > < método constructor>.
Por ejemplo:
D d1 = new D ();
2.1.2 Clase.
El concepto clase dentro de la programacion Orientada a Objetos es la siguiente:
Es una plantilla que contiene metodos y atributos los cuales definen a un objeto de forma general.
¿Cómo se define una clase?
Sintaxis:
[Atributos] [modificador_de_acceso] Class nombre_de_la_clase [: clase_base [, interface(s)]] { Declaración_de_atributos Declaración_de_métodos
22
}
Ejemplo:
Class Dado { Public Random generador; Public Dado () { Generador = new Random (); } Public int Lanzar () { Int valor = generador.Next (1, 7); Return valor; }}
2.1.3 Contenido de una clase.
Atributos. Son propiedades o mejor dicho variables que describen a un objeto, estos son representados con un tipo de dato, pueden ser declarados como globales, estas son privadas.
2.1.4. Modificadores de acceso.
Son palabras reservadas de C#, que especifican la accesibilidad algún componente de una clase.
Esta tabla presenta los modificadores de acceso:
23
Public .
Indica que el componente es visible de una clase.
Private
Indica que el componente son exclusivos de la clase.
Protected.
Este es exclusivo para herencia , indica que los componentes de una clase derivada son compartidos por una clase padre.
2.1.5 Metodos.
Son las acciones que realiza la instancia de una clase.
Un método tiene un valor de retorno, o la palabra reservada void. Un método puede tener cualquier número de parámetros.
Los parámetros se clasifican en:
Se clasifican en:
Por valor. Se envía una copia del valor de la variable.Por ejemplo:
Public void Depositar (Decimal cantidad).
Por referencia .Se envía la dirección de la variable.
Por ejemplo:
Static void Metodo (ref int y).
En C# los métodos se clasifican en dos:
Procedimientos. No devuelven un valor. Estos identificados por la palabra reservada void. Funciones. Devuelven un valor.
2.1.6 Método constructor.
Es un método creado por default por el IDE, que limita la creación de instancias. Características:
Debe poseer el mismo nombre de la clase. No posee tipo de dato de retorno. Los constructores siempre deben tener el modificador de acceso público, ya que de lo contrario no se
podrán invocar al momento de crear instancias de la clase.
2.2 Herencia.
La herencia es uno de los pilares de la POO que permite extender o compartir los componentes a partir de una clase base a una clase derivada.C# solamente permite un tipo de herencia, que es la herencia simple; Como su nombre lo menciona esta clasificación no permite herencia múltiple es decir “solo permite tener una clase derivada”.
A continuación la imagen muestra la declaración de herencia en C#.Como se observa en la imagen para indicar que una clase está heredando se debe de poner (:).
24 Ejemplo de Herencia en C#.
2.3 Encapsulamiento.
Es la propiedad de ocular atributos o propiedades de una clase. Las propiedades para el encapsulado tienen las siguientes caracteristicas:
Modificador, Tipo de dato y el nombre de la propiedad, seguido de un par de llaves. Dentro de las llaves declarar los métodos de acceso get y set. El método set tiene un parámetro implícito de nombre value.
Ejemplo:
Private string nombre;
public string NombreDelCurso { get { Return nombre; } set { Nombre = value; }
2.4 Polimorfismo.
El polimorfismo es una caracteristica de la POO, que permite la definición de metodos o propiedades idénticos, pero que se puedan utilizar en múltiples clases.
Una clase polimórfica en C# tiene las siguientes caracteristicas:
Una clase base con metodos virtuales (palabra reservada virtual). Una clase derivada que sobrescriba (Override) los metodos virtuales de la clase base.
2.4.1 Métodos virtuales.
Los metodos virtuales son acciones polimórficas, declarados en una clase base con la palabra virtual para poder ser reescritos en una clase derivada.
A continuación se muestra la declaración de un método virtual:
25
2.5 Sobrecarga.
Según MSDN, “La sobrecarga consiste en crear más de un procedimiento, constructor de instancia o propiedad en una clase con el mismo nombre y distintos tipos de argumento”.
Observar la siguiente imagen en donde se implementa la sobrecarga.
2.6 Clases abstractas.
Son clases en las que se obliga la herencia, ya que no es posible crear objetos.
Estas clases son declaradas con la palabra reservada abstract. Las clases que heredan de una clase abstracta, deberán nombrar sus metodos abstractos.
26
Implementacion de un metodo polimorfico.
Ejemplo de Sobrecarga.
2.7 Interfaces.
Una interfaz es similar a una clase es un templete en donde se definen metodos, propiedades y eventos. Al igual que las clases abstractas obligan la herencia.
2.7.1 Declaración de una interfaz.
Una interfaz se declara de la siguiente manera: Siempre son declaradas con el modificador de acceso Public. Los modificadores de acceso jamas son declarados dentro de una interfaz.
2.7.2.1 Implementacion .
Las interfaces se implementan de la misma manera que se implenta la herencia ( es por eso que se dice que se obliga a herencia (:). Se pueden implementar en una clase. Ademas se pueden implementar interfaces derivadas.
Acontinuacion se observa como se declara e implementa una interfaz en C#.
27
Ejemplo de clases abstractas.
Declaración de una interfaz.
Cuestionario.
o ¿Qué es Poo?o Menciona los elementos de la POO.o ¿Qué es una clase?o ¿Qué es un objeto?o ¿Qué es Herencia?
Conclusiones.
La programacion Orientada a objetos es un nuevo paradigma para realizar programas, y Apis de usuarios.La programación orientada a objetos es una manera de reutilización y organización en el código.
III. Estructura de datos Avanzada.Las colecciones son estructuras de datos que son utilizadas para la manipulación de datos y la gestión de memoria del sistema operativo.
En .net framework, tiene algunas colecciones:
System.Array.
System.Collections.Generic.
3. 1 Arreglos.
La clase System.Array es una es una clase abstracta sencillamente conocida como vector o matriz.Una matriz es una colección de datos del mismo tipo.
Las matrices se declaran de la siguiente manera:
28
Ejemplo de implementacion de una clase
Ejemplo de herencia de Interfaces.
Declaracion de una matriz.
Como asignar casillas a una matriz.
Para almacenar datos dentro de en una matriz se hace uso de la estructura de control iterativa (for).
La siguiente imagen muestra el llenado de una matriz.
Las matrices se clasifican por dimensión en: Unidimensionales. Multidimensionales.
La propiedad más utilizada en esta clase es Length, esta indica la longitud de una matriz.
3.2 Listas enlazadas simples.
La clase List es una clase que pertenece al espacio de nombres System.Collections.Generic.
Una lista es una colección de datos en donde cada nodo apunta al siguiente.
Una lista se declara de la siguiente forma:
Esta colección proporciona metodos siguientes:
Agregar. Buscar. Ordenar.
29
Ejemplo de llenado de una matriz
Declaración de una lista
III.3 Colas (Queue).
Es una colección genérica que manipula datos, de tipo FIFO “el primero en entrar es el primero en salir”.
Tres principales operaciones se pueden realizar en una cola y sus elementos:
Enqueue. Añade un elemento al final de la cola. Dequeue. Elimina el elemento más antiguo desde el inicio de la cola.
3.3 Pilas.
Las pilas o stack al igual que las colas con una colección de manipulación de datos de inserción y borrado (LIFO) “último en entrar, primero en salir”.
Los principales elementos:
Método Pop: devuelve el último elemento de la lista y lo borra. Método Push: añade un elemento al final de la lista.
Cuestionario
30
Ejemplo de Queue
Ejemplo de Stack.
o Define es una estructura de datos.o Tipos de estructura de datoso ¿Qué es una colección de datos?o Tipos de colecciones que hay en C#o Menciona cuales son los espacios de nombres utilizados en C#, para estructuras de datos.
Conclusiones.
Todo lenguaje de programacion tiene una serie de bibliotecas para la manipulación de datos, estas bibliotecas facilitan la búsqueda o bien agregar datos de una colección,
IV. MANEJO DE ERRORES A TRAVÉS DE EXCEPCIONES.4.1 Excepciones.
Son alertas programados o de sistema nativos que indican un problema de ejecución.
4.2 La clase para controlar una excepción.
La clase system. Exception es la clase padre de todas las clases de Excepciones. Esta a su vez se clasifica en Excepciones creadas por el usuario (ApplicationException) y la clase nativa de .net.
El siguiente diagrama muestra detalladamente la composición de la Clase System.Exception.
31
Clase Exception.
4.2 Capturar excepciones.
Las exepciones se captuaran mediante la depuracion de codigo mendiante el CLR . Una caracteristica de C# es una sintaxis de excepciones estructurado de manipulación. Para tener un buen control de C# brinda 3 palabras reservadas: try… catch... finally.
El anterior esquema explica el manejo de excepciones mediate el manejo de los bloques try… Catch… Finally.
4.3 Creación de excepciones personalizadas.
Según MSDN libray enlista algunas características que deben tener las exepciones personalizadas.
32
Estructura de cacheo de excepciones.
Cotiene el código
que lanzara
una excepción
Cacha el código
para ser enviado .
Contiene el código
que siempre
va a ejecutar.
Cuestionario.
o ¿Qué es una excepción?o Menciona los tipos de excepciones en C#.o ¿Qué es una excepción de usuario?o ¿Cuáles son las clases derivadas de Excepción?o ¿Cómo se crea una excepción?
Conclusiones.
Las excepciones ayudan a controlar eventos o bien una mala sintaxis de programacion.
V. APLICACIONES EN MODO GRÁFICO.5.1 Componentes para la interfaz gráfica.
Los formularios de Windows Forms son una biblioteca de controles derivadas de la clase System.Windows.Forms.Control que son utilizados para crear GIU de Windows.
5.1.1 Controles.
La clase System.Windows.Forms.Control es la encargada de gestionar la funcionalidad de los controles (eventos y propiedades).
A continuación a siguiente imagen muestra los controles para desarrollar formularios Windows, estos se encuentran en el IDE.
33
No tener demasiados espacios de nombres.No iniciar excepciones System.Exception ni System.SystemException.Una excepción debe ser serializable para funcionar correctamente atravesando dominios de aplicación y límites de comunicación remota.Almacene la información confidencial de seguridad útil en estado de excepción privado. Asegúrese de que sólo el código de confianza puede obtener la información.
Exepciones personalizad
as.
.
5.1.2 Propiedades.
La clase System.Windows.Forms contiene propiedades que utilizan los controles para manipular su comportamiento.
La Tabla muestra algunas de las propiedades más comunes de la Clase Controls.
34
Controles para aplicaciones windows form.
5.2 Manejo de eventos.
5.2.1 Eventos.
Todas las aplicaciones GIU, son controladas por eventos, estos son accedidos desde el IDE, se manipula de la siguiente manera:
Desde la ventana de propiedades, una vez iniciado el IDE para especificar el evento.
Seleccionar un control en el diseñador y haga clic con el icono Rayo en el botón Eventos de la barra de herramientas de la ventana Propiedades para ver los eventos del control.
El icono siguiente muestra el botón de eventos.
Observar el la imagen siguiente:
35
Propiedades de controles windows form.
Manipulacion de eventos en windows forms.
5.3 Creación de aplicaciones gráficas.
La MSDN library nos menciona los pasos para crear una GUI.
“Los tres pasos básicos para crear interfaces de usuario son:
Agregar los controles a la superficie de diseño. Establecer las propiedades iniciales de los controles. Escribir los controladores para los eventos especificados.
Aunque también puede escribir su propio código para crear la interfaz de usuario, los diseñadores permiten hacer este trabajo mucho más rápidamente. “.
Cuestionario.
o ¿De qué clase de .net se definen la funcionalidad básica de los controles?o Define algunas propiedades de la clase control.o Explica la manipulación de eventos de un control.o ¿Qué tipo de aplicaciones se pueden crear en Visual Studio?o Describe los pasos para crear formularios Windows form.
Conclusiones.
Vusual Studio es el IDE en donde se pueden crear formularios Windows Form, estos tienen componentes derivados de la clase sistem.controls.Cada control contiene las siguientes caracteristicas:
Eventos. Propiedades.
VI. APLICACIONES PARA INTERNET6.1 Introducción y elementos necesarios para una aplicación web.
Asp.net (Active Server Pages .NET) es una poderosa herramienta contenida en .NET Framework para realizar aplicaciones dinámicas.
Tiene clases en los espacios de nombres: System.Web.UI.HtmlControls. System.Web.UI. WebControls.
36
6.2 Servidores y protocolos.
El uso de ASP.NET para aplicaciones Web en el sistema cliente sólo requiere un simple navegador Web. Se puede utilizar Internet Explorer, Opera, Netscape Navigator, Firefox o cualquier otro navegador Web que soporteHTML. El sistema cliente no requiere .NET para ser instalado.
En el sistema del servidor, se necesita el tiempo de ejecución de ASP.NET. Si usted tiene Internet Information Services (IIS) en el sistema, el tiempo de ejecución de ASP.NET es configurado con el servidor cuando se instala .NET Framework.
Durante el desarrollo, no hay necesidad de trabajar con Internet Information Services porque Visual StudioOfrece su propio Desarrollo Web ASP.NET Server que puede utilizar para probar y depurar la solicitud.
Para entender cómo el tiempo de ejecución de ASP.NET entra en acción, considere una solicitud Web típica de un navegador .El cliente solicita un archivo, por ejemplo, default.aspx, desde el servidor. Todas las páginas web ASP.NET suelen tener la extensión de archivo .aspx. Debido a que esta extensión de archivo se ha registrado en IIS, o conocido por el servidor de desarrollo de ASP.NET Web, el tiempo de ejecución de ASP.NET y el trabajo de ASP.NET proceso de entrar en el cuadro. Con la solicitud primeros en el expedientedefault.aspx, se inicia el programa de análisis ASP.NET, y el compilador compila el fi le junto con un C # fi le, que se asocia con la extensión .aspx y crea un ensamblado. Entonces la asamblea se compila a código nativo por el compilador JIT de .NET tiempo de ejecución. El conjunto contiene una Página clase que se invoca para devolver código HTML al cliente. Entonces la página objeto se destruye. El conjunto se mantiene para las solicitudes posteriores, sin embargo, lo que no es necesario para compilar el conjunto de nuevo.
6.3 Acceso a bases de datos mediante programas que corran del lado servidor.
ADO.NET 6es un conjunto de clases que provee servicios de acceso a datos para programadores de .NET.
Las clases de ADO.NET se dividen en dos componentes:
Proveedores de datos.
Consumidores de datos de datos.
6.3.1 Proveedores de datos.
6 Según Wikipedia “ADO.NET es a considerado como una evolución de la tecnología ActiveX Data Objects (ADO), pero fue cambiado tan extensivamente que puede ser concebido como un producto enteramente nuevo.”
37
Infrestructura de asp.net
El proveedor de datos se encarga de proveer servicios de acceso a datos. Enseguida se en listan sus componentes:
El Objeto Connection. Maneja los namespaces de acceso a datos. El objeto Command. Representa instrucciones SQL. DataAdapter. Es un adaptador de comunicaciones de un conjunto Objetos de comando pueden apoyar
sentencias SQL que devuelven uno o más conjuntos de filas o ningún valor en absoluto. Un DataReader es un objeto sólo lectura corriente de datos de una fuente de datos. El DataAdapter es funcionalmente el objeto más complejo en un proveedor de datos. El DataAdapter. Obtiene un conjunto de datos mediante un Command de protección. El DataSet es una representación residente en memoria de los datos.
Cuestionario.
Explica cómo funciona el proceso de petición en asp.net
o ¿Qué es ADO.NET?o ¿Cuáles son los componentes de las clases ADO.net?o ¿Qué es un objeto de conexión?o ¿Cuáles son los componentes que trabajan en un ambiente desconectado?o ¿Qué es DataAdapter?
Conclusiones.
Actualmente las aplicaciones web, tienen mucha demanda en el mercado, asp.net tiene librerías para manipular datos remotamente.
38
Diagrama de clasificaciones de ADO.NET.
VII. ARCHIVOS.7.1 Definición de Archivos de texto y archivos binarios.
7.1.1 Archivos de texto.
Un archivo de texto es una secuencia de caracteres planos.
7.1.2 Archivos binarios.
Los archivos binarios. Como su nombre lo dice son archivos que contienen una secuencia de informacion binaria (1010101010101000).
System.IO contiene las clases para leer y escribir datos desde y hacia archivos, y se puede hacer referencia a esta espacio de nombres en la aplicación C # para tener acceso a estas clases sin calificar plenamente nombres de tipos.Bastantes clases están contenidas en System.IO, como se muestra en la tabla, pero sólo estarán trabajando con las clases primarias necesarias para la entrada y salida de archivos.
7.2 Operaciones básicas en archivos texto y binario.
7.2. 1 Operaciones con Archivos de Texto .
Los archivos de texto se pueden leer y escribir utilizando las clases StreamWriter y StreamReader.
7.2.2 Operaciones Archivos Binarios.
Los archivos binarios t deberán escribirse y leerse en formato binario.
El espacio de nombres System.IO proporciona las clases: BinaryWriter BinaryReader.
Con estas clases se podrán manipular datos de los tipos primitivos y cadenas de caracteres en formato UTF-8.
7.3 Manejo de excepciones en archivos.
Una excepción de archivos se da cuando a crearse un archivo, este mismo no existe dentro de la ruta especificada. Para manejar estas excepciones, en la codificación se dividirán dos bloques de código para controlar mediante Los bloques try…catch.
39
Por ejemplo:
En un primer bloque, indicaremos los pasos que queremos "intentar" (try).
Después del bloque "catch” indicar una excepción más concreta, de forma que el mensaje de aviso sea más concreto, o que podamos dar pasos más adecuados para solucionar el problema.
Cuestionario.
o ¿Qué es un archivo de texto?o ¿Qué es un archivo binario?o ¿Cuáles son las clases de archivos binarios?o ¿Cuáles son las clases de archivos de texto?o ¿Cómo usar try…catch en archivos?
Conclusiones.
Los archivos son importantes, para manipularlos o bien son útiles para almacenar datos.
40
Bibliografíao Beginning Visual C# 2010.
Karli Watson.
o Microsoft ADO .NET Step by Step
by Rebecca M. Riordan ISBN: 0735612366
Microsoft Press © 2002 (512 pages).
Referencias electrónicas.https://msdn.microsoft.com/es-es/library
41
