Este documento describe conceptos fundamentales de programación como constantes, enums, modificador protected, listas e interfaces. Explica que las constantes son valores inmutables declarados con const, los enums permiten definir conjuntos de valores y las listas son estructuras de datos dinámicas que almacenan objetos u otros datos. También define el modificador protected y cómo restringe el acceso a miembros, e introduce las interfaces como contratos que definen comportamientos.

1. holamundo.co
_ amando
O
O
P
0
5
progra

2. Agenda
Constantes
Enums
Modificador - protected
List
Interface

3. Constantes
Son valores inmutables que no cambian durante la ejecución del pro-
grama y se conocen en tiempo de compilación. Las constantes son
declaradas con el modificador const. Se debe asignar el valor de la con-
stante en el momendo de declaración.
Tipos definidos por el usuario como clases, arreglos, structs no pueden
ser una constante. Constantes son accedidas como si fueran campos es-
táticos por los el valor de una constante es el mismo para todas la in-
stancias del mismo tipo. Por tanto no se usa la palabra reservada static
para declararlas. Expresiones que no estan en la clase que define la con-
stante, debe usar el nombre de la clase, punto y el nombre de la con-
stante para acceder al valor.
public const int MESES = 12;
float impuesto = Constantes.IVA;
Clase Constante

4. enum Dias
{
Lunes,
Martes,
Miercoles,
Jueves,
Viernes,
Sabado,
Domingo
}
De forma predeterminada, los valores de
constante asociados de miembros de enu-
meración son del tipo int; comienzan con
cero y aumentan en uno después del
orden del texto de la definición.
Enums - enumeración
Un tipo de enumeración es un tipo de valor definido por un conjunto de
constantes con nombre del tipo numérico integral subyacente. Para
definir un tipo de enumeración, use la palabra clave enum y especifique
los nombres de miembros de enumeración
0
1
6
.
.
. Un tipo de enumeración se usa para repre-
sentar una opción de un conjunto de va-
lores mutuamente excluyentes o una com-
binación de opciones.

