POE Unidad 2: Diseño y construcción de programas visuales y orientados a eventos

Programación Orientada a Eventos Carrera de Software
Ph.D. Franklin Parrales 1
29/04/2022
Diseño y construcción de
programas visuales y
orientados a eventos
Unidad 2
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Programación Orientada a Eventos

29/04/2022
Objetivo general de la Unidad 2
Construir programas con interfaces visuales y orientados a
eventos, basados en el uso de clases provistas por un
framework y creadas por el desarrollador para la
interacción con el usuario final.

29/04/2022
Contenido
• Introducción al IDE de desarrollo.
• Sintaxis, tipos de datos y conversiones,
estructuras de control, métodos y manejo de
excepciones.
• Programación en capas (MVC) y aplicaciones con
conceptos de orientación a objetos (Herencia,
Polimorfismo y Lista de Objetos)
• Formularios, Controles Comunes y sus eventos.
(TextBox, Label, Button, ComboBox,
DateTimePicker, DatagridView, ListBox,
CheckBox, RadioButton, PictureBox)
• Manejo de eventos del mouse, teclado, ítems, etc.

29/04/2022
IDE: Visual Studio
La palabra Visual hace referencia al método para
crear la interfaz gráfica del usuario (GUI), en
donde se colocan objetos prefabricados dentro de
la pantalla.
Para crear una aplicación con Visual Basic, se
emplean proyectos; los cuales son una colección
de archivos que generan a su vez nuevos
formularios.

29/04/2022
Entorno

29/04/2022
Formulario
El formulario es el objeto principal
ubicado en la ventana del
programa. Se pueden emplear
tantas ventanas como sean
necesarias en una aplicación,
siempre y cuando no existan dos
formularios con el mismo
nombre. Visual Studio por
defecto coloca a cada formulario
el nombre de Form1, Form2 y así
sucesivamente cada vez que se
agreguen nuevos formularios.

29/04/2022
Permite visualizar los
proyectos, aplicaciones y
formularios en forma
jerárquica, de la solución
que se está creando.
Para acceder al explorador
se da clic en el menú
ver/explorador de
soluciones o el ícono
Desde el teclado Ctrl Alt L
Explorador de soluciones

29/04/2022
Permite visualizar
los errores
generado en el
código. También
advertencias.
Para acceder a la
ventana se da clic
en el menú ver
/resultados
Desde el teclado
Ctrl Alt O
Ventana de resultados

29/04/2022
Cuadro de herramientas
• Contiene las herramientas agrupadas
por categorías como: Todos los
formularios de Windows Forms,
controles comunes, contenedores,
puntero, menús y barras de
herramientas entre otros.
• El cuadro de herramientas se visualiza
a través del menú Ver/Cuadro de
herramientas o el ícono de
herramientas.
• Desde el teclado Ctrl Alt X

29/04/2022
Un programa en visual está formado
por objetos
Es cualquier control
que forma parte de la
aplicación y estos a su
vez tienen asociado
un conjunto de
propiedades,
métodos y eventos.
Ejemplo: una caja de
texto (textbox), una
etiqueta (label) o un
botón (button).

29/04/2022
Son las características
específicas que posee un
objeto o formulario.
Ejemplo color de fondo
(backcolor), fuente (font) y
color de letra (forecolor),
imagen de fondo
(backgroundimage) entre
otros.
Propiedades

29/04/2022
Creando un proyecto de C# en Visual
Studio
• Creamos un proyecto de C# de tipo Windows Project
Application
• Le asignamos un nombre como solíamos hacer en
proyectos de Algoritmos y Lógica de Programación
• Por primera vez vamos a tener una interfaz gráfica!!

29/04/2022
Vista principal de un proyecto de
Escritorio

29/04/2022
Contenido
excepciones.

29/04/2022
Contenido
• Sintaxis
• Tipos de datos y conversiones
• Variables de tipo valor
• Variables de tipo referencia
• Estructuras de control
• Métodos y parámetros
• Manejo de excepciones

29/04/2022
C#
• Lenguaje Creado específicamente para la
plataforma .NET
• Estándar ECMA (Ecma-334).
• Orientado a Objetos y Componentes.
• Soporta todas las características de la POO:
- Abstracción
- Encapsulación.
- Herencia.
- Polimorfismo.
• Sintaxis derivada de C, C++, Delphi y Java.

29/04/2022
Arquitectura de .Net Framework
.
N
E
T
F
r
a
m
e
w
o
r
k
Múltiples
Lenguajes
VB C# C++ JScript ...
Especificación de Lenguaje común (CLS)
Librerías
de clases
extendidas
ASP.NET
ADO.NET
Windows Forms
XML
Librerías de clases base
Tiempo de ejecución en Lenguaje Común
(CLR)
Visual
Studio
.Net
Servicios
Operativos
MSMQ COM+ IIS Windows

29/04/2022
CLS - Elección del lenguaje
• .NET posee un único runtime (el CLR) y un
único conjunto de bibliotecas para todos los
lenguajes
• No hay diferencias notorias de performance
entre los lenguajes provistos por Microsoft
• El lenguaje a utilizar, en gral., dependerá de
su experiencia previa con otros lenguajes o de
gustos personales
– Si conoce Java, Delphi, C++, etc. → C#
– Si conoce Visual Basic o VBScript → VB.NET
• Los tipos de aplicaciones .NET son
INDEPENDIENTES del lenguaje que elija

29/04/2022
Sintaxis C#
• Terminación de Línea, es con un “;”
int a = 1 + b;
int a = 1
+ b;
int a =
1 + b;
int a =
1 +
b;

