You are on page 1of 34

Programación C# (C Sharp

)
Variables: Son objetos de algún tipo que pueden cambiar de valor durante la ejecución
del código.

Constantes: Son objetos de algún tipo que no cambian durante la ejecución del código.
Las variables y constantes puedes ser globales ósea para toda la clase o solo para un
método el programador decidirá si créala variables globales o solo para el método, hay que
tener encuentra
Que las variables serán globales si muchos métodos van a usar esa variable o si hay que
darle salida (un GET) si el método retorna un tipo de dato y se requiere que se retornen más
tipos.
Ejemplo:
public class ClassPruebas
{
//CONTRUCTOR DE LA CLASE
public ClassPruebas() { }
}
Tenemos una llamada “ClassPruebas” y en el constructor no se inicializa ninguna variable
Constructor: Es el método que se llama cuando se crea un objeto de una clase ósea que
cuando yo creo desde otra clase un objeto
ClassPruebas classPruebas = new ClassPruebas();
Cuando le digo new ClassPruebas() se está llamando al constructor de esa clase
Retomemos el tema de las variables y constantes: vamos a crear unas variables y una
constante
public class ClassPruebas
{
//VARIABLES Y CONSTANTES GLOBALES (DE CLASE)
int codigo; //VARIABLE TIPO ENTERO
double multiplicacion; //VARIABLE TIPO REAL
string nombre; // VARIABLE TIPO TEXTO
DateTime fecha; // VARIABLE TIPO FECHA
bool sexo; // VARIABLE TIPO BOOLEANA
const string nombreClase = "ClassPruebas"; // CONSTANTE TIPO TEXTO
//CONTRUCTOR DE LA CLASE
public ClassPruebas() { }
}
Bueno vemos que hay 4 variables (código, nombre, fecha y sexo) de varios tipos ósea que
el valor de estas puede cambiar durante la ejecución del programa pero hay una constante
que se llama “nombreClase” y el valor durante la ejecución del programa siempre va a ser el
mismo, siempre va ser "ClassPruebas";

Propiedades: Son objetos de algún tipo que le dan salida o entrada a valores a una
variable (GET y SET).
Como las variables son privadas en el caso que estamos trabajando (Al no tener ni public y
ni private el compilador entiende que esa variables son privadas), no se podrían tomar los
valores de estas variables desde otra clase ni tampoco ingresarle valores, para ello vamos a
implementarle las propiedades a la variables que necesitemos que entren o que salgan o
ambos casos.

Puede darse el caso que tengamos los propiedades de salida o solo de entrada como en el
ejemplo a continuación

public class ClassPruebas
{
//VARIABLES Y CONSTANTES GLOBALES (DE CLASE)
int codigo; //VARIABLE TIPO ENTERO
double multiplicacion; //VARIABLE TIPO REAL
string nombre; // VARIABLE TIPO TEXTO
DateTime fecha; // VARIABLE TIPO FECHA
bool sexo; // VARIABLE TIPO BOOLEANA
const string nombreClase = "ClassPruebas"; // CONSTANTE TIPO TEXTO
//CONTRUCTOR DE LA CLASE
public ClassPruebas() { }
//PROPIEDADES
//Nombre RETORNA Y ENTRAN VALORES como tiene el get y el set
public string Nombre
{
set { nombre = value; } // SET ES EL QUE SE ENCARGA DE ENTRAR LOS VALORES
get { return nombre; } // GET ES EL QUE SE ENCARGA DE RETORNAR LOS VALORES
}
//Multiplicacion SOLO RETORNA LOS VALORES como solo tiene el get solo salen valores
public double Multiplicacion
{
get { return multiplicacion; }
}
//Fecha SOLO ENTRAN VALORES como solo tiene el set solo entran valores
public DateTime Fecha
{
set { fecha = value; }
}
}
*. Como podemos ver la Propiedad para la variable fecha se llama igual pero en mayúscula
la primera y solo es de entrada ósea que ninguna clase podrá tomar el valor de la variable
fecha por que solo tiene el set.
*. Muy distinto para la Propiedad Codigo para la variable codigo es distinto nadie le podrá
entrar valores desde otra clase pero si podrá tomar el valor por que solo tiene el get.
*. La propiedad Nombre para la variable nombre tiene tanto get como el set, eso quiere
decir que le pueden entrar valor y salir valores

Métodos: Son los encargados de hacer operaciones ya sean cálculos, sean validaciones,
sean operaciones contra servidores, etc.., Los métodos entre más se puedan reutilizar mejor.

Estructura de un Método
Tipo + Que retorna + Nombre + ( Parámetros )
Ejemplo
// Public es el tipo
// Bool Lo que tiene que retornar
// Multi es nombre del método

