Técnica de Programación

C# Primera Aplicación
Iniciando en C#

Crear la Aplicación
1. Iniciar Visual studio 2008.

2. En algunos casos cuando iniciamos C# por primera vez nos aparece la siguiente ventana

1 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

3. Luego estamos en la siguiente ventana ()

4. Pulse Visual C# Projects en el cuadro Project Types (Tipos de proyecto).

5. Pulse Console Application (Aplicación de consola) en el cuadro Templates

2 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

6. Pulse Console Application (Aplicación de consola) en el cuadro Templates (Plantillas).

7. Escriba Saludos en el cuadro Name (Nombre).
8. Escriba la ubicación deseada para el proyecto en el cuadro Location (Cree una carpeta D:\)
(Ubicación) y pulse OK.

NOMBRE: Dale el nombre y ubicación que quieras para tu aplicación. Es aconsejable que
marques la casilla de verificación "Crear directorio para la solución", como en la imagen. Así
tendrás bien organizados todos los archivos de la misma.

Project Type: El de la izquierda sirve, como puedes ver, para indicar el lenguaje que vas a
utilizar.

Template o Plantilla:El de la derecha para indicar el tipo de aplicación que vas a diseñar. Más
adelante los iremos viendo, pero aún no es el momento más adecuado. De momento vamos a
crear aplicaciones de consola (es decir, programas que se ejecutan en una ventana de DOS).

Porque DOS
¿Que quieres empezar ya a hacer aplicaciones para Windows? Así me gusta, hombre, que seas
valiente. Sin embargo, no vamos a empezar con eso aún. Por ahora lo que quiero es enseñaros
el lenguaje C# propiamente dicho, ya que comenzar desde cero (o prácticamente cero)
diseñando aplicaciones para Windows sin conocer el lenguaje no haría sino entorpecer el
aprendizaje del mismo. Cuando conozcas el lenguaje podrás comprobar que no te cuesta
ningún trabajo adaptarte al diseño para Windows.

9. Cambie el nombre de la clase a Saludo

3 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

10. Guarde el proyecto seleccionando Save All (Guardar todo) en el menú File).
11. Inserte la siguiente línea en el método Main después de los comentarios
12. Una vez terminado, el método Main debe contener lo siguiente:

Tiene barra de menús y barras de botones como casi todos los programas de hoy en
día. Debajo, y de izquierda a derecha, tienes: El cuadro de herramientas, que se
desplegará cuando pases el ratón por encima. Si quieres que esté siempre desplegado
(al estilo del cuadro de herramientas de VB 6.0, por ejemplo) tendrás que hacer clic
sobre un pequeño icono con forma de chincheta que hay al lado del botón cerrar de
dicho cuadro. A continuación tienes el espacio de trabajo: en él te aparecerán las
ventanas de código de cada archivo, así como el examinador de objetos, la ayuda...
Cada ventana mostrará una pequeña pestaña en la parte superior (justo debajo de las
barras de botones), para que puedas pasar de unas a otras con un solo clic (en esta
imagen tienes las pestañas StarPage y Program.cs). A la derecha tienes el explorador
de soluciones. Bueno... realmente son cuatro ventanas en una: fíjate en las pestañas
que tiene justo debajo: el explorador de soluciones, que se ocupa de mostrarte los
archivos que componen la solución que estás creando con una jerarquía en árbol; la
vista de clases, que muestra las clases que componen la solución, organizadas también
en árbol; el contenido de la ayuda, que muestra eso precisamente; y la búsqueda de
ayuda, que, obviamente, sirve para buscar algo en la ayuda. Justo debajo está la
ventana de propiedades, que se ocupa de mostrar las propiedades de algún archivo
del proyecto, o alguna clase, o algún objeto, o algún método... Aquí tenéis también
otra pestaña, la de ayuda dinámica, que va mostrando temas de ayuda que tienen que

4 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

ver con lo que estás haciendo (si escribes class te salen temas sobre class, si escribes
string te salen temas sobre eso, etc). Debajo tienes más ventanas (la lista de tareas,
ventana de comandos, resultados, resultados de búsqueda de símbolos). Puede que a
ti no te coincidan, ya que todo esto es perfectamente configurable, y como yo me lo
he configurado a mi gusto y no recuerdo cuáles eran las opciones por defecto, pues
eso, que puede ser que a ti no te aparezcan las mismas ventanas que a mi (sobre todo
aquí abajo). En el menú Ver puedes mostrar y ocultar todas las ventanas que quieras, y
también puedes cambiarlas de sitio simplemente arrastrándolas con el ratón. Venga,
poned todo esto como más cómodo os resulte y seguimos...

Bueno, ahora que ya me he asegurado de que nos vamos a entender cuando yo hable
de una ventana o de otra, podemos continuar. Visual Studio .NET guarda los distintos
archivos que componen un programa con distintas extensiones, dependiendo de para
qué sirva. Los distintos archivos que contienen el código fuente en lenguaje C# los
guarda con la extensión "cs" (fijate en el explorador de soluciones, en el cual tienes
Program.cs). Al archivo de proyecto que está escrito en C# le pone la extensión
"csproj".

El archivo de proyecto contiene diversa información sobre el mismo: opciones de

compilación, una lista de referencias y una lista de los archivos que lo componen. Más
adelante entraremos en más detalles.

El último archivo que nos interesa por ahora es el archivo de solución, al cual le pone la
extensión "sln". Este contiene información sobre los proyectos que componen la
solución.

El programa que vamos a desarrollar mostrará sencillamente el texto "Hola Mundo" en

la consola (a partir de ahora, la consola es la ventana de DOS). De entrada, Visual
Studio .NET nos ha escrito casi todo el código. Es el que sigue:

using System;

namespace ConsoleApplication1

5 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

{
classSaludo
{
staticvoid Main(string[] args)
{

//Codigo

}
}
}

Siempre que crees una aplicación de Consola en C#, Visual Studio .NET añadirá este
código.

using Systemnos permitirá usar miembros de este espacio de nombres sin poner la
palabra System delante.

namespaceun espacio de nombres para la aplicación, que se llama igual que la misma
(ConsoleApplication1).

class Una clase llamada Saludo con un método Main que es static, que es el método
por el que empezará la ejecución del programa.

//Codigo Añade aquí el código para que empiece la aplicación". O sea, que ya sabes
dónde hay que escribir el código de nuestra aplicación "Hola Mundo": en el método
Main. Escribe esto:

System.Console .WriteLine("Hola mundo");

Cómo compilar y ejecutar el programa

1. En el menú Build, seleccione Build Solution (o pulse CTRL+SHIFT+B).

2. Corrija los posibles errores de compilación y vuelva a compilar si es necesario.

6 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Ejecutar la aplicación
3. En el menú Debug, seleccione Start Without Debugging (o pulse CTRL+F5).

5. Después de ver el saludo, pulse una tecla cuando aparezca el mensaje “Pulse cualquier
tecla para continuar”.

Console.Read(); o
Console.ReadLine();

Es como lo que se uso como Getch en C++

ConsoleConsole es una clase que pertenece a la biblioteca de clases de .NET Framework y

está dentro del espacio de nombres System. Sirve para efectuar diversas operaciones de
consola. Nosotros nos fijaremos principalmente en dos de ellas: Escribir datos en la consola y
leer datos de la misma.

7 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Imprimir Datos
Para IMPRIMIRlos datos tenemos los métodos Console.Write y
Console.WriteLine. Este último, como puedes apreciar, es el que hemos usado para
nuestra aplicación. La diferencia entre ambos es que Write escribe lo que sea sin añadir el
carácter de fin de línea a la cadena, de modo que lo siguiente que se escriba se pondrá a
continuación de lo escrito con Write. WriteLine sí añade el carácter de fin de línea a la
cadena, de modo que lo siguiente que se escriba se colocará en la siguiente línea. Es decir, el
siguiente fragmento de código:

Console.Write("Hola");
Console.WriteLine("Pepe");
Console.Write("¿Cómo andas, ");

Hay 19 sobrecargas del método WriteLine, y otras 18 del método Write.

Sobrecarga de metodos
Aun no quería tocar este tema pero En fin... veremos muy detallada la sobrecarga de
métodos cuando lleguemos al tema de los métodos. Mientras tanto, sepas que, más o
menos, quiero decir que podemos usar estos métodos de diversas maneras.

Leer Datos
Para LERRdatos de la consola tenemos los métodos Console.ReadLine y
Console.Read. El método Read obtiene el primer carácter que aún no se haya extraído
del buffer de entrada. En caso de que el buffer esté vacío o bien contenga un caracter no
válido, retornará -1.