29/04/2022
Sintaxis C#
• Declaración en Bloques en llaves “{}”:
class Programa{
public static void Main(string[] args) {
Console.WriteLine(“Hola Mundo!");
}
}

29/04/2022
Sintaxis C#
• Comentarios en el código:
string nombre = “Juan”; // Comentario de una sola línea
/* Comentario con mas
de una línea*/
/// <summary>
/// Documentación XML que puede ser consumida por otras
/// herramientas para mostrar ayuda dinámica o generar
/// documentación en varios formatos
/// </summary>
public class Matematica {
/// <summary>
/// Calcula la suma de dos números enteros
/// </summary>
/// <param name="x">El primer operando de la suma</param>
/// <param name="y">El segundo operando de la suma</param>
/// <returns> La suma entera de ambos operandos</returns>
public int Sumar (int x, int y) {return x + y;}
}

29/04/2022
Sintaxis C#
• C# es un lenguaje “case-sensitive”
system.console.writeline(“HOLA”); //INCORRECTO
System.Console.WriteLine(“HOLA”); //CORRECTO
int a; //INCORRECTO
A = 1; //INCORRECTO
int a; //CORRECTO
A = 1; //CORRECTO

29/04/2022
Sintaxis C#
• Declaración de variables
int i;
decimal d;
rectangle r;
Persona per;

29/04/2022
Sintaxis C#
• Inicialización de variables
int i; //INCORRECTO
System.Console.WriteLine(i); //INCORRECTO
int i=0; //CORRECTO
System.Console.WriteLine(i); //CORRECTO

29/04/2022
Sintaxis C#
• Conversión de Tipos
Cuenta cta = new CtaCte();
CtaCte cc = cta; //Error: puede que cta no sea una CtaCte
CtaCte cc = (CtaCte)cta; //Conversion explicita “CASTING”
CtaCte cc = cta as CtaCte; //Usando el operador “as”
if (cta is CtaCte) ... //Comparación con el operador “is”

29/04/2022
Operadores
Descripción C#
Asignación =
Adición +
Sustracción -
Multiplicación *
División /
Negación !
Módulo (Parte entera de la división) %
Mayor >
Menor <
Mayor o Igual >=
Menor o Igual <=

29/04/2022
Operadores Lógicos
Distinto
!=
Igual
==
Negacion logica
!
Operador logico O
ll
Operador logico Y
&&
Operador
C#
En C# todas las evaluaciones se hacen por “cortocircuito”
//Si Hacer1() es True, entonces //Si Hacer1() es False, entonces
//NO se evalua Hacer2() //NO se evalua Hacer2()
if (Hacer1() || Hacer2()) if (Hacer1() && Hacer2())
{ {
} }

29/04/2022
Namespaces
C#
namespace BancoARG
{
namespace Gestion
{
public class CtaCte
{
}
public class CajaAhorro
{
}
}
}
//Referencia “full”
BancoARG.Gestion.CtaCte;
BancoARG.Gestion.CajaAhorro;
//Referencia “corta”
using BancoARG.Gestion;
CtaCte cc = new CtaCte();
CajaAhorro ca = new CajaAhorro();
Los namespaces (espacios de nombre)
funcionan como un método de
organización de clases (tanto las que
escribimos nosotros como las incluidas
en .NET), agrupando en un conjunto a
aquellas clases que están relacionadas
lógicamente.
Un namespace puede contener tanto
tipos (clases) como otros namespaces, y
dentro de un namespace no puede haber
dos clases con el mismo nombre.
El nombre completo de una clase se
construye a partir de todos los
namespaces que la contienen (la
jerarquía se arma separándolos con “.”)
+ el nombre mismo de la clase.

29/04/2022
Herencia
En C# la herencia se define:
class Cuenta //Clase Base
{
}
class CtaCte : Cuenta //Clase Derivada
{
}
En .NET solo
se permite
Herencia
Simple

29/04/2022
Contenido
• Sintaxis

29/04/2022
CTS (Common Type System)
• Define un conjunto común de “tipos” de datos
orientados a objetos
• Todo lenguaje de programación .NET debe
implementar los tipos definidos por el CTS
• Todo tipo hereda
directa o
indirectamente del
tipo System.Object
• Define Tipos de
VALOR y de
REFERENCIA

29/04/2022
CTS: Características
• Cada tipo puede tener cero o mas miembros
(campo, método, propiedad, evento).
• No puede existir la herencia Múltiple.
• Todo Tipo hereda directa o indirectamente
del tipo System.Object
• Los objetos que lanzan un tipo de excepción
deben heredar (directa o indirectamente) de
System.Exception
• Los tipos declarados en 2 ensamblados
distintos, son distintos, aunque tengan el
mismo nombre.

29/04/2022
Tipos
Overview
• Un programa en C# es una colección de
tipos
– Classes, structs, enums, interfaces, delegates
• C# proporciona un conjunto de tipos
predefinidos
– E.g. int, byte, char, string, object, …
• Puedes crear tus propios tipos.
• Todos los datos y el código se definen dentro
de un tipo.
– No hay variables globales, ni funciones globales

29/04/2022
Tipos
Overview
• Tipos contienen:
– Data members
• Fields, constants, arrays
• Events
– Function members
• Methods, operators, constructors, destructors
• Properties, indexers
– Otros tipos
• Classes, structs, enums, interfaces, delegates

29/04/2022
Tipos
Overview
• Tipos pueden ser instanciados…
– …y luego usados: call methods,
get y set properties, etc.
• Puede convertirse de un tipo a otro
– Implicitamente y explicitamente
• Tipos están organizados
– Namespaces, files, assemblies
• Hay dos categorías de tipos: valor y
referencia.
• Los tipos se organizan en una jerarquía.

29/04/2022
Tipos
Unified Type System
• Value types
– Directly contain data
– Cannot be null
• Reference types
– Contain references to objects
– May be null
int i = 123;
string s = "Hello world";
123
i
s "Hello world"

29/04/2022
Los Tipos de Datos
• El CLR administra dos segmentos de memoria:
Stack (Pila) y Heap (Montón)
• El Stack es liberado automáticamente y el Heap
es administrado por el GC (Garbage Collector)
• Los tipos VALOR se
almacenan en el
Stack
• Los tipos
REFERENCIA se
almacenan en el
Heap

29/04/2022
Tipos de Datos por Valor
Categoría Clase Descripción C# Alias
Enteros Byte Un entero sin signo (8-bit) byte
SByte Un entero con signo (8-bit) sbyte
Int16 Un entero con signo (16-bit) short
Int32 Un entero con signo (32-bit) int
Int64 Un entero con signo (64-bit) long
Punto
Flotante Single
Un número de punto flotante de simple precisión (32-
bit) float
Double
Un número de punto flotante de doble precisión (64-
bit) double
Decimal Un número decimal de 96-bit decimal
Lógicos Boolean Un valor booleano (true o false) bool
Otros Char Un caracter Unicode (16-bit) char
Object La raíz de la jerarquía de objetos object
String
Una cadena de caracteres unicode inmutable y de
tamaño fijo string

29/04/2022
Tipos
Unified Type System
• Value types
– Primitivos int i; float x;
– Enums enum State { Off, On }
– Structs struct Point {int x,y;}
• Reference types
– Root object
– String string
– Classes class Foo: Bar, IFoo {...}
– Interfaces interface IFoo: IBar {...}
– Arrays string[] a = new
string[10];
– Delegates delegate void Empty();

29/04/2022
Tipos
Unified Type System
Value (Struct) Reference (Class)
Variable holds Actual value Memory location
Allocated on Stack, member Heap
Nullability Always has value May be null
Default value 0 null
Aliasing (in a scope) No Yes
Assignment means Copy data Copy reference

29/04/2022
Tipos
Unified Type System
• Beneficios de value types
– No heap allocation, less GC pressure
– Más eficiente uso de memoria
– Less reference indirection
– Unified type system
• No primitive/object dichotomy

29/04/2022
Tipos
Conversiones
• Conversiones implícitas
– Occur automatically
– Guaranteed to succeed
– No information (precision) loss
• Explicit conversions
– Require a cast
– May not succeed
– Information (precision) might be lost
• Tanto las conversiones implícitas como las
explícitas pueden ser definidas por el usuario

29/04/2022
Tipos
Conversiones
int x = 123456;
long y = x; // implicit
short z = (short)x; // explicit
double d = 1.2345678901234;
float f = (float)d; // explicit
long l = (long)d; // explicit

29/04/2022
Tipos
Unified Type System
• Todo es un objeto
– Todos los tipos finalmente heredan de object
– Cualquier dato puede almacenarse,
transportarse y manipularse sin trabajo
adicional
M
em
oryStream FileStream
Stream Hashtable int double
object

29/04/2022
Tipos
Unified Type System
• Polimorfismo
– La capacidad de realizar una operación en un
objeto sin conocer el tipo preciso del objeto.
void Poly(object o) {
Console.WriteLine(o.ToString());
}
Poly(42);
Poly(“abcd”);
Poly(12.345678901234m);
Poly(new Point(23,45));

29/04/2022
Tipos
Unified Type System
• Pregunta: ¿Cómo podemos tratar
polimórficamente los tipos de valor y
referencia?
– ¿Cómo se convierte un int (tipo de valor) en
un objeto (tipo de referencia)?
• Respuesta: Boxing!
– Only value types get boxed
– Reference types do not get boxed

29/04/2022
Conversión de tipos por Valor y Referencia
• Para poder convertir tipos por valor a referencia y
viceversa se utiliza una técnica conocida como:
• BOXING:
Convierte un tipo por valor a uno por referencia.
• UNBOXING:
Convierte un tipo por referencia a un tipo por valor.
Tipo por Valor
Tipo por
Referencia
Boxing
Unboxing

29/04/2022
Types
Unified Type System
• Boxing
– Copies a value type into a reference type
(object)
– Each value type has corresponding “hidden”
reference type
– Note that a reference-type copy is made of the
value type
• Value types are never aliased
– Value type is converted implicitly to object, a
reference type
• Essentially an “up cast”

29/04/2022
Types
Unified Type System
• Unboxing
– Inverse operation of boxing
– Copies the value out of the box
• Copies from reference type to value type
– Requires an explicit conversion
• May not succeed (like all explicit conversions)
• Essentially a “down cast”

29/04/2022
Types
Unified Type System
• Boxing and unboxing
int i = 123;
object o = i;
int j = (int)o;
123
i
o
123
j
123
System.Int32

29/04/2022
Types
Unified Type System
• Benefits of boxing
– Enables polymorphism across all types
– Collection classes work with all types
– Eliminates need for wrapper classes
– Replaces OLE Automation's Variant
• Lots of examples in .NET Framework
Hashtable t = new Hashtable();
t.Add(0, "zero");
t.Add(1, "one");
t.Add(2, "two");
string s = string.Format(
"Your total was {0} on {1}",
total, date);

29/04/2022
Types
Unified Type System
• Disadvantages of boxing
– Performance cost
• The need for boxing will decrease when
the CLR supports generics (similar to C++
templates)

29/04/2022
Types
Predefined Types
• Value
– Integral types
– Floating point types
– decimal
– bool
– char
• Reference
– object
– string

29/04/2022
Predefined Types
Value Types
• All are predefined structs
Signed sbyte, short, int, long
Unsigned byte, ushort, uint, ulong
Character char
Floating point float, double, decimal
Logical bool

29/04/2022
Predefined Types
Integral Types
C# Type System Type Size (bytes) Signed?
sbyte System.Sbyte 1 Yes
short System.Int16 2 Yes
int System.Int32 4 Yes
long System.Int64 8 Yes
byte System.Byte 1 No
ushort System.UInt16 2 No
uint System.UInt32 4 No
ulong System.UInt64 8 No

29/04/2022
Predefined Types
Floating Point Types
• Follows IEEE 754 specification
• Supports ± 0, ± Infinity, NaN
C# Type System Type Size (bytes)
float System.Single 4
double System.Double 8

29/04/2022
Predefined Types
decimal
• 128 bits
• Essentially a 96 bit value scaled by a
power of 10
• Decimal values represented precisely
• Doesn’t support signed zeros, infinities
or NaN
decimal System.Decimal 16

29/04/2022
Predefined Types
decimal
• All integer types can be implicitly
converted to a decimal type
• Conversions between decimal and floating
types require explicit conversion due to
possible loss of precision
• s * m * 10e
– s = 1 or –1
– 0  m  296
– -28  e  0

29/04/2022
Predefined Types
Integral Literals
• Integer literals can be expressed as decimal
or hexadecimal
• U or u: uint or ulong
• L or l: long or ulong
• UL or ul: ulong
123 // Decimal
0x7B // Hexadecimal
123U // Unsigned
123ul // Unsigned long
123L // Long

29/04/2022
Predefined Types
Real Literals
• F or f: float
• D or d: double
• M or m: decimal
123f // Float
123D // Double
123.456m // Decimal
1.23e2f // Float
12.3E1M // Decimal

29/04/2022
Predefined Types
bool
• Represents logical values
• Literal values are true and false
• Cannot use 1 and 0 as boolean values
– No standard conversion between other types
and bool
bool System.Boolean 1 (2 for arrays)

29/04/2022
Predefined Types
char
• Represents a Unicode character
• Literals
– ‘A’ // Simple character
– ‘u0041’ // Unicode
– ‘x0041’ // Unsigned short hexadecimal
– ‘n’ // Escape sequence character
Char System.Char 2

29/04/2022
Predefined Types
char
• Escape sequence characters (partial list)
Char Meaning Value
’ Single quote 0x0027
” Double quote 0x0022
Backslash 0x005C
0 Null 0x0000
n New line 0x000A
r Carriage return 0x000D
t Tab 0x0009

29/04/2022
Predefined Types
Reference Types
Root type object
Character string string

29/04/2022
Predefined Types
object
• Root of object hierarchy
• Storage (book keeping) overhead
– 0 bytes for value types
– 8 bytes for reference types
• An actual reference (not the object)
uses 4 bytes
object System.Object 0/8 overhead

29/04/2022
Predefined Types
object Public Methods
• public bool Equals(object)
• protected void Finalize()
• public int GetHashCode()
• public System.Type GetType()
• protected object MemberwiseClone()
• public void Object()
• public string ToString()

29/04/2022
Predefined Types
string
• An immutable sequence of Unicode
characters
• Reference type
• Special syntax for literals
– string s = “I am a string”;
String System.String 20 minimum

29/04/2022
Predefined Types
string
• Normally have to use escape characters
• Verbatim string literals
– Most escape sequences ignored
• Except for “”
– Verbatim literals can be multi-line
string s1= “serverfilesharefilename.cs”;
string s2 = @“serverfilesharefilename.cs”;

29/04/2022
Types
User-defined Types
• User-defined types
Enumerations enum
Arrays int[], string[]
Interface interface
Reference type class
Value type struct
Function pointer delegate

29/04/2022
Types
Enums
• An enum defines a type name for a related
group of symbolic constants
• Choices must be known at compile-time
• Strongly typed
– No implicit conversions to/from int
– Can be explicitly converted
– Operators: +, -, ++, --, &, |, ^, ~, …
• Can specify underlying type
– byte, sbyte, short, ushort, int, uint, long, ulong

29/04/2022
Types
Enums
enum Color: byte {
Red = 1,
Green = 2,
Blue = 4,
Black = 0,
White = Red | Green | Blue
}
Color c = Color.Black;
Console.WriteLine(c); // 0
Console.WriteLine(c.Format()); // Black

29/04/2022
Types
Enums
• All enums derive from System.Enum
– Provides methods to
• determine underlying type
• test if a value is supported
• initialize from string constant
• retrieve all values in enum
• …

29/04/2022
Types
Arrays
• Arrays allow a group of elements of a specific
type to be stored in a contiguous block of
memory
• Arrays are reference types
• Derived from System.Array
• Zero-based
• Can be multidimensional
– Arrays know their length(s) and rank
• Bounds checking

29/04/2022
Types
Arrays
• Declare
• Allocate
• Initialize
• Access and assign
• Enumerate
int[] primes;
int[] primes = new int[9];
int[] prime = new int[] {1,2,3,5,7,11,13,17,19};
int[] prime = {1,2,3,5,7,11,13,17,19};
prime2[i] = prime[i];
foreach (int i in prime) Console.WriteLine(i);

29/04/2022
Types
Arrays
• Multidimensional arrays
– Rectangular
•int[,] matR = new int[2,3];
• Can initialize declaratively
•int[,] matR =
new int[2,3] { {1,2,3}, {4,5,6} };
– Jagged
• An array of arrays
•int[][] matJ = new int[2][];
• Must initialize procedurally

29/04/2022
Types
Interfaces
• An interface defines a contract
– Includes methods, properties, indexers, events
– Any class or struct implementing an interface
must support all parts of the contract
• Interfaces provide polymorphism
– Many classes and structs may implement
a particular interface
• Contain no implementation
– Must be implemented by a class or struct

29/04/2022
Types
Classes
• User-defined reference type
– Similar to C++, Java classes
• Single class inheritance
• Multiple interface inheritance

29/04/2022
Types
Classes
• Members
– Constants, fields, methods, operators,
constructors, destructors
– Properties, indexers, events
– Static and instance members
• Member access
– public, protected, private, internal,
protected internal
• Default is private
• Instantiated with new operator

29/04/2022
public class Car : Vehicle {
public enum Make { GM, Honda, BMW }
Make make;
string vid;
Point location;
Car(Make m, string vid; Point loc) {
this.make = m;
this.vid = vid;
this.location = loc;
}
public void Drive() {
Console.WriteLine(“vroom”); }
}
Car c =
new Car(Car.Make.BMW,
“JF3559QT98”,
new Point(3,7));
c.Drive();
Types
Classes

29/04/2022
Types
Structs
• Similar to classes, but
– User-defined value type
– Always inherits from object
• Ideal for lightweight objects
– int, float, double, etc., are all structs
– User-defined “primitive” types
• Complex, point, rectangle, color, rational
• Multiple interface inheritance
• Same members as class
• Member access
– public, internal, private
• Instantiated with new operator

29/04/2022
public struct Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int X { get { return x; }
set { x = value; } }
public int Y { get { return y; }
set { y = value; } }
}
Point p = new Point(2,5);
p.X += 100;
int px = p.X; // px = 102
Types
Structs