5. enum Estado{
Asignado,Descanso,Extra
}
enum Dias{
Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo
}
Estado []agenda = new Estado[7];
agenda[(int)Dias.Martes] = Estado.Asignado;
agenda[(int)Dias.Sabado] = Estado.Extra;
agenda[(int)Dias.Domingo] = Estado.Descanso;
Console.Write($"El empleado el dia {Dias.Martes}”);
Console.WriteLine($”esta {agenda[(int)Dias.Martes]}");
El empleado el dia Martes esta Asignado
Se debe hacer un casting
de Dias a int
Se definen por fuera de
la clase
Enums - ejemplo
En el siguiente ejemplo, se definen el estado de cada día de la semana
de la agenda de una persona.

6. Modificador
protected
La palabra protected es
un modificador de acceso
de miembro, es una pal-
abra reservada.
Un miembro protegido es
accesible dentro de su
clase y por parte de in-
stancias de clases hijas,
derivadas por herencia.
A
#variable:string
#Metodo():int
B
+UsarMetodo():void
Programa
Miembro dato
protected
Método
protected
Clase heredada que
puede usar los miembros
dato y métodos protegidos
Si una clase no hereda de A o B,
no puede usar miembros dato
o métodos protegidos.
+Main(args:cadena[]):void

7. ¿Cómo se ve en código?
El modificador protected restringe el acceso solo a la misma clase o a
clases hijas, a continuación se observa un ejemplo de su uso.
public class A
{
protected string variable;
protected int Metodo(){
return 0;
}
}
public class B:A
{
public void UsarMetodo(){
Console.WriteLine(variable);
Console.WriteLine(Metodo());
}
}
Se puede acceder, por
la relación de herencia
B hereda de A

8. A obj1 = new A();
B obj2 = new B();
obj2.UsarMetodo();
obj1.variable;
obj1.Metodo();
A.variable is inaccessible due to its protection level
A.Metodo() is inaccessible due to its protection level
En el siguiente código, el cual puede ser escrito en la clase Main o en una
clase C que no tenga una relación directa con A o B, este seria el resulta-
do de intentar acceder a miembros dato o métodos.
B hereda de A, por tanto puede tener
un metodo “UsarMetodo” el cual
hace uso de la variable protegida y el
método protegido de A.
Si se intenta acceder a los miembros
de A, desde un contexto diferente a
una relación de herencia, el pro-
grama no compila.
Al momento de compilar...

9. List<T>
Es una estructura de datos dinámica, es decir que en tiempo de eje-
cución puede modificar su contenido, realizando diferentes opera-
ciones sobre los datos contenidos en ella. Se usa por lo general para
guardar objetos, sin embargo también puede guardar datos primitivos.
Any Type : Cualquier tipo
Galleta Galleta Galleta
Instancias de Galleta
Fin
Count = 3
Es posible
insertar al final,
en el medio o al
inicio, solo se
debe especificar
la posición
Inicio
No hay longitud fija
0 1 2

10. using System.Collections.Generic;
List<string> frutas;
frutas = new List<string>();
List<T> - Configuración
Las listas no esta disponibles por defecto, para poderlas usar se debe
importar el respectivo namespace, agregue la siguiente línea al princip-
io de la clase, por fuera de su definición.
Se declara la lista y se define el tipo (T) de datos que se almacenaran en
la lista, este valor puede ser incluso objetos definidos por el usuario.
Finalmente se inicializa la lista, creando una nueva instancia, en este
momento la lista se encuentra sin elementos.

11. List<T> - Métodos
Lo importante de esta estructura es su versatilidad de uso, su flexibilidad
y comportamientos preestablecidos definidos en funciones, a continu-
ación estudiaremos algunos de ellos.
frutas.Add(”Manzana”);
Console.WriteLine(frutas[3]);
Console.WriteLine(frutas.Count);
Agrega elementos al final de la lista
Agrega un array al final de la lista
Recorre cada uno de los nodos de la lista
El indice se puede usar para obtener un elemento específico
de la lista, en este caso Mango.
string[] nuevas_frutas = { "Pera", "Mora", "Mango" };
frutas.AddRange(nuevas_frutas);
foreach (string f in frutas){
Console.WriteLine(f);
}
Esta es una propiedad que obtiene la cantidad de
elementos actualmente en la lista

12. Interface - Definición
Es un tipo de clase, donde se define un contrato, que indica el comporta-
miento y/o propiedades, que las clases que implementan dicho contra-
to estan obligadas a cumplir, es decir lo que dicta el contrato. Es una
plantilla donde los miembros del contrato son declarados. La interface
es un concepto abstracto, no confundir con UI (user interface).
<<Interface>>
IEmpacar
+peso:float
+Empacar():void
Paquete
+Cerrar():void
+Abrir():void
+Empacar():void
Interface, con un
miembro dato y
un método
Clase que implementa
la interface, debe cumplir
con el contrato
<<implementa>>
+peso:float
La interface se nombra con la letra I mayuscula antes del nombre,
los métodos solo tienen la firma, sin implementación.

13. Interface - Sintaxis
public class Empaque:IEmpacar{
public float peso{ get; set; }
public void Empacar(){
//Cuerpo
}
}
Método sin implementación
La I, se usa para diferencia la
implementación de una interfaz
de la herencia
Método concreto, donde
se realiza la implementación
del código
interface IEmpacar {
public float peso{ get; set; }
public void Empacar();
}
Definición de la interface, con un miembro dato y un método, observe
que solo se define la firma de la función.
Implementación de la interface

14. Reglas crear una Interface
2
3
4
5
6
Identificar propiedades o métodos
Crear una interface y asignar variables y firma de métodos
Incluir la letra I en el nombre para identificar la interface
Crear una clase concreta, que implemente la interfaz
Defina las variables y defina los métodos concretos
Cree instancias de la clase y use los miembros concretos
Una clase puede implementar múltiples interfaces
1

15. Interface - Implementación
interface IBonus{
public void Descripcion(int id);
}
public class Empaque:IEmpacar,Ibonus{
public float peso{ get; set; }
public void Empacar(){
//Cuerpo
}
public void Descripcion(int id){
//Cuerpo
return 0;
}
}
Se pueden implementar múltiples
interfaces, pero heredar de una única
clase padre. Cada nueva implementación
de interface, se indica con una coma
seguido del nombre de la siguiente
interface. No es posible crear instancias
de una interfaz.