ReadLineobtiene una línea completa del buffer de entrada, es decir, toda la cadena de
caracteres hasta encontrar el carácter de fin de línea (bueno, realmente el fin de línea está
definido por dos caracteres, pero tampoco vamos a darle más importancia.

Estos dos métodos no están sobrecargados

¿Qué es eso del buffer de entrada?

Pues vamos a ver: cuando el programa ejecuta un método Read y tú escribes Hola, don Pepito,
hola don José y después pulsas la tecla intro, todo lo que has escrito va a dicho buffer. Read,
decíamos, obtiene el primer carácter no extraído del buffer, de modo que la primera vez
devuelve la H, la segunda la o, luego la l, luego la a, y así hasta terminar el buffer. Por lo tanto,
el buffer de entrada es, para que me entiendas, una zona de memoria donde se almacenan
datos que se han ingresado pero que aún no se han leído.

Usando sobrecargas

8 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

No voy a tocar una a una todas las sobrecargas de los métodos Write y .Voy a explicar de qué
formas los vamos a usar más comúnmente, y si en algún momento del curso los usamos de
otro modo, ya te lo explicaré. El método Write lo usaremos de las siguientes formas:

Console.Write(cadena);
Console.Write(objeto);
Console.Write(objeto.miembro);
Console.Write("literal {0} literal {1} literal {2}...", dato0,
dato1, dato2);

 "cadena" puede ser una cadena literal (por lo tanto, entre comillas)
 cadena Puede ser una variable de tipo string (por lo tanto, sin comillas).
 objeto será cualquier variable de cualquier tipo, o bien una expresión.
 Objeto.miembro será de nuevo cualquier variable de cualquier tipo, y lo usaremos así
cuando queramos escribir lo que devuelva un miembro de ese objeto (una propiedad o un
método).
 La última forma del método Write la usaremos cuando queramos intercalar datos dentro
de un literal. Write escribiría esa cadena intercalando dato0 donde está {0}, dato1 donde
está {1}, y dato2 donde está {2}, y así tantos datos como queramos intercalar. Por cierto,
estos datos pueden ser objetos de cualquier tipo, o bien expresiones o bien lo que
devuelva algún miembro de algún objeto.

Los métodos Read y ReadLine no tienen sobrecargas, así que solamente los podremos usar así:

variable = Console.Read();
cadena = Console.ReadLine();

En la primera línea he puesto "variable" porque Read devolverá un valor de tipo int,
equivalente al código del carácter unicode recibido del buffer. Por este motivo, la variable
solamente puede ser de tipo int.

En la segunda línea, ReadLine retorna siempre un valor de

tipo string, por lo tanto, "cadena" debe ser una variable de
tipo string.

Si queremos cambiar el nombre de la clase (Program.cs) ,

vamos a cambiarlo. Haz clic sobre el archivo Program.cs en el
explorador de soluciones. A continuación, en la ventana de
propiedades busca "Nombre de archivo" y cambia
Program.cs por un nombre más significativo (HolaMundo.cs,
por ejemplo). Por último, en la ventana de código, cambia
Program por HolaMundoApp. Es una buena costumbre

9 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

colocar el método Main en una clase que se llame como la aplicación más las letras App..

No te olvides de guardarlo antes de salir de Visual Studio .NET, con Archivo, Guardar Todo, o
bien el botón con varios diskettes dibujados, o bien la combinación de teclas
Control+Mayúsculas+F5. De todos modos, si se te olvida y ha habido modificaciones, Visual
Studio te preguntará si quieres guardarlas antes de salir. Nuestro primer programa en C# ha
quedado así:

Palabras clave de C#
Las palabras clave son identificadores predefinidos reservados que tienen un significado
especial para el compilador. No se pueden utilizar como identificadores en un programa a
menos que incluyan el carácter @ como prefijo. Por ejemplo, @if es un identificador válido
pero if no, por ser una palabra clave.

abstract event new struct

as explicit null switch

base extern object this

bool false operator throw

break finally out true

byte fixed override try

case float params typeof

catch for private uint

char foreach protected ulong

checked goto public unchecked

class if readonly unsafe

const implicit ref ushort

continue in return using

decimal int sbyte virtual

default interface sealed volatile

delegate internal short void

do is sizeof while

double lock stackalloc

else long static

enum namespace string

10 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Algunas consideraciones al definir identificadores

En la práctica, la letra de subrayado ( _ ) se emplea para dar mayor legibilidad a nombres
compuestos por varias palabras. Además, se acostumbra emplear letras minúsculas para
nombrar a las variables y las mayúsculas se usan al comienzo de una palabra en funciones
declaradas con identificadores compuestos.

Se recomienda elegir nombres que sean representativos del elemento (atributo o método) que
se defina o del valor que la variable guarde. Por ejemplo, una variable que guardará la edad de
un empleado podría llamarse edad_empleado o edad, y no simplemente xyz, aunque éste es
un identificador válido y el programa funcionará correctamente este nombre.

Ejemplos de identificadores

puntero
nombre_empleado
area
TAMANO_STRING
EdadEmpleado
potencia10
i
For
iF
While
Nombre
nombre

Los siguientes son identificadores inválidos

nombre-empleado
teléfono
while

TRABAJAR CON VARIABLES.

En C#, las variables reciben nombres que respetan las reglas de los identificadores. Además,
toda variable debe tener un tipo de dato asociado, que define básicamente la clase de dato
que se almacenará en ella y la forma en que deberá ser tratado.

Como se verá más adelante, toda variable debe ser declarada previamente a su uso dentro del
programa, y esto debe hacerse respetando una sintaxis establecida.

En resumen: Una variable es un objeto que almacena un dato, es asociado a un identificador y

a un tipo.

La forma genérica es la siguiente:

<modificador><tipo><identificador> [= <valorInicial>] ;

Donde

<tipo> puede ser: int, float, char, entre otras posibilidades. []significa opcional.
<valor_inicial> puede corresponder a una constante del tipo entero, real, caracter, arreglo,
etc.

11 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

<modificador> puede ser una de las siguientes posibilidades: public, protected, private, static,
const, readonly; que corresponden a descripciones del comportamiento de esta variable en
relación al resto de los elementos del programa.

Ejemplos de declaraciones de variables:

int numero;
char sigla;
string nombre;
Asociadas a un dato

int numero = 10;

char sigla = 'G';
string nombre = "Juan";

Visible para Otros objetos:

staticvoid Main(string[] args)

publicint numero = 10; // Visible para otros objetos
privatechar sigla = 'G'; // Invisible para otros objetos
conststring nombre = "Juan"; // Valor fijo, constante

Los modificadores private, public, protected definen la visibilidad que tendrán otros objetos de
tener acceso a dichos campos. Por otro lado, const, readonly, se refieren a la factibilidad de
poder modificar el valor del campo una vez inicializado o definido. Finalmente, static define el
comportamiento de todas las instancias de la misma clase, y el tratamiento que puedan tener
sobre el campo en cuestión.

Tipos de Datos
Para la plataforma .NET, los tipos de datos básicos son los siguientes, varios de los cuales
sirven para representar cantidades numéricas, y otros para representar texto y otros.

.NET
VB.NET C# .NET Almacenamiento Intervalo
Framework
Boolean bool Boolean - true/false
Byte byte Byte 1 byte [0;255]
Short short Int16 2 bytes [-32768;32767]
[-
Integer int Int32 4 bytes
2147483648;2147483647]
Long long Int64 8 bytes [-10E19;10E19]*
Single float Single 4 bytes [-10E38;10E38]*
Double double Double 8 bytes [-10E308;10E308]*
Decimal decimal Decimal 12 bytes (parte entera) [-10E28;10E28]*
Date System.DateTime DateTime 8 bytes [1/1/0001;31/12/9999]
String string String - -
Char char Char 2 bytes -
Object object Object 4bytes (32 bits) / 8 bytes -

12 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

(64 bits)
SByte sbyte Sbyte 1 byte [-128/127]
UShort ushort UInt16 2 bytes [0:65535]
UInteger uint UInt32 4 bytes [0;4.294.967.295]
ULong ulong UInt64 8 bytes [0;1,8E19]

Para completar, no siempre se tienen presente y una tabla comparativa entre los dos lenguajes
y el framework:

Short es más lento que integer, aunque pueda ocupar menos memoria.
Interger es el tipo numérico más eficiente en términos de rendimiento.
Los enteros sin signo (UInt16/32/64) son igualmente rápidos que los signados y con mayor
capacidad, siempre que se sepa que solo se almacenaran enteros positivos, pero no son cls
compliant.
Decimal es el tipo con mayor rango pero las operaciones con este tipo son mucho más lentas
que con el resto
Double es el tipo real más rápido (en plataformas de 32 bits)
A partir del framework 3.5, existe una nueva estructura para albergar fechas y horas:
DataTimeOffset, que maneja zonas UTC. Si bien sigue existiendo DateTime, DateTimeOffset
será la recomendación de Microsoft.

Ejecute el siguiente ejemplo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CApplication2
{
classProgram
{
staticvoid Main(string[] args)
{
string cadena = "hola";
int entero = 7;
double real = 0.2;
bool booleana = true;

Console.WriteLine("definición de varias variables, de varios

tipos...");
Console.WriteLine("cadena={0}", cadena);
Console.WriteLine("entero={0}", entero);
Console.WriteLine("booleana={0}", booleana);
Console.WriteLine("real={0}", real);

}
}
}

13 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Métodos o Funciones
Una “función”, genéricamente se describe como un conjunto de instrucciones (posiblemente
acompañadas de algunos datos temporales), que llevan a cabo una subtarea dentro de un
programa más complejo. Un método es una función que pertenece a una clase en particular.

Por ejemplo, dentro de un programa que convierte una lista de temperaturas expresadas en
grados Fahrenheit, a grados Celsius, podríamos definir una función que haga una de las
conversiones, y la emplearíamos varias veces para lograr completar nuestra tarea.

Tenemos entonces que las funciones dentro de un programa cumplen con subtareas, para las
cuales es necesario suministrarles algunos datos de entrada, y luego de completadas,
recibiremos como resultado algunos datos de salida. Para el caso de una función que calcula el
área de un círculo, la entrada que requiere la función sería el radio del círculo, y la salida que
arrojaría luego del cómputo sería el valor para el área. Este hecho se ilustra en el diagrama que
se muestra abajo, en el que podemos ver la tarea de transformación de datos que cumple una
función: La alimentamos con una entrada y recibimos una salida en respuesta.

Por otra parte, para especificar el proceso de transformación que debe llevar a cabo la función,
es necesario emplear las instrucciones del lenguaje de programación. Es necesario respetar
algunas pautas, tanto para la especificación de los parámetros de entrada, como del valor de
retorno, pero la estructura general es la misma.

Sintaxis de la definición de Funciones o Métodos

La sintaxis general de definición de métodos es la siguiente:

<accesibilidad><tipo_retorno><nombre_función> ( <lista_parámetros> ) {
<declaración_de_variables_locales>;
<cuerpo_de_la_función> ;
return (<valor_retorno>) ;
}

<accesibilidad> se refiere a la visibilidad que tienen otras partes de un programa para ejecutar el
método.
Las posibilidades son public, private, protected, lo cual define la accesibilidad que se tiene a este
método desde otras clases.

<tipo_retorno> es el tipo del valor que devolverá la función. Es posible definir funciones que
no devuelven ningún valor (para por ejemplo definir funciones que solo imprimen valores o
ciertos mensajes en pantalla, para los que no es necesario que devuelva valor alguno). Para
definirlos o declararlos, se utiliza como tipo de retorno la palabra reservada void. A estas
funciones se las conoce también como procedimientos, porque no devuelven ningún valor.

<nombre_función> debe ser sustituido por un identificador que corresponde al nombre con
que se invocará la función posteriormente (o llamada de la función). Debe ser un identificador
válido. El valor de retorno de la función es asociado al nombre de la función.

<lista_parámetros> corresponde con una lista de variables denotadas por identificadores

asociados a un tipo, cada uno representa un parámetro de entrada. La lista de parámetros
puede ser vacía pero los paréntesis deben aparecer.
<declaración_de_variables_locales> se refiere a variables locales que podrán ser utilizadas
únicamente dentro de la función. Fuera de ella, no serán reconocidas.

14 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

<cuerpo_de_la_función> es una lista de instrucciones, separadas por punto y coma.

<valor_retorno>, debe ser una expresión (constante, aritmética, lógica del tipo que se
especificó como <tipo_retorno>, y establece la expresión que retornará la función una vez que
haya terminado.

Ejemplos: Definición de Funciones

• Función que convierte temperaturas

// Función que recibe una temperatura en grados Fahrenheit y
// retorna su equivalente en Celsius. El argumento de entrada es
// farenheit de tipo int. El valor de retorno es de tipo int.
// La fórmula de es C=(F-32)*(5/9). Puede ocurrir truncamiento.
int celsius(int fahrenheit)
{
return((fahrenheit-32.0)*(5.0/9.0));
}

• Función que convierte temperaturas

// Función que recibe una temp expresada en grados Celsius y

retorna
// su equivalente en Faherenheit. El argumento de entrada es
celsius
// de tipo int. El valor de retorno también es de tipo int.
// La fórmula de conv es F=32+(C*9/5). Puede ocurrir
truncamiento.

int fahrenheit(int celsius)

{
return((celsius*9.0/5.0)+32.0);
}

• Función que calcula el área de un círculo

// Función que calcula el área de un círculo dado su radio.

Tanto el
// argumento de entrada (radio) como el valor de retorno es de
tipo
// float. La fórmula implementada es A=Pi*R*R.
float area(float radio)
{
return(3.14 * radio * radio);
}

Sintaxis de la llamada a las Funciones definidas

La sintaxis general de las llamadas a las funciones definidas es la siguiente:

<variable> = <nombre_función> ( <lista_parámetros> );

<variable>corresponde a una variable denotada por un identificador del mismo tipo del valor
que devolverá la función.

<nombre_función> es el identificador que corresponde al nombre con que se invoca a la

función.

15 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

<lista_paramétros> debe corresponder a una lista de variables denotadas por identificadores

asociadas a un tipo, o expresiones de un tipo. Ya sean variables o expresiones, éstas deben
corresponder en cuanto a cantidad, posición y tipos a las variables que se definieron como
parámetros de entrada en la definición de la función. Representan los valores que se entregan
como entrada a la función. Si en la definición de la función no se usó parámetro alguno,
entonces en la llamada tampoco debe escribirse ninguna expresión o variable, pero los
paréntesis deben aparecer.

De los ejemplos anteriores

int grados_celsius ;
grados_celsius = celsius(int fahrenheit) ;

//-------------------------------
int grados_farenheit ;
grados_farenheit = fahrenheit(31) ;
//-------------------------------

float calculo_area ;
float radio = 5.56 ;
calculo_area = area(5.56);
calculo_area = area(radio);

Un ejemplo usando funciones

namespace CApplication2
{
classProgram
{
staticvoid Main(string[] args)
{
string var = "Ejeplo que suma dos numeros";
System.Console.WriteLine("Hola {0}!", var);
int num1 = 120;
int num2 = 3;

int resultado = Suma(num1, num2);

System.Console.WriteLine("{0}+{1} = {2}", num1, num2,
resultado);

Console.ReadLine();
}

staticint Suma(int valor1, int valor2)

{
return (valor1 + valor2);
}

}
}

16 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

{
int num1, num2;
string var = "Ejeplo que suma dos numeros";
System.Console.WriteLine("Hola {0}!", var);
Console.WriteLine("ingrese n1");
num1 = int.Parse(Console.ReadLine());

Console.WriteLine("ingrese n2");
num2 = int.Parse(Console.ReadLine());

int resultado = Suma(num1, num2);

System.Console.WriteLine("{0}+{1} = {2}", num1, num2,
resultado);

Console.ReadLine();

staticint Suma(int valor1, int valor2)

{
return (valor1 + valor2);

EXPRESIONES

Expresiones Aritméticas
Las expresiones aritméticas son valores numéricos, de tipos enteros o reales. Pueden ser
constantes, resultados de operaciones aritméticas como sumas o multiplicaciones, contenido
de variables numéricas, o combinaciones de las anteriores unidas mediante operadores
aritméticos.

Operadores binarios:

+ Suma
- Resta
* Multiplicación
/ División
% Módulo (sólo sobre tipos de números enteros)

Operadores unitarios:
- Signo negativo
++ Incremento
-- Decremento
Precedencia:
++ -- -(unitario)
*/%
+-
Asociatividad:
Por la izquierda

17 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Operadores Descripción Tipo Asociativi

dad
(expresión) Control de precedencia Primario Ninguna
objeto.miembro Acceso a miembro de objeto Primario Ninguna
método(argumento, argumento, ...) Enumeración de argumentos Primario Ninguna
array[indice] Elemento de un array Primario Ninguna
var++, var-- Postincremento y postdecremento Primario Ninguna
new Creación de objeto Primario Ninguna
typeof Recuperación de tipo (reflexión) Primario Ninguna
sizeof Recuperación de tamaño Primario Ninguna
checked, unchecked Comprobación de desbordamiento Primario Ninguna
+ Operando en forma original Unitario Ninguna
- Cambio de signo Unitario Ninguna
! Not lógico Unitario Ninguna
~ Complemento bit a bit Unitario Ninguna
++var, --var Preincremente y predecremento Unitario Ninguna
(conversión) var Conversión de tipos Unitario Ninguna
*, / Multiplicación, división Binario Izquierda
% Resto de división Binario Izquierda
+, - Suma, resta Binario Izquierda
<<, >> Desplazamiento de bits Binario Izquierda
<, >, <=, >=, is, ==, != Relacionales Binario Izquierda
& AND a nivel de bits Binario Izquierda
^ XOR a nivel de bits Binario Izquierda
| OR a nivel de bits Binario Izquierda
&& AND lógico Binario Izquierda
|| OR lógico Binario Izquierda
?: QUESTION Binario Izquierda
=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |= De asignación Binario Derecha

Están puestos en orden de precedencia, es decir, en el caso de haber una expresión con varios
de ellos, se ejecutan por ese orden. Ya te explicaré esto con más detalles.

En el caso de “(expresión)”, los operadores son realmente los paréntesis. Sirven para modificar
la precedencia. ¿Qué es eso? Tranquilo, más adelante.

En “objeto.miembro”, el operador es el punto. Sirve para especificar un miembro de una clase

(sea una variable, una propiedad o un método).

En “método(argumento, argumento, ...)”, los operadores vuelven a ser los paréntesis. En este
caso, sirven para especificar la lista de argumentos de un método.

En array[índice], los operadores son los corchetes. Sirven para indicar el elemento de un array
o un indizador.

Los operadores de incremento (++) y decremento (--) sirven para incrementar o disminuir el
valor de una variable en una unidad. Por ejemplo:

18 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

num++;

hará que num incremente su valor en una unidad, es decir, si valía 10 ahora vale 11. Los
operadores de incremento y decremento se pueden poner delante (preincremento ó
predecremento) o bien detrás (postincremento ó postdecremento), teniendo
comportamientos distintos. Me explico: si hay un postincremento o postdecremento, primero
se toma el valor de la variable y después se incrementa o decrementa. En caso contrario, si lo
que hay es un preincremento o un predecremento, primero se incrementa o decrementa la
variable y después se toma el valor de la misma. En una línea como la anterior esto no se ve
claro, porque, además, el resultado sería el mismo que poniendo ++num. Sin embargo, veamos
este otro ejemplo (num vale 10):

a = ++num;
b = a--;

Después de ejecutar la primera línea, tanto a como num valdrían 11,

Ahora bien, después de ejecutar la segunda línea, b valdrá 11, y a valdrá 10. ¿Por qué? Porque
el postdecremento de a hace que primero se asigne su valor actual a b y después se
decremente el suyo propio.

El operador “new” sirve para instanciar objetos.

El operador “typeof” es un operador de reflexión, y la reflexión es la posibilidad de recuperar

información de un tipo determinado en tiempo de ejecución.

“sizeof” devuelve el tamaño en bytes que ocupa un tipo determinado. Ahora bien, solamente
se puede utilizar sizeof con tipos valor y en contextos de código inseguro.

“checked” y “unchecked” sirven para controlar si una expresión provoca o no

desbordamiento. ejemplo: sabemos que las variables de tipo byte pueden almacenar valores
entre 0 y 255. Si escribimos el siguiente código:

byte i=253;
checked {i+=10;}
Console.WriteLine(i);

El programa se compila, pero al ejecutar se produce un error de desbordamiento, ya que la

variable i es de tipo byte y no puede almacenar valores mayores que 255. Sin embargo, si
cambiamos checked por unchecked:

byte i=253;
unchecked {i+=10;}
Console.WriteLine(i);

El programa no produciría error de desbordamiento, ya que unchecked hace que se omitan

estos errores.

las variables numéricas tienen un rango de datos limitado, es decir, una variable de tipo byte,
por ejemplo, no puede almacenar valores menores que 0 ni mayores que 255. Cuando se
trunca el valor, lo que se hace es, colocar seguidos en una lista todos los valores que la variable
acepta, empezando de nuevo por el primero cuando el rango acaba, y después se va
recorriendo esta lista hasta terminar la operación de suma. Como dicho así resulta bastante
ininteligible, fíjate en la siguiente tabla y lo verás enseguida:

19 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

... 250 251 252 253 254 255 0 1 2 3 4 5 6 7 8 9 10 ...

(253 + 10) +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 ...

En la primera fila están la lista de valores que acepta la

variable, y en negrilla el valor que contiene. Como ves, a
continuación del último que acepta vuelve a estar el primero. Al
sumarle 10 (segunda fila) es como si se fueran contando valores
posibles hacia adelante, de modo que i ahora vale 7. Otro
ejemplo usando el tipo sbyte (que acepta valores entre -128 y
127):

sbyte i=126;
unchecked {i+=10;}
Console.WriteLine(i);

... 125 126 127 - - - - - - - - -120 -119 - - ...

128 127 126 125 124 123 122 121 118 117
(126 + 10) +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 ...

De modo que i valdría -120 después de la suma.

Los operadores unitarios + y - sirven sencillamente para mantener o cambiar el signo de un

operando.

int i=10;
int b=-i;
Console.WriteLine("Valor de i: {0} Valor de b: {1}", i, b);

El operador unitario ! es un not lógico, es decir, invierte el valor de un dato de tipo

boolean. En el siguiente ejemplo, i valdría true y b valdría false:

bool i=true;
bool b=!i;

El operador unitario ~ es de complemento a nivel de bits, o sea, que devuelve el valor

complementario al operando al que afecta. Para entender esto usaremos una variable de tipo
int y escribiremos tanto su valor como el de su complementario en hexadecimal:

int i=10;
Console.WriteLine("Valor de i: {0:X8} Valor de ~i: {1:X8}", i,
~i);

La salida en la consola sería la siguiente:

Valor de i: 0000000A Valor de ~i: FFFFFFF5

Como sabes, el número hexadecimal A equivale al 10 en base decimal, por eso escribe A como
valor de i. El número FFFFFFF5 es el complementario en hexadecimal de 10, y en base decimal
equivale a 4294967285. Veamos estos números en código binario (que es como se almacenan
en la memoria):

A: 0000 0000 0000 0000 0000 0000 0000 1010

FFFFFFF5: 1111 1111 1111 1111 1111 1111 1111 0101

20 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

El operador ~ solamente es aplicable a variables de tipo int, uint, long y ulong.

En el operador (conversion), lo que ha de ir entre paréntesis es el tipo al que se quiere

convertir (int), (uint), (long)... Ya lo explicamos con anterioridad cuando hablamos del sistema
de tipos.

Los opeardores * y / son, respectivamente, para multiplicar y dividir. Es muy sencillo. Si, por
ejemplo, tenemos la siguiente expresión: 4*6/2, el resultado sería el que se supone: 12.

El operador % devuelve el resto de una división. Por ejemplo, 8 % 3 devolvería 2.

Los operadores + y – (binarios) son para sumar o restar. 4+7-3 devolvería 8.

Los operadores << y >> efectúan un desplazamiento de bits hacia la izquierda o hacia la
derecha. Ya sé que esto de los bits puede que resulte algo confuso para alguno, así que me
extenderé un poquito. Veamos el siguiente ejemplo, también usando números hexadecimales:

int i = 15;
int b;
int c;
Console.WriteLine("Valor de i: {0:X}", i);
b = i >> 1;
Console.WriteLine("Ejecutado b = i >> 1;");
Console.WriteLine("Valor de b: {0:X}", b);
c = i << 1;
Console.WriteLine("Ejecutado c = i << 1;");
Console.WriteLine("Valor de c: {0:X}", c);

Veamos la salida en la consola y después la examinamos:

Valor de i: F
Ejecutado b = i >> 1;
Valor de b: 7
Ejecutado b = i << 1;
Vaor de b: 1E

Variable Valor hex. Valor binario

i 0000000F 0000 0000 0000 0000 0000 0000 0000 1111
b 00000007 0000 0000 0000 0000 0000 0000 0000 0111
c 0000001E 0000 0000 0000 0000 0000 0000 0001 1110

Como puedes apreciar, a la variable b le asignamos lo que vale i desplazando sus bits hacia la
derecha en una unidad. El 1 que había más a la derecha se pierde. En la variable c hemos
asignado lo que valía i desplazando sus bits hacia la izquierda también en una unidad. Como
ves, el la parte derecha se rellena el hueco con un cero.

Los operadores relacionales < (menor que), > (mayor que), <= (menor o igual que), >= (mayor o
igual que), is, == (igual que), != (distinto de) establecen una comparación entre dos valores y
devuelven como resultado un valor de tipo boolean (true o false). Veamos un ejemplo:

int i;
int b;
Console.Write("Escribe el valor de i: ");
i = Int32.Parse(Console.ReadLine());

21 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.Write("Escribe el valor de b: ");

b = Int32.Parse(Console.ReadLine());

Console.WriteLine("i<b devuelve: {0}", (i < b));

Console.WriteLine("i<=b devuelve: {0}", (i <= b));
Console.WriteLine("i>b devuelve: {0}", (i > b));
Console.WriteLine("i>=b devuelve: {0}", (i >= b));
Console.WriteLine("i==b devuelve: {0}", (i == b));
Console.WriteLine("i!=b devuelve: {0}", (i != b));

Probar la salida. de estas líneas de programa sería la siguiente (en rojo está lo que se ha escrito
durante la ejecución de las mismas):

Escribe el valor de i: 2
Escribe el valor de b: 3
i<b devuelve: True
i<=b devuelve: True
i>b devuelve: False
i>=b devuelve: False
i==b devuelve: False
i!=b devuelve: True

Los operadores & (and a nivel de bits), | (or a nivel de bits) y ^ (xor -o exclusivo- a nivel de bits)
hacen una comparación binaria (bit a bit) de dos números devolviendo el resultado de dicha
comparación como otro número. Vamos con un ejemplo.

int i = 10;
int b = 7;
int res;
res = i & b;
Console.WriteLine("{0} & {1} Dec: {2} Hexad: {3:X}", i, b, res, res);
res = (i | b);
Console.WriteLine("{0} | {1} Dec: {2} Hexad: {3:X}", i, b, res, res);
res = (i ^ b);
Console.WriteLine("{0} ^ {1} Dec: {2} Hexad: {3:X}", i, b, res, res);

La salida en pantalla de este fragmento sería la que sigue:

10 & 7 retorna: Decimal: 2 Hexadecimal: 2

10 | 7 retorna: Decimal: 15 Hexadecimal: F
10 ^ 7 retorna: Decimal: 13 Hexadecimal: D

Fíjate primero en que en ninguno de los casos se ha hecho una suma normal de los dos
números. Veamos estas tres operaciones de un modo algo más claro. Marcaremos en negrilla
los valores que provocan que el bit resultante en esa posición valga 1:

Operación: i & b
Variable Valor dec. Valor hex. Valor binario
i 10 A 0000 0000 0000 0000 0000 0000 0000 1010
b 7 7 0000 0000 0000 0000 0000 0000 0000 0111
Resultado 2 2 0000 0000 0000 0000 0000 0000 0000 0010

Operación: i | b
Variable Valor dec. Valor hex. Valor binario

22 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

i 10 A 0000 0000 0000 0000 0000 0000 0000 1010

b 7 7 0000 0000 0000 0000 0000 0000 0000 0111
Resultado 15 F 0000 0000 0000 0000 0000 0000 0000 1111

Operación: i ^ b
Variable Valor dec. Valor hex. Valor binario
i 10 A 0000 0000 0000 0000 0000 0000 0000 1010
b 7 7 0000 0000 0000 0000 0000 0000 0000 0111
Resultado 13 D 0000 0000 0000 0000 0000 0000 0000 1101

Vamos operación por operación. En la primera de ellas, i & b, el resultado es 0010 porque el
operador & hace una comparación bit a bit, devolviendo uno cuando ambos bits comparados
también valen uno (se ve claramente que tanto para i como para b, el segundo bit por la
derecha vale 1), y 0 cuando alguno de ellos (o los dos) es 0.

En la segunda operación, i | b, el resultado es 1111 porque el operador | devuelve 1 cuando al

menos uno de los bits comparados es 1, y 0 cuando ambos bits comparados son también 0.

En el tercer caso, i ^ b, el resultado es 1101 porque el operador ^ devuelve 1 cuando uno y sólo
uno de los bits comparados vale 1, y cero cuando ambos bits valen 1 o cuando ambos bits
valen 0.

Los operadores && (AND lógico) y || (OR lógico) se ocupan de comparar dos valores de tipo
boolean y retornan como resultado otro valor de tipo boolean.

El operador && devuelve true cuando ambos operandos son true, y false cuando uno de ellos
o los dos son false.

El operador || devuelve true cuando al menos uno de los operandos es true (pudiendo ser
también true los dos), y false cuando los dos operandos son false.

Por ejemplo, la siguiente expresión devolvería true si un número es mayor que 10 y menor que
20:

(num > 10) && (num < 20)

Para que veas otro ejemplo, la siguiente expresión devolvería true si el número es igual a 10 o
igual a 20:

(num == 10) || (num == 20)

El operador ? : (question) evalúa una expresión como true o false y devuelve un valor que se le
especifique en cada caso (Si programabas en Visual Basic, equivale más o menos a la función
iif). Vamos a verlo con un ejemplo:

string mensaje = (num == 10) ? "El número es 10" : "El número no es

10";

int a=5;
int b=a;

23 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

b++;

El resto de operadores de asignación son operadores compuestos a partir de otro operador y

el operador de asignación. Veamos a qué equivalen los operadores *=, /=, %=, +=, -=, <<=, >>=,
&=, ^=, |=

num *= 10; // Equivale a num = num * 10

num /= 10; // Equivale a num = num / 10
num %= 10; // Equivale a num = num % 10
num += 10; // Equivale a num = num + 10
num -= 10; // Equivale a num = num - 10
num<<= 10; // Equivale a num = num << 10
num>>= 10; // Equivale a num = num >> 10
num&= 10; // Equivale a num = num & 10
num ^= 10; // Equivale a num = num ^ 10
num |= 10; // Equivale a num = num | 10

Ejercicio

int a, b, r;

Console.WriteLine("ingrese n1");
a = int.Parse(Console.ReadLine());

Console.WriteLine("ingrese n2");
b = int.Parse(Console.ReadLine());

r = a + b;
Console.WriteLine("el resultado{0} ",r);

Console.ReadLine();
Ejercicio

decimal a, b, r;

Console.WriteLine("ingrese valor 1");

a = decimal.Parse(Console.ReadLine());

Console.WriteLine("ingrese valor 2");

b = decimal.Parse(Console.ReadLine());

r = a * 2 + (b *1/2)*1/3 ;

Console.WriteLine(" resutado{0} ", r);

Console.ReadLine();

24 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

CONSTANTE

Una constante es una variable cuyo valor puede determinar el compilador durante la compilación y
puede aplicar optimizaciones derivadas de ello. Para que esto sea posible se ha de cumplir que el valor
de una constante no pueda cambiar durante la ejecución, por lo que el compilador informará con un
error de todo intento de modificar el valor inicial de una constante. Las constantes se definen como
variables normales pero precediendo el nombre de su tipo del modificador const y dándoles siempre un
valor inicial al declararlas. O sea, con esta sintaxis:

const<tipoConstante><nombreConstante>=<valor>;

Así, ejemplos de definición de constantes es el siguiente:

const int a = 123;

const int b = a + 125;

ESTRUCTURAS DE CONTROL

Estructuras Condicionales

 Simples – Dobles
if(<condicion>){ <instrucciones;>}

else{<instrucciones;> }

25 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

1. Realizar un programa que permita ingresar 2 números y luego reporte dichos números indicando su
condición.

usingSystem;

namespaceEjemplo1

classProgram

publicstatic void Main(string[] args)

int n1,n2;

//Leer Numeros

Console.Write("Numero 1 -> ");

n1 = int.Parse(Console.ReadLine());

Console.Write("Numero 2 -> ");

n2 = int.Parse(Console.ReadLine());

//Evaluar N1

if(n1<0)

Console.WriteLine("Numero: {0}, es negativo",n1);

else if(n1==0)

Console.WriteLine("Numero: {0}, es cero",n1);

else

Console.WriteLine("Numero: {0}, es positivo",n1);

//Evaluar N2

if(n2<0)

Console.WriteLine("Numero: {0}, es negativo",n2);

else if(n2==0)

Console.WriteLine("Numero: {0}, es cero",n2);

else

26 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.WriteLine("Numero: {0}, es positivo",n2);

Console.ReadKey(true); //Hacer Pausa

2. Implementar un programa que permita ingresar 2 nombres y luego reporte quien de ellos tiene la
mayor cantidad de caracteres.

namespace Ejemplo1

class Program

public static void Main(string[] args)

String nom1,nom2;

//Leer Numeros

Console.Write("Primer Nombre -> ");

nom1 = Console.ReadLine();

Console.Write("Segundo Nombre -> ");

nom2 = Console.ReadLine();

//Evaluar N1

if(nom1.Length >nom2.Length)

Console.WriteLine("Nombre 1 tiene Mayor Longitud");

else if(nom1.Length <nom2.Length)

Console.WriteLine("Nombre 2 tiene Mayor Longitud");

else

Console.WriteLine("Nombres tienen igual Longitud");

Console.ReadKey(true); //Hacer Pausa

27 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

 Múltiples

Swith(<expresion>)

case <valor>:

<instrucciones>;

Break;

case <valor>:

<instrucciones>;

Break;

Case else:

<instrucciones>;

Break;

1. Realizar un programa que permita ingresar un número (1 - 12) y luego reporte el mes
correspondiente a dicho número.

using System;

namespace ejemplo2

class Program

public static void Main(string[] args)

int numero;

28 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.Write("Ingrese Numero:");

numero = int.Parse(Console.ReadLine());

switch(numero){

case 1: Console.Write("Enero"); break;

case 2: Console.Write("Febrero"); break;

case 3: Console.Write("Marzo"); break;

case 4: Console.Write("Abril"); break;

case 5: Console.Write("Mayo"); break;

case 6: Console.Write("Junio"); break;

case 7: Console.Write("Julio"); break;

case 8: Console.Write("Agosto"); break;

case 9: Console.Write("Setiembre"); break;

case 10: Console.Write("Octubre"); break;

case 11: Console.Write("Noviembre"); break;

case 12: Console.Write("Diciembre"); break;

Console.ReadKey(true);

Estructuras Repetitivas

 While

Sintaxis

while(<condicion>){

<instrucciones>

29 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

1. Elaborar un programa que reporte los 10 primeros números primos.

using System;

namespace ejemplo3

class Program {

public static void Main(string[] args){

//Reportar los 10 primeros numeros primos

int c=0,i=1,n=1,j=0;

while(j<10){

while(i<=n){

if(n%i==0)c++;

i++;

if(c==2){

Console.WriteLine("Primo[{0}] ->{1}",j+1,n);

j++;

c=0;

n++;

i=1;

Console.ReadKey(true);

30 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

 Do .. While
1. Elaborar un programa que permita ingresar 2 notas y luego reportar el promedio. Las notas deben
estar obligatoriamente en el rango de 0 a 20.

using System;

namespace ejemplo4{

class Program {

public static void Main(string[] args){

int nota1=0, nota2=0;

double promedio=0;

//validar ingreso

do{

Console.Write("Nota 1 -->");

nota1 = int.Parse(Console.ReadLine());

}while(nota1<0 || nota1>20);

do{

Console.Write("Nota 2 -->");

nota2 = int.Parse(Console.ReadLine());

}while(nota2<0 || nota2>20);

promedio = (nota1 + nota2)/2;

Console.Write("Promedio -->{0}",promedio);

Console.ReadKey(true);

 For
1. Elaborar un programa que permita ingresar un nombre y luego reportarlo con letra por letra.

31 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

using System;

namespace ejemplo5

class Program

public static void Main(string[] args)

String nombre="";

Console.Write("Ingrese Nombre -->");

nombre = Console.ReadLine();

//Reportar caracteres

for(int i=0;i<nombre.Length;i++)

Console.WriteLine("Letra -->{0}",nombre.Substring(i,1));

Console.ReadKey(true);

 Foreach
1. Elaborar un programa que permita reportar los datos de un arreglo de enteros.

using System;

namespace ejemplo6

class Program{

public static void Main(string[] args){

int[] num = {10,50,-5,12,60};

foreach(int n in num)

32 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.WriteLine("Elemento -->{0}",n);

Console.ReadKey(true);

 Instrucción Continue

using System;

namespace ejemplo7{

class Program{

public static void Main(string[] args){

int[] num = {1,50,-5,2,60};

for(int i=0;i<num.Length;i++){

if(i==2) continue; //Pasa al siguiente valor

Console.WriteLine("Elemento[{1}] -->{0}",num[i],i+1);

Console.ReadKey(true);

 Instrucción goto

using System;

namespace ejemplo7

class Program

33 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

public static void Main(string[] args)

for(int i=0;i<6;i++){

if(i==3) goto Demo; //Pasa al siguiente valor

Console.WriteLine("Linea {0}",i);

Demo: Console.WriteLine("Ejemplo de Goto");

Console.ReadKey(true);

Ejercicios Propuestos

 Elaborar un programa que permita ingresar 3 edades, y luego determinar el promedio de las edades
que son mayores a 18. Las edades que se ingresan están en el rango de 1 a 100.
 Elaborar un programa que permita realizar las siguientes operaciones:
 Ingresar la cantidad de alumnos mujeres y hombres de un aula. Considerar que las
cantidades pueden ir desde 0 hasta 40.
 Reportar la cantidad total de alumnos.
 Mostrar que porcentaje representa cada cantidad ingresada con respecto al total de
alumnos.
 Elaborar un programa que permita reportar los 5 números menores y mayores de un número
ingresado. Ejemplo: n=10, debe reportar: 5,6,7,8,9,11,12,13,14,15
 Elaborar un programa que permita ingresar un numero natural y luego indicar si se trata de un
numero compuesto.

Matrices (Arreglos)
Los arreglos son estructuras de datos complejas (en el sentido de que no son atómicas) que
agrupan datos de un mismo tipo en particular, llamado el tipo base del arreglo. El tipo base de
un arreglo puede ser cualquiera de los tipos básicos de C#, o incluso algunos tipos complejos
como las clases.
Un arreglo es también ejemplo de un modelo. Un arreglo puede considerarse como ejemplo
de una variable compuesta capaz de almacenar uno o más datos al mismo tiempo.

34 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Una matriz de cinco elementos enteros se puede declarar como se muestra en el ejemplo
siguiente:

La sintaxis del lenguaje permite referirse a cada uno de los elementos que constituyen el
arreglo empleando índices. Esto es posible pues los elementos del arreglo están numerados
en forma jerárquica y consecutiva, empezando en 0 en cada dimensión.
El siguiente gráfico ilustra un ejemplo de un arreglo llamado números, cuya posición 0
almacena el valor 10, la posición 1 el valor de 21, etc. Este arreglo en total almacena n+1
elementos. El valor de n, depende de la memoria que pueda tener el computador y el tipo de
elementos que se almacenen en el arreglo.

Sintaxis:

35 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Arreglos unidimensionales
Los arreglos, al igual que las demás variables deben declararse antes de poder utilizarlas, y
cumplen con las mismas reglas de alcance y vida.

Los arreglos de una sola dimensión reciben también el nombre de vectores. La sintaxis de la
declaración de un arreglo unidimensional es la siguiente:

<tipo-base>[] <identificador>;

Ejemplo:

// Arreglo para 10 enteros

int[] numeros;
numeros = newint[10];

// Arreglo para 10 enteros

int[] numeros = newint[10];

// Arreglo para 10 enteros

int[] numeros = { 1, 1, 1, 2, 3, 5, 2, 5, 3, 4 };

Ejemplo a

int[] numeros = { 1, 2, 3, 4, 5, 6 };
Console.Write("imprime {0}", numeros[1]);
Console.ReadLine();

Uso de Arreglos Unidimensionales

Los elementos de un arreglo son variables del tipo base del vector, por lo que se utilizan de la
misma manera en expresiones y demás instrucciones, como la asignación. Por ejemplo, para
asignar un valor a un elemento de un arreglo basta con escribir:

<arreglo>[indice] = <expresion>;

Donde <arreglo> es el nombre de la variable e indice hace referencia a la posición del

elemento al que se le quiere asignar el <expresion>. La referencia de valores en un arreglo,
se indexa desde el 0 al N-1.

Importante: Puesto que los arreglos son estructuras complejas (es decir, no básicas), no
es posible asignar un arreglo a otro mediante una simple asignación (=). Para hacer esto es
necesario escribir un ciclo y asignar elemento a elemento.

Como se mencionó anteriormente, el lenguaje C# no controla la validez de los índices que se

emplean para referenciar un arreglo. Esto quiere decir que es posible cometer errores muy
difíciles de detectar en este sentido. Es necesario prestar especial interés a los valores que
toman los índices para evitar estos problemas.

Por ejemplo, la siguiente porción de código compila sin problemas (es decir, sin errores
sintácticos), pero probablemente produzca un error en tiempo de ejecución al referenciarse
posiciones inexistentes del arreglo.

36 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

// Las posiciones con índices del 10 al 19 son inválidas.

int[] arreglo = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; // 10
elementos
int i;
for (i = 0; i < 20; i++)
arreglo[i] = 0; // Error para i >= 10

También es común cometer estos errores olvidando que las posiciones de los arreglos están
numeradas a partir del índice cero. Es decir, en un arreglo de tamaño N las posiciones están
numeradas de 0 a N-1.

Funciones más comunes con arreglos

En C#, los arreglos se representan con un tipo específico, y por ello cuentan con sus propios
atributos y métodos específicos. Por ejemplo, para obtener el largo (la cantidad de elementos
dimensionados) de un arreglo, o para ordenarlo.

El Largo de un Arreglo
En el caso de los arreglos unidimensionales, el tamaño o cantidad de elementos se obtiene con
la propiedad Length.

int [] numeros = { 1,2,3,4,5,6 }

Console.WriteLine(“Largo: {0}”, numeros.Length);

Ordenamiento de un Arreglo
En el caso de los arreglos que sean de uno de los tipos predefinidos (int, float, char, etc.), es
factible ordenarlos en forma creciente, aprovechando el método básico Sort() de la clase
Array:

int[] numeros = { 4, 5, 2, 3, 1, 6 };
Array.Sort(numeros); // 1,2,3,4,5,6

Revertir el Orden de un Arreglo

En el mismo caso en que se pueda ordenar un arreglo, se puede reordenar exactamente al
revés de cómo está, aprovechando el método básico Reverse() de la clase Array:

int[] numeros = { 1, 2, 3, 4, 5, 6 };
Array.Reverse(numeros); // 6,5,4,3,2,1

Ejemplo de Manipulación de Arreglos

Hacer la sumatoria de los elementos de un arreglo.

int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int total = 0;
for (int i = 0; i < a.Length; i++)
total += a[i];
Console.WriteLine("Suma de todos los elementos del array: " + total);

Console.ReadLine();

37 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Crear un histograma (barras a base de asteriscos) a partir de unos datos.

int[] n = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };

//usamos \t para dar tab

string salida = "Elemento\tValor\tHistograma\n";
// construir salida
for (int i = 0; i < n.Length; i++)
{
salida += "\n" + i + "\t\t\t" + n[i] + "\t\t";
for (int j = 1; j <= n[i]; j++) // imprimir una barra
salida += "*";
}
Console.WriteLine(salida);

Console.ReadLine();

Esta matriz contiene elementos desde array[0] hasta array[4]. El operador new se utiliza para
crear la matriz e inicializar sus elementos con valores predeterminados. En este ejemplo, todos
los elementos de la matriz se inicializan con cero.

Una matriz que almacena elementos de cadena se puede declarar del mismo modo. Por
ejemplo:

Sintaxis
string[] stringArray = newstring[6];

Inicialización de matrices
Es posible inicializar una matriz en el momento de su declaración, en cuyo caso, no es
necesario el especificador de rango ya que éste viene dado por el número de elementos de la
lista de inicialización. Por ejemplo:

Sintaxis
int[] array1 = newint[5] { 1, 3, 5, 7, 9 };

Una matriz de cadena se puede inicializar del mismo modo. A continuación, se muestra una
declaración de una matriz de cadena en la que cada elemento de la matriz se inicializa con el
nombre de un día de la semana:

Sintaxis

string[] weekDays = newstring[] { "Sun", "Mon", "Tue", "Wed", "Thu",

"Fri", "Sat" };

Cuando se inicializa una matriz en el momento de su declaración, se pueden utilizar los

siguientes métodos abreviados:

Sintaxis

38 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

int[] array2 = { 1, 3, 5, 7, 9 };
string[] weekDays2 = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};

Es posible declarar una variable de matriz sin inicializarla, pero se debe utilizar el operador
new al asignar una matriz a esta variable. Por ejemplo:

Sintaxis

int[] array3;
array3 = newint[] { 1, 3, 5, 7, 9 }; // OK
//array3 = {1, 3, 5, 7, 9}; // Error

Matrices de tipo de valor y tipo de referencia

Considere la siguiente declaración de matriz:

Sintaxis

SomeType[] array4 = new SomeType[10];

El resultado de esta instrucción depende de si SomeType es un tipo de valor o un tipo de

referencia. Si es un tipo de valor, la instrucción genera una matriz de 10 instancias del tipo
SomeType. Si SomeType es un tipo de referencia, la instrucción crea una matriz de 10
elementos, cada uno de los cuales se inicializa con una referencia nula.

Ejemplo Matriz

string[,] abecedario = { { "A", "B", "C", "D", "E" }, { "F", "G", "O",
"I", "J" }, { "T", "L", "U", "M", "N" } };
Console.Write("imprime {0}", abecedario[1, 4]);

Ejemplo usando Arreglos con FOR

int []nota=newint[5];

for(int i=0; i<nota.Length;i++)

{

do
{
Console.Write("nota[{0}]",i);
nota[i]=int.Parse(Console.ReadLine());

} while(nota[i]<0||nota[i]>20);

for(int i=0; i<nota.Length;i++)

{
if(nota[i]>10)

Console.WriteLine("nota:{0}",nota[i]);

39 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.ReadLine();

Ejercicico

Elaborar un programa que permita inicializar un arreglo con los nombres de países y luego
reportarlos.

Arreglos

1. Elaborar un programa que permita:

a. Registrar los nombres de 5 cursos.
b. Reportar los totales ordenados alfabéticamente ascendentemente.

Solución:

using System;

namespace Ejemplo1{

class Program{

40 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

public static void Main(string[] args){

string [] curso = new string[5];

string aux="";

//ingreso de datos

for(int i=0;i<curso.Length;i++){

Console.Write("Curso[{0}]:",i);

curso[i]=Console.ReadLine();

//ordenar cursos ascendente

for(int i=0;i<curso.Length;i++){

for(int j=0;j<curso.Length - 1;j++){

if(curso[j].CompareTo(curso[j+1])>0){

aux= curso[j];

curso[j] = curso[j+1];

curso[j+1] = aux;

Console.WriteLine("Cursos Ordenados");

Console.WriteLine("================");

for(int i=0;i<curso.Length;i++)

Console.WriteLine("{0}",curso[i]);

Console.ReadKey(true);

Ejercicios Propuestos

41 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

 Elaborar un programa que permita ingresar un numero expresado en segundos, luego

debe reportar el numero de horas, minutos y segundos. Ejemplo: numero=3662, debe
reportar horas=1, minutos=1 y segundos=2.
 Elaborar un programa que permita ingresar 3 edades, y luego determinar el promedio de
las edades que son mayores a 18. Las edades que se ingresan están en el rango de 1 a
100.
 Elaborar un programa que permita realizar las siguientes operaciones:
 Ingresar la cantidad de alumnos mujeres y hombres de un aula. Considerar
que las cantidades pueden ir desde 0 hasta 40.
 Reportar la cantidad total de alumnos.
 Mostrar que porcentaje representa cada cantidad ingresada con respecto al
total de alumnos.
 Elaborar un programa que permita reportar los 5 números menores y mayores de un
número ingresado. Ejemplo: n=10, debe reportar: 5,6,7,8,9,11,12,13,14,15
 Elaborar un programa que permita ingresar un numero natural y luego indicar si se trata
de un numero compuesto.
 Elaborar un programa que permita:
1. Registrar 10 con números.
2. Calcular el promedio de los números.
3. Reportar la cantidad de números son mayores que el promedio y cuantos
menores o iguales.
 Hacer un programa que permita:
1. Registrar las edades 5 alumnos en un Arreglo llamado A.
2. Registrar las edades 5 alumnos en un Arreglo llamado B.
3. Generar un Arreglo llamado C, dado por la suma del primer valor de „A‟ mas
el último de „B‟; el segundo valor de „C‟ será el segundo de „A‟ mas el
penúltimo de „B‟; y así sucesivamente.
4. Finalmente deberán imprimirse los tres vectores.

OPERACIONES CON ARREGLOS

Las operaciones que se pueden realizar con arreglos durante el proceso de resolución de
un problema son:

1. Asignación
Nombres [5] = “Ana”;

Asigna el valor ‘Ana’ al elemento 8 del vector Nombres

2. Lectura/Escritura
La Lectura/Escritura de datos en un arreglo u operaciones de entrada/salida
normalmente se realizan con estructuras repetitivas, aunque puede también hacerse
con estructuras selectivas. Las instrucciones simples de lectura/escritura se
representarán como:

Console.WriteLine (“Nombre:{0}”, Nombres [5]);

42 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Lee el elemento 5 del vector Nombres

3. Recorrido (acceso secuencial)

Se puede acceder a los elementos de un vector para introducir datos (escribir) en el o
bien para visualizar su contenido (leer). Estas operaciones se realizan utilizando
estructuras repetitivas, cuyas variables de control se utilizan como subíndices del
vector. El incremento del contador del bucle producirá el tratamiento sucesivo de los
elementos del vector.

Ejemplo:

Lectura de 15 valores enteros de un vector denominado TOTAL.

int [ ] TOTAL= new int [15]

For (int i=0; i<TOTAL.Length; i++)

Console.WriteLine (“Valor:{0}”, TOTAL[i]);

4. Actualizar (añadir, borrar, insertar)

Puede constar de tres operaciones más elementales:

 Añadir elementos (añade un nuevo elemento al final del vector)

Un arreglo A se ha dimensionado a 6 elementos, pero solo se han asignado 4
valores a los elementos A(1), A(2), A(3), A(4), se podrán añadir dos elementos
más con una simple acción de asignación.

A [5] = 15; A [6] = 9;

 Insertar elementos (introduce un elemento en el interior de un vector)

Ejemplo: Se tiene un arreglo N de 6 elementos de nombres de personas y se
desea insertar un nuevo nombre, según una posición indicada.

namespace arreglos

classEjemplo3

publicstaticvoidMain(string[] args)

//Declaracion de Arreglos

43 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

string[] nombre = newstring[6]; //arreglo de 6 elementos

int pos = -1, index = 0;

console.WriteLine(“ingrese por favor 4 edades”);

for (int i = 0; i < 4; i++)

Console.Write("Edad[{0}]:", i);

nombre[i] = Console.ReadLine();

index = 4;

//Reporte de Datos

Console.WriteLine("-----------------------------");

for (int i = 0; i < index; i++)

Console.WriteLine("Nombre:{0}", nombre[i]);

Console.WriteLine("-----------------------------");

Console.WriteLine(“Por favor solo puede ingresar posiciones o

numeros 0,1,2,3”);

//Insertar Elemento

do

Console.Write("Posicion a Insertar:");

pos = int.Parse(Console.ReadLine());

} while (pos < 0 || pos > nombre.Length);

Console.Write("Nombre:");

string aux = Console.ReadLine();

for (int i = index + 1; i >= pos; i--)

nombre[i] = nombre[i - 1];

nombre[pos] = aux;

44 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

//Reporte de Datos

index++;

Console.WriteLine("-----------------------------");

for (int i = 0; i < index; i++)

Console.WriteLine("Nombre:{0}", nombre[i]);

Console.ReadKey(true);

TEMA: MÉTODOS

Los métodos, también llamados funciones, son trozos de código que reciben unos datos, hacen
algo con esos datos, y a veces devuelven algún valor. En C#, todos los métodos se encuentran
contenidos dentro de una clase.

La estructura mínima de un método tiene las siguientes partes:

o Static (opcional, si se indica se podrá llamar al método sin tener creada una instancia, o lo
que es lo mismo, un objeto de la clase que contiene el método)
o Visibilidad del método (public, protected, private)

45 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

o Tipo devuelto (opcional, puede no devolver nada, en cuyo caso se indica con la palabra
clave void)
o Nombre del método
o Parámetros (puede ser vacío)
o Cuerpo del método

De forma que el siguiente método:

double Divide(double a, double b)

return a / b;

Devuelve un tipo double, tiene por nombre Divide, los parámetros son a y b, ambos del tipo
double, y el cuerpo del método es simplemente "return a/b;". Para llamar a un método,
debemos simplemente poner el nombre del método y sus argumentos dentro de un paréntesis
separado por comas. Para llamar al método Divide declarado antes, simplemente debemos
escribir Divide(8, 2);

Según lo que hemos visto, el ejemplo del método Divide() completo necesita tener una clase
donde definirse y un método Main() donde ejecutarse.

classEjemplo1

publicdouble Divide(double a, double b) //No es static

return a / b;

publicstaticvoidMain()

Ejemplo1 m = newEjemplo1();//Instancia

Console.WriteLine(m.Divide(8, 2)); //Notese “m.”

Console.ReadKey(true);

46 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

El mismo ejemplo sin usar instancia:

classEjemplo2

publicstaticdouble Divide(double a, double b) //Si es

static

return a / b;

publicstaticvoidMain()

Console.WriteLine(Divide(6, 2)); //Consumo directo

Console.ReadKey(true);

Pasando valores a los métodos:

PARÁMETROS

La declaración formal de parámetros también define variables. Hay cuatro tipos de parámetros:
parámetros por valor, por referencia, parámetros de salida, y arreglos de parámetros.

1. Paso por valor, El paso de parámetros por valor es usado por defecto para pasar
parámetros a métodos. Cuando se pasa un parámetro por valor a una función realmente se
está pasando una copia de dicho parámetro, por lo que las modificaciones que le hagamos
al parámetro dentro del método no afectarán al parámetro original.

Ejemplo:

47 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

classEjemplo3

staticvoid F(int p)

p++;

Console.WriteLine("p = {0}", p);

staticvoidMain()

int a = 1;

Console.WriteLine("pre: a = {0}", a);

F(a);

// a no cambia:

Console.WriteLine("post: a = {0}", a);

Console.ReadKey(true);

Aunque el valor del parámetro p haya sido modificado dentro del método, éste parámetro
solamente tenía una copia del valor del parámetro a que pasamos al método; por lo que
cuando imprimimos el parámetro a vemos que éste parámetro ha mantenido su valor
original.

2. Paso por referencia, El paso de parámetros por referencia es la contraposición lógica al paso
por valor. En el paso por referencia no se realiza ninguna copia del objeto, sino que lo que
se le pasa a la función es una referencia del objeto, de forma que el parámetro pasa
directamente a la función y cualquier modificación sobre el parámetro dentro de la función
afectará al parámetro original.

Ejemplo:

classEjemplo4

staticvoid intercambiar(refint a, refint b)

48 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

// intercambia los dos valores

int t = a;

a = b;

b = t;

staticvoid Main()

int x = 1;

int y = 2;

Console.WriteLine("antes: x = {0}, y = {1}", x, y);

intercambiar(ref x, ref y);

//x e y cambian:

Console.WriteLine("despues: x = {0}, y = {1}", x, y);

Console.ReadKey(true);

La palabra clave ref debe de ser usada tanto en la declaración formal de la función como en
los usos que se hace de ésta.

3. Parámetro de salida, El parámetro de salida es similar al parámetro por referencia, salvo

que el valor inicial de dicho argumento carece de importancia. Un argumento de salida se
declara con el modificador out.

Ejemplo:

classEjemplo5

staticvoid Divide(int N1, int N2, outint result, outint

resid)

49 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

//Parámetros de salida: result , resid

result = N1 / N2;

resid = N1 % N2;

staticvoidMain()

int N1 = 10;

int N2 = 3;

int D, R;

//Uso de operadores out:

Divide(N1, N2, out D, out R);

Console.WriteLine("\n");

Console.WriteLine("\tDivisión: {0} / {1} = {2}", N1,

N2, D);

Console.WriteLine("\tResiduo : {0} % {1} = {2}", N1,

N2, R);

Console.ReadKey(true);

En el ejemplo anterior se muestra un método Divide que incluye dos parámetros de salida.
Uno para el resultado (variable: result) de la división y otro para el resto (variable:resid).
Vemos que estos resultados son asignados a las variables: respuesta y residuo,
respectivamente.

50 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

4. Arreglo de parámetros, Habrá ocasiones que necesitemos pasar varios parámetros a un

método (o función) pero no sabemos con anticipación cuántos parámetros tendremos que
pasar; para esto podremos usar un arreglo de parámetros. Un arreglo de parámetros
permite guardar una relación de varios a uno: varios argumentos pueden ser representados
por un único arreglo de parámetros. En otras palabras, los arreglos de parámetros permiten
listas de argumentos de tamaño variable. Un arreglo de parámetros se declara con el
modificador params. Sólo puede haber un arreglo de parámetros en cada método, y
siempre debe ser el último parámetro especificado. El tipo del arreglo de parámetros debe
ser siempre un tipo arreglo unidimensional. Al llamar a la función se puede pasar uno o
varios argumentos del tipo del arreglo.

Ejemplo:

classEjemplo6

//Metodo con arreglo de parametros

staticint sumaDatos(paramsint[] d)

int s = 0;

foreach (int n in d)

s = s + n;

return s;

publicstaticvoidMain(string[] args)

Console.WriteLine("La suma es:{0}", sumaDatos(10, 20,

30));

Console.ReadKey(true);

Modificadores:

51 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

PUBLIC Y STATIC

El modificador public lo hemos utilizado anteriormente. Se puede utilizar en la declaración de

cualquier método o variable, y como es de esperar, produce el efecto de que el campo afectado
se vuelve público, esto es, se puede utilizar desde otras clases.

Ejemplo:

classPrincipal

//Este método no es static...

publicdouble Divide(double a, double b)

return a / b;

publicstaticvoidMain()

//...es necesario instanciar

Principal m = newPrincipal();

Console.WriteLine(m.Divide(8, 2));//=4

Console.ReadKey();

Si por ejemplo intentamos declarar el método Divide sin el modificador public, obtendremos
un error en tiempo de compilación. El modificador complementario de public es private, que
provoca que el método o dato solo sea accesible desde la clase en la que está declarado. Si no se
especifica nada, se toma por defecto el modificador private.

Además, tampoco es necesario crear una instancia de la clase sólo para acceder a un método
declarado en ella. Para eso debemos anteponer a la declaración del método el modificador
static. Los métodos estáticos se caracterizan por no necesitar una instancia de la clase para
cumplir su función, pero como contrapartida, no pueden acceder a datos propios de la clase.

52 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Ejemplo:

classPrincipal

//Este metodo es static...

publicstaticdouble Divide(double a, double b)

return a / b;

publicstaticvoidMain()

//...no es necessario instanciar:

Console.WriteLine(Divide(8, 2));//=4

Los métodos estáticos se utilizan en multitud de situaciones. Por ejemplo, el método

Console.WriteLine() o las funciones de la librería matemática estándar no son más que métodos
estáticos de sus respectivas clases.

Constructores e instancias de una clase:

NEW

Como hemos visto, las instancias de una clase se crean con la sintaxis:

<nombre clase><nombre del objeto> = new <nombre clase> (<argumentos>);

Donde nombre clase es el nombre que le hemos dado a la definición de la clase, argumentos es
una lista de argumentos posiblemente vacía y objeto es el nombre que queremos darle a

53 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

lainstancia de la clase. Una vez creada una clase, sus miembros se inicializan a sus valores
predeterminados (cero para valores numéricos, cadena vacía para el tipo string, etc.).

Ejemplo: La siguiente clase representa un punto sobre el plano, de forma que tiene dos valores
públicos X e Y, y un método que calcula la distancia al origen del punto (módulo):

//Definiremos una clase punto y una clase principal:

classPunto

publicdouble X;

publicdouble Y;

publicdouble Modulo()//MODULO

double d;

d = Math.Sqrt(X * X + Y * Y); //Sqrt = raiz cuadrada

//Formula matematica: D^2 = X^2 + Y^2

return d;

classPrincipal

publicstaticvoidMain()

//Instancia: uso de new

Punto A = newPunto();

A.X = 3;

A.Y = 4;

Console.WriteLine("El modulo del punto ({0},{1}) es:

{2}", A.X, A.Y, A.Modulo());

Console.ReadKey();

54 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Ahora bien, la forma en la que se crea la instancia, es decir, inicializando los datos a cero
(ejercicio: comprobar esto), se puede personalizar, de forma que podemos construir nuestro
propio constructor que le diga a la clase los valores por defecto que debe tomar. Esto se realiza
simplemente escribiendo dentro de la clase un método que tenga el mismo nombre que la clase
y en el que no se especifica el valor devuelto. La clase Punto con un constructor sería así:

Ejemplo:

classPunto

publicdouble X;

publicdouble Y;

public Punto()

//constructor valores por defecto:

X = 1;

Y = 1;

publicdouble Modulo()

double d;

d = Math.Sqrt(X * X + Y * Y); //Sqrt = raiz cuadrada

return d;

publicstaticvoidMain()

//Instancia: uso de new

Punto A = newPunto();

55 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

//...no asignamos nada a A.X ni a A.Y...

Console.WriteLine("El modulo del punto ({0},{1}) es: {2}",

A.X, A.Y, A.Modulo());

Console.ReadKey();

El mismo ejemplo pero asignando valores a X e Y:

classPunto

publicdouble X;

publicdouble Y;

public Punto()

//constructor

X = 1;

Y = 1;

publicdouble Modulo()

double d;

56 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

d = Math.Sqrt(X * X + Y * Y); //Sqrt = raiz cuadrada

return d;

publicstaticvoidMain()

//Instancia: uso de new

Punto A = newPunto();

//Ahora si asignamos valores:

A.X = 3;

A.Y = 4;

Console.WriteLine("El modulo del punto ({0},{1}) es: {2}",

A.X, A.Y, A.Modulo());

Console.ReadKey();

using System;

using System.Collections.Generic;

using System.Text;

namespace ConsoleApplication2

/*1. Elaborar un programa que cumplan con los siguientes requerimientos:

57 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

*o Ingresar 3 notas. Debe estar en el rango de 0 a 20. Implementar un

método.

*o Elaborar métodos para:

* Sumar las notas.

* Calcular el promedio.

* Obtener la nota mayor.

* Obtener la nota menor.

*/

//...................(METODOS)..............................

publicclassALUMNADO

publicstaticvoid NOTAS(outint N1, outint N2, outint N3)

do

Console.Write("Ingrese primera nota : ");

N1 = int.Parse(Console.ReadLine());

} while (N1 < 0 || N1 > 20);

do

Console.Write("Ingrese segunda nota : ");

N2 = int.Parse(Console.ReadLine());

} while (N2 < 0 || N2 > 20);

do

Console.Write("Ingrese tercera nota : ");

N3 = int.Parse(Console.ReadLine());

} while (N3 < 0 || N3 > 20);

58 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

publicstaticint SUMA(int N1, int N2, int N3)

int Suma;

Suma = N1 + N2 + N3;

return Suma;

publicstaticdouble PROM_NOTAS(int N1, int N2, int N3)

double PROM;

PROM = (ALUMNADO.SUMA(N1, N2, N3)) / 3;

return PROM;

publicstaticint NOTA_MAYOR(int N1, int N2, int N3)

int MAYOR;

if (N1 > N2)

if (N1 > N3)

MAYOR = N1;

else

//N3<N1

MAYOR = N3;

else

//N2<N1

if (N3 > N2)

59 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

MAYOR = N3;

else

MAYOR = N2;

return MAYOR;

publicstaticint NOTA_MENOR( int N1, int N2, int N3)

int MENOR;

if (N1 < N2)

if (N1 < N3)

MENOR = N1;

else

//N3 < N1

MENOR = N3;

else

//N2<N1

if (N3 < N2)

60 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

MENOR = N3;

else

//N2 < N3

MENOR = N2;

return MENOR;

classProgram

staticvoid Main(string[] args)

int NOTA1 = 0, NOTA2 = 0, NOTA3 = 0;

ALUMNADO.NOTAS(out NOTA1, out NOTA2, out NOTA3);

Console.WriteLine("LA SUMA DE NOTAS ES :{0}", ALUMNADO.SUMA(NOTA1, NOTA2,

NOTA3));

Console.WriteLine("EL PROMEDIO :{0}", ALUMNADO.PROM_NOTAS(NOTA1, NOTA2,

NOTA3));

Console.WriteLine("LA MAYOR NOTA ES :{0}", ALUMNADO.NOTA_MAYOR(NOTA1, NOTA2,

NOTA3));

Console.WriteLine("LA MENOR NOTA ES : {0}",

ALUMNADO.NOTA_MENOR(NOTA1,NOTA2,NOTA3));

Console.ReadKey(true);

61 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Ejercicios propuestos

1. Elaborar un programa que cumplan con los siguientes requerimientos:

o Ingresar 3 notas. Debe estar en el rango de 0 a 20. Implementar un
método.
o Elaborar métodos para:
 Sumar las notas.
 Calcular el promedio.
 Obtener la nota mayor.
 Obtener la nota menor.

Solución 1:

namespace Lab_metodos

class Program

//Metodo con parametros de Ingreso

public static void ingresar(out int n1, out int n2, out int n3){

do{

Console.Write("Nota 1:");

n1 = int.Parse(Console.ReadLine());

}while(n1<0||n1>20);

do{

Console.Write("Nota 2:");

n2 = int.Parse(Console.ReadLine());

}while(n2<0||n2>20);

do{

Console.Write("Nota 3:");

n3 = int.Parse(Console.ReadLine());

}while(n3<0||n3>20);

62 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

//Metodo con arreglo de parametros

public static int sumar(params int[] n){

int s=0;

foreach(int item in n)

s=s+item;

return s;

//Promedio

public static double promedio(int s,int n){

return s/n;

//Mayor

public static int mayor(params int[] n){

int m=0;

foreach(int item in n)

m = Math.Max(m,item);

return m;

//Menor

public static int menor(params int[] n){

int m=21;

foreach(int item in n)

m = Math.Min(m,item);

return m;

//-------------------------------------------

public static void Main(string[] args){

63 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

int a,b,c;

ingresar(out a,out b,out c);

//Reporte de datos

Console.WriteLine("Suma es:{0}",sumar(a,b,c));

Console.WriteLine("Promedio es:{0}",promedio(sumar(a,b,c),3));

Console.WriteLine("Nota Mayor es:{0}",mayor(a,b,c),3);

Console.WriteLine("Nota Menor es:{0}",menor(a,b,c),3);

Console.ReadKey(true);

Solución 2:

using System;

namespace lab_metodos_01_b

class Program{

//ingreso

public static int[] ingreso(int n){

int[] v = new int[n];

for(int i=0;i<v.Length;i++){

do{

Console.Write("Nota[{0}] -->",i+1);

v[i]= int.Parse(Console.ReadLine());

}while(v[i]<0 || v[i]>20);

return v;

//suma

public static int suma(int[] n){

64 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

int s=0;

foreach(int nota in n)

s = s+nota;

return s;

//promedio

public static double promedio(int n, int c){

return n/c;

//mayor

public static int mayor(int[] n){

int m=0;

foreach(int nota in n)

m = Math.Max(m,nota);

return m;

//menor

public static int menor(int[] n){

int m=21;

foreach(int nota in n)

m = Math.Min(m,nota);

return m;

//-----

public static void Main(string[] args){

int[] notas = new int[3];

notas = ingreso(notas.Length);

Console.WriteLine("Suma -->{0}",suma(notas));

Console.WriteLine("Promedio --
>{0}",promedio(suma(notas),notas.Length));

Console.WriteLine("Mayor -->{0}",mayor(notas));

65 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.WriteLine("Menor -->{0}",menor(notas));

Console.ReadKey(true);

2. Elaborar un programa que permita ingresar 3 valores (numéricos o cadenas). Luego

debe implementar un método que permita ordenar los valores en orden ascendente o
descendente, según el parámetro enviado. Considere la posibilidad de aplicar sobrecarga
de métodos.

namespace ConsoleApplication1{

classProgram{

publicstaticvoid ingresar(outstring a, outstring b, outstring c)

Console.Write("Valor 1 -->");

a = Console.ReadLine();

Console.Write("Valor 2 -->");

b = Console.ReadLine();

Console.Write("Valor 3 -->");

c = Console.ReadLine();

publicstaticvoid ordenar(int a, int b, int c, char t)

int m1 = 0, m2 = 0, m3 = 0;

switch (t)

case'D':

if (a > b && a > c)

m1 = a;

66 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

if (b > c) { m2 = b; m3 = c; }

else { m2 = c; m3 = b; }

if (b > a && b > c)

m1 = b;

if (a > c) { m2 = a; m3 = c; }

else { m2 = c; m3 = a; }

if (c > b && c > a)

m1 = c;

if (a > b) { m2 = a; m3 = b; }

else { m2 = b; m3 = a; }

break;

case'A':

if (a < b && a < c)

m1 = a;

if (b < c) { m2 = b; m3 = c; }

else { m2 = c; m3 = b; }

if (b < a && b < c)

m1 = b;

if (a < c) { m2 = a; m3 = c; }

else { m2 = c; m3 = a; }

if (c < b && c < a)

m1 = c;

67 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

if (a < b) { m2 = a; m3 = b; }

else { m2 = b; m3 = a; }

break;

Console.WriteLine("Ordenados {0},{1},{2}", m1, m2, m3);

Console.ReadKey(true);

publicstaticvoid ordenar(string a, string b, string c, char t)

string m1 = "", m2 = "", m3 = "";

switch (t)

case'D':

if (a.CompareTo(b) > 0 && a.CompareTo(c) > 0)

m1 = a;

if (b.CompareTo(c) > 0) { m2 = b; m3 = c; }

else { m2 = c; m3 = b; }

if (b.CompareTo(a) > 0 && b.CompareTo(c) > 0)

m1 = b;

if (a.CompareTo(c) > 0) { m2 = a; m3 = c; }

else { m2 = c; m3 = a; }

if (c.CompareTo(b) > 0 && c.CompareTo(a) > 0)

m1 = c;

if (a.CompareTo(b) > 0) { m2 = a; m3 = b; }

else { m2 = b; m3 = a; }

68 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

break;

case'A':

if (a.CompareTo(b) < 0 && a.CompareTo(c) < 0)

m1 = a;

if (b.CompareTo(c) < 0) { m2 = b; m3 = c; }

else { m2 = c; m3 = b; }

if (b.CompareTo(a) < 0 && b.CompareTo(c) < 0)

m1 = b;

if (a.CompareTo(c) < 0) { m2 = a; m3 = c; }

else { m2 = c; m3 = a; }

if (c.CompareTo(b) < 0 && c.CompareTo(a) < 0)

m1 = c;

if (a.CompareTo(b) < 0) { m2 = a; m3 = b; }

else { m2 = b; m3 = a; }

break;

Console.WriteLine("Ordenados {0},{1},{2}", m1, m2, m3);

Console.ReadKey(true);

publicstaticint menu() {

int r=0;

do{

Console.Clear();

Console.WriteLine("Menu Opciones");

Console.WriteLine("-------------");

69 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.WriteLine("[1] Ingreso");

Console.WriteLine("[2] Ordenar Numeros");

Console.WriteLine("[3] Ordenar Cadenas");

Console.WriteLine("[4] Salir");

Console.Write("Opcion -->");

r = int.Parse(Console.ReadLine());

} while(r<1 || r>4);

return r;

publicstaticvoidMain(string[] args)

string v1="", v2="", v3="";

int r = 0;

char op=' ';

do

r = menu();

switch (r) {

case 1:

ingresar(out v1, out v2, out v3); break;

case 2:

//Ordenar Nros

Console.Write("Ordenar ASC / DESC -->");

op = char.Parse(Console.ReadLine());

ordenar(int.Parse(v1), int.Parse(v2),

int.Parse(v3), op); break;

case 3:

//Ordenar Cadenas

Console.Write("Ordenar [A]SC / [D]ESC -->");

op = char.Parse(Console.ReadLine());

ordenar(v1, v2, v3,op); break;

70 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

}while(r!=4);

Console.ReadKey(true);

3. Desarrolle un programa que encuentre todos los números primos menores que un
número ingresado. Implementar un método de clase.
4. Elaborar una aplicación para procesar información de un artículo. Considere los
siguientes datos como: descripción, Stock y precio. Elabore los métodos para aumentar
o disminuir el precio y el stock.

TEMA: PROGRAMACION ORIENTADA A OBJETOS

La programación orientada a objetos, intenta simular el mundo real a través del significado
de objetos que contiene características y funciones. Los lenguajes orientados a objetos se
clasifican como lenguajes de quinta generación. Como su mismo nombre indica, la
programación orientada a objetos se basa en la idea de un objeto, que es una combinación
de atributos y métodos que juntos conforman una entidad de programación.

Objeto

Un objeto es una agrupación de código, compuesta de propiedades y métodos, que pueden

ser manipulados como una entidad independiente. Las propiedades definen los datos o
información del objeto, permitiendo consultar o modificar su estado; mientras que los
métodos son las rutinas que definen su comportamiento.

Clase

Una clase no es otra cosa que el conjunto de especificaciones o normas que definen cómo va
a ser creado un objeto de un tipo determinado; algo parecido a un manual de instrucciones
conteniendo las indicaciones para crear el objeto.

71 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Instancias de una clase

El proceso por el cual se obtiene un objeto a partir de las especificaciones de una clase se
conoce como instanciación de objetos.

Características básicas de un sistema orientado a objeto

Para que un lenguaje o sistema sea considerado orientado a objeto, debe cumplir las
características de los siguientes apartados.

o Abstracción
La abstracción es aquella característica que nos permite identificar un objeto a través de
sus aspectos conceptuales. Las propiedades de los objetos de una misma clase, pueden
hacerlos tan distintos que sea difícil reconocer que pertenecen a una clase idéntica. No
obstante, nosotros reconocemos a qué clase pertenecen, identificando además, si se
trata de la misma clase para ambos. Ello es posible gracias a la abstracción.

Tomemos como ejemplo dos objetos coche, uno deportivo y otro familiar; su aspecto
exterior es muy diferente, sin embargo, cuando pensamos en cualquiera de ellos,
sabemos que ambos pertenecen a la clase Coche, porque realizamos una abstracción o
identificación mental de los elementos comunes que ambos tienen (ruedas, volante,
motor, puertas, etc.).

72 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

o Encapsulación
La encapsulación establece la separación entre el interfaz del objeto y su
implementación, aportándonos dos ventajas fundamentales. Por una parte proporciona
seguridad al código de la clase, evitando accesos y modificaciones no deseadas; una
clase bien encapsulada no debe permitir la modificación directa de una variable, ni
ejecutar métodos que sean de uso interno para la clase.

Por otro lado la encapsulación simplifica la utilización de los objetos, ya que un

programador que use un objeto, si este está bien diseñado y su código correctamente
escrito, no necesitará conocer los detalles de su implementación, se limitará a utilizarlo.

Tomando un ejemplo real, cuando nosotros utilizamos un objeto Coche, al presionar el

acelerador, no necesitamos conocer la mecánica interna que hace moverse al coche,
sabemos que el método Acelerar del coche es lo que tenemos que utilizar para
desplazarnos, y simplemente lo usamos.

o Polimorfismo
El polimorfismo determina que el mismo nombre de método, realizará diferentes
acciones según el objeto sobre el que sea aplicado. Al igual que sucedía en la

73 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

encapsulación, el programador que haga uso del objeto, no necesita conocer los detalles
de implementación de los métodos, se limita a utilizarlos.

Pasando a un ejemplo real, tomamos dos objetos: Pelota y VasoCristal; si ejecutamos

sobre ambos el método Tirar, el resultado en ambos casos será muy diferente; mientras
que el objeto Pelota rebotará al llegar al suelo, el objeto VasoCristal se romperá.

o Herencia
Se trata de la característica más importante de la POO, y establece que partiendo de una
clase a la que denominamos clase base, padre o superclase, creamos una nueva clase
denominada clase derivada, hija, o subclase. En esta clase derivada dispondremos de
todo el código de la clase base, más el nuevo código propio de la clase hija, que
escribamos para extender sus funcionalidades.

A su vez podemos tomar una clase derivada, creando una nueva subclase a partir de
ella, y así sucesivamente, componiendo lo que se denomina una jerarquía de clases, que
explicaremos seguidamente.

Existen dos tipos de herencia: simple y múltiple.

La herencia simple es aquella en la que creamos una clase derivada a partir de una
sola clase base, mientras que la herencia múltiple nos permite crear una clase
derivada a partir de varias clases base. El entorno de .NET Framework sólo permite
utilizar herencia simple, por lo que este es el tipo de herencia que podremos usar con el
lenguaje VB.NET.

Como ejemplo real de herencia, podemos usar la clase Coche como clase base; en ella
reconocemos una serie de propiedades como Motor, Ruedas, Volante, etc., y unos
métodos como Arrancar, Acelerar, Frenar, etc. Como clase derivada creamos
CocheDeportivo, en la cuál, además de todas las características mencionadas para la
clase Coche, encontramos propiedades y comportamiento específicos como ABS, Turbo,
etc.

74 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Relaciones entre objetos

Los objetos existentes en una aplicación se comunican entre sí mediante una serie de
relaciones que describimos a continuación:

1. Herencia, Como acabamos de describir en el apartado sobre características de la

OOP, cuando a partir de una clase existente, creamos una nueva clase derivada, esta
nueva clase dispone de todas las propiedades y métodos de la clase base, mas el
código propio que implemente. Para reconocer si existe esta relación entre dos
objetos, debemos realizar un análisis sintáctico sobre la misma usando la partícula
“es un”.

2. Pertenencia, Los objetos pueden estar formados a su vez por otros objetos. Un
objeto Factura puede estar compuesto por objetos CabeceraFactura, LineaFactura,
etc. Se dice en este caso que hay una relación de pertenencia, puesto que existe un
conjunto de objetos que pertenecen a otro objeto o se unen para formar otro objeto.
A este tipo de relación se le denomina también Contenedora.
Para reconocer si existe esta relación entre dos objetos, debemos realizar un análisis
sintáctico sobre la

misma usando la partícula “tiene un”. Así, por ejemplo, la frase “Un objeto Factura
tiene un objeto

LineaFactura” devolvería verdadero.

3. Utilización, Hay situaciones en que un objeto utiliza a otro para realizar una
determinada tarea, sin que ello suponga la existencia de una relación de pertenencia
entre dichos objetos.
Por ejemplo, un objeto Ventana puede utilizar un objeto Empleado para mostrar al
usuario las propiedades del empleado, sin necesidad de que el objeto Empleado sea
propiedad del objeto Ventana.

75 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Nótese la importante diferencia entre esta relación y la anterior, ya que aquí, el

objeto Ventana a través de código, creará, o le será pasado como parámetro, un
objeto Empleado, para poder mostrarlo en el área de la ventana.

Para reconocer si existe esta relación entre dos objetos, debemos realizar un análisis
sintáctico sobre la misma empleando la partícula “usa un”. Así, por ejemplo, la frase
“Un objeto Ventana usa un objeto

Empleado” devolvería verdadero.

4. Reutilización, Un objeto bien diseñado, puede ser reutilizado en otra aplicación de

modo directo o creando una clase derivada a partir de él. Este es uno de los
objetivos perseguidos por la POO, aprovechar en lo posible el código ya escrito,
ahorrando un considerable tiempo en el desarrollo de programas.

Ejemplo 1

Elaborar un programa que permita registrar los siguientes datos de un producto: código,
nombre, cantidad y precio. Debe definir una clase llamada producto y otra clase llamada
AppProducto la cual permitirá agregar los datos a los productos

Paso 1: Definir la clase Producto

using System;

namespace ejemplos_poo

public class Producto

private int codigo;

private string nombre;

private int cantidad;

private double precio;

//metodos constructores

public Producto(){

codigo=0;

76 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

nombre="";

cantidad=0;

precio=0;

public Producto(int c, string n, int ca, double p){

codigo=c;

nombre=n;

cantidad=ca;

precio=p;

//metodos getter y setter

public int Codigo {

get { return codigo; }

set {this.codigo=value; }

public string Nombre {

get { return nombre; }

set {this.nombre=value; }

public int Cantidad {

get { return cantidad; }

set {this.cantidad=value; }

public double Precio {

get { return precio; }

set {this.precio=value; }

77 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Paso 2: Crear la clase AppProducto

using System;

namespace metodos

public class AppProducto

public static void Main(string[] args){

//creando instancia de una clase

Producto objP = new Producto();

//agregar datos al objeto

try{

Console.WriteLine("Ingreso de Datos");

Console.Write("Codigo:");

objP.Codigo = int.Parse(Console.ReadLine());

Console.Write("Nombre:");

objP.Nombre = Console.ReadLine();

Console.Write("Cantidad:");

objP.Cantidad = int.Parse(Console.ReadLine());

Console.Write("Precio:");

objP.Precio = double.Parse(Console.ReadLine());

//reportar datos del objeto

Console.WriteLine("\nReporte de Datos");

Console.WriteLine("-----------------");

Console.WriteLine("Codigo:{0}",objP.Codigo);

Console.WriteLine("Nombre:{0}",objP.Nombre);

Console.WriteLine("Cantidad:{0}",objP.Cantidad);

Console.WriteLine("Precio:{0}",objP.Precio);

78 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

catch(Exception xe)

Console.WriteLine(xe.Message);

Console.ReadKey(true);

Ejercicio practico

Proponga tres ejemplos de objetos del mundo real:

 Para cada uno de ellos, determine la clase a la que pertenecen. Enumere varios atributos
y métodos para cada una de las clases.
 Represente gráficamente las clases utilizando la notación UML.
 A partir de los diagramas UML, escriba el código necesario para definir las clases
utilizando el lenguaje de programación C Sharp.

Laboratorio

Objetivo:

 Identificar clases, definiendo sus atributos y métodos.

Un centro dedicado a impartir cursos de formación ocupacional desea diseñar una base de
datos que contemple la información que se relaciona a continuación. Para los cursos que
imparte se desea conocer el código de curso (único), nombre, fecha de inicio, número
máximo de alumnos, duración en horas, precio/hora a pagar al profesor y aula o aulas en las
que se imparte. De las aulas interesa conocer el código de aula, capacidad en número de
alumnos y si tiene ordenadores o no. En cada aula se imparten varios cursos y un curso
debe impartirse al menos en un aula, pudiéndose impartir en más de una. Cada curso tendrá
un director del curso, un secretario y varios profesores que imparten el curso, siendo de
interés reflejar esta información en el diseño de la base de datos. De estas personas se debe
conocer el código (único), nombre y apellidos, teléfono, titulación académica y datos
bancarios (banco, sucursal y cuenta bancaria). Una persona puede ser director secretario o
profesor de varios cursos, para un mismo curso no puede ser director y secretario a la vez,
pero si puede impartir clase al mismo tiempo que ejerce de director o secretario del curso.
Es de interés conocer el dinero que cobra el director y el secretario en un curso, y además el
número de horas que imparte cada profesor, sabiendo que el sueldo del director y secretario,

79 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

y el número de horas por profesor puede variar de un curso a otro. Por otra parte, la
documentación que se utiliza para impartir los cursos la preparan los profesores. Interesa
conocer qué profesor prepara cada documentación, sabiendo que una documentación
determinada la prepara un solo profesor y que un profesor puede preparar varias
documentaciones. De cada documentación se desea conocer el código, descripción, extensión
(N° de paginas), profesor que la prepara y los cursos en los que se utiliza, sabiendo que en
cada curso los profesores utilizan varias documentaciones (al menos una) y que una
documentación determinada puede ser utilizada en varios cursos.

TEMA: ARREGLO DE OBJETOS

Laboratorio

Objetivo

 Aprender a definir un tipo de abstracto y utilizarlo en la elaboración de un programa.

Ejemplo 1: Elaborar un programa que permita registrar los datos de dos cliente. Debe
considerar los siguientes atributos para los clientes: ruc, nombre y Sueldo básico.

Paso 1: declarar una clase de nombre Cliente

80 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Nota: La forma de generar métodos get y set. Debe seleccionar el atributo. Luego proceda a
pulsar clic derecho Refactor >> encapsulate Field

81 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Paso 2: Definir una clase de tipo aplicación

Ejemplo 2: Modificar el programa elaborado en el ejemplo1, de tal manera que permita

registrar los datos de 5 clientes.

82 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Paso 1: Realizar cambios en la clase App. Donde se debe declarar un arreglo de 5 elementos
tipo de dato Cliente.

Ejercicios Propuestos

 Elaborar una clase en C sharp que represente un círculo; el círculo queda perfectamente
definido si se conoce su radio. Defina además, para esta clase, dos métodos (públicos)
que permitan calcular el área del círculo y el perímetro de la circunferencia que delimita
el círculo.
a) El área circulo = PI * r2
b) Perímetro = 2 * PI * r
 Elaborar una aplicación en C sharp que denote la clase Punto, que represente a un punto
geométrico en el plano cartesiano. Elaborar un menú de opciones con las siguientes
funciones:
a) Ingreso de datos de dos puntos.
b) Listado de datos de los puntos.
c) Pendiente entre dos puntos.
d) Punto medio entre dos puntos.
e) Salir

83 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

84 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

HERENCIA

El uso de la herencia en la programación orientada a objetos implica una creación de

clases a partir de las clases ya existentes. La herencia se manifiesta con la creación de
un tipo de dato definido por el usuario (clase), que puede heredar las características de otra
clase ya existente o derivar las suyas a otra nueva clase.

 Cuando se hereda, las clases derivadas reciben las características (datos y funciones) de
la clase original, a las que se pueden añadir nuevas características o modificar las
características heredadas.
 La derivación de las clases consigue la reutilización efectiva del código de la clase base
para sus necesidades.
 La herencia organiza las clases en una estructura jerárquica:

PUBLICACION

LIBRO
REVISTA

INVESTIGACION MAGAZINE

También llamada clase

CLASE BASE ascendiente o
superclase.

Características:

 Una clase derivada puede, a su vez, ser una clase base, dando lugar a una jerarquía de
clases.
 Una clase derivada puede acceder a los miembros PUBLIC y PROTECTED de la clase
base, como si fueran miembros de ella. No pueden tener acceso a los miembros Private.
 Una clase derivada puede añadir sus propios datos y funciones.

Tipos de Herencia:

Existen dos tipos de herencia: Simple y Múltiple.

Herencia Simple: Es aquella en la que cada clase derivada hereda de una única clase. En
herencia simple, cada clase tiene un solo ascendiente. Cada clase base puede sin embargo
tener muchos descendientes.

85 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Herencia Múltiple: Es aquella en la cual una clase derivada tiene más de una clase base.
Aunque el concepto de herencia múltiple es muy útil, el diseño de clases suele ser más
complejo, y en ocasiones es preferible realizar la aplicación con herencia múltiple mediante
emulación de herencia simple.

CLASE BASE

CLASE DERIVADA CLASE DERIVADA CLASE DERIVADA

Herencia Simple

CLASE BASE A CLASE BASE B CLASE BASE C

CLASE DERIVADA CLASE DERIVADA

Herencia Múltiple

Sintaxis:

CLASS CLASE_DERIVADA : ACCESO NOMBRE_CLASE_BASE

{

Declaraciones de Miembros

Ejemplo:

Class alfa

86 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
Clase Base
 Técnica de Programación

private int suma;

//Funciones públicas

Class beta: alfa

{
Clase
Private int n; Derivada

//Funciones públicas

Ejemplo
Desarrollar un programa en que permita implementar una clase base llamada Empleado,
posteriormente implementar la clase derivada: Administrativo

class Empleado

Private string nombre, apellidos;

Private double dni;

Private int edad;

public Empleado(string nom, string ape, double d, int e)

nombre = nom;

apellidos = ape;

dni = d;

edad = e;

class Administrativo : Empleado

87 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

string categoría, oficina;

public Administrativo (string xnom, string xape, double xdni, int xedad, string xcat, string
xofi)

:base(xnom, xape, xdni, xedad)

categoria = xcat;

oficina = xofi;

class AppEjercicio

static void main()

CAdministrativo adm;

string xn, xa, xc, xo;

double xd;

int xe;

Console.WriteLine(“------ Ingreso Datos ---------”);

Console.Write(“Nombre”); xn = Console.ReadLine();

Console.Write(“Apellido”); xa = Console.ReadLine();

Console.Write(“DNI:”); xd = Double.Parse(Console.ReadLine());

Console.Write(“Edad:”); xe = int.Pase(Console.ReadLine());

Console.Write(“Categoria:”); xc = Console.ReadLine();

Console.Write(“Oficina:”); xo = Console.ReadLine();

adm = new CAdministrativo(xn,xa,xd,xe,xc,xo);

88 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

POLIMORFISMO

Es una funcionalidad que permite al código antiguo invocar nuevo código. Es uno de los
mayores beneficios de la programación orientado a objetos, porque le permiten extender o
mejorar su sistema sin romper o modificar el código existente.

Por ejemplo digamos que definimos un método que necesita iterar a través de una colección
de objetos Empleado, invocando el método CalcularPago de cada objeto. Eso funciona
bien cuando su compañía tiene solo un tipo de empleado, porque puede entonces insertar el
tipo de objeto exacto en la colección. Sin embargo qué pasa cuando empieza a contratar
otros tipos de empleados, para ello una solución orientada a objetos maneja las diferencias
como esta a través del polimorfismo.

Cada clase que se derive de la clase Empleado debería así tener su propia implementación
del método CalcularPago, con el polimorfismo, cuando tenga un puntero a un objeto
convertido al tipo de la clase base e invoque a ese método del objeto, el entorno de
ejecución del lenguaje asegurara que se llame a la versión correcta del método.

Ejemplo:

using System;

namespace polyApp{

class Empleado{

string apellido, nombre;

int edad;

double pago;

public Empleado(string n, string a, int e, double p)

this.apellido=a;

this.nombre=n;

this.edad=e;

this.pago=p;

89 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

publicvirtualdouble CalcularPago(int horasTrabajadas)

Console.WriteLine("Empleado Calcular Pago");

return 400; //Valor Imaginario

class EmpleadoSalario:Empleado

public EmpleadoSalario(string xn, string xa, int xe, double xp)

:base(xn, xa, xe, xp)

publicoverridedouble CalcularPago(int horasTrabajadas)

Console.WriteLine("Empleado Salario , Calcular Pago");

return 400; //Valor Imaginario

class EmpleadoContrato:Empleado

public EmpleadoContrato(string xn, string xa, int xe, double xp)

:base(xn, xa, xe, xp)

publicoverridedouble CalcularPago(int horasTrabajadas)

90 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Console.WriteLine("Empleado Contrato, Calcular Pago");

return 400; //Valor Imaginario

class PolyApp

Empleado [] emp;

protectedvoid cargarDatos()

Console.WriteLine("Cargando datos de empleados...");

emp= new Empleado[2];

emp[0] = new EmpleadoSalario("Jose","Perez",28,100);

emp[1] = new EmpleadoContrato("Luisa","Rojas",35,110);

protectedvoid calcularPagos()

foreach(Empleado e in emp)

e.CalcularPago(40);

91 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

publicstaticvoidMain()

PolyApp app = new PolyApp();

app.cargarDatos();

app.calcularPagos();

Console.ReadLine();

Revisando podamos darnos cuenta la capacidad de agrupar objetos que tienen una clase
base común y tratarlos consistentemente. En el ejemplo anterior, aunque técnicamente
tenemos dos tipos de objetos diferentes (EmpleadoSalario y EmpleadoContrato), podemos
tratarlo como objetos Empleado. Esto permite agruparlos en un arreglo que se define como
un arreglo de objetos Empleado.

Ejmplo 1r

namespace c1
{

publicclassAgenda
{
float version = 1.0f; // variable privada
// no puede salir de la clase
// solo puede ser usada
// dentro de la clase
publicstring Nombre; // poniendo "public" delante
// de cualquier funcion
// o variable, habilitamos
// su uso al invocar la clase
privateint Sexo;

publicvoid DameTuNombre()
{
if (Version() == 1.0f)
92 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

{
Console.WriteLine("Cual es tu nombre?");
Nombre = Console.ReadLine();
}
}
// podemos sobrecargar una función
// en otras palabras, crear la misma
// función con diferentes argumentos
publicvoid DameTuNombre(string nombre)
{
Nombre = nombre;
}
publicstring DameTu(string algo)
{
Console.WriteLine("Escribe tu {0,0:s}", algo);
Nombre = Console.ReadLine();
return Nombre;
}
privatefloat Version()
{
return version;
}
// como ves, no es nada del otro mundo
// luego hay más historias, cómo el tema
// de los punteros en C#, el "delegate"
// la herencia, y esas cosillas..ZZzzz
}

classProgram
{
staticvoid Main(string[] args)
{

int numero = 3;
string cadena = "mi cadena";

Agenda A = newAgenda();

A.Nombre = "Pedro";

93 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

A.DameTuNombre();
A.DameTuNombre("Pepito");
cadena = A.DameTu("el nombre de tu
abuela");

Console.WriteLine("Hola {0,0:s}! ah! y tú también

Mundo...jajaj", cadena);

Console.ReadLine();

}
}
}

Ejemplo 2

namespace c2
{

classClase1
{

publicint a = 1;
privatedouble b = 3;
publicString c = "akkkkk";
}

classProgram
{
staticvoid Main(string[] args)
{
Clase1 MiClase = newClase1(); // asi creamos una
instancia de Clase1
Console.WriteLine("{0} esto abc",MiClase.c);

Console.WriteLine(MiClase.c);

Console.ReadKey();
}
}
94 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

Ejemplo3

namespace c3
{

classClase1{

publicint a = 1;
publicdouble b = 3;
publicchar c = 'a';

publicvoid Descripcion()
{
Console.WriteLine("Hola, soy una clase");
}

classProgram
{
staticvoid Main(string[] args)
{

Clase1 MiClase = newClase1(); // asi creamos una

instancia de Clase1
Console.WriteLine(MiClase.c); //podemos usar todos
los tipos que hay dentro de Clase1
Console.WriteLine(MiClase.Descripcion());
MiClase.Descripcion();

Console.ReadKey();

}
}
}

Ejemplo 4

95 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

namespace c4
{

classMetodo
{
publicdouble Divide(double a, double b)
{
return a / b;
}
}

classProgram
{

staticvoid Main(string[] args)

{
Metodo m = newMetodo();
Console.WriteLine(m.Divide(8, 2));
m.Divide(8, 2);
Console.ReadKey();

}
}
}

Ejemplo 5

namespace c5
{

classClase1
{

publicvoid nombre()
{
String a;
Console.WriteLine("ingrese nombre");
a = Console.ReadLine();
Console.WriteLine("el resultado es {0}",a);

96 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

classProgram
{
staticvoid Main(string[] args)
{
Clase1 MiClase = newClase1(); // asi creamos una
instancia de Clase1

MiClase.nombre();

Console.ReadKey();

}
}
}

Ejemplo6

namespace c6
{

classClase1
{

publicvoid modulo()
{
double d;
double x, y;
Console.WriteLine("ingrese el valor de un punto
inicial");
x = int.Parse(Console.ReadLine());
Console.WriteLine("ingrese el valor de un punto
final");
y = int.Parse(Console.ReadLine());

97 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

d = Math.Sqrt(x * x + y * y); //Sqrt =

raiz cuadrada
Console.WriteLine("el resultado es {0}", d);

classProgram
{
staticvoid Main(string[] args)
{
Clase1 A = newClase1();
//A.X = 1;
//A.Y = -1;
A.modulo();
//Console.WriteLine("El modulo del punto (1,1) es:
{0}", A.Modulo());
Console.ReadKey();

}
}
}
Ejmplo 7

namespace c7
{

classPunto
{
publicdouble X;
publicdouble Y;

publicdouble Modulo()
{
double d;
d = Math.Sqrt(X * X + Y * Y); //Sqrt =
raiz cuadrada
98 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

return d;
}
}

classProgram
{
staticvoid Main(string[] args)
{

Punto A = newPunto();

A.X = 1;
A.Y = -1;

Console.WriteLine("El modulo del punto (1,1) es:

{0}", A.Modulo());
Console.ReadKey();
}
}
}

Ejemplo 8

namespace C8
{
classoperaciones
{

publicvoid promedio()
{
int nota1 , nota2;
double promedio;

do{
Console.Write("Nota 1 -->");
nota1 =
int.Parse(Console.ReadLine());
}while(nota1<0 || nota1>20);

99 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

do{
Console.Write("Nota 2 -->");
nota2 =
int.Parse(Console.ReadLine());
}while(nota2<0 || nota2>20);

promedio = (nota1 + nota2)/2;

Console.Write("Promedio -->{0}", promedio);

classProgram
{
staticvoid Main(string[] args)
{
operaciones MiClase = newoperaciones(); // asi
creamos una instancia de Clase1

MiClase.promedio();
Console.ReadKey();
}
}
}

IMPRIMIENDO VALORES DESDE UNA FUNCION :D

namespace C11
{

classPunto
{
publicdouble X;
publicdouble Y;

100 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez
 Técnica de Programación

publicdouble Modulo()
{
double d;
Console.WriteLine("ingresar numero1");
X=double.Parse(Console.ReadLine());
Console.WriteLine("ingresar numero2");
Y=double.Parse(Console.ReadLine());
d= Math.Sqrt(X * X + Y * Y);
//Sqrt = raiz cuadrada
Console.WriteLine("resultado es {0}", d);

return d;
}
}

classProgram
{
staticvoid Main(string[] args)
{
Punto A = newPunto();
A.Modulo();
//A.X = 1;
//A.Y = -1;
//Console.WriteLine("El modulo del punto (1,1) es:
{0}", A.Modulo());
Console.ReadKey();
}
}
}

101 Ing. Humberto Coveñas – Ing. Heber Gomez – Ing. Miguel Valle Pelaez