29/04/2022
Types
Classes and Structs
struct SPoint { int x, y; ... }
class CPoint { int x, y; ... }
SPoint sp = new SPoint(10, 20);
CPoint cp = new CPoint(10, 20);
10
20
sp
cp
10
20
CPoint

29/04/2022
Class Struct
Reference type Value type
Can inherit from any
non-sealed reference type
No inheritance
(inherits only from System.ValueType)
Can have a destructor No destructor
Can have user-defined
parameterless constructor
No user-defined parameterless
constructor
Types
Classes and Structs: Differences

29/04/2022
Comparación entre clases y
estructuras
Clases Estructuras
Pueden definir miembros de datos,
propiedades y métodos
Pueden definir miembros de datos,
propiedades y métodos
Soportan constructores e
inicialización de miembros
Sin constructor predeterminado ni
inicialización de miembros
Soportan el método Finalize No soportan el método Finalize
Extensibles por herencia No soportan herencia
Tipo Referencia Tipo Valor

29/04/2022
Types
Classes and Structs: Static vs. Instance Members
• By default, members are per instance
– Each instance gets its own fields
– Methods apply to a specific instance
• Static members are per type
– Static methods can’t access instance data
– No this variable in static methods
• Don’t abuse static members
– They are essentially object-oriented
global data and global functions