// () Lo que hay dentro de los paréntesis son los parámetros para el ejemplo dos numero
enteros
public bool Multi(int num1, int num2)
{ //INICIO DEL METODO
} //FIN DEL METODO
public bool Multi(int num1, int num2)
{//INICIO DEL METODO
try
{// INICIO DEL TRY
multiplicacion = num1 * num2; // OPERACION
return true; // Si es exitoso el proceso de la multiplicacion retorna un
// Verdadero ya que el método tiene que retornar siempre un booleano
}//FIN DEL TRY
catch (Exception ex) // CAPTURA DE LA EXCEPCION EN LA VARIABLE ex
{// INICIO DEL CATCH
return false; // Si entra en el catch es porque fallo alguna de las operaciones del
try
// Entonces retornara un falso
}// FIN DEL CATCH
}//FIN DEL METODO
Pero qué tal si queremos decirle al usuario porque fallo como vemos el método Multi solo
retorna si fue bueno o malo tendríamos que colocar una variable del tipo Exception y darle
propiedades
Nuestra clase quedaría de la siguiente manera
public class ClassPruebas
{
//VARIABLES Y CONSTANTES GLOBALES (DE CLASE)
int codigo; //VARIABLE TIPO ENTERO
double multiplicacion; //VARIABLE TIPO REAL
string nombre; // VARIABLE TIPO TEXTO
DateTime fecha; // VARIABLE TIPO FECHA
bool sexo; // VARIABLE TIPO BOOLEANA
Exception exception; // VARIABLE TIPO EXCEPTION la creamos para que
const string nombreClase = "ClassPruebas"; // CONSTANTE TIPO TEXTO
//CONTRUCTOR DE LA CLASE
public ClassPruebas() { }
//PROPIEDADES
//Nombre RETORNA Y ENTRAN VALORES como tiene el get y el set
public string Nombre
{
set { nombre = value; } // SET ES EL QUE SE ENCARGA DE ENTRAR LOS VALORES
get { return nombre; } // GET ES EL QUE SE ENCARGA DE RETORNAR LOS VALORES
}
//Multiplicacion SOLO RETORNA LOS VALORES como solo tiene el get solo salen valores
public double Multiplicacion
{
get { return multiplicacion; }
}
//Fecha SOLO ENTRAN VALORES para la variable fecha como solo tiene el set solo
entran valores
public DateTime Fecha

} } //METODOS public bool Multi(int num1. } get { return exception. } //Exception RETORNA Y ENTRAN VALORES para la variable que se llama exception public Exception Exception { set { exception = value.{ } set { fecha = value. // Si entra en el catch es porque fallo alguna de las operaciones del try // Entonces retornara un falso }// FIN DEL CATCH }//FIN DEL METODO } Como podemos usar las propiedades (GET y SET) cuando creamos objetos de una clase EJEMPLO SET SOLO VALORES por las propiedades Desde el método principal se crea un objeto del tipo de nuestra clase ClassPruebas y luego utilizando el set de la propiedad Fecha le damos un valor. // Si es exitoso el proceso de la multiplicacion retorna un // Verdadero ya que el método tiene que retornar siempre un booleano }//FIN DEL TRY catch (Exception ex) // CAPTURA DE LA EXCEPCION EN LA VARIABLE ex {// INICIO DEL CATCH exception = ex. // le asigna la ex capturada a la variable de clase exception para que pueda ser // Retornada en la propiedad con nombre Exception return false. // OPERACION return true. . int num2) {//INICIO DEL METODO try {// INICIO DEL TRY multiplicacion = num1 * num2.

} public double nota3 { get. set. Hacer un programa que calcule el promedio de las notas (4 notas) de 3 estudiantes y mostrarlo por pantalla. validar que la lista no sea nula y para calcular el promedio *. set. y usaremos los set y get de la clase que creamos EJERCICIOS 1.EJEMPLO llamando un método. Hacer el programa en clases Solución Podemos hacer una matriz para guardar las notas o podemos hacer una clase tipo entidad Y crear una lista de ese tipo Nuestra entidad quedara de la siguiente manera public class Notas { public string estudianteNombre { get. } } Ahora nos dicen que tenemos que hacer el programa en clases. Tendrá un método público para agregar objetos a la lista . set. } public double nota1 { get. set. La clase la haremos tendra los siguientes métodos para agregar objetos a la lista. } public double nota4 { get. set. } public double nota2 { get.

} get { return listaNotas. } get { return exception. } } . //VARIABLE TIPO LISTA DE NOTAS Exception exception. Y tendremos un método para devolver el promedio Ósea que devolverá un real y le tiene que entrar los valores de las 4 notas La clase completa quedaría de la siente manera public class ClsNotas { //VARIABLES GLOBALES List<Notas> listaNotas. } else //SI EL METODO Validar() retorna false { //RETORNA false PORQUE NO INSERTO EN LA LISTA return false. } } //PROPIEDAD DE SALIDA Y ENTRADA DE EXCEPCIONES public Exception Exception { set { exception = value. } } //PROPIEDAD DE SALIDA Y ENTRADA DE PROMEDIO public double Promedio { set { promedio = value. Un método privado para validad que lista no sea nula si es nula que la cree como nueva y es privado porque las otras clases no tienen por qué utilizar este método *. //VARIABLE TIPO EXCEPTION double promedio. //RETORNA VERDADERO PORQUE INSERTO EN LA LISTA return true. //VARIABLE TIPO REAL //CONSTRUCTOR public ClsNotas() { } //PROPIEDADES //PROPIEDAD DE SALIDA Y ENTRADA DE LA LISTA DE NOTAS public List<Notas> ListaNotas { set { listaNotas = value.Add(nota). } get { return promedio. } } //METODOS PUBLICOS //ESTE METODO SE ENCARGA DE AGREGAR NOTAS A LA LISTA public bool AgregarEntidad(Notas nota) { try { if (Validar()) // SI EL METODO Validar() RETORNA true ENTRA { // Y AGREGA LA NOTA QUE ENTRO COMO PARAMETRO EN EL METODO listaNotas.*.

