UNIVERSIDAD DON BOSCO

FACULTAD DE ESTUDIOS TECNOLOGICOS

COORDINACIÓN DE COMPUTACION
GUIA DE LABORATORIO #5
Nombre de la practica: Programación Orientada a Objetos (POO)
Lugar de ejecución: Centro de computo
CICLO II
Tiempo estimado: 2 horas con 30 minutos
Materia: Desarrollo de aplicaciones con software propietario

I.OBJETIVOS
Qué el estudiante:
• Defina que es la Programación Orientada a Objetos
• Sea capaz de crear clases en C#.NET 2015
• Defina propiedades y métodos dentro de una clase

II. INTRODUCCION TEORICA

NET Framework y la Programación Orientada a Objetos (POO)

NET Framework está basado en clases (u objetos). A diferencia de las versiones anteriores, la versión .NET de
este lenguaje basa su funcionamiento casi exclusivamente en las clases contenidas en .NET Framework, además
casi sin ningún tipo de limitaciones. Debido a esta dependencia en las clases del .NET Framework y sobre todo
a la forma “hereditaria" de usarlas, C# .NET tiene que ofrecer esta característica sin ningún tipo de
restricciones.

Bases de la Programación Orientada a Objetos

Los tres pilares de la Programación Orientada a Objetos (POO) son:

1. Herencia
2. Encapsulación
3. Polimorfismo

Herencia
La herencia es la cualidad de crear clases que estén basadas en otras clases. La nueva clase heredará todas las
propiedades y métodos de la clase de la que está derivada, además de poder modificar el
comportamiento de los procedimientos que ha heredado, así como añadir otros nuevos.

Imaginemos tres clases: Cliente, Empleado y Persona. Los atributos y operaciones de la clase base
Persona también pueden aplicarse a Cliente o Empleado. La reutilización de estos atributos y
operaciones es una técnica eficaz.

C#.NET soporta herencia simple a nivel de clase. Es decir, una clase únicamente puede heredar de una
sola clase base. Esto se muestra en el ejemplo de la ilustración anterior. Otros lenguajes, como C++,
permiten que una clase herede de múltiples clases.

1
Encapsulación
La encapsulación es la capacidad de separar la implementación de la interfaz de una clase del código que hace
posible esa implementación. Esto realmente sería una especie de abstracción, ya que no nos importa cómo esté
codificado el funcionamiento de una clase, lo único que nos debe interesar es cómo funciona.

Polimorfismo
El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con
métodos o propiedades denominados de forma idéntica, que pueden utilizarse de manera
intercambiable mediante código cliente en tiempo de ejecución.

Definiendo una Clase

Una clase es esencialmente un proyecto, a partir del cual puede crear objetos. Una clase define las
características de un objeto, incluyendo las propiedades que definen los tipos de datos que ese objeto
puede contener y los métodos que describen el comportamiento del objeto. Estas características
determinan la manera en que otros objetos pueden acceder y trabajar con los datos que se incluyen en el objeto.

Para definir una clase, se coloca la palabra class Perro

{
clave Class antes del nombre de su clase, y public decimal altura;
después se insertan los miembros de la public decimal peso;
clase (datos y métodos) entre la llave de public string color;
apertura y cierre.
Si incluye los métodos, entonces el código de void Caminar(int pasos) {
}
cada método también se debe
incluir entre la declaración del método void Ladrar() {
y el final del mismo. Observe a la derecha la }
definición de la clase Perro. Este contiene 3
atributos: Altura, Peso y Color. Además se void Comer() {
}
definen 3 métodos: Caminar, Ladrar y Comer.
}

2
¿Qué es un Objeto?
Un objeto es la instancia de una clase. Una clase es la representación abstracta de un concepto en el
mundo real, y proporciona la base a partir de la cual creamos instancias de objetos específicos. Como
ejemplo, puede crear una clase que defina a un cliente. Después puede crear una nueva instancia de la clase
cliente para tener un objeto utilizable de Cliente. Para poder crear un objeto de la clase cliente, debe crear
una nueva instancia basada en esa clase.
Por ejemplo:
public Perro PastorAleman= new Perro();