29/04/2022
public class MyClass {
public const string version = “1.0.0”;
public const string s1 = “abc” + “def”;
public const int i3 = 1 + 2;
public const double PI_I3 = i3 * Math.PI;
public const double s = Math.Sin(Math.PI); //ERROR
...
}
Types
Classes and Structs: Constants
• A constant is a data member that is
evaluated at compile-time and is implicitly
static (per type)
– e.g. Math.PI

29/04/2022
Types
Classes and Structs: Fields
• A field is a member variable
• Holds data for a class or struct
• Can hold:
– a class instance (a reference),
– a struct instance (actual data), or
– an array of class or struct instances
(an array is actually a reference)

29/04/2022
Types
Classes and Structs: Readonly Fields
• Similar to a const, but is initialized at
run-time in its declaration or in a constructor
– Once initialized, it cannot be modified
• Differs from a constant
– Initialized at run-time (vs. compile-time)
• Don’t have to re-compile clients
– Can be static or per-instance
public class MyClass {
public static readonly double d1 = Math.Sin(Math.PI);
public readonly string s1;
public MyClass(string s) { s1 = s; } }

29/04/2022
public class Button: Control {
private string caption;
public string Caption {
get { return caption; }
set { caption = value;
Repaint(); }
}
}
Button b = new Button();
b.Caption = "OK";
String s = b.Caption;
Types
Classes and Structs: Properties
 A property is a virtual field
 Looks like a field, but is implemented with code
 Can be
read-only,
write-only,
or read/write

29/04/2022
public class ListBox: Control {
private string[] items;
public string this[int index] {
get { return items[index]; }
set { items[index] = value;
Repaint(); }
}
}
ListBox listBox = new ListBox();
listBox[0] = "hello";
Console.WriteLine(listBox[0]);
Types
Classes and Structs: Indexers
 An indexer lets an instance behave as a
virtual array
 Can be overloaded (e.g. index by int and by string)
 Can be
read-only,
write-only,
or read/write

29/04/2022
Types
Delegates
• Delegates are essentially function pointers. This is
the mechanism used to implement event in the
frameworks.
• A delegate is a reference type that defines a
method signature
• A delegate instance holds one or more methods
– Essentially an “object-oriented function pointer”
– Methods can be static or non-static
– Methods can return a value
• Provides polymorphism for individual functions
• Foundation for event handling

29/04/2022
Types
Delegates
delegate double Del(double x); // Declare
static void DemoDelegates() {
Del delInst = new Del(Math.Sin); // Instantiate
double x = delInst(1.0); // Invoke
}

29/04/2022
Types
Multicast Delegates
• A delegate can hold and invoke multiple
methods
– Multicast delegates must contain only methods
that return void, else there is a run-time
exception
• Each delegate has an invocation list
– Methods are invoked sequentially, in the order
added
• The += and -= operators are used to add
and remove delegates, respectively
• += and -= operators are thread-safe