//RETORNA VERDADERO PORQUE INSERTO EN LA LISTA return true. } // RETORNA true return true. } catch (Exception ex)// SI FALLA { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex. } } //ESTE METODO SE ENCARGA DE CALCULAR EL PROMEDIO public bool CalcularPromedio(double nota1. } } } . } catch (Exception ex) // SI FALLA { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex. double nota4) { try { //LA VARIABLE GLOBAL VA SER IGUAL A LA SUMA DE LAS NOTAS DIVIDO EL NUMERO DE NOTAS QUE ES 4 promedio = (nota1 + nota2 + nota3 + nota4) / 4. //RETORNA false POR QUE FALLO return false. //RETORNA false POR QUE FALLO return false.catch (Exception ex) // SI FALLA { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex. double nota2. //RETORNA false POR QUE FALLO return false. } } //METODOS PRIVADOS //ESTE METODO SE ENCARGA DE VALIDAR QUE LA LISTA NO SEA NULA SINO LA CREA private bool Validar() { try { //SI LA LISTA ES NULA if (listaNotas == null) { // CREA LA LISTA COMO NUEVA listaNotas = new List<Notas>(). double nota3.

Esto se ejecutara desde un evento de un botón o desde el método principal Veremos paso a paso cómo funciona el codigo y para el siguiente ejemplo se omitirá este paso Este es el codigo para agregar las notas a la lista y mostrar la nota final vamos a hacer debug y explicar paso a paso Lo primero es que va crear un objeto de la ClsNotas() entrando al constructor de la clase .Ahora tenemos que agregar a la lista las notas de tres estudiantes según el requerimiento y mostrar las notas finales.

Como vemos en la imagen Luego de crear un objeto de la clase creara un objecto de la clase tipo entidad Notas y le setteara todos los valores que necesita Como veremos en la siguiente imagen ya el objeto con nombre nota del tipo entidad Notas Tiene los valores asignados gracias a los Set En la línea que esta amarilla en la imagen superio llamara al metodo de la ClsNotas AgregarEntidad y le enviara un objeto del tipo entidad notas Cuando entra al método AgregarEntidad Va a llamar al método privado de clase para validar la lista .

Como la lista esta nula él va entrar en el if y la va a crear como nueva Como vemos ya no es null si no que 0 datos Y luego el metodo validar() retorna verdadero porque se ejecuto bien .

Como el metodo Validar() retorno true continuara en el metodo AgregarEntiedad por la opcion del verdadero y tratara de agregar la entidad a la lista la nota que entro como parametro en el metodo Para el caso la agrego bien entonces retorno verdadero .

Y vuelve al Metodo principal o al evento Luego el objeto nota se le indicara que ya sera otro nuevo objeto para que podamos agregar un objeto distinto a la lista sino modificaremos los valores de la entidad que ya ingresamos a la lista. por eso es necesario decirle que la nota sera una nueva entidad Y luego le settearemos los valores En la línea que esta amarilla en la imagen superior llamara al método de la ClsNotas AgregarEntidad y le enviara un objeto del tipo entidad notas con los nuevos datos Cuando entra al método AgregarEntidad Va a llamar al método privado de clase para validar la lista . ya que el compilador guarda un apuntador a la memoria de ese objeto como la nota sigue siendo el mismo objeto si lo modificamos estaremos modificando el que esta en la lista.

Como la lista ya no es nula por que ya se habia creado un registro entonces no entrara al if pero retornara true por que el metodo no fallo Como el metodo Validar() retorno true continuara en el metodo AgregarEntiedad por la opcion del verdadero y tratara de agregar la entidad a la lista la nota que entro como parametro en el metodo Como agrego la entidad a la lista entonces retorna verdadero y continua en el metodo principal o el evento .

luego tiene una condicion (para el caso mientras que el contador sea menor que n) y luego como va ir aumentando o decrementando y adentro de los corchetes va el codigo que queremos que se repita n veces El while solo tiene la condicion y mientras la condicion se cumpla ejecutara n veces el codigo que tenga en sus corchetes Tanto como el for y while son muy similares y se pueden utilizar para lo mismo El foreach no tiene que cumplir una condicion como el for o while. llamar al metodo que agrega a la lista.. EL TIPO DE LA VARIABLE ITEM TIENE QUE SER IGUAL AL TIPO DE LA LISTA Osea que la lista es del tipo de Notas (es una lista del tipo Notas) . este asu vez llama al metodo que valida que la lista no sea null y luego inserta y retorna Ya nuestra lista tiene los 3 estudiantes del enunciado y utilizamos clases Y entidades ahora mostraremos los promedios NOTA---------------------------------------------------------------------------------------------------Utilizaremos un foreach para recorrer estructuras especiales como las listas for: Es una estructura que contiene un contador. Ejemplos: El for como dijimos tiene una variable contador. settearle los valores. etc.Y nuevamente hace el mismo proceso de crear un objeto. desde que el objeto que vamos ha recorrer tenga datos el tomara registro de la lista uno a uno y se lo dara a la variable temporar que le colocamos el nombre de item. una condición y un tipo de aumento o decremento while: Es una estructura que contiene una condición y mientras esta se cumple se mantiene en el ciclo(bucle) foreach: Es una estructura especial para recorrer objetos complejos como listas o vectores.

