Universidad Nacional Autónoma de Nicaragua, León

Facultad de Ciencias y Tecnología

Departamento de Computación

Componente: Programación Orientada a Objetos

Práctica #2:

Título: EJERCICIOS RESUELTOS Y PROPUESTOS SOBRE LOS

ELEMENTOS DEL LENGUAJE C#, Parte 1

Objetivos:

➢ Uso de los tipos de datos, literales, constantes, variables, conversión entre tipos
primitivos, operadores y orden de evaluación de los operadores.

Elaborado por:

➢ MSc. Álvaro R. Altamirano Osorio.

“A la libertad por la Universidad”

 Programación Orientada a Objetos

1. Elementos del Lenguaje C#

C# (pronunciado "si sharp" en inglés) es un lenguaje de programación moderno, basado en

objetos y con seguridad de tipos. C# tiene sus raíces en la familia de lenguajes C, y a los
programadores de C, C++, Java y JavaScript les resultará familiar inmediatamente.

C# tiene un sistema de tipo unificado. Todos los tipos de C#, incluidos los tipos primitivos como
int y double, se heredan de un único tipo object raíz. Por lo tanto, todos los tipos comparten un
conjunto de operaciones comunes. Además, C# admite tipos de valor y tipos de referencia definidos
por el usuario.

Estructura del programa: los principales conceptos organizativos en C# son programas, espacios
de nombres, tipos, miembros y ensamblados. Los programas de C# constan de uno o más archivos
de origen. Los programas declaran tipos, que contienen miembros y pueden organizarse en espacios
de nombres. Las clases e interfaces son ejemplos de tipos. Los campos, los métodos, las propiedades
y los eventos son ejemplos de miembros. Cuando se compilan programas de C#, se empaquetan
físicamente en ensamblados. Normalmente, los ensamblados tienen la extensión de archivo .exe o
.dll, dependiendo de si implementan aplicaciones o bibliotecas, respectivamente.

Tipos y variables: Hay dos clases de tipos en C#: tipos de valor y tipos de referencia. Las
variables de tipos de valor contienen directamente los datos, mientras que las variables de los tipos
de referencia almacenan referencias a los datos, lo que se conoce como objetos.

Con los tipos de referencia, es posible que dos variables hagan referencia al mismo objeto y que,
por tanto, las operaciones en una variable afecten al objeto al que hace referencia la otra.

Con los tipos de valor, cada variable tiene su propia copia de los datos y no es posible que las
operaciones en una variable afecten a la otra (excepto para las variables de parámetro ref y out).

Los tipos de valor de C# se dividen en tipos simples, tipos de enumeración, tipos de estructura y
tipos de valores NULL. Los tipos de referencia de C# se dividen en tipos de clase, tipos de interfaz,
tipos de matriz y tipos delegados.

• Tipos de valor
o Tipos simples
▪ Entero con signo: sbyte, short, int,long
▪ Entero sin signo: byte, ushort, uint,ulong
▪ Caracteres Unicode: char
▪ Punto flotante binario IEEE: float, double
▪ Punto flotante decimal de alta precisión: decimal
▪ Booleano: bool
o Tipos de enumeración
▪ Tipos definidos por el usuario con el formato enum E {...}
o Tipos de estructura
▪ Tipos definidos por el usuario con el formato struct S {...}
o Tipos de valores que aceptan valores NULL
▪ Extensiones de todos los demás tipos de valor con un valor null

2
 Programación Orientada a Objetos

• Tipos de referencia
o Tipos de clase
▪ Clase base definitiva de todos los demás tipos: object
▪ Cadenas Unicode: string
▪ Tipos definidos por el usuario con el formato class C {...}
o Tipos de interfaz
▪ Tipos definidos por el usuario con el formato interface I {...}
o Tipos de matriz
▪ Unidimensional y multidimensional; por ejemplo, int[] y int[,]
o Tipos delegados
▪ Tipos definidos por el usuario con el formato delegate int D(...)

Expresiones: las expresiones se construyen con operandos y operadores. Los operadores de una
expresión indican qué operaciones se aplican a los operandos. Ejemplos de operadores incluyen +, -,
*, / y new. Algunos ejemplos de operandos son literales, campos, variables locales y expresiones.

Cuando una expresión contiene varios operadores, la precedencia de los operadores controla el
orden en que se evalúan los operadores individuales. Por ejemplo, la expresión x + y * z se evalúa
como x + (y * z) porque el operador * tiene mayor precedencia que el operador +.

Clases y objetos: Las clases son los tipos más fundamentales de C#. Una clase es una estructura
de datos que combina estados (campos) y acciones (métodos y otros miembros de función) en una
sola unidad.

Una clase proporciona una definición para instancias creadas dinámicamente de la clase,
también conocidas como objetos. Las clases admiten herencia y polimorfismo, mecanismos por los
que las clases derivadas pueden extender y especializar clases base.