29/04/2022
Types
Multicast Delegates
delegate void SomeEvent(int x, int y);
static void Foo1(int x, int y) {
Console.WriteLine("Foo1");
}
static void Foo2(int x, int y) {
Console.WriteLine("Foo2");
}
public static void Main() {
SomeEvent func = new SomeEvent(Foo1);
func += new SomeEvent(Foo2);
func(1,2); // Foo1 and Foo2 are called
func -= new SomeEvent(Foo1);
func(2,3); // Only Foo2 is called
}

29/04/2022
Delegates
and Interfaces
• Could always use interfaces instead of
delegates
• Interfaces are more powerful
– Multiple methods
– Inheritance
• Delegates are more elegant for event handlers
– Less code
– Can easily implement multiple event handlers on
one class/struct

29/04/2022
Contenido
• Sintaxis

29/04/2022
Aspectos generales del CTS
• El CTS admite tanto tipos de valor como
de referencia
Tipo de referencia
Tipo
Tipo de valor

29/04/2022
Comparación de tipos de valor y de
referencia
◼ Tipos de valor:
◼ Contienen sus datos
directamente
◼ Cada una tiene su
propia copia de datos
◼ Las operaciones
sobre una no afectan
a otra
◼ Tipos de referencia:
◼ Almacenan referencias a
sus datos (conocidos como
objetos)
◼ Dos variables de referencia
pueden apuntar al mismo
objeto
◼ Las operaciones sobre una
pueden afectar a otra

29/04/2022
Comparación de tipos de valor
predefinidos y definidos por el usuario
◼ Ejemplos de tipos de
valor predefinidos:
◼ int
◼ float
◼ Ejemplos de tipos de valor
definidos por el usuario:
◼ enum
◼ struct
Del usuario
Tipos de valor
Predefinido

29/04/2022
Tipos simples
• Se identifican mediante palabras
reservadas
– int // Palabra reservada
- o -
– System.Int32

29/04/2022
Reglas y recomendaciones para
nombrar variables
• Reglas
– Use letras, el signo de
subrayado y dígitos
• Recomendaciones
– Evite poner todas las letras
en mayúsculas
– Evite empezar con un
signo de subrayado
– Evite el uso de
abreviaturas
– Use PascalCasing para
nombres con varias
palabras
diferente
Diferente
Respuesta42
42Respuesta
✓
✓

✓
Mal
_regular
Bien

✓

Msj
Mensaje
✓


29/04/2022
Palabras clave de C#
• Las palabras clave son identificadores
reservados
• No utilice palabras clave como nombres de
variables
– Produce errores en tiempo de compilación
• Procure no usar palabras clave cambiando
mayúsculas y minúsculas
abstract, base, bool, default, if, finally
int INT; // Mal estilo

29/04/2022
Declaración de variables locales
• Se suelen declarar por tipo de dato y nombre de
variable:
• Es posible declarar múltiples variables en una
declaración:
--o--
int objetoCuenta;
int objetoCuenta, empleadoNúmero;
int objetoCuenta,
empleadoNúmero;

29/04/2022
Asignación de valores a variables
• Asignar valores a variables ya declaradas:
• Inicializar una variable cuando se declara:
• También es posible inicializar valores de
caracteres:
int empleadoNumero;
empleadoNumero = 23;
int empleadoNumero = 23;
char inicialNombre = 'J';

29/04/2022
Asignación compuesta
• Es muy habitual sumar un valor a una
variable
• Se puede usar una expresión más práctica
• Esta abreviatura es válida para todos los
operadores aritméticos:
itemCount = itemCount + 40;
itemCount += 40;
itemCount -= 24;

29/04/2022
Operadores comunes
Operadores comunes
• Operadores de igualdad
• Operadores relacionales
• Operadores condicionales
• Operador de incremento
• Operador de decremento
• Operadores aritméticos
• Operadores de asignación
Ejemplo
== !=
< > <= >= is
&& || ?:
++
- -
+ - * / %
= *= /= %= += -= <<=
>>= &= ^= |=

29/04/2022
Incremento y decremento
• Es muy habitual cambiar un valor en una unidad
• Se puede usar una expresión más práctica
• Existen dos formas de esta abreviatura
objetoCuenta += 1;
objetoCuenta -= 1;
objetoCuenta++;
objetoCuenta--;
++objetoCuenta;
--objetoCuenta;

29/04/2022
Precedencia de operadores
• Precedencia y asociatividad de
operadores
– Todos los operadores binarios, salvo los de
asignación, son asociativos por la izquierda
– Los operadores de asignación y el operador
condicional son asociativos por la derecha

29/04/2022
Enumeraciones
• Definición de una enumeración
• Uso de una enumeración
• Visualización de una variable de enumeración
enum Color { Rojo, Verde, Azul }
Color colorPaleta = Color.Rojo;
Console.WriteLine(“{0}”, colorPaletta); // Muestra Rojo

29/04/2022
Estructuras
• Definición de una estructura
• Uso de una estructura
Employee empresaEmpleado;
empresaEmpleado.pilaNombre = "Juan";
empresaEmpleado.age = 23;
public struct Empleado
{
public string pilaNombre;
public int age;
}

29/04/2022
Conversión implícita de tipos de datos
• Conversión de int a long
• Las conversiones implícitas no pueden fallar
– Se puede perder precisión, pero no magnitud
using System;
class Test
{
static void Main( )
{
int intValor = 123;
long longValor = intValor;
Console.WriteLine("(long) {0} = {1}", intValor,
longValor);
}
}

29/04/2022
Conversión explícita de tipos de datos
• Para hacer conversiones explícitas se
usa una expresión de cast (molde):
using System;
class Test
{
static void Main( )
{
long longValor = Int64.MaxValor;
int intValor = (int) longValor;
Console.WriteLine("(int) {0} = {1}", longValor,
intValor);
}
}

29/04/2022
Contenido
• Sintaxis

29/04/2022
Comparación de tipos valor y tipos
referencia
◼ Tipos valor
⚫ La variable
contiene el valor
directamente
⚫ Ejemplos:
char, int
42
int mol;
mol = 42;
•
string mol;
mol = “Hola";
Hola
◼ Tipos referencia
⚫ La variable contiene una
referencia al dato
⚫ El dato se almacena en un
área de memoria aparte

29/04/2022
Declaración y liberación de variables
referencia
◼ Declaración de variables referencia
coordenada c1;
c1 = new coordinate();
c1.x = 6.12;
c1.y = 4.2;
• 6.12 4.2
c1 = null;
• 6.12 4.2
◼ Liberación de variables referencia

29/04/2022
Referencias no válidas
• Si hay referencias no válidas
– No es posible acceder a miembros o
variables
• Referencias no válidas en tiempo de
compilación
– El compilador detecta el uso de referencias
no inicializadas
• Referencias no válidas en tiempo de
ejecución
– El sistema generará un error de excepción