La estructura del foreach es foreach (TipoDeDato NombreParElItem in ObjectoLista) { } Eso quiere decir que el objeto ObjectoLista es del tipo Lista<TipoDeDato> FIN DE LA NOTA-------------------------------------------------------------------------------------Continuando el codigo recorremos la lista que nos retorna la propiedad ListaNotas de la clase ClsNotas Esa propiedad nos retorna una Lista de notas por eso nuestra temporal es del tipo Entidad Notas Como Se explico en la anteriormente. lo cual recorreremos la lista item por item En la clase ClsNotas creamos un metodo que nos calcula el promedio entonces le enviaremos de cada item los valores de la nota de cada estudiante y luego con la propiedad Promedio con el Get obtendremos en valor calculado veamoslo funcionando El foreach mira que la lista tenga datos para recorrer Luego le asigna al item el primer registro de la lista .

Y pasa a calcular llamando al metodo CalcularPromedio de la clase ClsNotas enviando las notas del item osea del estudiante A la variable promedio de la ClsNotas la va hacer igual al valor de ese calculo matematico Como hizo bien la operación le dio el valor a la variable de 3. si se dio cuenta el texto esta mal escrito pero jodase Y muestra .Show() le mostraremos al usuario El nombre del estudiante + el texto “ El nota final es: ” + el valor que tiene la propiedad Promedio de la clase clsNotas convertido a Texto.075 y devuelve true por que no fallo y volvemos al metodo principal o el evento Luego con el MessageBox.