Las clases nuevas se crean mediante declaraciones de clase. Una declaración de clase se inicia
con un encabezado que especifica los atributos y modificadores de la clase, el nombre de la clase, la
clase base (si se indica) y las interfaces implementadas por la clase. Al encabezado le sigue el cuerpo
de la clase, que consta de una lista de declaraciones de miembros escritas entre los delimitadores { y
}.

Matrices: Una matriz es una estructura de datos que contiene un número de variables a las que
se accede mediante índices calculados. Las variables contenidas en una matriz, denominadas
también elementos de la matriz, son todas del mismo tipo y este tipo se conoce como tipo de
elemento de la matriz.

Los tipos de matriz son tipos de referencia, y la declaración de una variable de matriz
simplemente establece un espacio reservado para una referencia a una instancia de matriz. Las
instancias de matriz reales se crean dinámicamente en tiempo de ejecución mediante el operador
new. La nueva operación especifica la longitud de la nueva instancia de matriz, que luego se fija para
la vigencia de la instancia. Los índices de los elementos de una matriz van de 0 a Length - 1. El
operador new inicializa automáticamente los elementos de una matriz a su valor predeterminado,
que, por ejemplo, es cero para todos los tipos numéricos y null para todos los tipos de referencias.

Interfaces: Una interfaz define un contrato que se puede implementar mediante clases y structs.
Una interfaz puede contener métodos, propiedades, eventos e indexadores. Una interfaz no

3
 Programación Orientada a Objetos

proporciona implementaciones de los miembros que define, simplemente especifica los miembros
que se deben proporcionar mediante clases o structs que implementan la interfaz.

Delegados: Un tipo de delegado representa las referencias a métodos con una lista de
parámetros determinada y un tipo de valor devuelto. Los delegados permiten tratar métodos como
entidades que se puedan asignar a variables y se puedan pasar como parámetros. Los delegados son
similares al concepto de punteros de función en otros lenguajes, pero a diferencia de los punteros
de función, los delegados están orientados a objetos y presentan seguridad de tipos.

Constantes: Las constantes son valores inmutables que se conocen en tiempo de compilación y
que no cambian durante la vida del programa. Las constantes se declaran con el modificador const.
Solo los tipos integrados de C# (excluido System.Object) pueden declararse como const.

Los tipos definidos por el usuario, incluidas las clases, las estructuras y las matrices, no pueden
ser const. Use el modificador readonly para crear una clase, una estructura o una matriz que se
inicialice una vez en tiempo de ejecución (por ejemplo, en un constructor) y que posteriormente no
se pueda cambiar.

C# no admite métodos, propiedades ni eventos const. Las constantes se deben inicializar al

declararse.

Conversiones entre tipos: Dado que C# tiene tipos estáticos en tiempo de compilación, después
de declarar una variable, no se puede volver a declarar ni se le puede asignar un valor de otro tipo a
menos que ese tipo sea convertible de forma implícita al tipo de la variable. Por ejemplo, string no
se puede convertir de forma implícita a int. Por tanto, después de declarar i como un valor int, no se
le puede asignar la cadena "Hello".

Pero es posible que en ocasiones sea necesario copiar un valor en una variable o parámetro de
método de otro tipo. Por ejemplo, es posible que tenga una variable de entero que se necesita pasar
a un método cuyo parámetro es de tipo double. O es posible que tenga que asignar una variable de
clase a una variable de tipo de interfaz. Estos tipos de operaciones se denominan conversiones de
tipos. En C#, se pueden realizar las siguientes conversiones de tipos:

Conversiones implícitas: no se requiere ninguna sintaxis especial porque la conversión tiene

seguridad de tipos y no se perderá ningún dato. Los ejemplos incluyen conversiones de tipos enteros
más pequeños a más grandes, y conversiones de clases derivadas a clases base.

Conversiones explícitas: las conversiones explícitas requieren el operador de conversión (). La

conversión es necesaria si es posible que se pierda información en la conversión, o cuando es posible
que la conversión no sea correcta por otros motivos. Entre los ejemplos típicos están la conversión
numérica a un tipo que tiene menos precisión o un intervalo más pequeño, y la conversión de una
instancia de clase base a una clase derivada.

4
 Programación Orientada a Objetos

2. Ejercicios Resueltos
2.1. Ejercicio resuelto 1:

Compile el siguiente programa y analice el código:

using System;

namespace HolaMundo
{
class Program
{
static void Main(string[] args)
{
string nom;
Console.WriteLine("Hola Mundo!");

Console.WriteLine("Hola, escribe tu nombre: ");

nom = Console.ReadLine();
Console.WriteLine("Buenos días " + nom);
}
}
}

2.2. Ejercicio resuelto 2:

Analice y compile el siguiente código, donde se hace uso de algunos elementos básicos del
lenguaje C#:

int op1, op2, num;

char op;
const double PI = 3.141516;
float radio = 0, area = 0;