29/04/2022
Comparación de valores y comparación
de referencias
• Comparación de tipos valor
– == and != comparan valores
• Comparación de tipos referencia
– == and != comparan las referencias, no los
valores
• 1.0 2.0
• 1.0 2.0
Diferente

29/04/2022
Referencias múltiples a un mismo objeto
• Dos referencias pueden apuntar a un mismo
objeto
– Dos formas de acceder a un mismo objeto para
lectura/escritura
coordinate c1= new coordinate ( );
coordinate c2;
c1.x = 2.3; c1.y = 7.6;
c2 = c1;
Console.WriteLine(c1.x + " , " + c1.y);
Console.WriteLine(c2.x + " , " + c2.y);
•
2.3 7.6
•
c1
c2

29/04/2022
Uso de referencias como parámetros de
métodos
• Las referencias se pueden usar como
parámetros
– Si se pasan por valor, es posible cambiar el dato
referenciado
static void PassCoordinateByValue(coordinate c)
{
c.x++; c.y++;
}
loc.x = 2; loc.y = 3;
PassCoordinateByValue(loc);
Console.WriteLine(loc.x + " , " + loc.y);
2 3 3 4
•
•

29/04/2022
◆Uso de tipos referencia comunes
• Clase Exception
• Clase String
• Métodos, operadores y propiedades
comunes de String
• Comparaciones de cadenas de caracteres
• Operadores de comparación en String

29/04/2022
Clase Exception
• Exception es una clase
• Los objetos Exception se usan para lanzar
excepciones
– Para crear un objeto Exception se usa new
– Para lanzar el objeto se usa throw
• Los tipos Exception son subclases de
Exception

29/04/2022
Clase String
• Cadenas de caracteres Unicode
• Abreviatura de System.String
• Inmutable
string s = "Hola";
s[0] = 'c'; // Error al compilar

29/04/2022
Métodos, operadores y propiedades
comunes de String
• Corchetes
• Método Insert
• Propiedad Length
• Método Copy
• Método Concat
• Método Trim
• Métodos ToUpper y ToLower

29/04/2022
Comparaciones de cadenas de
caracteres
• Método Equals
– Comparación de valores
• Método Compare
– Más comparaciones
– Opción para no distinguir mayúsculas y
minúsculas
– Ordenación alfabética
• Opciones locales de Compare

29/04/2022
Operadores de comparación en String
• Los operadores == y != están
sobrecargados para cadenas
• Son equivalentes a String.Equals y
!String.Equals
string a = "Test";
string b = "Test";
if (a == b) ... // Devuelve true

29/04/2022
◆ La jerarquía de objetos
• El tipo object
• Métodos comunes
• Reflexión

29/04/2022
El tipo object
• Sinónimo de System.Object
• Clase base para todas las demás clases
Exception
SystemException
MyClass
Object
String

29/04/2022
Métodos comunes
• Métodos comunes para todos los tipos
referencia
– Método ToString
– Método Equals
– Método GetType
– Método Finalize

29/04/2022
Reflexión
• Es posible obtener información sobre el
tipo de un objeto
• Espacio de nombres System.Reflection
• El operador typeof devuelve el tipo de
un objeto
– Sólo para clases en tiempo de compilación
• Método GetType en System.Object
– Información sobre clases en tiempo de
ejecución

29/04/2022
◆ Espacios de nombres en .NET
Framework
• Espacio de nombres System.IO
• Espacio de nombres System.Xml
• Espacio de nombres System.Data
• Otros espacios de nombres útiles

29/04/2022
Espacio de nombres System.IO
• Acceso a entrada/salida del sistema de
archivos
– File, Directory
– StreamReader, StreamWriter
– FileStream
– BinaryReader, BinaryWriter

29/04/2022
Espacio de nombres System.Xml
• Compatibilidad con XML
• Estándares de XML

29/04/2022
Espacio de nombres System.Data
• System.Data.SqlClient
– SQL Server .NET Data Provider
• System.Data
– Consta básicamente de las clases que
constituyen la arquitectura ADO.NET

29/04/2022
Otros espacios de nombres útiles
• Espacio de nombres System
• Espacio de nombres System.Net
• Espacio de nombres System.Net.Sockets
• Espacio de nombres
System.Windows.Forms

29/04/2022
◆ Conversiones de datos
• Conversión de tipos valor
• Conversiones padre/hija
• El operador is
• El operador as
• Conversiones y el tipo object
• Conversiones e interfaces
• Boxing y unboxing

29/04/2022
Conversión de tipos valor
• Conversiones implícitas
• Conversiones explícitas
– Operador de cast
• Excepciones
• Clase System.Convert
– Control interno de conversiones

29/04/2022
Conversiones padre/hija
• Conversión a referencia de clase padre
– Implícita o explícita
– Siempre tiene éxito
– Siempre se puede asignar a un objeto
• Conversión a referencia de clase hija
– Es necesario cast explícito
– Comprueba que la referencia es del tipo correcto
– Si no lo es, causa una excepción
InvalidCastException

29/04/2022
El operador is
• Devuelve true si es posible realizar una
conversión
Pajaro b;
if (a is Pajaro)
b = (Pajaro) a; // No hay problema
else
Console.WriteLine("No es Pájaro");