Hacer un programa que calcule los servicios de una casa energía. valor gas y valor energía). Hacer el programa en clases. .Y luego va al siguiente item de la lista Calcula con el metodo de la clase nuevamente y luego muestra su resultado igual que en el anterior Y vuelve y repite para cada registro de la lista Ejercicio Para Resolver el Estudiante 1. y gas mostrar en pantalla el total a pagar y el valor de cada servicio (valor agua. Se aplicaría igual que en el ejercicio que se explicó. Mínimo mostrar 2 totales dos personas. agua.

} } Pudiéramos solo haber hecho una entidad Persona con una propiedad tipo que nos indicara esto Pero para el ejercicio es para ver cómo podemos relacionar 3 entidades Como no nos pidieron descuentos. Personas *. Por ultimo crearemos el método que calcula y muestra los totales por empleado . Productos por Factura Como no nos piden algo específico solo colocaremos un codigo y el nombre de la persona que compra public class Personas { public string codigoPersona { get. Solución Vamos a crear 3 entidades *. set. } } Como no nos piden algo específico solo colocaremos el cogido y el nombre del empleado public class Empleados { public string codigoEmpleados { get. Hacer por clases y con foreach. } public double producto { get. Crearemos Variables privadas *. Hacer un programa que ingrese personas y empleados que no se repitan. set. } public string personaCodigo { get. set. Crearemos las propiedades *. set. y realizar una factura con n productos para cada persona. } } Las entidades son para guardar los datos tal como nos dicen el enunciado Ahora haremos la clase para administrar las listas y cálculos que necesitaremos Métodos para agregar a la lista para ahorrar codigo no colocaremos los métodos privados para Validar las listas lo haremos e *. Crearemos los métodos para administrar las listas e internamente validaremos en empleado y personas que no se repitan *.Ejercicios 1. } public string nombreEmpleados { get. nuestra entidad solo va tener un valor y que empleado la vendio y que persona la compro public class ProductosFactura { public string empleadoCodigo { get. ni cantidades de productos. } public string nombrePersona { get. Luego un constructor donde inicializaremos nuestras listas *. Empleados *. set. set. set.

Where(x => x. //Y RETORNAMOS FALSO POR QUE NO SE AGREGO return false. } .codigoPersona == persona. } //SI CONTINUA POR ACA ES POR QUE NO ENCONTRO LA PERSONA EN LA LISTA //ENTONCES TRATARA DE INSERTAR LA PERSONA QUE ENTRO COMO PARAMETRO listaPersonas. //RETORNA TRUE return true. } //PROPIEDADES public List<Personas> ListaPersonas { get { return listaPersonas. Exception exception.codigoPersona). } } //METODOS PUBLICOS public bool AgregarPersona(Personas persona) { try { //SI LA LISTA ES NULA SERA IGUAL A UNA NUEVA SINO TENDRA EL VALOR DE ELLA MISMA listaPersonas = listaPersonas == null ? new List<Personas>() : listaPersonas. List<ProductosFactura> listaProductosFactura. } set { listaEmpleados = value. //CONSTRUCTOR public ClsCalculos() { //VAMOS A INICIALIZAR LAS LISTAS listaPersonas = new List<Personas>().public class ClsCalculos { //VARIABLES List<Personas> listaPersonas. } } public Exception Exception { get { return exception. listaEmpleados = new List<Empleados>(). listaProductosFactura = new List<ProductosFactura>().Add(persona). } } public List<ProductosFactura> ListaProductosFactura { get { return listaProductosFactura. List<Empleados> listaEmpleados. //BUSCAREMOS EN LA LISTA UNA PERSONA CON EL CODIGO DE LA PERSONA QUE ENTRO EN EL METODO if (listaPersonas. } set { listaProductosFactura = value. } set { exception = value. } set { listaPersonas = value. } } public List<Empleados> ListaEmpleados { get { return listaEmpleados.FirstOrDefault() != null) { //SI FUE DIFERENTE DE NULL OSEA SI SE ENCONTRO UNA PERSONA CREAMOS UNA EXCEPCION CON EL MENSAJE exception = new Exception("Ya existe la persona"). } catch (Exception ex) { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex. //RETORNA false POR QUE FALLO return false.

//Y RETORNAMOS FALSO POR QUE NO SE AGREGO return false.FirstOrDefault() != null) { //SI FUE DIFERENTE DE NULL OSEA SI SE ENCONTRO UNA PERSONA CREAMOS UNA EXCEPCION CON EL MENSAJE exception = new Exception("Ya existe el empleado"). return true.Where(x => x. } //CREA VARIABLES DE METODO double totalFactura = 0. //RETORNA TRUE return true. //PARA SUMAR EL TOTAL DE LOS VALORES DE LOS PRODUCTOS int totalNumeroProductos = 0. //PARA CONTAR EL NUMERO DE PRODUCTOS POR PERSONA //TOMAMOS DE LA LISTA DE PRODUCTOS LAS PERSONAS .codigoEmpleado == empleado. //BUSCAREMOS EN LA LISTA UNA PERSONA CON EL CODIGO DE LA PERSONA QUE ENTRO EN EL METODO if (listaEmpleados. } catch (Exception ex) { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex. //Y RESTONRA FALSE POR QUE NO HAY DATOS EN ALGUNA DE LAS LISTAS QUE NECESITAMOS return false.} public bool AgregarEmpleado(Empleados empleado) { try { //SI LA LISTA ES NULA SERA IGUAL A UNA NUEVA SINO TENDRA EL VALOR DE ELLA MISMA listaEmpleados = listaEmpleados == null ? new List<Empleados>() : listaEmpleados. } catch (Exception ex) { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex.Add(empleado). //RETORNA false POR QUE FALLO return false. } } public bool AgregarProductos(ProductosFactura producto) { try { //SI LA LISTA ES NULA SERA IGUAL A UNA NUEVA SINO TENDRA EL VALOR DE ELLA MISMA listaProductosFactura = listaProductosFactura == null ? new List<ProductosFactura>() : listaProductosFactura.Add(producto).codigoEmpleado). //RETORNA false POR QUE FALLO return false. } } public bool CalcularYMostrarFacturas() { try { //VALIDARA SI LAS LISTAS TIENEN DATOS if (listaPersonas == null || listaEmpleados == null || listaProductosFactura == null) { //SI NO TIENEN DATOS ALGUNA DE LAS LISTAS CREA LA EXCEPTION CON EL MENSAJE exception = new Exception("No hay datos en las listas"). //TRATARA DE INSERTAR EL EMPLEADO QUE ENTRO COMO PARAMETRO listaProductosFactura. } //SI CONTINUA POR ACA ES POR QUE NO ENCONTRO EL EMPLEADO EN LA LISTA //ENTONCES TRATARA DE INSERTAR EL EMPLEADO QUE ENTRO COMO PARAMETRO listaEmpleados.

personaCodigo == itemPersona). //CONTINUARA CON EL SIGUIENTE ITEM DEL FOREACH "continue" OSEA QUE NO EJECUTRAR //EL CODIGO DE BAJO DE ESTA INSTRUCCION continue.codigoPersona == itemPersona). } } .ToString() + " producto(s)" + ". totalNumeroProductos = 0. //VALIDA QUE HAYA ENCONTRADO UNA PERSONA CON ESE CODIGO if (persona == null) { //SI NO ENCONTRO MUESTRA UN MENSAJE MessageBox.Where(x => x.Show("El total para La persona: " + persona.ToList().producto. } return true.Distinct().FirstOrDefault(). } //SI EL EMPLEADO ES NULO ES POR QUE NO ENCONTRO UN EMPLEADO EN EL FOREACH INTERNO if (empleado == null) { //SI NO ENCONTRO MUESTRA UN MENSAJE MessageBox. } //LE SUMA A LA VARIABLE totalFactura LO QUE ELLA TENGA MAS EL VALOR DEL PRODUCTO totalFactura = totalFactura + item. //RETORNA false POR QUE FALLO return false.Show("No se encontro la empleado con el codigo: " + itemPersona).FirstOrDefault().nombrePersona + " es de: " + totalFactura. } //VA BUSCAR EN LA LISTA DE PERSONAS DONDE EL CODIGO DE LA PERSONA SE IGUAL A //EL CODIGO DE LA PERSONA DEL PRIMER FOREACH Y TOMA EL PRIMER VALOR QUE COINCIDA persona = listaPersonas. } //SI CONTINUA POR ACA ES PORQUE ENCONTRO UN EMPLEADO Y UNA PERSONA //Y MOSTRARA EL TOTAL DE LA PERSONA Y QUIEN LO ATENDIO MessageBox.Show("No se encontro la persona con el codigo: " + itemPersona).codigoPersona + " con nombre: " + persona. //CONTINUARA CON EL SIGUIENTE ITEM DEL FOREACH "continue" OSEA QUE NO EJECUTRAR //EL CODIGO DE BAJO DE ESTA INSTRUCCION continue. se llevo " + totalNumeroProductos. empleado= null.List<string> personas = listaProductosFactura. //CUENTA UN PRODUCTO MAS totalNumeroProductos++.nombreEmpleado). } catch (Exception ex) { //ASIGNA LA ex CAPTURADA A LA VARIABLE exception exception = ex.ToString() + ". El vendor fue: " + empleado.codigoEmpleado == item.ToList()) { //SI EL EMPLEADO ES NULLO if (empleado == null) { //VA BUSCAR EN LA LISTA DE EMPLEADOS DONDE EL EMPLEADO SE IGUAL AL EMPLEADO Y TOMA EL PRIMER //VALOR QUE COINCIDA empleado = listaEmpleados. //RECORREMOS LA LISTA DE PERSONAS QUE CREAMOS foreach (string itemPersona in personas) { //REFRESCAMOS LOS VALORES A MOSTRAR totalFactura = 0. //CREAMOS UNA VARIABLE PARA TENER EL PERSONA DE LA FATURA Personas persona = null.Select(x => x.Where(x => x.Where(x => x.personaCodigo).empleadoCodigo). //CREAMOS UNA VARIABLE PARA TENER EL EMPLEADO DE LA FATURA Empleados empleado = null. //RECORREREMOS LA LISTA DE PRODUCTOS DONDE LA PERSONA SEA itemPersona foreach (ProductosFactura item in listaProductosFactura.

esto funciona como un si y un sino. if (listaPersonas == null) { listaPersonas = new List<Personas>(). el if puede ser igual de complejo. Que tiene que cumplir para usar este tipo de if Que tanto el si como el sino tienen tienen que tener una linea de codigo y asignarle valor a la misma variable. NOTA IF CORTO Cuando utilizamos listaPersonas = listaPersonas == null ? new List<Personas>() : listaPersonas. eso dependera del programador Valor que tomara la variable en el si Valor que tomara la variable en el sino Ejemplos ObjetoClase variable = variable == null ? new ObjetoClase() : variable List<Objeto> variable = variable == null ? new List<Objeto>() : variable string variable = variable == null ? "" : variable METODOS DE LAS LISTAS *.FirstOrDefault() .//METODOS PRIVADOS // NO HAY METODOS PRIVADOS } NOTAS-------------------------------------------------------------------------------------------------*.codigoPersona). } else { listaPersonas = listaPersonas. Como vemos en el ejemplo tanto el si como el sino le estan asignando un valor a la misma variable Lo cual podemos transformarlo a un if corto Variable que se le asignara el valor en el if y en el sino Condicion del if. NOTA METODO WHERE() Metodo Where lo podemos utilizar para buscar los items que coincidan de una lista y como el resultado lo podremos convertir a otra lista (Esta lista sera el resultado de la busqueda) o podremos invocar el metodo FirstOrDefault() que tomara el primer valor que coincida con la busqueda que estemos realizando veamos algunos ejemplos En el metodo agregar persona se utiliza la siguiente linea de codigo listaPersonas.Where(x => x.codigoPersona == persona. } listaPersonas = listaPersonas == null ? new List<Personas>() : listaPersonas.

codigoPersona Y esto es lo que ejecutara para la busqueda.Propiedad2 ¡= Valor2 || x. NOTA METODO TOLIST() Como el Where retorna es una IEnumerable es practicamente una lista pero no lo es en su totalidad.Propiedad3 = = Valor3) ) Como vimos podemos realizar la busqueda que necesitemos *. Y a esa lista que retorno el where se le toma la primera posicion SI EL VALOR QUE RETORNA EL FIRSTORDEFAULT POSEE VALOR DE UNA ENTIDAD OSEA QUE ES DIFERENTE DE NULO ES PORQUE YA EXISTE UNO EN LA LISTA QUE COINCIDA CON EL VALOR Por eso devolvemos el error Pero no solo se utiliza para validaciones podemos para mostrar por pantallar Ejemplo cuando buscamos un empleado el metodo de calcular y mostar Esta la siguiente linea de codigo Empleados empleado = listaEmpleados.donde en la lista listaPersonas le estamos llamando el metodo Where para realizar una busque como funciona este metodo: Internamente el recibe una expresion lamba para el caso es la siguiente x => x.Where(x => x. razon por la cual podemos llamar despues de una Where el toList() para convertir el resultado del where en una lista deobjetos.Where(x => x.codigoPersona == persona.Propiedad >= Valor && (x.Where(x => x.Propiedad == Valor) Tambien pueden ser mar complejas las busquedas en el where por ejemplo donde x es nuestro alias Where(x => x.FirstOrDefault() != null) Osea que en si esta linea de codigo lo que hace es validar si el metodo where encuentra algun item que coincida con la expresion lamba y retorna una lista con datos si algun item coincide sino una lista vacia.FirstOrDefault(). en otras palabras si algun item coincidio con lo que se busco en el where este metodo tendra restornara IEnumerable en otras palabras Una lista y a esta lista respuesta le estamos diciendo con el metodo FirstOrDefault() que nos devuelva el primer valor de la lista if (listaPersonas.codigoPersona == persona.FirstOrDefault() la parte seleccionada con azul realizo la busqueda en la lista de algun item que coincidiera con lo que tenemos dentro nuestro Where pero que hace ese metodo .empleadoCodigo). Where(Alias => Alias.codigoEmpleado == item. Buscara en la lista de empleados utilizando el metodo Where buscando donde algun item sea igual a el codigo del empleado que tiene la variable item y tomara el primer valor Y se lo dara a la variable empleado del tipo Empleados Pero como indicamos puede que el where no encuentre algun item que coincida por lo cual el fisrtordefault retornara nulo y nuestra variable *.codigoPersona == persona. List<Personas> listaResp = listaPersonas.codigoPersona == persona. Ejemplo.FirstOrDefault() Primero es un metodo de las listas para tomar el primer valor de la lista. NOTA METODO FIRSTORDEFAULT() Osea que en nuestro ejemplo listaPersonas. .codigoPersona).ToList().Where(x => x.codigoPersona).codigoPersona).

Nuestra expression Lamba es x => x. NOTA METODO DISTINCT() Los ejemplos no estan en el codigo que hicimos El metodo distinct tambien retorna una IEnumerable osea practicamente una lista pero no es su totalidad razon por la cual cada vez que llamemos este metodo tenemos que llamar al metodo ToList Pero este metodo Distinct() buscara y nos retornara la una IEnumerable con los valores no repetidos Ejemplo List<ProductosFactura> listaRespuesta = listaProductosFactura.ToList(). Distinct(). lo que retorna es una IEnumerable pero del tipo de la propiedad que seleccionesmos y al igual que el Where tambien recibe una expression Lamba pero simple. Esa es nuestra entidad como dice en la explicacion el metodo Select() de las listas retornan una lista Del tipo de la propiedad NO UNA LISTA DE ENTIDADES.La lista respuesta “listaResp” tendra una lista con los valores que hayan coincidido en el Where CABE RESALTAR QUE QUE LA RESPUESTA DE UN WHERE SERA DEL MISMO TIPO DE LA LISTA A LA QUE LE ESTAMOS HACIENDO LA BUSQUEDAD En el ejemplo la lista listaPersonas es del tipo Personas y la lista respuesta listaResp es tambien del mismo tipo Personas *.personaCodigo Osea que la lista sera del tipo de dato string Porque le estamos diciendo que del alias x tome la propiedad Por eso la lista respuesta es List<string> . La lista respuesta tendra una lista donde los valores no sean repetidos del mismo tipo de lista que la lista listaProductosFactura que es de tipo ProductosFactura Pero si te dicen que necesita que la lista no tenga valores repetidos puedes reasignarle el valor y no tener que crear otra lista listaProductosFactura = listaProductosFactura.ToList(). Distinct().ToList(). Asi aseguramos que los items en la lista no esten repetidos Pero solo si nos lo piden *. Distinct(). Ejemplo List<string> personas = listaProductosFactura.personaCodigo). NOTA METODO SELECT() El metodo Select es el ultimo que veremos.Select(x => x.

Show(clsCalculos. persona. if (!clsCalculos.nombrePersona = "Rafael".Exception.codigoEmpleado = "76546".codigoPersona = "12354". } . if (!clsCalculos.AgregarPersona(persona)) { MessageBox. persona. if (!clsCalculos. if (!clsCalculos.Show(clsCalculos. persona.AgregarEmpleado(empleado)) { MessageBox. //AGREGEMOS LAS PERSONAS Personas persona = new Personas().AgregarPersona(persona)) { MessageBox.ToString()).codigoPersona = "4654".ToString()). persona.Show(clsCalculos.Show(clsCalculos. persona. empleado.AgregarPersona(persona)) { MessageBox.FIN DE LA NOTAS-----------------------------------------------------------------------------------Continuemos en el metodo principal o el evento que llame nuestra clase Haremos una variacion a lo que haciamos anteriormente si un metodo falla insertando en una lista Entonces le mostraremos al usuario que fallo El siguiente es el codigo del metodo principal o evento y pasaremos hacer debug private void Button_Click(object sender.Exception.nombreEmpleado = "Luz". RoutedEventArgs e) { try { ClsCalculos clsCalculos = new ClsCalculos().nombrePersona = "Andres".codigoPersona = "4654".ToString()).Exception. } //AGREGEMOS LOS EMPLEADOS Empleados empleado = new Empleados(). } //TRATAREMOS DE INGRESAR NUEVAMENTE UNA PERSONA persona = new Personas().ToString()).nombrePersona = "Andres".Exception. empleado. } persona = new Personas(). persona.

if (!clsCalculos. if (!clsCalculos.ToString()).Exception. } //LLAMAREMOS AL METODO QUE NOS CALCULA LAS FACTUAS if (!clsCalculos.personaCodigo = "12354". } } catch (Exception ex) { MessageBox.Show(clsCalculos. } producto = new ProductosFactura(). empleado.AgregarProductos(producto)) { MessageBox. } producto = new ProductosFactura().nombreEmpleado = "Alfonoso".Show(ex. if (!clsCalculos. producto. if (!clsCalculos. producto.Exception.ToString()). producto.producto = 96464.codigoEmpleado = "3298898".Exception.AgregarEmpleado(empleado)) { MessageBox. producto.Exception. empleado. producto.Exception.empleadoCodigo = "3298898".empleado = new Empleados().ToString()).empleadoCodigo = "76546". producto.ToString()).ToString()).Show(clsCalculos.personaCodigo = "4654". producto.personaCodigo = "4654".AgregarProductos(producto)) { MessageBox. producto.CalcularYMostrarFacturas()) { MessageBox.Show(clsCalculos.Show(clsCalculos.empleadoCodigo = "3298898".producto = 32135.ToString()). } //AGREGEMOS LAS PRODUCTOS ProductosFactura producto = new ProductosFactura().producto = 120656. producto. } } DEBUG Y EXPLICACION Lo primero es que va crear un objeto de la ClsCalculos() entrando al constructor de la clase .AgregarProductos(producto)) { MessageBox.Show(clsCalculos.

En este constructor como vemos las variables de clase estan nulas lo que haremos es inicializarlas Como vemos ya las listas no son nulas y estan vacias Crearemos un objeto de la entidad Personas y le setearemos los valores y llamaremos al metodo AgregarPersona que agrega la entidad a la lista Esta linea lo que quiere decir Es si devuelve falso el metodo Seria lo mismo tener Nota el ! solo se utiliza para negar en los if Entramos en el metodo En la linea que esta amarilla como ya explicamos se valida que la lista no es nula y si es nula la crea como nueva sino sera ella misma .

Ahora creara una nueva entidad y la insertara Para el ejemplo oviaremos que se inserto bien Ahora traremos de insertar una nueva entidad pero con los mismos datos que la primera .Luego buscara en la lista y tomaremos la primera posicion si es diferente de nulo es porque encontro un item que coincide y crearemos unas excepcion y devolveremos falso Como la lista estaba vacia no encontro item y trara de agregar el item que entro en el metodo Y si inserta retornara true Como vimos inserto bien y retorno true y volveremos al metodo principal o evento Como vemos como retorno true no es igual a falso y no entrara en el if por que el metodo no retorno falso.

Entremos en el metodo Primero valido y luego validara que en la lista no haya el valor que tiene la persona que entro en el metodo como parametro como lo muestra la imagen Como vemos la lista ya tiene ese valor entonces si encontrara un item y entrara en el if Creara la exception y retornara false .

como las listas no son nulas no entrara Y pasara a crear la variables para ir sumando la cantidad de productos y el total de la factura .Y retornaremos al metodo principal y como esta vez retorno false entonces entrara en el if Y mostrara la excepcion que creamos Ahora terminaremos de insertar los demas datos obviando que estuvo bien ejecutaremos el metodo que calcula las facturas Si devuelve falso mostraremos el error Pero veamos que hace internamente Validara que todas las listas tno sean nulas.

como vemos solo tiene los codigos de las personas y recorreremos uno a uno en el forwach Luego reiniciamos las variables ya que cada item es una persona nueva lo cual quiere decir que es una factura nueva a mostrar Recorreremos la lista de productos pero donde el empleado se el que estamos recorriendo en el foreach principal Luego si el empleado es nulo entrara y le asiganara a la variable de metodo empleado lo que encuentre Con el codigo que esta en la factura como vemos en las dos siguientes imagenes Y como vemos la variable empleado ya quedo con valores Como se ve en la imagen la variable factura sera igual a la suma de ella mas el valor del producto.En la linea superior creamos una lista de string con los valores de los codigos de las personas que no se repitan y luego Crearemos variables de metodo para almacenar temporalmente cada empleado y persona para mostrarle al usuario Y luego recorreremos la lista con los codigos de las personas que se les facturo. la lista que creamos con el Select y distinct. y por el momento tiene 0 el total sera entonces igual a 0 + valor del producto .

Vemos que el total es igual a ese precio y luego contara un producto Seguimos en el siguiente item de productos. como el empleado ya no es nulo ya no entrara a buscarlo Y sumara a el total de la factura el valor del nuevo producto y sumara un producto mas Asi sucesivamente hasta que termine el numero de productos Luego saldra del foreach interno y continuara con codigo Luego como se muestra en la imagen superior Se buscara en la lista de personas la persona con el codigo que tenga Si la persona o el empleado es nulo mostrara mensaje de error si no mostrara al final la factura El continue sirve para continuar con el siguiente item del foreach sin terminar de ejecutar el codigo que hay debajo de el Osea que si la persona es nula mostrara el mensaje y continuara con el siguiente item del foreach .

Hacer un programa que permita ingresar personas. Y luego en otra pantalla realizar el ingreso de la factura En total son 1 entidad para empleados 1 entidad para personas 1 entidad para productos 1 entidad para la factura La factura tendrá un codigo ya que una persona podrá tener más de una factura . productos cada una de estas opciones son pantallas separadas. empleados.Luego se hace lo mismo para el empleado si es nulo no podemos mostrar el empleado en la factura por lo cual no podemos mostrar la factura entonces mostraremos mensaje de error y luego aplicaremos el Continue con el siguiente item del foreach Tal como esta el comentario de la imagen superior si se encontro una persona y un empleado se mostrara por pantalla el resultado de los calculos y seguira asi por cada persona a la que se le haya facturado Y luego el mismo proceso de limpiar variables sumar valores y validar y mostrar Ejercicio 2 Para Resolver el Estudiante 1.

.El programa principal solo tendrá botones que lanzaran las otras ventanas como popup Se aplicaría igual que en el ejercicio que se explicó.