Cada objeto es un elemento único de la clase en la que se basa. Por tanto, si una clase es como un molde,
entonces un objeto es lo que se crea a partir del molde. La clase es la definición de un elemento; el objeto es
el elemento. El molde para una figura de cerámica en particular, es como una clase; la figura es el
objeto.

Miembros de la clase
Los elementos de una clase que contienen sus datos y definen su comportamiento, es decir, las
propiedades y métodos, reciben el nombre de miembros de la clase. Existen dos formas de almacenar los
datos o información en una clase: a través de campos de clase y de propiedades. La diferencia entre un
campo y una propiedad son concernientemente a preservar la encapsulación del código de la clase.

Creación de campos para la clase

Un campo de una clase no es otra cosa que una variable, generalmente con ámbito público, accesible
desde el interior de la clase. Citando nuestra clase Perro, podremos observar que contiene tres campos:
Altura, Peso y Color. La manera de manipular estos campos es sencillo, debemos instanciar un objeto
Perro, a continuación de la variable que lo contiene situar un punto (.), y finalmente el nombre del campo a
manipular. Perro PastorAleman = new Perro();
PastorAleman.color ="negro";
PastorAleman.peso = 2;
PastorAleman.altura = 5;
textBox1.Text = PastorAleman.color;

3
Creación de propiedades para la clase
Una propiedad en una clase se define, por normal general, mediante dos elementos: una variable de
propiedad y un procedimiento de propiedad.
La variable de propiedad, tal y como su nombre indica, es una variable con ámbito privado a nivel de la clase,
que se encarga de guardar el valor de propiedad. Por su parte el procedimiento de propiedad o Property,
es el encargado de actuar de puente entre el código cliente y la variable de propiedad, realizando las
operaciones de acceso y asignación de valores a dicha variable.
Por lo tanto, para crear una propiedad en nuestra clase, declararemos en primer lugar una variable
Private, y en segundo lugar un procedimiento de tipo Property, que consta de dos bloques: Get, para
devolver el valor de la variable de la propiedad (podemos usar la palabra clave Return para devolver el
valor); y Set, para asignárselo (aquí debe usar un parámetro con el nombre Value, que contiene el valor
para asignárselo). La sintaxis a emplear se muestra en el siguiente código fuente.
class Perro
{
//Variable de propiedad para la propiedad altura
public decimal altura;
//Variable de propiedad para la propiedad peso
public decimal peso;
//Variable de propiedad para la propiedad color
public string color;

//Procedimiento de propiedad
//Declarar el procedimiento property
public decimal PAltura {
//Bloque get para devolver el valor de la propiedad altura
get {
return altura;
}
set {
altura = value;
}
}

//Propiedad de solo lectura

public decimal PPeso {
get {
return peso;
}
}

public string PColor {

get {
return color;
}
set {
color = value;
}
}
}
Cuando declaramos un procedimiento Property, debemos, al igual que una función, tipificarlo, ya que una
de sus labores consiste en la devolución de un valor. Para el ejemplo anterior, se observa que, la
propiedad Altura devuelve un valor decimal y la propiedad Pcolor devuelve un valor cadena. La manera de
crear un objeto a partir de esta clase y usarlo, se muestra en el siguiente ejemplo:

4
Perro PastorAleman = new Perro();
private void Form1_Load(object sender, EventArgs e)
{
PastorAleman.PColor ="negro";
PastorAleman.PAltura = 5;
textBox1.Text ="La altura es:" + Convert.ToString(PastorAleman.PAltura) + " y su peso es:" +
Convert.ToString(PastorAleman.PPeso);
}
PROPIEDADES DE SÓLO LECTURA O SÓLO ESCRITURA
Se plantea ahora un nuevo caso para una nueva clase Empleado: debemos guardar el valor del código de
cuenta bancaria del empleado en el objeto, pero sin permitir que dicha información sea accesible desde el
código cliente. Igualmente y en función de los primeros dígitos de la cuenta bancaria, necesitamos mostrar el
nombre de la entidad, pero sin permitir al código cliente su modificación, ya que esta va a ser siempre una
operación que debe calcular el código de la clase. Utilizando campos de clase no es posible resolver esta
situación, ya que al ser de ámbito público, permiten tanto la escritura como lectura de sus valores.
Las propiedades pueden leerse usando su descriptor de acceso get y puede escribirse en ellas usando
descriptor de acceso set. Estas propiedades reciben el nombre de propiedades de lectura y escritura. Cuando se
diseñan clases en C# hay que implementar una propiedad de solo lectura o de solo escritura. En C# esto es
sencillo.
Si hace falta implementar una propiedad de solo lectura se especifica una propiedad con un descriptor de
acceso get pero sin descriptor set. Si hace falta implementar una propiedad de solo escritura, se especifica una
propiedad con un descriptor de acceso set pero sin descriptor de acceso get.
El siguiente código fuente es un ejemplo de cómo resolver el problema comentado.
class Empleado Publ
{ ic DateTime FechaIngreso {
public int Id; get {
public string nombre; return _FechaIngreso;
private string _CtaBancaria; }
private string _entidad; set {
private DateTime _FechaIngreso; _FechaIngreso = value;
public double remuneracion; }
public int CostoHora; }
public int HorasTrabajadas;

public string CtaBancaria { public string Entidad {

set{ get {
switch(value){ return _entidad;
case "1111": }
_entidad="Banco del }
Perú";
break; //propiedad virtual
case "2222": public string MesIngreso {
_entidad= "Banco get {
Continental"; return String.Format("{0:M
break; MM MMM MMMM}", _FechaIngreso);
default: }
_entidad = "no existe }
entidad";
break; public double sueldo(int horas) {
} remuneracion = horas *
} CostoHora;
} return remuneracion;}
}

5
 III. REQUERIMIENTOS O MATERIAL Y EQUIPO

Nº Descripción Cantidad
1 Guía de Laboratorio de #05 1
2 PC con Microsoft Visual Studio 2015 .NET instalado 1
3 Memoria USB 1

IV. PROCEDIMIENTO

Parte 1: Se presentan a continuación los enlaces de unos videos de YouTube, que tratan el tema
de POO en C#. Deberá de realizar los ejercicios mostrados en los videos como parte de la
práctica de laboratorio.
 https://www.youtube.com/watch?v=5FA7oHIHIqs (POO en C#)
https://www.youtube.com/watch?v=fT4GD4rRAkY (POO en C#)
 https://www.youtube.com/watch?v=Sl1udfide14 (POO en C#)

Parte 2: Creación de clase que registran información personal de un empleado.

1. Creará una clase que permita manejar los datos personales y laborales de un empleado general, bajo una
fecha de contrato y un sueldo base, que debe tener entre 18 hasta 50 años de edad, y al cual se le aplica
una tasa de renta e isss dada por un administrador.
2. Agregue un nuevo modulo de clase a su proyecto, ubicándose en el explorador de soluciones y dar clic
secundario sobre el nombre del proyecto. Del menú emergente, seleccionar Agregar -> Clase…
3. Denominar clsEmpleado a este módulo de clase.
4. Ente los limites de esta clase, digite los componentes iniciales (atributos, propiedades y métodos, entre
ellos al constructor) a continuación:
CLASE clsEmpleado
LIBRERIAS
 Agregar la librería de controles windows en la clase:
using System.Windows.Forms;
ATRIBUTOS
/*
*--------------------------------
* Atributos
* --------------------------------
* Datos Personales */
private string Nombres;
private string Apellidos;
private DateTime FechaNacimiento;
private int Edad;
//Datos Laborales
private DateTime FechaContratacion;
private decimal TasaIsss;
private decimal TasaRenta;
private decimal SueldoBase;

6
 private decimal SueldoFinal;
//Banderas: indican estado registro de datos de c/empleado
private Boolean DatosCompletos;
private Boolean DatosLaboralesListos;
PROPIEDADES
/*
*--------------------------------
* PROPIEDADES
* --------------------------------
* Propiedades (Procedimiento de Propiedad) */
public string nombrecompleto
{
get
{
return Apellidos + "," + Nombres;
}
}
public Boolean datospersonales_aceptados
{
get
{
return DatosCompletos;
}
}

public Boolean datoslaborales_aceptados {

get {
return DatosLaboralesListos;
}
}

METODO Constructor
/*
*--------------------------------
* METODOS
* --------------------------------
* Metodo Constructor*/
public clsEmpleado() {
TasaIsss = 3; //3% por defecto
TasaRenta = 10; //10% por defecto
FechaContratacion = DateTime.Now;
//Establece que sus datos personales y laborales aun no han sido registrados
DatosCompletos = false;
DatosLaboralesListos = false;
}
METODOS DefinirDatosPersonales
public void DefinirDatosPersonales(string nom,string apel1,DateTime fechanac) {
/*Recibe c/dato personal, para evaluar si son correctos y
asignarlos a los atributos internos*/
long totalannos;//diferencia años entre 2 fechas cualquiera
DatosCompletos = false; //asume datos recibidos son incorrectos

nom = nom.Trim();
if (nom.Length == 0)
{
MessageBox.Show("Falta ingresar nombres a empleados");
return;

7
 }
else {
Nombres = nom;//asigna parametro recibido a atributo nombres
}
apel1 = apel1.Trim();
if(apel1.Length==0){
MessageBox.Show("Falta ingresar apellidos de empleado");
return;
}
else
{
Apellidos = apel1;//asigna parametro recibido a atributo nombres
}

//determina si fecha nacimiento esta ubicada 18(min) hasta 50(max) años

//antes de la fecha actual del SO de la PC
totalannos = DateTime.Now.Year - fechanac.Year;
if (totalannos>50){
MessageBox.Show("ERROR:Empleado debe jubilarse,segun codigo de trabajo de ES");
return;
}
else if(totalannos >0 && totalannos<18){
MessageBox.Show("ERROR:Persona menor de edad segun codigo trabajo de ES");
return;
}
else if (totalannos < 0)
{
MessageBox.Show("ERROR:Revise fecha de nacimiento ingresada");
return;
}
else {
FechaNacimiento = fechanac;
Edad = Convert.ToInt32(totalannos);
}
DatosCompletos = true;
}

METODO DefinirDatosLaborales
public void DefinirDatosLaborales(DateTime fechacontrato,decimal sueldoinic) {
//Recibe datos laborales de empleado(fecha contratacion y sueldo base)
long totalannos;//diferencia años entre 2 fechas cualquiera
DateTime fechainic18;//fecha min laboral de empleado segun du fecha nacimiento

DatosLaboralesListos = false;
//Antes de continuar, evalua si datos personales estan incompletos.
if(!(DatosCompletos)){
MessageBox.Show("Datos laborales no aceptados", "ERROR", MessageBoxButtons.OK,
MessageBoxIcon.Error);
MessageBox.Show("Antes de continuar, Revise los datos
personales","Información",MessageBoxButtons.OK,MessageBoxIcon.Information);
return;
}
/* Revisa datos laborales recibidos en parametros.
* Determina si diferencia fecha contrato esta ubicada entre 18 años despues
* de la fecha nacimiento de empleado(edad min. laboral) y hasta la fecha de hoy
*/
fechainic18 = FechaNacimiento.AddYears(18);

8
 totalannos = fechacontrato.Year - DateTime.Now.Year;

if(fechacontrato<fechainic18){
MessageBox.Show("Fecha contrato debe ser posterior al" + fechainic18);
return;
}
else if (fechacontrato > DateTime.Now)
{
MessageBox.Show("Fecha contrato valida solo entre " + fechainic18 + "y hoy" +
DateTime.Now.ToString());
return;}
else {
SueldoBase = sueldoinic;
}
//Datos laborales son correctos y completos
DatosLaboralesListos = true;

CalcularSueldoNeto();
}

METODO AsignaDescuento
public void AsignarDescuentos(decimal isss=2.50m,decimal renta=10.50m) {
//Evalua procentaje recibidos en parametros
if (isss > 2.50m && isss < 40)
{
TasaIsss = isss;//asigna tasa del isss recibido en parametros
}
else {
MessageBox.Show("Porcentaje de isss incorrecto, se usara" +
TasaIsss.ToString()+" %");
}

if (renta > 10.5m && renta < 40)

{
TasaRenta = renta;
}
else {
TasaRenta = 10.5m;//asigna tasa 10.5% predeterminado
}
}
METODO VerSueldos
public void VerSueldos(ref string sb,ref string sf) {
//Retorna valores de sueldo base y final de empleado
sb = SueldoBase.ToString();
sf = SueldoFinal.ToString();
}
METODO CalcularSueldoNeto
private void CalcularSueldoNeto() {
//Hace los calculos de su propio sueldo neto
decimal Desc;
SueldoFinal = SueldoBase;
Desc = SueldoBase * (TasaIsss / 100);
SueldoFinal -= Desc;
Desc=SueldoBase*(TasaRenta/100);
SueldoFinal -= Desc;

9
 }

Parte 2: Registro de N empleados en una planilla.

5. Agregue a su proyecto un nuevo módulo de clase denominado clsPlanilla. Luego digite los siguientes
componentes dentro de la misma.

CLASE clsPlanilla
LIBRERIAS
 Agregar la librería de controles windows en la clase:
using System.Windows.Forms;
ATRIBUTOS
/*
*--------------------------------
* Atributos
* --------------------------------
* Define avance de generacion planilla contable
*/
private int Estado;//Valores:1.Sin iniciar,2.En proceso,3.Finalizada
//Identificacion de propietario de planilla
private String Empresa;
private DateTime FechaPlanilla;

//Diccionario de objetos con informe de c/u de los empleados

private Dictionary<int, clsEmpleado> Listaempleados = new Dictionary<int, clsEmpleado>();

//Totales finales al generar planilla

private int TotalEmpleados;
METODO CONSTRUCTOR
public clsPlanilla(){
Estado = 1;//planilla sin autorizacion de apertura.
Empresa = "";//empresa que requiere planilla.
FechaPlanilla = DateTime.Now;//asume que planilla se inicia hoy mismo.
TotalEmpleados = 0;//ningun empleado registrado.
}
METODO AbrirPlanilla
public void AbrirPlanilla(DateTime fechaInicio,string nombreempresa="(Sin nombre)") {
/*Activa una nueva planilla
evalua estado actual del objeto*/
nombreempresa = nombreempresa.Trim();
switch(Estado){
case 1:
//Asigna atributos para identificacion de planilla
FechaPlanilla = fechaInicio;
if(nombreempresa.Length>0){
Empresa = nombreempresa;
}
Estado = 2;//Estado planilla ya esta activa en proceso
MessageBox.Show("Planilla Abierta, inicie registro empleados","Planilla

10
de "+Empresa+",APERTURA: "+FechaPlanilla.ToString());
break;
case 2:
//La planilla ya esta activa, se le indica a usuario
MessageBox.Show("Planilla ya esta abierta desde
el:"+FechaPlanilla.ToString(),"Planilla de "+Empresa);
break;
case 3:
//La planilla ya finalizo
MessageBox.Show("Planilla creada el"+FechaPlanilla.ToString()+" ya se
cerro","Planilla de"+Empresa);
break;
}
}
METODO RecibirEmpleado
public void RecibirEmpleado(clsEmpleado nuevoEmpleado) {
/*Agrega trabajador recibido al dictionay de empleados de la planilla
evalua que Estado Actual de planilla sea 2 (En proceso)*/
if (Estado == 2)
{
//Evalua si ha recibido un trabajdor con todos sus datos completos

if (nuevoEmpleado.datospersonales_aceptados == false)
{
MessageBox.Show("Error, datos personales estan incompletos", "Control
planilla");
return;
}
if (nuevoEmpleado.datoslaborales_aceptados == false)
{
MessageBox.Show("Error, datos laborales estan incompletos", "Control
planilla");
return;
}
//Registra un nuevo empleado al listado de la planilla abierta
TotalEmpleados += 1;
Listaempleados.Add(TotalEmpleados, nuevoEmpleado);
}
else {
MessageBox.Show("Planilla aun no esta abierta","Planilla de"+Empresa);
return;
}
}
METODO GenerarListado
public void GenerarListado(ref DataGridView cuadro) {
//se prepara a generar y mostrar lista en objeto Datagridview recibido en
parametro
int i=1;
string sb = "0";
string sn = "0";
//Evalua si planilla AUN no esta abierta!!
switch(Estado){
case 1:
MessageBox.Show("Planilla aun no ha sido abierta","Planilla"+Empresa);
return;
break;
case 2:

11
 //evalua si listado esta vacio
if(TotalEmpleados==0){
MessageBox.Show("Planilla no tiene aun empleados
registrados","Planilla de "+Empresa);
return;
}
Estado = 3;
MessageBox.Show("Planilla cerrada con "+TotalEmpleados+"
empleados","Planilla de "+Empresa);
MessageBox.Show("Planilla abierta el " + FechaPlanilla.ToString() + " se
muestra ahora!!", "Planilla de " + Empresa);
break;
}

//Finaliza planilla activa y la genera en un datagrid

cuadro.Rows.Clear();
cuadro.Columns.Clear();
cuadro.Columns.Add("id","num");
cuadro.Columns.Add("nom", "nombre completo");
cuadro.Columns.Add("sb", "sueldo base");
cuadro.Columns.Add("sf", "sueldo neto final");
//Alternar colores de datagridview
cuadro.RowsDefaultCellStyle.BackColor = System.Drawing.Color.Bisque;
cuadro.AlternatingRowsDefaultCellStyle.BackColor = System.Drawing.Color.Beige;

//comienza a llenar filas del grid con los datos de c/empleado registrado en
planilla
foreach(var result in Listaempleados)
{
cuadro.Rows.Add();
cuadro.Rows[i - 1].Cells[0].Value = result.Key;
cuadro.Rows[i - 1].Cells[1].Value = result.Value.nombrecompleto;
result.Value.VerSueldos(ref sb,ref sn);
cuadro.Rows[i - 1].Cells[2].Value = sb;
cuadro.Rows[i - 1].Cells[3].Value = sn;
i++;
}
MessageBox.Show("Planilla de pago final completa generada en pantalla!!");
}
PROPIEDAD TotaldeEmpleado
//PROPIEDAD(procedimientos de propiedad)
public string TotaldeEmpleado {
get {
return TotalEmpleados.ToString();
}
}

12
Parte 3: Utilizando Clases en Formulario

6. Ahora diseñe un form con los siguientes controles mostrados en la imagen.

7. Proceda a modificar las propiedades de los controles anteriores, de acuerdo a la tabla de asignaciones a
continuación:
GroupBox1
(propiedades) (propiedades)
Control Name Text Control Name Text
Label1 Lblnombres Nombres: Textbox1 txtNombres (vacio)
Label2 Lblapellidos Apellidos: Textbox1 txtApellidos (vacio)
Label3 lblfechanac Fecha nacimiento: DateTimePicker1 dtpFechaNac
Button1 btnNuevo Nuevo empleado Groupbox1 Datos personales
de empleados
Button2 btnAceptar Proximo empleado Form1 frmRegistoEmpleado Registro inicial de
s empleados

13
 GroupBox2
(propiedades)
Control Name Text DecimalPlaces Increment Maximum
GroupBox2 Datos laborales:
Label4 lblContrato Fecha contrato:
Label5 lblSueldo Sueldo base:
Label6 lblRenta Tasa Renta:
Label7 lblISSS Tasa ISSS:
TextBox3 txtSueldoini (vacio)
DateTimePicker2 dtpFechaContrato
NumericUpDown1 nudRenta 1 0,1 30
NumericUpDown2 nudISSS 1 0,1 30
Button3 btnAbrirPlanilla Abrir Planilla
Button4 btnGenerarPlanilla Generar Planilla

8. Instanciar de forma global el objeto planillaEPSON, con la siguiente línea de código:

clsPlanilla planillaEPSON = new clsPlanilla();
9. Ahora, digite los siguientes bloques de código dentro de c/procedimiento de evento indicado

Control | Evento
Form1 | Load
try {
//define fecha min y max que podra seleccionar en dtpFechaNac
DateTime fecha = DateTime.Now;
dtpFechaNac.MinDate = fecha.AddYears(-70);
dtpFechaNac.MaxDate = fecha.AddYears(15);

groupBox1.Enabled = false;
groupBox2.Enabled = false;
btnNuevo.Enabled = false;
btnAceptar.Enabled = false;
btnGenerarPlanilla.Enabled = false;
btnNuevo.Focus();
}
catch(Exception ex){
MessageBox.Show(ex.Message);
}
btnAceptar | Click
try
{
//se prepara a registrar un nuevo empleado
clsEmpleado trabajador = new clsEmpleado();//Crea un objeto de la clase
ClsEmpleado
trabajador.DefinirDatosPersonales(txtNombres.Text, txtApellidos.Text,

14
dtpFechaNac.Value);
//Empleado será aceptado hasta que objeto trabajador lo confirme

if (trabajador.datospersonales_aceptados)
{
/*Tranfiere datos laborales, para que confirme si son correctos
evalua si ha escrito mal el sueldo inicial*/
if (!(Int32.Parse(txtSueldoini.Text) >= 0))
{
MessageBox.Show("ERROR, Sueldo inicial no valido");
txtSueldoini.Focus();
return;
}
//evalua si valor tasa isss es incorrecto
if (nudRenta.Value <= 0.0m)
{
MessageBox.Show("ERROR, revise tasa renta");
nudRenta.Focus();
return;
}
//evalua si valor tasa isss es incorrecto
if (nudISSS.Value <= 0.0m)
{
MessageBox.Show("ERROR, revise tasa ISSS");
nudISSS.Focus();
return;
}
trabajador.DefinirDatosLaborales(dtpFechaContrato.Value,
Convert.ToDecimal(txtSueldoini.Text));
if (trabajador.datoslaborales_aceptados)
{
trabajador.AsignarDescuentos(Convert.ToDecimal(nudISSS.Text),
Convert.ToDecimal(nudRenta.Text));
planillaEPSON.RecibirEmpleado(trabajador);
groupBox1.Enabled = false;
groupBox2.Enabled = false;

btnNuevo.Enabled = true;
btnAceptar.Enabled = false;
btnNuevo.Focus();
}
else
{
txtNombres.Focus();
}
}
else
{
txtNombres.Focus();
}

}
catch (Exception e) {
MessageBox.Show(e.Message);
}
btnAbrirPlanillla | Click
btnNuevo.Enabled = true;
btnGenerarPlanilla.Enabled = true;

15
 //Activa planilla actual, para que se agreguen los N empleados
planillaEPSON.AbrirPlanilla(DateTime.Now,"Epson Internacional");
btnGenerarPlanilla | Click
//Finaliza ingreso empleados, para poder generar planilla completa!!
planillaEPSON.GenerarListado(ref dataGridView1);
btnNuevo | Click
//deja controles en blanco para un proximo empleado
txtNombres.Clear();
txtApellidos.Clear();
txtSueldoini.Clear();
nudISSS.Value = 0;
nudRenta.Value = 0;
dtpFechaContrato.Value = DateTime.Now;
dtpFechaNac.Value = DateTime.Now;
groupBox1.Enabled = true;
groupBox2.Enabled = true;
btnNuevo.Enabled = false;
btnAceptar.Enabled = true;
txtNombres.Focus();
txtnombres txtapellidos | KeyPress
//solo letras
if (!(char.IsLetter(e.KeyChar)) && (e.KeyChar != (char)Keys.Back))
{
MessageBox.Show("Solo se permiten letras", "Advertencia",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
e.Handled = true;
return;
}

nudRenta nudISSS txtSueldoini | KeyPress

//solo numeros
if (!(char.IsNumber(e.KeyChar)) && (e.KeyChar != (char)Keys.Back))
{
MessageBox.Show("Solo se permiten numeros", "Advertencia",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
e.Handled = true;
return;
}

10. Ejecute de nuevo el proyecto y presione el botón btnGenerarPlanilla. Evalué el mensaje mostrado.
Sin finalizar la ejecución de la prueba anterior:
A. presione botón btnAbrirPlanilla y luego presione nuevamente a btnGenerarPlanilla. Evalué los
mensajes y resultados generados.
B. Ingrese unos 2 o 3 empleados con datos correctos y luego presione otra vez botón btnGenerarPlanilla.
Evalué los mensajes y resultados generados.
11. Finalmente, ejecute la aplicación, ingrese 3 o 4 empleados con datos correctos y genere la planilla.

Ejercicio Complementario:
+ Modifique la aplicación diseñada en el procedimiento de la práctica, para que todas las validaciones que se
realizan actualmente desde el formulario, se puedan ejecutar desde la clase clsempleados.

16
+ Haga las acciones necesarias, para que una vez mostrada la planilla en el datagridview y antes de finalizar el
programa, desarrolle un método de la clase clsPlanilla que sea capaz de generar un archivo de texto
simple/plano (.txt, cuyo nombre lo defina usuario). Este nuevo archivo deberá contener los datos generados
en la planilla.

VI. DISCUSION DE RESULTADOS

1. Crea una clase Cuenta (bancaria) con atributos para el número de cuenta , el DUI del cliente, el saldo
actual y el interés anual que se aplica a la cuenta (Entre 10% - 22.3%). El n número de la cuenta debe
ajustarse al siguiente formato DDMMYYYY-XXXXXX donde XXXXXX es un número correlativo que
comienza en 1000001.
Defina en la clase los siguientes miembros.
 Propiedades para número de cuenta, DUI y saldo actual.
 actualizarSaldo(): actualizará el saldo de la cuenta aplicándole el interés diario. (interés
anual dividido entre 365 aplicado al saldo actual).
 ingresar(double): permitirá ingresar una cantidad ($) en la cuenta.
 retirar(double): permitirá sacar una cantidad ($) de la cuenta (si hay saldo).
 Método que nos permita mostrar todos los datos de la cuenta.
2. Con la clase anterior, tiene que crear una aplicación que permita al Banco Adajet, llevar el control de
n cuentas de ahorro de sus clientes. Tome en cuenta que un cliente puede decidir cerrar su cuenta.
3. Realizar validaciones necesarias desde la clase cuenta.

17