29/04/2022
El operador as
• Hace conversiones entre tipos referencia,
como cast
• En caso de error
– Devuelve null
– No causa una excepción
Pajaro b = a as Pajaro; // Convertir
if (b == null)
Console.WriteLine("No es Pájaro”);

29/04/2022
Conversiones y el tipo object
• El tipo object es la base para todas las clases
• Se puede asignar a object cualquier referencia
• Se puede asignar cualquier variable object a
cualquier referencia
– Con conversión de tipo y comprobaciones
• El tipo object y el operador is
object buey;
buey = a;
buey = (object) a;
buey = a as object;
b = (Pajaro) buey;
b = buey as Pajaro;

29/04/2022
Conversiones e interfaces
• Una interfaz sólo se puede usar para
acceder a sus propios miembros
• No es posible acceder a otros miembros y
variables de la clase a través de la interfaz

29/04/2022
Boxing y unboxing
• Sistema de tipos unificado
• Boxing
• Unboxing
• Llamadas a métodos de object en tipos
valor
int p = 123;
object box;
box = p;
• 123
123 p = (int)box;

29/04/2022
Contenido
• Sintaxis

29/04/2022
Bloques de instrucciones
◼ Se usan llaves
para delimitar
bloques
{
// code
} {
int i;
...
{
int i;
...
}
}
{
int i;
...
}
...
{
int i;
...
}
◼ Un bloque y su
bloque padre o
pueden tener una
variable con el
mismo nombre
◼ Bloques
hermanos pueden
tener variables
con el mismo
nombre

29/04/2022
Tipos de instrucciones
Instrucciones Condicionales
Las instrucciones if y switch
Instrucciones de iteración
Las instrucciones while, do, for, y foreach
Instrucciones de salto
Las instrucciones goto, break, y continue

29/04/2022
La instrucción if
• Sintaxis:
• No hay conversión implicita de int a bool
int x;
...
if (x) ... // Debe ser if (x != 0) en C#
if (x = 0) ... // Debe ser if (x == 0) en C#
if ( expresión-booleana )
primera-instrucción-incrustada
else
segunda-instrucción-incrustada

29/04/2022
Instrucciones if en cascada
enum Palo { Treboles, Corazones, Diamantes, Picas}
Palo cartas = Palo.Corazones;
if (cartas == Palo.Treboles)
color = “Negro”;
else if (cartas == Palo.Corazones)
color = “Rojo";
else if (palo == Palo.Diamantes)
color = "Rojo";
else
color = “Negro";

29/04/2022
La instrucción switch
• Las instrucciones switch se usan en bloques de
varios casos
• Se usan instrucciones break para evitar caídas
en cascada (fall through)
switch (palo) {
case Palo.Treboles :
case Palo.Picas :
color = "Negro"; break;
case Palo.Corazones :
case Palo.Diamantes :
color = "Rojo"; break;
default:
color = "ERROR"; break;
}

29/04/2022
La instrucción while
• Ejecuta instrucciones en función de un valor
booleano
• Evalúa la expresión booleana al principio del
bucle
• Ejecuta las instrucciones mientras el valor
booleano sea True
int i = 0;
while (i < 10) {
Console.WriteLine(i);
i++;
}
0 1 2 3 4 5 6 7 8 9

29/04/2022
La instrucción do
• Ejecuta instrucciones en función de un valor
booleano
• Evalúa la expresión booleana al final del bucle
• Ejecuta las instrucciones mientras el valor
booleano sea True
int i = 0;
do {
i++;
} while (i < 10);
0 1 2 3 4 5 6 7 8 9

29/04/2022
La instrucción for
• La información de actualización está al principio del bucle
• Las variables de un bloque for sólo son válidas en el bloque
• Un bucle for puede iterar varios valores
for (int i = 0; i < 10; i++) {
}
0 1 2 3 4 5 6 7 8 9
for (int i = 0; i < 10; i++)
Console.WriteLine(i); // Error: i está fuera de ámbito
for (int i = 0, j = 0; ... ; i++, j++)

29/04/2022
La instrucción foreach
• Elige el tipo y el nombre de la variable de iteración
• Ejecuta instrucciones incrustadas para cada
elemento de la clase collection
ArrayList numeros = new ArrayList( );
for (int i = 0; i < 10; i++ ) {
numeros.Add(i);
}
foreach (int number in numeros) {
Console.WriteLine(numero);
}
0 1 2 3 4 5 6 7 8 9

29/04/2022
La instrucción goto
• Transfiere el flujo de control a una instrucción con
etiqueta
• Pueden dar lugar fácilmente a código “spaghetti”
de difícil interpretación
if (numero % 2 == 0) goto Par;
Console.WriteLine(“impar");
goto Fin;
Par:
Console.WriteLine(“par");
Fin:;

29/04/2022
Las instrucciones break and continue
• La instrucción break salta fuera de una iteración
• La instrucción continue salta a la siguiente
iteración
int i = 0;
while (true) {
i++;
if (i < 10)
continue;
else
break;
}

29/04/2022
Contenido
• Sintaxis

29/04/2022
Métodos
• Todo código se ejecuta en un método
– Los constructores, destructores y operadores
son tipos especiales de métodos.
– Las propiedades y los indexadores se
implementan con métodos get/set
• Los métodos tienen listas de argumentos
• Los métodos contienen declaraciones
• Los métodos pueden devolver un valor.
– Solo si el return no es void

29/04/2022
Definición de métodos
• Main es un método
– Para definir métodos propios se usa la misma
sintaxis
using System;
class ExampleClass
{
static void ExampleMethod( )
{
Console.WriteLine("ExampleMethod");
}
static void Main( )
{
// ...
}
}

29/04/2022
Llamadas a métodos
• Una vez definido un método, se puede:
– Llamar a un método desde dentro de la misma
clase
• Se usa el nombre del método seguido de una lista de
parámetros entre paréntesis
– Llamar a un método que está en una clase
diferente
• Hay que indicar al compilador cuál es la clase que
contiene el método que se desea llamar
• El método llamado se debe declarar con la palabra
clave public
– Usar llamadas anidadas
• Unos métodos pueden hacer llamadas a otros, que a
su vez pueden llamar a otros métodos, y así
sucesivamente

29/04/2022
Uso de la instrucción return
• Return inmediato
• Return con una instrucción condicional
static void ExampleMethod( )
{
int numBeans;
//...
Console.WriteLine("Hello");
if (numBeans < 10)
return;
Console.WriteLine("World");
}

29/04/2022
Uso de variables locales
• Variables locales
– Se crean cuando comienza el método
– Son privadas para el método
– Se destruyen a la salida
• Variables compartidas
– Para compartir se utilizan variables de clase
• Conflictos de ámbito
– El compilador no avisa si hay conflictos entre
nombres locales y de clase

29/04/2022
Devolución de valores
• El método se debe declarar con un tipo que no sea
void
• Se añade una instrucción return con una expresión
– Fija el valor de retorno
– Se devuelve al llamador
• Los métodos que no son void deben devolver un
valor
static int DosMasDos( ) {
int a,b;
a = 2;
b = 2;
return a + b;
}
int x;
x = DosMasDos( );
Console.WriteLine(x);

29/04/2022
Declaración y llamadas a parámetros
• Declaración de parámetros
– Se ponen entre paréntesis después del nombre del
método
– Se definen el tipo y el nombre de cada parámetro
• Llamadas a métodos con parámetros
– Un valor para cada parámetro
static void MethodWithParameters(int n, string y)
{ ... }
MethodWithParameters(2, "Hola, mundo");

29/04/2022
Mecanismos de paso de parámetros
• Tres maneras de pasar parámetros
entrada Paso por valor
entrada
salida
Paso por referencia
salida Parámetros de salida

29/04/2022
Paso por valor
• Mecanismo predeterminado para el paso de
parámetros:
– Se copia el valor del parámetro
– Se puede cambiar la variable dentro del método
– No afecta al valor fuera del método
– El parámetro debe ser de un tipo igual o compatible
static void SumaUno(int x)
{
x++; // Incrementar x
}
static void Main( )
{
int k = 6;
SumaUno(k);
Console.WriteLine(k); // Muestra el valor 6, no 7
}

29/04/2022
Paso por referencia
• ¿Qué son los parámetros referencia?
– Una referencia a una posición de memoria
• Uso de parámetros referencia
– Se usa la palabra clave ref en la declaración
y las llamadas al método
– Los tipos y valores de variables deben
coincidir
– Los cambios hechos en el método afectan al
llamador
– Hay que asignar un valor al parámetro antes
de la llamada al método

29/04/2022
Parámetros de salida
• ¿Qué son los parámetros de salida?
– Pasan valores hacia fuera, pero no hacia
dentro
• Uso de parámetros de salida
– Como ref, pero no se pasan valores al método
– Se usa la palabra clave out en la declaración
y las llamadas al método
static void OutDemo(out int p)
{
// ...
}
int n;
OutDemo(out n);

29/04/2022
Uso de listas de parámetros de
longitud variable
• Se usa la palabra clave params
• Se declara como tabla al final de la lista de
parámetros
• Siempre paso por valor
static long AddList(params long[ ] v)
{
long total, i;
for (i = 0, total = 0; i < v.Length; i++)
total += v[i];
return total;
}
static void Main( )
{
long x = AddList(63,21,84);
}

29/04/2022
Normas para el paso de parámetros
• Mecanismos
– El paso por valor es el más habitual
– El valor de retorno del método es útil para un solo
valor
– ref y/o out son útiles para más de un valor de
retorno
– ref sólo se usa si los datos se pasan en ambos
sentidos
• Eficiencia
– El paso por valor suele ser el más eficaz

29/04/2022
Uso de métodos recursivos
• Un método puede hacer una llamada a sí
mismo
– Directamente
– Indirectamente
• Útil para resolver ciertos problemas

29/04/2022
Declaración de métodos sobrecargados
• Métodos que comparten un nombre en una
clase
– Se distinguen examinando la lista de parámetros
class OverloadingExample
{
static int Suma(int a, int b)
{
return a + b;
}
static int Suma(int a, int b, int c)
{
return a + b + c;
}
static void Main( )
{
Console.WriteLine(Suma(1,2) + Suma(1,2,3));
}
}

29/04/2022
Signaturas de métodos
• Las signaturas de métodos deben ser
únicas dentro de una clase
• Definición de signatura
◼ Nombre del método
◼ Tipo de parámetro
◼ Modificador
Forman la definición
de la signatura
◼ Nombre de parámetro
◼ Tipo de retorno de
método
No afectan a la
signatura

29/04/2022
Uso de métodos sobrecargados
• Conviene usar métodos sobrecargados si:
– Hay métodos similares que requieren
parámetros diferentes
– Se quiere añadir funcionalidad al código
existente
• No hay que abusar, ya que:
– Son difíciles de depurar
– Son difíciles de mantener

29/04/2022
Contenido
• Sintaxis

29/04/2022
¿Por qué se emplean excepciones?
• El tradicional tratamiento procedural de
errores es demasiado complicado
int errorCodigo = 0;
FileInfo source = new FileInfo("code.cs");
if (errorCodigo == -1) goto Fallo;
int longitud = (int)source.Length;
char[] contenido = new char[longitud];
// No hay problemas ...
Fallo: ... Trat. De errores
Lógica del programa

29/04/2022
La clase Exception
◼ Las clases Exception permiten recuperar información sobre cualquier
excepción que encontremos
◼ Las propiedades de la clase base Exception permiten analizar
excepciones
– Principales propiedades: StackTrace, Message, HelpLink,
Source
IOException
Exception
OutOfMemoryException
ApplicationException
SystemException
FileNotFoundException
◼ El .NET Framework proporciona el siguiente modelo de objeto de
excepciones:

29/04/2022
Obejetos Excepción
Exception
SystemException
OutOfMemoryException
IOException
NullReferenceException
ApplicationException

29/04/2022
¿Qué es la gestión estructurada de
excepciones?
• Detecta y responde a errores mientras se ejecuta una
aplicación
• Utiliza Try…Catch…Finally para encapsular y
proteger bloques de código que podrían provocar
errores
– Cada bloque tiene uno o más controladores asociados
– Cada controlador especifica alguna forma de condición de
filtro en el tipo de excepción que controla
• Ventajas:
– Permite la separación entre la lógica y el código de
gestión de errores
– Facilita la lectura, depuración y mantenimiento del código

29/04/2022
Uso de bloques try-catch
• Solución orientada a objetos para el tratamiento
de errores
– Poner el código normal en un bloque try
– Tratar las excepciones en un bloque catch aparte
try {
Console.WriteLine("Escriba un número");
int i = int.Parse(Console.ReadLine());
}
catch (OverflowException capturada)
{
Console.WriteLine(capturada);
}
Tratamiento de errores
Lógica del programa

29/04/2022
Bloques catch múltiples
• Cada bloque catch captura una clase de excepcion
• Un bloque try puede tener un bloque catch general
• Un bloque try no puede capturar una clase derivada de
una clase capturada en un bloque catch anterior
try
{
Console.WriteLine(“Escriba el primer número");
int i = int.Parse(Console.ReadLine());
Console.WriteLine("Escriba el segundo número");
int j = int.Parse(Console.ReadLine());
int k = i / j;
}
catch (OverflowException capturada) {…}
catch (DivideByZeroException capturada) {…}

29/04/2022
La instrucción throw
• Lanza una excepción apropiada
• Asigna a la excepción un mensaje significativo
throw expression ;
if (minuto < 1 || minuto >= 60) {
throw new InvalidTimeException(minuto +
" no es un minuto válido");
// !! Not alcanzado !!
}

29/04/2022
La cláusula finally
• Las instrucciones de un bloque finally se
ejecutan
Monitor.Enter(x);
try {
...
}
finally {
Monitor.Exit(x);
}
Bloques catch opcionales

29/04/2022
Comprobación de desbordamiento aritmético
• Por defecto, el desbordamiento aritmético no se
comprueba
– Un comando checked activa la comprobación de
desbordamiento
checked {
int numero = int.MaxValue;
Console.WriteLine(++numero);
}
unchecked {
int numero = int.MaxValue;
Console.WriteLine(++numero);
} -2147483648
OverflowException
Se lanza un objeto excepción.
WriteLine no se ejecuta
MaxValue + 1 es negativo?

29/04/2022
Normas para el tratamiento de
excepciones
• Lanzamiento
– Evitar excepciones para casos normales o esperados
– Nunca crear ni lanzar objetos de clase Exception
– Incluir una cadena de descripción en un objeto
Exception
– Lanzar objetos de la clase más específica posible
• Captura
– Ordenar los bloques catch de lo específico a lo
general
– No permitir que salgan excepciones de Main

29/04/2022
Directrices para el uso de la gestión
estructurada de excepciones
No utilizar la gestión estructurada de excepciones para
errores que se produzcan de modo rutinario. Utilizar otros
bloques de código para abordar estos errores.
⚫ If…End If, etc.
Devolver un valor para los casos de errores habituales
⚫ Ejemplo: los métodos de lectura de E/S de archivos
no lanzan una excepción de fín de archivo
Organizar los bloques Catch desde específicos hasta
generales

29/04/2022
Tratamiento de excepciones
using System;
public class Hola
{
public static void Main(string[ ] args)
{
try{
Console.WriteLine(args[0]);
}
catch (Exception e) {
Console.WriteLine(“Excepción en
{0}", e.StackTrace);
}
}
}

29/04/2022
Estructura de un programa C#
• Hola, mundo
• La clase
• El método Main
• La sentencia using y el espacio de nombres System
• Operaciones básicas de entrada/salida
– La clase Console
– Los métodos Write y WriteLine
– Los métodos Read y ReadLine
• Comentarios a aplicaciones

29/04/2022
Hola, mundo
using System;
class Hola
{
public static void Main()
{
Console.WriteLine("Hola, mundo");
}
}