Академический Документы
Профессиональный Документы
Культура Документы
NET
PROGRAMACIÓN EN .NET
ESCUELA DE CONSTRUCCIÓN E INGENIERÍA
Director de Escuela / Marcelo Lucero
ELABORACIÓN
Experto disciplinar / Cristián Molina
Diseñador instruccional / Evelyn Aguilera
VALIDACIÓN PEDAGÓGICA
Jefa de diseño instruccional y multimedia / Alejandra San Juan Reyes
Experto disciplinar / Carlos Garcés
DISEÑO DOCUMENTO
Didactic
En informática, una clase es una plantilla para la creación de objetos de datos según un
modelo predefinido. Las clases se utilizan para representar entidades o conceptos, como
los sustantivos en el lenguaje. Cada clase es un modelo que define un conjunto de
variables -el estado, y métodos apropiados para operar con dichos datos -el
comportamiento. Cada objeto creado a partir de la clase se denomina instancia de la clase.
Las clases de objetos son un pilar fundamental de la programación orientada a objetos.
Permiten abstraer los datos y sus operaciones asociadas al modo de una caja negra. Los
lenguajes de programación que soportan clases difieren sutilmente en su soporte para
diversas características relacionadas con clases. La mayoría soportan diversas formas de
herencia. Muchos lenguajes también soportan características para proporcionar
encapsulación, como especificadores de acceso.
Una clase también puede tener una representación (metaobjeto) en tiempo de ejecución,
que proporciona apoyo en tiempo de ejecución para la manipulación de los metadatos
relacionados con la clase.
La programación orientada a objetos (POO, en español; OOP, según sus siglas en inglés)
es un paradigma de programación que viene a innovar la forma de obtener resultados. Los
objetos manipulan los datos de entrada para la obtención de datos de salida específicos,
donde cada objeto ofrece una funcionalidad especial.
Muchos de los objetos prediseñados de los lenguajes de programación actuales permiten la
agrupación en bibliotecas o librerías, sin embargo, muchos de estos lenguajes permiten al
usuario la creación de sus propias bibliotecas.
Está basada en varias técnicas: herencia, cohesión, abstracción, polimorfismo,
acoplamiento y encapsulamiento.
Su uso se popularizó a principios de la década de 1990. En la actualidad, existe una gran
variedad de lenguajes de programación que soportan la orientación a objetos.
1.1.2. ORIGEN
Los conceptos de la POO tienen origen en Simula 67, un lenguaje diseñado para hacer
simulaciones, creado por Ole-Johan Dahl y Kristen Nygaard, del Centro de Cómputo
Noruego en Oslo. En este centro se trabajaba en simulaciones de naves, que fueron
confundidas por la explosión combinatoria de cómo las diversas cualidades de diferentes
naves podían afectar unas a las otras. La idea surgió al agrupar los diversos tipos de naves
en diversas clases de objetos, siendo responsable cada clase de objetos de definir sus
"propios" datos y comportamientos. Fueron refinados más tarde en Smalltalk, desarrollado
en Simula en Xerox PARC (cuya primera versión fue escrita sobre Basic) pero diseñado
para ser un sistema completamente dinámico en el cual los objetos se podrían crear y
modificar "sobre la marcha" (en tiempo de ejecución) en lugar de tener un sistema basado
en programas estáticos.
La POO se fue convirtiendo en el estilo de programación dominante a mediados de los
años 1980, en gran parte debido a la influencia de C++, una extensión del lenguaje de
programación C. Su dominación fue consolidada gracias al auge de las interfaces gráficas
de usuario, para las cuales la POO está particularmente bien adaptada. En este caso, se
habla también de programación dirigida por eventos.
Las características de orientación a objetos fueron agregadas a muchos lenguajes
existentes durante ese tiempo, incluyendo Ada, BASIC, Lisp más Pascal, entre otros. La
adición de estas características a los lenguajes que no fueron diseñados inicialmente para
ellas condujo a menudo a problemas de compatibilidad y en la capacidad de mantenimiento
EJEMPLIFICACIÓN
Para complementar los temas vistos, les invitamos a revisar los documentos llamados:
- Ejemplos de la estructura
- Ejemplos de tipos de variables
Pueden acceder a él a través del menú Recursos complementarios de la unidad 1, Material
complementario.
El lanzamiento de una Exception da lugar a que el método que se está ejecutando finalice
inmediatamente. Sin embargo, la sentencia throw no proporciona un valor, ni tampoco
quien haya efectuado la llamada reanuda la ejecución desde el punto en que se ha
producido la invocación. Lo que ocurre es que la Exception lanzada va pasando por todas
las invocaciones habidas a lo largo de la cadena, obligando a que todos los métodos
invocados vayan finalizando. Para todos los métodos que se encuentran en el camino,
parece que el método fuera el que hubiera lanzado la Exception. De hecho, se puede decir
que todos los métodos hallados a lo largo del camino lanzan la Exception. Finalmente, la
cadena llegará al método main que ha hecho comenzar la ejecución, momento en el cual
concluye el programa. Por tanto, la sentencia
c).- Throw [referencia-de-objeto-Exception]
...da lugar a que el programa concluya. Se puede pensar que se trata de una escotilla de
escape. Sin embargo, la instrucción Throw inicia una excepción que se puede controlar con
código de control estructurado de excepciones (Try...Catch...Finally) o con código de
control no estructurado de excepciones (On Error GoTo).
AlgunObjetoNet.AlgunMetodoNet()
Catch ex As Exception
....
End Try
Try
AlgunObjetoNet.AlgunMetodoNet()
Catch ex As Exception
End Try
El código que aparece entre las llaves que siguen a la palabra reservada Try es lo que se
denomina el bloque Try; también diremos que este código está rodeado por un Try...Catch.
El código que aparece después del match es lo que examina el bloque catch.
Pueden declararse varias referencias a objetos Exceptions:
Dim MyDate As Object 'Debe contener un date/time
Dim MyNextDate As Date 'para almacenar el año; truncado al valor integral.
Try
MyNextDate = DateAdd("yyyy", 100, MyDate)
Catch ThisExcep As System.ArgumentException
' El argumento proporcionado para el método no es válido.
Catch ThisExcep As ArgumentOutOfRangeException
Catch ex As System.ArithmeticException
z = -1
Dim x, y As Double
Dim r As Double = 0
Try
x = Double.Parse(Me.TextDividendo.Text)
y = Double.Parse(Me.TextDivisor.Text)
Catch ex As Exception
MsgBox("Ingrese números")
Me.TextDividendo.Clear()
Me.TextDivisor.Clear()
Me.TextResultado.Text = "Operación sin éxito"
Return
End Try
Me.TextResultado.Text = ex.ToString()
r = -1
End Try
End Sub
Estos son los resultados. Si ingreso un número y una cadena String, desde luego que debe
desencadenarse una excepción.
También debe originarse una excepción, al intentar dividir entre cero. Recuerda que esta
excepción la estamos manejando mediante la clase que habíamos extendido de la clase
System.Exception.
Nota: Debe colocar una instrucción Exit Sub inmediatamente antes de bloque de control de
errores. De lo contrario, Visual Basic ejecutará el código de control de errores cuando
llegue al final de la subrutina, lo que puede provocar resultados inesperados o no
deseados.
Inherits System.Windows.Forms.Form
Dim n As Byte
Exit Sub
MyException:
Case Else
MsgBox(Err.Description & ": " & Err.Number.ToString, MsgBoxStyle.Exclamation,
"On Error GoTo")
End Select
Me.TextBox2.Text = "Err.LastDllError: " +
Err.LastDllError.ToString + _
class A
{
Public void F()
{
G();
}
static public void G()
{
int c = 0; int d = 2/c;
}
Al compilarlo no se detectará ningún error ya que al compilador no le merece la pena
calcular el valor de c en tanto que es una variable, por lo que no detectará que dividir 2/c no
es válido. Sin embargo, al ejecutarlo se intentará dividir por cero en esa instrucción y ello
provocará que aborte la aplicación mostrando el siguiente mensaje:
Unhandled Exception: System.DivideByZeroException: Attempted to divide by zero.
at PruebaExcepciones.Main()
Como se ve, en este mensaje se indica que no se ha tratado una excepción de división por
cero (tipo DivideByZeroException) dentro del código del método Main() del tipo
PruebaExcepciones. Si al compilar el fuente hubiésemos utilizado la opción /debug, el
compilador habría creado un fichero .pdb con información extra sobre las instrucciones del
ejecutable generado que permitiría que al ejecutarlo se mostrase un mensaje mucho más
detallado:
Unhandled Exception: System.DivideByZeroException: Attempted to divide by zero.
at A.G() in E:\c#\Ej\ej.cs:line 22 at A.F() in E:\c#\Ej\ej.cs:line 16
at PruebaExcepciones.Main() in E:\c#\Ej\ej.cs:line 8
catch (<excepción1>)
<tratamiento1>
catch (<excepción2>)
<tratamiento2>
...
finally
<instruccionesFinally>
El significado de try es el siguiente: si durante la ejecución de las <instrucciones> se lanza
una excepción de tipo <excepción1> (o alguna subclase suya) se ejecutan las instrucciones
<tratamiento1>, si fuese de tipo <excepción2> se ejecutaría <tratamiento2>, y así hasta
que se encuentre una cláusula catch que pueda tratar la excepción producida. Si no se
encontrase ninguna y la instrucción try estuviese anidada dentro de otra, se miraría en los
catch de su try padre y se repetiría el proceso. Si al final se recorren todos los trys padres y
no se encuentra ningún catch compatible, entonces se buscaría en el código desde el que
se llamó al método que produjo la excepción. Si así se termina llegando al método que
inició el hilo donde se produjo la excepción y tampoco allí se encuentra un tratamiento
apropiado se aborta dicho hilo; y si ese hilo es el principal (el que contiene el punto de
entrada) se aborta el programa y se muestra el mensaje de error con información sobre la
excepción lanzada ya visto.
Así, para tratar la excepción del ejemplo anterior de modo que una división por cero
provoque que a d se le asigne el valor 0, se podría reescribir G() de esta otra forma:
static public void G()
{
try
{
}
int c = 0; int d = 2/c;
catch (DivideByZeroException)
{ d=0; }
}
También hay que señalar que cuando en <instrucciones> se lance una excepción que sea
tratada por un catch de algún try -ya sea de la que contiene las <instrucciones>, de algún
1.8. BLOQUES
Cuando se produce una excepción en try un bloque, el sistema busca en catch los bloques
asociados en el orden en el que aparecen en el código de la catch aplicación hasta que
encuentra un bloque que controla la excepción. Un catch bloque controla una excepción de
tipo T si el filtro de tipo del bloque catch especifica T o cualquier tipo que T se derive de. El
sistema detiene la búsqueda después de encontrar el catch primer bloque que controla la
excepción. Por esta razón, en el código de la catch aplicación, un bloque que controla un
tipo debe especificarse antes que un bloque que controla sus tipos base, como se muestra
en el ejemplo que sigue a catch esta sección. Un bloque catch que controla
System.Exception se especifica en último lugar.
Si ninguno de los catch bloques asociados al bloque actual try controla la excepción y el
bloque actual try está anidado dentro de otros try bloques de la llamada actual, los catch
bloques asociados al siguiente se busca try en el bloque de inclusión. Si no catch se
encuentra ningún bloque para la excepción, el sistema busca en los niveles de anidamiento
anteriores de la llamada actual. Si no catch se encuentra ningún bloque para la excepción
en la llamada actual, la excepción se pasa a la pila de llamadas y se busca en el marco de
pila anterior catch un bloque que controla la excepción. La búsqueda de la pila de llamadas
continúa hasta que se controla la excepción o hasta que no existen más fotogramas en la
pila de llamadas. Si se alcanza la parte superior de la pila de llamadas sin catch encontrar
un bloque que controla la excepción, el controlador de excepciones predeterminado lo
controla y la aplicación finaliza.
El bloque finally es opcional, y si se incluye ha de hacerlo tras todas los bloques catch.
Las <instruccionesFinally> de este bloque se ejecutarán tanto si se producen excepciones
en <instrucciones> como si no. En el segundo caso sus instrucciones se ejecutarán tras las
<instrucciones>, mientras que en el primero lo harán después de tratar la excepción pero
antes de seguirse ejecutando por la instrucción siguiente al try que la trató. Si en un try no
se encuentra un catch compatible, antes de pasar a buscar en su try padre o en su método
llamante padre se ejecutarán las <instruccionesFinally>.
using System;
class MiException:Exception {} class Excepciones
{
public static void Main()
{
try
{
}
catch (DivideByZeroException)
{ Console.WriteLine(“En el catch de Método2()”); } finally
{ Console.WriteLine(“finally de Método2()”); }
}
}
La idea de todo este mecanismo de excepciones es evitar mezclar el código normal con
el código de tratamiento de errores. Así, en <instrucciones> se escribiría el código como
si no se pudiesen producir errores, en las cláusulas catch se tratarían los posibles
errores, y en la cláusula finally se incluiría código a ejecutar tanto si produjesen errores
como si no (suele usarse para liberar recursos ocupados, como fichero o conexiones de
red abiertas), también es posible escribir cada cláusula catch definiendo una variable que
se podrá usar dentro del código de tratamiento de la misma para hacer referencia a la
excepción capturada. Esto se hace con la sintaxis:
catch (<tipoExcepción> <nombreVariable>)
{
<tratamiento>
}
Todas las excepciones derivan de System.Exception, para definir una cláusula catch que
pueda capturar cualquier tipo de excepción basta usar:
catch(System.Exception <nombreObjecto>)
{
<tratamiento>
}
EJEMPLIFICACIÓN
Para complementar los temas vistos, les invitamos a revisar el documento llamado:
- Ejemplificación de excepción
Pueden acceder a través del menú Recursos complementarios de la unidad 1, Material
complementario.
namespace PruebaExcepcion5
{
class Program
{
static void Main(string[] args)
{
try
{
Console.Write("Ingrese un valor:");
string linea = Console.ReadLine();
var num = int.Parse(linea);
var cuadrado = num * num;
Console.WriteLine($"El cuadrado de {num} es {cuadrado}");
}
catch (FormatException e)
{
Console.WriteLine($"Propiedad Message: {e.Message}\n");
Console.WriteLine($"Propiedad StackTrade: {e.StackTrace}\n");
Console.WriteLine($"Propiedad Source: {e.Source}\n");
Console.WriteLine($"Propiedad TargetSize: {e.TargetSite}");
}
Console.ReadKey();
La clase 'PilaVaciaException' hereda de la clase 'Exception', esto significa que quien lance
una excepción de este tipo luego deberá ser capturada en forma obligatoria.
https://www.tutorialesprogramacionya.com/javaya/detalleconcepto.php?punto=86&codigo=166&inicio
=80
EJEMPLIFICACIÓN
Para complementar los temas vistos, les invitamos a revisar el documento llamado:
- Ejemplificación excepciones – múltiples catch para un try
Pueden acceder a través del menú Recursos complementarios de la unidad 1, Material
complementario.