Console.WriteLine(".....OPERACIONES ARITMETICAS .... ");

Console.WriteLine("Ingrese el operando 1: ");
op1 = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el operando 2: ");
op2 = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el operador (+)(-): ");
op = char.Parse(Console.ReadLine());
Console.WriteLine(op == '+' ? op1 + op2 : op1 - op2);
Console.ReadKey();

Console.Clear();

Console.WriteLine(".....CALCULANDO EL AREA DE UN CIRCULO .... ");

Console.WriteLine("Ingrese el radio del circulo: ");
radio = float.Parse(Console.ReadLine());
area = (float)(PI * Math.Pow(radio, 2));
Console.WriteLine("Area del Circulo: {0}", area);
Console.ReadKey();

5
 Programación Orientada a Objetos

Console.Clear();

Console.WriteLine(".....VERIFICANDO SI UN NUMERO ES PAR .... ");

Console.WriteLine("Ingrese un valor entero positivo: ");
num = int.Parse(Console.ReadLine());
Console.WriteLine(num % 2== 0 ? num + " es PAR" : num + " es IMPAR");
Console.ReadKey();

2.3. Ejercicio resuelto 3

Analice y compile el siguiente código, donde se hace uso de los operadores (con su precedencia
y asociatividad) del lenguaje C#:

double a = 10, b = 20, c = 30, res = 0, distancia;

int x1, y1, x2, y2;

res = a * a + b / c;

Console.WriteLine("Resultado: " + res);

res = (a - b + c) / b * c / (c + a % b);

Console.WriteLine("Resultado: " + res);

Console.ReadKey();
Console.Clear();

float cel = 0, fah = 0;

Console.WriteLine("Ingrese un valor de temperatura en grados fahrenheit:

");
fah = float.Parse(Console.ReadLine());

cel = (fah - 32) * 5 / 9;

Console.WriteLine(fah + " grados fahrenheit equivalen a " + cel + " grados

celcius...");

Console.ReadKey();
Console.Clear();

Console.WriteLine("Calculando la distancia entre dos puntos...");

Console.WriteLine("Ingrese las coordenadas del Punto 1 (x1,y1): ");

x1 = int.Parse(Console.ReadLine());
y1 = int.Parse(Console.ReadLine());

Console.WriteLine("Ingrese las coordenadas del Punto 2 (x2,y2): ");

x2 = int.Parse(Console.ReadLine());
y2 = int.Parse(Console.ReadLine());

distancia = Math.Sqrt((double)(Math.Pow(x2-x1,2)+Math.Pow(y2-y1,2)));

Console.WriteLine("Distancia: " + distancia);

6
 Programación Orientada a Objetos

2.4. Ejercicio Resuelto 4:

Analice y compile el siguiente código, donde se hace uso de estructuras del lenguaje C#:

struct Empleado
{
public string nombre;
public string telefono;
public double salario;
}

static void Main(string[] args)

{
Console.WriteLine(".....CREANDO EMPLEADOS .... ");
Empleado e1 = new Empleado();
LeerEmpleado(ref e1);
EscribirEmpleado(e1);
Empleado e2 = e1;
e1 = new Empleado();
EscribirEmpleado(e2);
EscribirEmpleado(e1);
}
private static void LeerEmpleado(ref Empleado e1)
{
Console.WriteLine("Leyendo los datos del empleado...");
Console.WriteLine("Nombre: ");
e1.nombre = Console.ReadLine();
Console.WriteLine("Telefono: ");
e1.telefono = Console.ReadLine();
Console.WriteLine("Salario: ");
e1.salario = double.Parse(Console.ReadLine());
}

private static void EscribirEmpleado(Empleado e1)

{
Console.WriteLine("Escribiendo los datos del empleado...");
Console.WriteLine("Nombre: " + e1.nombre);
Console.WriteLine("Telefono: " + e1.telefono);
Console.WriteLine("Salario: " + e1.salario);
}

7
 Programación Orientada a Objetos

3. Ejercicios Propuestos

3.1. Ejercicio Propuesto 1

Escriba un programa que reciba como datos de entrada el valor de la hipotenusa y uno de los catetos
de un triángulo rectángulo. El programa debe calcular e imprimir el valor del otro cateto.

3.2. Ejercicio Propuesto 2

Escriba un programa que reciba como dato de entrada un valor de temperatura expresado en grados
Kelvin. El programa debe convertir ese valor a grados Fahrenheit.

3.3. Ejercicio Propuesto 3

Escriba un programa que declare una estructura llamada “Automóvil”, con los atributos: marca,
color, kilometraje y precio. Cree métodos para leer e imprimir los datos de un automóvil y pruebe su
funcionamiento en el Main, declarando varias variables de tipo Automóvil.

8
 Programación Orientada a Objetos

1. Bibliografía

• Ceballos, F.J. (2011). Microsoft C#, Curso de Programación, 2ª. Edición. Madrid, España.
Editorial RA-MA.