Introducción a .NET Core y C# con ejemplos

Materia: Paradigmas Año 2019 Docente Lic.
Martín Tejerina
Versión 6.3 Página 1
Versión del documento 6.2 20190525
Contenido
UNIDAD 1– INTRODUCCION A NET CORE..........................................................................................................................4
Información general acerca de .NET Framework...........................................................................................................4
.NET Core tiene las siguientes características:...............................................................................................................4
Introducción a C#..........................................................................................................................................................5
Palabras reservadas o clave...........................................................................................................................................5
Tipos de valor................................................................................................................................................................6
Características principales de los tipos de valor............................................................................................................6
Tipos de datos integrados.............................................................................................................................................6
Tabla de conversiones numéricas implícitas.................................................................................................................7
Operadores de C#..........................................................................................................................................................7
Operadores unarios.......................................................................................................................................................7
Operadores de aritméticos – multiplicación..................................................................................................................8
Operadores aditivos......................................................................................................................................................8
Operadores de igualdad................................................................................................................................................8
Operador condicional AND............................................................................................................................................8
Operador condicional OR..............................................................................................................................................8
Estructura general de un programa de C# (Guía de programación de C#.....................................................................9
Instrucciones...............................................................................................................................................................10
Expression (instrucción)..............................................................................................................................................10
Instrucciones de selección o control de flujo..............................................................................................................11
Instrucciones de iteración o repetición......................................................................................................................11
Matrices (Guía de programación de C#)......................................................................................................................13
Compilación de una aplicación "Hola mundo" en C# con el SDK de .NET Core en Visual Studio 2017........................14
Depuración de la aplicación Hola mundo de .NET Core en C# o Visual Basic con Visual Studio 2017.........................18
Ejercicios estructuras de secuencia:............................................................................................................................24
Ejercicios Estructuras de decisión (IF /Switch).............................................................................................................27
Ejercicios Estructuras de repetición............................................................................................................................30
Creación de menú.......................................................................................................................................................32
Estructuras de repetición ejercicios combinados, Máximos y Mínimos Y cortes de control.......................................35
Materia: Paradigmas Año 2019 Docente Lic. Martín Tejerina
Métodos.......................................................................................................................................................................... 37
Firma de método.............................................................................................................................................................37
Pasar por referencia frente a Pasar por valor..................................................................................................................38
Valores devueltos............................................................................................................................................................39
Código completo.............................................................................................................................................................39
Ejercicios de integración..............................................................................................................................................40
Ejemplo de utilización de vectores o “arreglos” unidimensionales.................................................................................41
PILA................................................................................................................................................................................. 46
Introducción................................................................................................................................................................46
CONCEPTO DE PILA.....................................................................................................................................................46
Poner y quitar elementos de la pila.............................................................................................................................48
T IPO DE DATO PILA IMPLEMENT ADO CON ARRAYS..................................................................................................49
Estructra de dato Cola....................................................................................................................................................51
Ejercicios Pilas y colas......................................................................................................................................................54
Trabajo Práctico 1– Algoritmos de ordenamiento...........................................................................................................55
Lineamientos básicos......................................................................................................................................................55
Cálculo empírico de tiempos de ejecución......................................................................................................................55
GLOSARIO de .NET...........................................................................................................................................................56
ASP.NET....................................................................................................................................................................... 56
ASP.NET Core..............................................................................................................................................................56
ensamblado.................................................................................................................................................................56
CoreCLR....................................................................................................................................................................... 57
GC................................................................................................................................................................................ 57
IL.................................................................................................................................................................................. 57
JIT................................................................................................................................................................................ 57
implementación de .NET.............................................................................................................................................57
Biblioteca..................................................................................................................................................................... 58
Metapaquete...............................................................................................................................................................58
Mono........................................................................................................................................................................... 58
Núcleo de .NET............................................................................................................................................................58
CLI de .NET Core..........................................................................................................................................................58
SDK de .NET Core.........................................................................................................................................................58
.NET Framework..........................................................................................................................................................59
.NET Native.................................................................................................................................................................. 59
Fuentes:.............................................................................................................................................................................. 61
UNIDAD 1– INTRODUCCION A NET CORE
Informació n general acerca de .NET Framework
 .NET Framework es una tecnología que admite la compilación y ejecución de la última generación de aplicaciones y
Servicios web XML. El diseño de .NET Framework está enfocado a cumplir los objetivos siguientes:
 Proporcionar un entorno coherente de programación orientada a objetos, en el que el código de los objetos se
pueda almacenar y ejecutar de forma local, ejecutar de forma local pero distribuida en Internet o ejecutar de forma
remota.
 Proporcionar un entorno de ejecución de código que reduzca lo máximo posible la implementación de software y
los conflictos de versiones.
 Ofrecer un entorno de ejecución de código que promueva la ejecución segura del mismo, incluso del creado por
terceras personas desconocidas o que no son de plena confianza.
 Proporcionar un entorno de ejecución de código que elimine los problemas de rendimiento de los entornos en
los que se utilizan scripts o intérpretes de comandos.
 Ofrecer al programador una experiencia coherente entre tipos de aplicaciones muy diferentes, como las basadas
en Windows o en Web.
 Basar toda la comunicación en estándares del sector para asegurar que el código de .NET Framework se puede
integrar con otros tipos de código
.NET Core tiene las siguientes características:
 Multiplataforma: se ejecuta en los sistemas operativos Windows, macOS y Linux.

 Coherente entre arquitecturas: el código se ejecuta con el mismo comportamiento en varias arquitecturas,
como x64, x86 y ARM.
 Herramientas de línea de comandos: incluye herramientas de línea de comandos sencillas que se pueden usar
para el desarrollo local y en escenarios de integración continua.
 Implementación flexible: se puede incluir en la aplicación o se puede instalar de forma paralela a nivel de
usuario o de equipo.Se puede usar con contenedores de Docker.
 Compatible: .NET Core es compatible con .NET Framework, Xamarin y Mono, mediante .NET Standard.
 Código abierto: la plataforma .NET Core es de código abierto, con licencias de MIT y Apache 2. .NET Core es un
proyecto de .NET Foundation.
Introducció n a C#
C# es un lenguaje de programación sencillo, moderno, orientado a objetos y con seguridad de tipos. C# tiene sus raíces
en la familia de lenguajes C y le resultará familiar inmediatamente a los programadores de C, C++ y Java.
Palabras reservadas o clave
Las palabras clave son identificadores reservados predefinidos que tienen un significado especial para el compilador. No
podrá utilizarlos como identificadores en el programa a no ser que incluyan @ como prefijo. Por ejemplo, @if es un
identificador válido, pero if no lo es, porque if es una palabra clave.
En la primera tabla de este tema se muestran las palabras clave que son identificadores reservados en cualquier parte de
un programa en C#.
palabras reservadas
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in int interface internal
is lock long namespace
new null object operator
out override params private
protected public readonly ref
return sbyte sealed short
sizeof stackalloc static string
struct switch this throw
true try typeof uint
ulong unchecked unsafe ushort
using
using virtual void
static
volatile while
Tipos
El sistema de tipos de C# contiene las siguientes categorías:

 Tipos de valor
 Tipos de referencia
 Tipos de puntero
Las variables que son tipos de valor almacenan datos y las que son tipos de referencia almacenan referencias a los datos
reales. Las instancias de tipos de referencia también se conocen como objetos.
Es posible convertir un tipo de valor en un tipo de referencia y volver a un tipo de valor mediante el uso de la conversión
boxing y unboxing.
Tipos de valor
Características principales de los tipos de valor
Una variable de un tipo de valor contiene un valor del tipo. Por ejemplo, una variable del tipo int podría contener el
valor 42.Esto difiere de una variable de un tipo de referencia, que contiene una referencia a una instancia del tipo y que
también se conoce como un objeto. Al asignar un nuevo valor a una variable de un tipo de valor, se copia ese valor. Al
asignar un nuevo valor a una variable de un tipo de referencia, se copia la referencia, no el propio objeto.
Todos los tipos de valor se derivan implícitamente de System.ValueType.
A diferencia de los tipos de referencia, no puede derivar un tipo nuevo de un tipo de valor. En cambio, como los tipos de
referencia, los structs pueden implementar interfaces.
Las variables de tipo de valor no pueden ser null de forma predeterminada.
Tipos de datos integrados
En la siguiente tabla se muestran las palabras clave para los tipos de C# integrados, que son alias de los tipos predefinidos
en el espacio de nombres System.
Tipo Intervalo Tamaño
sbyte De -128 a 127 Entero de 8 bits con signo
byte De 0 a 255 Entero de 8 bits sin signo
char U+0000 a U+ffff Carácter Unicode de 16 bits
short De -32 768 a 32 767 Entero de 16 bits con signo
ushort De 0 a 65.535 Entero de 16 bits sin signo
int De -2.147.483.648 a 2.147.483.647 Entero de 32 bits con signo
uint De 0 a 4.294.967.295 Entero de 32 bits sin signo

De -9.223.372.036.854.775.808 a
long Entero de 64 bits con signo
9.223.372.036.854.775.807
ulong De 0 a 18.446.744.073.709.551.615 Entero de 64 bits sin signo
Tabla de conversiones numéricas implícitas
sbyte short, int, long, float, double o decimal
byte short, ushort, int, uint, long, ulong, float, double o decimal
char ushort, int, uint, long, ulong, float, double o decimal
short int, long, float, double o decimal
ushort int, uint, long, ulong, float, double o decimal
int long, float, double o decimal
uint long, ulong, float, double o decimal
long float, doubleo decimal
ulong float, doubleo decimal
float double
Operadores de C#
C# proporciona muchos operadores, que son símbolos que especifican las operaciones (matemáticas, indización, llamada
de función, etc.) que se realizan en una expresión. Puede sobrecargar muchos operadores para cambiar su significado al
aplicarlos a un tipo definido por el usuario.
Las operaciones de tipos enteros (como ==, !=, <, >, & y |) suelen estar permitidas en los tipos de enumeración (enum).
En las secciones siguientes se enumeran los operadores de C# desde la precedencia más alta a la más baja. Los
operadores de cada sección comparten el mismo nivel de precedencia. (esto es solo un resumen en relación a lo visto en
Paradigmas)
Operadores unarios
x++: incremento de postfijo. Devuelve el valor de x y, a continuación, actualiza la ubicación de almacenamiento con el
valor de x que es uno mayor (normalmente agrega el entero 1).
x--: decremento de postfijo. Devuelve el valor de x; a continuación, actualiza la ubicación de almacenamiento con el
valor de x que es uno menos (normalmente resta el entero 1).
+x: devuelve el valor de x.
-x: negación numérica.
!x: negación lógica.
~x: complemento bit a bit.
++x: incremento de prefijo. Devuelve el valor de x después de actualizar la ubicación de almacenamiento con el valor de
x que es uno mayor (normalmente agrega el entero 1).
--x: decremento de prefijo. Devuelve el valor de x después de actualizar la ubicación de almacenamiento con el valor de
x que es uno menos (normalmente resta el entero 1).
(T)x: conversión de tipos, en java lo llamábamos casteo.
Operadores de aritméticos – multiplicació n

Estos operadores tienen mayor precedencia que los de la sección siguiente y menor que el de la anterior.
x * y: multiplicación.
x / y: división. Si los operandos son enteros, el resultado es un entero que se trunca hacia cero (por ejemplo, -7 / 2 is
-3).
x % y: resto. Si los operandos son enteros, devuelve el resto de dividir x entre y. Si q = x / y y r = x % y,
entonces x = q * y + r.
Operadores aditivos
x + y: suma.
x – y: resta.
Operadores relacionales
x < y: menor que (true si x es menor que y).

x > y: mayor que (true si x es mayor que y).
x <= y: menor o igual que.
x >= y: mayor o igual que.
Operadores de igualdad
x == y: igualdad. De forma predeterminada, para los tipos de referencia distintos de string, devuelve igualdad de
referencia (prueba de identidad). Sin embargo, los tipos pueden sobrecargar ==, por lo que si su intención es probar la
identidad, es mejor usar el método ReferenceEquals en object.
x != y: distinto de. Vea el comentario de ==. Si un tipo sobrecarga ==, debe sobrecargar !=.
Operador condicional AND

Este operador tiene mayor precedencia que el de la sección siguiente y menor que el de la anterior.
x && y: AND lógico. Si el primer operando se evalúa como false, C# no evalúa el segundo operando.
Operador condicional OR
Este operador tiene mayor precedencia que el de la sección siguiente y menor que el de la anterior.
x || y: OR lógico. Si el primer operando se evalúa como true, C# no evalúa el segundo operando.
Estructura general de un programa de C# (Guía de programació n de C#
Los programas de C# pueden constar de uno o más archivos. Cada archivo puede contener cero o más espacios de
nombres. Un espacio de nombres puede contener tipos como clases, structs, interfaces, enumeraciones y delegados,
además de otros espacios de nombres. El siguiente es el esqueleto de un programa de C# que contiene todos estos
elementos.
Instrucciones
Las acciones de un programa se expresan mediante instrucciones. C# admite varios tipos de instrucciones diferentes,
varias de las cuales se definen en términos de instrucciones insertadas.
Un bloque permite que se escriban varias instrucciones en contextos donde se permite una única instrucción. Un bloque
se compone de una lista de instrucciones escritas entre los delimitadores { y }.
Las instrucciones de declaración se usan para declarar variables locales y constantes.
Las instrucciones de expresión se usan para evaluar expresiones. Las expresiones que pueden usarse como instrucciones
incluyen invocaciones de método, asignaciones de objetos mediante el new operador, asignaciones mediante = y los
operadores de asignación compuesta, operaciones de incremento y decremento mediante el ++y
Las instrucciones de selección se usan para seleccionar una de varias instrucciones posibles para su ejecución en función
del valor de alguna expresión. En este grupo están las instrucciones if y switch.
Instrucciones de iteración se usan para ejecutar varias veces una instrucción incrustada. En este grupo están las
instrucciones while,do, for y foreach.
Las instrucciones de salto se usan para transferir el control. En este grupo están las
instrucciones break, continue, goto, throw, return y yield.
La instrucción try... catch se usa para detectar excepciones que se producen durante la ejecución de un bloque, y la
instrucción try... finally se usa para especificar el código de finalización que siempre se ejecuta, tanto si se ha producido
una excepción como si no.
Hay otras pero no las incluiremos.
A continuación se muestran ejemplos de cada tipo de instrucción de las que incluiremos en la cursada.
Declaraciones de variable locales

static void Main() {
int a;
int b = 2, c = 3;
a = 1;
Console.WriteLine(a + b + c);
}
Declaración de constante local

const float PI = 3.1415927f;
const int R = 25;
Console.WriteLine(PI * R * R);
}
Expression (instrucción)

int i;
i = 123;
Console.WriteLine(i);
i++;
Console.WriteLine(i);
}
Compilació n de una aplicació n "Hola mundo" en C# con el SDK de .NET Core en Visual Studio 2017
En este tema se proporciona una introducción detallada para compilar, depurar y publicar una sencilla aplicación de
consola .NET Core con C# en Visual Studio 2017. Visual Studio 2017 proporciona un entorno de desarrollo completo para
la compilación de aplicaciones .NET Core. Siempre que la aplicación no tenga dependencias específicas de la plataforma,
la aplicación puede ejecutarse en cualquier plataforma que tenga como destino .NET Core y en cualquier sistema que
tenga instalado .NET Core.
Aplicación Hola mundo “sencilla”
Comience creando una aplicación de consola "Hola mundo" sencilla. Siga estos pasos:
1. Inicie Visual Studio 2017. Seleccione Archivo > Nuevo > Proyecto de la barra de menús. En el cuadro de

diálogo Nuevo proyecto*, seleccione el nodo Visual C# seguido del nodo .NET Core. Después, seleccione la plantilla
del proyecto Aplicación de consola (.NET Core). En el cuadro de texto Nombre, escriba "Hola mundo". Seleccione
el botón Aceptar.
2. Visual Studio usa la plantilla para crear el proyecto. La plantilla de aplicación de consola de C# para .NET Core
define automáticamente una clase, Program, con un único método, Main, que adopta una matriz String como
argumento. Main es el punto de entrada de la aplicación, el método que se llama automáticamente mediante el
tiempo de ejecución cuando inicia la aplicación. Los argumentos de línea de comandos proporcionados cuando se
inicia la aplicación están disponibles en la matriz args.
La plantilla crea una aplicación "Hola mundo" sencilla. Llama al método Console.WriteLine(String) para mostrar la

cadena literal "Hola mundo" en la ventana de la consola. Al seleccionar el botón HelloWorld con la flecha verde en
la barra de herramientas, puede ejecutar el programa en modo de depuración. Si lo hace, la ventana de la consola
se mostrará durante poco tiempo antes de cerrarse. Esto ocurre porque el método Main finaliza y la aplicación
termina en cuanto se ejecuta la única instrucción en el método Main.
3. Para que la aplicación se pause antes de que se cierre la ventana de la consola, agregue el siguiente código
inmediatamente después de la llamada al método Console.WriteLine(String):
Console.Write("Press any key to continue...");

Console.ReadKey(true);
Este código pide al usuario que presione cualquier tecla y, a continuación, detiene el programa hasta que se
presiona una tecla.
4. En la barra de menús, seleccione Compilar > Compilar solución. De esta forma, el programa se compila en un

lenguaje intermedio (IL) que se convierte en código binario mediante un compilador Just-In-Time (JIT).
5. Seleccione el botón HelloWorld con la flecha verde en la barra de herramientas para ejecutar el programa.

6. Presione cualquier tecla para cerrar la ventana de consola.
Mejorar la aplicación Hola mundo
Mejore su aplicación para pedir su nombre al usuario y mostrarlo junto con la fecha y la hora. Para modificar y probar el
programa, haga lo siguiente:
1. Escriba el siguiente código de C# en la ventana de código inmediatamente después del corchete de apertura que
sigue a la línea static void Main(string[] args) y antes del primer corchete de cierre:
Console.WriteLine("\nWhat is your name? ");

var name = Console.ReadLine();
var date = DateTime.Now;
Console.WriteLine($"\nHello, {name}, on {date:d} at {date:t}!");
Console.Write("\nPress any key to exit...");
Console.ReadKey(true);
Este código reemplaza las instrucciones Console.WriteLine, Console.Write y Console.ReadKey existentes.

Este código muestra "What is your name?" en la ventana de la consola y espera a que el usuario escriba una cadena
seguida de la tecla Entrar. Almacena esta cadena en una variable denominada name. También recupera el valor de
la propiedad DateTime.Now, que contiene la hora local actual, y lo asigna a una variable denominada date. Por
último, usa una cadena interpolada para mostrar estos valores en la ventana de la consola.
2. Compile el programa; para ello, seleccione Generar > Compilar solución.
3. Ejecute el programa en modo de depuración en Visual Studio; para ello, seleccione la flecha verde en la barra de
herramientas, presione F5 o seleccione el elemento de menú Depurar > Iniciar depuración. Responda a la
solicitud escribiendo un nombre y presionando la tecla Entrar.
4. Presione cualquier tecla para cerrar la ventana de consola.

Depuració n de la aplicació n Hola mundo de .NET Core en C# o Visual Basic con Visual Studio 2017
Hasta ahora, ha seguido los pasos descritos en Compilación de una aplicación Hola a todos en C# con .NET Core en
Visual Studio 2017 o Compilación de una aplicación Hola a todos en Visual Basic con .NET Core en Visual Studio
2017 para crear y ejecutar una aplicación de consola sencilla. Cuando haya escrito y compilado la aplicación, puede
comenzar a probarla. Visual Studio incluye un conjunto completo de herramientas de depuración que puede usar para
probar y solucionar problemas de la aplicación.
Depuración en modo de depuración
El modo de depuración y versión son dos de las configuraciones de compilación predeterminadas de Visual Studio. La

configuración de compilación actual se muestra en la barra de herramientas. En la siguiente imagen de la barra de
herramientas se muestra que Visual Studio está configurado para compilar la aplicación en el modo de depuración.
Siempre debe empezar probando el programa en modo de depuración. El modo de depuración desactiva la mayoría de
las optimizaciones del compilador y proporciona información más completa durante el proceso de compilación.
Establecer un punto de interrupción
Ejecute su programa en el modo de depuración y pruebe algunas características de depuración:
1. Un punto de interrupción interrumpe temporalmente la ejecución de la aplicación antes de que se ejecute la línea

con el punto de interrupción.
Establezca un punto de interrupción en la línea que dice Console.WriteLine($"\nHello, {name}, on {date:d} at

{date:t}!");haciendo clic en el margen izquierdo de la ventana de código en esa línea o seleccione el elemento de
menú Depurar > Alternar punto de interrupción con la línea seleccionada. Como se muestra en la siguiente
ilustración, para indicar la línea en la que se establece el punto de interrupción, Visual Studio lo resalta y muestra un
círculo rojo en el margen izquierdo.
2. Ejecute el programa en el modo de depuración seleccionando el botón HelloWorld con la flecha verde en la

barra de herramientas, presionando F5 o seleccionando Depurar > Iniciar depuración.
3. Cuando el sistema le pida un nombre, escriba una cadena en la ventana de consola y presione Entrar.
4. La ejecución del programa se detiene cuando llega al punto de interrupción y antes de que se ejecute el
método Console.WriteLine. La ventana Automático muestra los valores de variables que se usan en torno a la línea
actual. La ventana Variables locales (que puede ver haciendo clic en la pestaña Variables locales) muestra los
valores de las variables definidas en el método que se ejecuta actualmente.
5. Puede cambiar el valor de las variables para ver cómo afecta esto a su programa. Si la ventana Inmediato no está
visible, muéstrela, para ello, seleccione el elemento de menú Depurar > Ventanas > Inmediato. La ventana
Inmediato le permite interactuar con la aplicación que está depurando.
6. Puede cambiar los valores de las variables de manera interactiva. Escriba name = "Gracie" en la ventana
Inmediato y presione la tecla Entrar.
7. Escriba date = new DateTime(2016,11,01,11,59,00) en la ventana Inmediato y presione la tecla Entrar.
La ventana Inmediato muestra el valor de la variable de cadena y las propiedades del valor DateTime. Además, el

valor de las variables se actualiza en las ventanas Automático y Variables locales.
8. Seleccione el botón Continuar en la barra de herramientas para continuar con la ejecución del programa, o
seleccione el elemento de menú Depurar > Continuar. Los valores mostrados en la ventana de la consola
corresponden a los cambios realizados en la ventana Inmediato.
9. Presione cualquier tecla para salir de la aplicación y finalice el modo de depuración.

Establecimiento de un punto de interrupción condicional
Su programa muestra la cadena que escribe el usuario. ¿Qué sucede si el usuario no escribe nada? Puede probar esto con
una característica de depuración útil, el punto de interrupción condicional, que interrumpe la ejecución del programa
cuando se cumplen una o más condiciones.
Para establecer un punto de interrupción condicional y probar lo que sucede cuando el usuario no especifica una cadena,
haga lo siguiente:
1. Haga clic con el botón derecho en el punto rojo que representa al punto de interrupción. En el menú contextual,
seleccione Condiciones para abrir el cuadro diálogo Configuración del punto de interrupción. Marque la
casilla Condiciones.
2. Para la expresión condicional, reemplace "por ejemplo, x == 5" por lo siguiente:
String.IsNullOrEmpty(name)
Se está probando una condición de código, en la que la llamada al

método String.IsNullOrEmpty(name) es true porque name no tiene asignado un valor o porque su valor es una
cadena vacía (""). También puede especificar un número de llamadas, que es lo que interrumpe la ejecución antes
de que una instrucción se ejecute un número especificado de veces; o una condición de filtro, que es lo que
interrumpe la ejecución del programa en función de atributos como un identificador de subproceso, nombre de
proceso o nombre de subproceso.
3. Seleccione el botón Cerrar para cerrar el cuadro de diálogo.
4. Ejecute el programa en modo de depuración.
5. En la ventana de consola, cuando se le pida que escriba su nombre, presione la tecla Entrar.
6. Como la condición que hemos especificado, name es null o String.Empty, se ha cumplido, la ejecución del

programa se detiene cuando se alcanza el punto de interrupción y antes de que se ejecute el
método Console.WriteLine.
7. Seleccione la ventana Variables locales, que muestra los valores de las variables que son locales para el método
que se ejecuta actualmente, que es el método Main en su programa. Observe que el valor de la
variable name es "" o String.Empty.
8. Confirme que el valor es una cadena vacía escribiendo la siguiente instrucción en la ventana Inmediato. El
resultado es true.
? name == String.Empty
9. Seleccione el botón Continuar en la barra de herramientas para continuar la ejecución del programa.
10. Presione cualquier tecla para cerrar la ventana de consola y salir del modo de depuración.
11. Para borrar el punto de interrupción, haga clic en el punto en el margen izquierdo de la ventana de código, o
seleccione el elemento de menú Depurar > Alternar punto de interrupción con la fila seleccionada.
Ejecución paso a paso de un programa
Visual Studio también le permite recorrer línea a línea un programa y supervisar su ejecución. Normalmente, establecería
un punto de interrupción y usaría esta característica para seguir el flujo del programa mediante una pequeña parte de su
código de programa.Como nuestro programa es pequeño, puede ejecutar paso a paso el programa entero realizando lo
siguiente:
1. En la barra de menús, seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio
resalta y muestra una flecha junto a la siguiente línea de ejecución.
En este punto, la ventana Automático muestra que su programa ha definido solo una variable, args. Dado que no
ha pasado ningún argumento de línea de comandos al programa, su valor es una matriz de cadena vacía. Además,
Visual Studio ha abierto una ventana de consola en blanco.
2. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio ahora resalta la
siguiente línea de ejecución. Como se muestra en la ilustración, el código tarda en ejecutarse menos de una
milésima de segundo entre la última instrucción y esta. args sigue siendo la única variable declarada y la ventana de
consola sigue estando en blanco.
3. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio resalta la instrucción
que incluye la asignación de variables name. La ventana Automático muestra que name es null, y la ventana de
consola muestra la cadena "What is your name?".
4. Para responder a la solicitud, escriba una cadena en la ventana de consola y presione Entrar. La consola no
responde y la cadena que especifique no se muestra en la ventana de la consola, pero el
método Console.ReadLine capturará en cambio la entrada.
5. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio resalta la instrucción
que incluye la asignación de variables date (en C#) o currentDate (en Visual Basic). La ventana Automático muestra
el valor de propiedad DateTime.Now y el valor devuelto por la llamada al método Console.ReadLine. La ventana de
la consola también muestra la cadena especificada cuando se solicitó la entrada.
6. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. La ventana Automático muestra el

valor de la variable date tras la asignación desde la propiedad DateTime.Now. La ventana de consola permanece sin
cambios.
7. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio llama al

método Console.WriteLine(String, Object, Object). Los valores de las variables date (o currentDate) y name aparecen
en la ventana Automático y la ventana de consola muestra la cadena con formato.
8. Seleccione Depurar > Paso a paso para salir o presione la tecla Mayúscula y la tecla F11. Esta acción detiene la
ejecución paso a paso. La ventana de la consola muestra un mensaje y espera a que presione una tecla.
9. Presione cualquier tecla para cerrar la ventana de consola y salir del modo de depuración.
Ejercicios estructuras de secuencia:

Escriba el Pseudocódigo y dibuje el diagrama de flujo que represente el algoritmo necesario para resolver los
siguientes problemas:
1. Leer 2 números enteros, calcular la suma e informar el resultado. <<RESUELTO AL FINAL DE LA EJERCITACION>>
2. Leer 4 números enteros, calcular la suma e informar el resultado.
3. Dados 2 números enteros, que representan los lados de un rectángulo se pide informar la superficie del mismo.
4. Dado 1 número con decimales, que representa el lado de un cuadrado se pide informar la superficie del mismo.
5. Se ingresa 3 números que representan horas, minutos y segundos. Se pide informar el resultado expresado en
segundos. Determinar qué tipo de valor es el aconsejable para los datos solicitados
6. Se necesita calcular la superficie de un triángulo, y se dispone solamente de los valores de su base y altura.
Definir también que tipo de valor es aconsejable para las variables con la información que se tiene.
**No se podrá usar valores fijos en las fórmulas del algoritmo. Solo variables y/o constantes.**
7. Dados 6 números reales, informar el promedio de los mismos.
8. Dados 2 números enteros, que representan una cantidad parcial y total se pide: Calcular e informar el
porcentaje que representa la primera de la segunda. ¿Qué tipo de datos son los recomendados para este
algoritmo?
9. Dada una fecha que se lee en formato numérico DDMMAAAA (dos números para el día, dos para el mes, cuatro
para el año), se solicita obtener el día el mes y año por separado en tres variables. (usar descomposición
matemática)
10. En un curso de ciencias de la computación la calificación final del estudiante se determina a partir del
rendimiento en tres aspectos del trabajo. A) Existe una calificación por los exámenes parciales que representa el
30% del valor total de la nota final. B) la calificación por los trabajos prácticos corresponde al 20% del valor de la
nota final. C) el examen integrador que corresponde al 50% restante. (los valores de las notas pueden ir de 0 a
10)
11. Una concesionaria de autos paga a su personal, un salario de 5500 pesos por mes, mas una comisión del 200
pesos por cada auto vendido y un adicional del 5% del valor del auto vendido. Diseñar un algoritmo para calcular
el salario total del vendedor. Conociendo solamente el número de autos vendidos y el valor de venta de la
unidad.
RESOLUCION EJERCICIO 1
Ejemplo de clase if-switch

Crear un programa que a partir de un número de dia de la semana muestre el nombre del mismo en inglés o español.
Los días se identifican de lunes = 1 a domingo = 7. Idioma S = español.
Ejercicios Estructuras de decisió n (IF /Switch)
12. Dadas las 4 notas obtenidas por un alumno se pide calcular e informar el promedio y una leyenda que indique si
está aprobado. El dato de aprobación se hará a partir de un valor predeterminado que no podrá ser modificable
a lo largo del programa. <<RESUELTO AL FINAL DE LA EJERCITACION>>
13. Se ingresan dos números enteros y se pide el resultado de dividirlos, informando el resultado de la división o un
mensaje de error si el mismo no se pudo hacer porque uno de los valores no puede ser admitido para la división.
14. Leer dos fechas en formato DDMMAAAA. Informar cuál de ellas es la menor o si son iguales.
15. Se presentan dos personas en un banco, éste les asigna el primer lugar de la fila a la mayor de ellas, para lo cual
le solicita a cada una de ellas su día, mes y año de nacimiento por separado. Se solicita informar a cuál de las
personas se le asignará el primer lugar de la fila.
16. Se leen dos números y se necesita informarlos en orden ascendente.
17. Ingresar 3 números enteros e informar el menor de ellos. CONFECCIONAR PRUEBA DE ESCRITORIO
18. Ingresar 5 números reales e informar el menor de ellos.
19. Se leen tres datos que representan el apellido, sueldo básico y antigüedad de un empleado. Se debe informar el
nombre y el sueldo a cobrar. El sueldo se calcula adicionando al sueldo básico el 40% del mismo si la antigüedad
supera los 9 años.
20. Diseñar un algoritmo que realice la consistencia de una fecha, es decir que los tres datos leídos (día, mes, año)
correspondan a una fecha válida. Informando si la fecha es correcta, o bien informando la primer parte
inconsistente. Ej Fecha válida: 31 12 2013 Ej Fecha inválida: 12 31 2013.
Ejercicios combinados estructuras de secuencia – decisión simple y múltiple.
21. Se conoce la cantidad total de preguntas realizadas y la cantidad de respuestas correctas de un test de nivel par
ingresantes a la universidad. Se pide informar el porcentaje de respuestas correctas y una leyenda que indique
el nivel obtenido según el siguiente criterio:
a. Nivel 1  Porcentaje >=89%
b. Nivel 2  75<=Porcentaje<89
c. Nivel 3  50<=Porcentaje<70
d. Nivel 4  Porcentaje<50
¿Qué error tiene este algoritmo.?
22. Ingresar un número entero de cuatro dígitos que representa un año. Se pide indicar si fue, es, o será bisiesto.
Un año es bisiesto si es divisible por 400 ó, si es divisible por 4 pero no por 100.
23. Se necesita ingresar una fecha en formato DDMMAAAA dos dígitos para el día, dos dígitos para el mes y cuatro
dígitos para el año. Si pide informar si DD y MM son correctos o si son incorrectos. Utilizar una prueba booleana
para informar el resultado. (variable booleana puede tomar los valores true o false).
a. Ej. Fecha válida: 31122013
b. Ej. Fecha inválida: 12312013
c. Ej. Fecha inválida: 29022015
Ejercicios Estructuras de repetició n

24. Se necesita crear un programa que imprima lotes de 100 tiquets. La numeración de los tiquets tiene que tener
saltos de 10 en diez. Utilizando el ciclo de repetición Mientras – Hacer. <<RESUELTO AL FINAL DE LA
EJERCITACION>>
saltos de 10 en diez. Utilizando el ciclo de repetición Hacer – Mientras.
saltos de 10 en diez. Utilizando el ciclo de repetición Para.
27. Calcular e informar el factorial de un número positivo. (El Factorial de un número entero positivo se define como
n!=1*2*3….(n-2)*(n-1)*n. También se define que el factorial de 0=1  0!=1)
Utilizar un ciclo repetir para la lectura del dato con el fin de no permitir avanzar hasta que no se ingrese un
número mayor o igual que 0.
28. Informar las potencias de 2 a partir de 2 0 y como máximo 210
29. Calcular e informar el promedio de los números pares menores a un valor definido por el usuario. Dicho número
no debe ser superior a 1500.
30. Se leen 300 datos que representan el peso y la edad de los niños atendidos en un hospital, se pide informar el
peso promedio según el siguiente rango de edades:
 De 0 a 1 año inclusive / De 1 año a 3 inclusive / De 3 años a 5 inclusive
Las edades de los niños atendidos en el hospital van desde los 0 a los 14 años.
Informar la cantidad total de niños que no fueron contabilizados en el rango de edades.
Informar cuál fue el peso mínimo de todos los niños
Informar cual fue el peso máximo de todos los niños
31. Dados dos números enteros A y B, se pide calcular el producto A*B por sumas sucesivas. (Para obtener el
producto se va a sumar B veces el número A. Teóricamente se debe obtener el mismo resultado si se suma A
veces el número B. )
32. Dados dos números enteros A y B, se pide calcular el resultado de la división entera de dividir A sobre B, por
restas sucesivas (NO SE PUEDE USAR LA DIVISION DIRECTA). Para obtener la división entera de dividir A sobre B
se debe hacer:
A-B = r1, r1-b= r2, r2-B=r3…..rn-1-b=rn
La última resta es aquella que da como resultado rn<B. La cantidad de veces que se restó B es la división entera
buscada y el rn es el resto de la división. Por ejemplo, suponer que se quiere hacer 7 sobre 3 por restas
sucesivas, el algoritmo seria el siguiente:
7>=2 verdadero  7-2 = 5
5>=2 verdadero 5-2 = 3
3>=2 verdadero 3-2=1
1>=2 falso  finaliza el ciclo de restas
7 sobre 2 = cantidad de restas realizadas 3

Resto de hacer 7 sobre2 = el valor de la última resta realizada
Creació n de menú
El presente ejemplo está dividido en tres etapas, tres proyectos donde se aborda la creación de un menú desde cero.
Para la creación de un menú lo único que tenemos que tener en cuenta en la “receta”, es que debemos contar con una
estructura de decisión switch dentro de una estructura do-while, en el cual deberemos establecer una condición para
dejar de iterar para terminar y salir de la aplicación.
En los ejemplos evolucionaremos el menú partiendo desde un esqueleto donde la estructura del menú está
completamente definida y nos servirá para tener una idea completa del armado del mismo, el cual solo ejecutará
visualizaciones de consola. La segunda evolución constará en intercambiar el mensaje de consola por un ejercicio
completo tomado de la guía 1 de secuencias. La última evolución del programa sacará del código del programa principal
“la incrustación del código del ejercicio 1”, y la pegaremos dentro un método void creado para esta ocasión, para que
sea ejecutado desde el programa principal, esto dotará al programa principal de mayor claridad para comprender que es
lo que hace cada menú, como también esta acción de “desacople”, permitirá que los problemas sean resueltos en lugar
que corresponde minimizando la posibilidad de incurrir en errores.
Evolución N°1 esqueleto
Evolución N°2 esqueleto

Evolución N°3 extraigo el código suelto que incluí en la etiqueta case 1: y lo agrego en un nuevo método denominado
ejercicio1
Estructuras de repetició n ejercicios combinados, Má ximos y Mínimos Y cortes de control.
33. Informar el valor máximo de un conjunto de números reales que finaliza con valor 0, el cual pertenece al
conjunto. Se lee al menos un valor.
34. Informar el máximo valor de un lote de n números reales. La cantidad de N números reales será ingresada por el
usuario del programa.
35. Dado un listado con los nombres y las 4 notas obtenidas por los alumnos de un curso, calcular e informar el
promedio de cada uno y una leyenda que indique si está o no aprobado. No se conoce la cantidad total de
alumnos a procesar. De acuerdo a cada versión utilice la estructura de repetición más adecuada.
 Versión con listado de alumnos de 1 a n
 Versión con listado de 50 alumnos
 Versión con listado de 0 o n alumnos
36. Informar el valor máximo de un conjunto de números reales que finaliza con un valor 0, el cual no pertenece al
conjunto a leer.
Además Informar además la cantidad de veces que se repite el valor máximo en el conjunto.
37. Una gran cadena de electrodoméstico recibe mensualmente un informe consolidado de todas sus sucursales
conteniendo la siguiente información:
 Código de sucursal (alfabético 3 caracteres)
 Producto vendido (alfabético 5 caracteres)
 Cantidad vendida (numérico entero)
El listado se encuentra ordenado por código de sucursal, producto y cantidad vendida.
Se pide informar:
Cantidad total vendida por cada sucursal Respetando la siguiente leyenda “La sucursal XXX vendió
yyyyyy productos”
Sucursal con la mejor venta, se debe respetar la siguiente leyenda: “La sucursal con mejor venta fue XXX
y vendió yyyyy productos”
38. La misma cadena de electrodomésticos anterior comienza a recibir un informe consolidado de ventas por
productos. Conteniendo la siguiente información”
 Código de sucursal(alfabético 3 caracteres)
El listado se encuentra ordenado en la forma que están informados los datos anteriores.
Se pide:
 Informar código y cantidad del producto más vendido.
 Informar la cantidad del producto con menor venta.
39. Una institución educativa necesita evaluar la evolución de 5 materias correspondientes a primer, segundo y
tercer año de carrera. (1. Matemática, 2. Lengua, 3 Historia, 4 Geografía, 5 Tecnología)
Para realizar esta tarea se dispone de un listado, ordenado por Número de curso y Código de materia que
contiene la siguiente información:
 Número de curso (valores de 1 a 3)
 Código de Materia (valores de 1 a 5)
 Nota del Examen final de cada alumno
Se pide informar:
 Por cada materia se pide saber el promedio de nota de todo el curso
 La cantidad de alumnos aprobados
 La cantidad de alumnos desaprobados aprobados
 La materia con mayor índice de aprobación
 La materia con menor índice de aprobación
Métodos
Un método es un bloque de código que contiene una serie de instrucciones. Un programa hace que se ejecuten las
instrucciones al llamar al método, en caso de ser necesario podremos especificar los argumentos necesarios para su
funcionamiento. Haciendo analogía con Diagramación lógica, podemos decir que:
Un método que retorna un valor tiene el comportamiento de una función.
Un método que no retorna un valor tiene el comportamiento de un procedimiento.
En C#, la ejecución de todas las instrucciones se realiza en el contexto de un método. El método Main es el punto de
entrada para cada aplicación de C# llamándose cuando se inicia el programa.
Firma de método
Los métodos se declaran en una clase o struct especificando el nivel de acceso, como, el valor de retorno, el nombre del
método y cualquier parámetro de método. Todas estas partes forman la firma del método.
Los parámetros de método se encierran entre paréntesis y se separan por comas. Los paréntesis vacíos indican que el
método no requiere parámetros. Esta clase contiene cuatro métodos:
Parámetros de métodos frente a Argumentos
La definición del método especifica los nombres y tipos de todos los parámetros necesarios. Si el código de llamada
llama métodos, proporciona valores concretos denominados argumentos para cada parámetro. Los argumentos deben
ser compatibles con el tipo de parámetro, pero el nombre del argumento (si existe) utilizado en el código de llamada no
tiene que ser el mismo que el parámetro con nombre definido en el método. Por ejemplo:
Pasar por referencia frente a Pasar por valor

De forma predeterminada, cuando un tipo de valor se pasa a un método, se pasa una copia en lugar del propio
objeto. Por lo tanto, los cambios realizados en el argumento no tienen ningún efecto en la copia original del método de
llamada. Puede pasar un tipo de valor por referencia mediante la palabra clave ref
Valores devueltos
Los métodos pueden devolver un valor al autor de llamada. En líneas generales un método que devuelve un valor se
caracteriza porque no tiene la palabra clave void sino que en cambio especifica un tipo de dato a devolver, además se
incluye la palabre clave return .
Una instrucción con la palabra clave return seguida de un valor que coincide con el tipo de valor devuelto devolverá este
valor al autor de llamada del método.
Có digo completo
Ejercicios de integració n
40. Una gran cadena de electrodoméstico recibe mensualmente un informe consolidado de todas sus sucursales
conteniendo la siguiente información:
 Código de sucursal (alfabético 3 caracteres)
El listado se encuentra ordenado por código de sucursal, producto y cantidad vendida.
Se pide informar:
Cantidad total vendida por cada sucursal Respetando la siguiente leyenda “La sucursal XXX vendió
yyyyyy productos”
Sucursal con la mejor venta, se debe respetar la siguiente leyenda: “La sucursal con mejor venta fue XXX
y vendió yyyyy productos”
Ejemplo de utilizació n de vectores o “arreglos” unidimensionales

41. Se tienen los montos de ventas totales de los n primeros meses (definidos por el usuario), correspondiente a un
mismo año de un comercio. Se quiere calcular e informar la venta promedio de esos meses, así como el nombre
del mes y el monto de la venta de aquellos meses en que la venta superó a la venta promedio calculada. Las
ventas se encuentras ordenadas por mes ascendente (enero al mes indicado por el usuario). El usuario podría no
requerir ningún informe indicando 0 como número de meses a procesar.
42. Idem al ejercicio anterior pero se pide que el informe sea por mes descendente, (de aquellos meses que
superaron la venta promedio)
Además se solicitan informar el promedio de ventas de los meses que superaron la venta promedio total. (esto
quiere decir por ejemplo si tenemos venta promedio de los 12 meses por $100, se pide informar el promedio de
la venta de aquellos meses cuya venta superó al promedio)
Va un ejemplo de los datos (no está el ordenamiento)
Mes Venta mensual

1 23 Promedio de las ventas 64,75
2 44
3 53 Meses que superan la venta promedio
4 63 Mes 1 66
5 12 Mes 2 89
6 34 Mes 3 123
7 54 Mes 4 145
8 66 Mes 5 71
9 89
10 123 Promedio de las ventas de los meses que superan el promedio
11 145 98,8
12 71
43. Se tienen los montos de ventas diarias de un comercio para n meses (de un mismo año). La información no está
ordenada por mes, ni todos los meses registran ventas.
Se necesita informar un listado ordenado por mes de los montos mensuales indicando primeros aquellos meses
que no registraron ventas.
44. Una agencia de autos nos pide confeccionar un programa que permita informar el estado de las ventas de la
agencia por modelo de auto.
Se nos provee la siguiente información:
 Los modelos de autos están codificados numéricamente de 1 a 49.
 Las descripciones de los modelos de los autos son cargados manualmente por un usuario.
 Cada venta se registra con código de modelo, y el importe vendido. Las ventas no se realizan ordenadamente,
ni tienen determinada su finalización de carga de forma preestablecida.
Al final de del día se necesita contar con:

 Listado de las ventas totales registradas por cada modelo de auto, este listado debe mostrar el código del modelo,
Su descripción y el importe total vendido DEBE MOSTRAR SOLO LOS MODELOS QUE HAYAN REGISTRADO VENTAS.
Incluyendo el encabezado de títulos tal como se muestra a continuación.
 Modelo que registro la mayor venta unitaria. Se debe visualizar con leyenda “el modelo que registro la mejor venta
fue <<modelo>> por <<importe>> pesos.” .
Tomando el ejemplo suministrado debería visualizarse:
El modelo que registró la mejor venta fue: Mondeo por 280000 pesos.
PILA
Introducció n
La estructura de datos pila es, utilizada frecuentemente en los programas más usuales. Es una estructura de datos que
almacena y recupera sus elementos atendiendo a un orden estricto. Las pilas se conocen también como estructuras LIFO
(Last-in, first-out, último en entrar primero en salir).
Las pilas se utilizan en compiladores, sistemas operativos y programas de aplicaciones. Una aplicación interesante es la
evaluación de expresiones aritméticas, también la organización de la memoria.
CONCEPTO DE PILA
Una pila (stack) es una colección ordenada de elementos a los cuales sólo se puede acceder por un único lugar o
extremo de la pila. Los elementos se añaden o se quitan (borran) de la pila sólo por su parte superior (cima). Este es el
caso de una pila de platos, una pila de libros, etc.
A recordar
Una pila es una estructura de datos de entradas ordenadas que sólo se pueden introducir y eliminar por un extremo,
llamado cima.
Cuando se dice que la pila está ordenada, lo que se quiere decir es que hay un elemento al que se puede acceder primero
(el que está encima de la pila), otro elemento al que se puede acceder en segundo lugar (justo el elemento que está
debajo de la cima), un tercero, etc. No se requiere que las entradas se puedan comparar utilizando el operador “menor
que” (<) y pueden ser de cualquier tipo.
Las entradas de la pila deben ser eliminadas en el orden inverso al que se situaron en la misma. Por ejemplo, se puede
crear una pila de libros, situando primero un diccionario, encima de él una enciclopedia y encima de ambos una novela, de
modo que la pila tendrá la novela en la parte superior.
Cuando se quitan los libros de la pila, primero debe quitarse la novela, luego la enciclopedia y por último el diccionario.
Debido a su propiedad específica último en entrar, primero en salir se conoce a las pilas como estructuras de datos LIFO
(last-in, first-out)
Las operaciones usuales en la pila son Insertar y Quitar. La operación Insertar (push) añade un elemento en la cima de la
pila, y la operación Quitar (pop) elimina o saca un elemento de la pila. La Figura 9.2 muestra una secuencia de operaciones
Insertar y Quitar. El último elemento añadido a la pila es el primero que se quita de ella.
Poner y quitar elementos de la pila

La operación Insertar (push) sitúa un elemento dato en la cima de la pila, y Quitar (pop) elimina o quita el elemento de la
pila.
La pila se puede implementar guardando los elementos en un array, en cuyo caso su dimensión o longitud es fija.
También se puede utilizar un Vector para almacenar los elementos.
Una pila puede estar vacía (no tiene elementos) o llena (en la representación con un array —arreglo—, si se ha llegado al
último elemento).
Si un programa intenta sacar un elemento de una pila vacía, se producirá un error, una excepción, debido a que esa
operación es imposible; esta situación se denomina desbordamiento negativo (underflow). Por el contrario, si un
programa intenta poner un elemento en una pila llena, se produce un error, una excepción, de
desbordamiento (overflow) o rebosamiento. Para evitar estas situaciones se diseñan métodos que comprueban si la pila
está llena o vacía.
Especificaciones de una pila

Las operaciones que sirven para definir una pila y poder manipular su contenido son las siguientes
(no todas ellas se implementan al definir una pila):
Tipo de dato Dato que se almacena en la pila.

Operaciones
Crear Pila Inicia.
Insertar (push) Pone un dato en la pila.
Quitar (pop) Retira (saca) un dato de la pila.
Pila vacía Comprueba si la pila no tiene elementos.
Pila llena Comprueba si la pila está llena de elementos.
Limpiar pila Quita todos sus elementos y deja la pila vacía.
Cima Pila Obtiene el elemento cima de la pila.
Tamaño de la pila Número de elementos máximo que puede contener la pila.
T IPO DE DATO PILA IMPLEMENT ADO CON ARRAYS

Los elementos que forman la pila se guardan en arrays (arreglo. La implementación con un array (arreglo) es estática ya
que el arrray es de tamaño fijo. La clase PilaLineal, con esta representación, necesita un array y una variable numérica,
cima, que apunte al último elemento colocado en la pila. Al utilizar un array es necesario tener en cuenta que el tamaño
de la pila no puede exceder el número de elementos del array, y la condición pila llena será significativa para el diseño.
El método usual de introducir elementos en una pila es definir el fondo de la pila en la posición 0 del array y sin ningún
elemento en su interior, es decir, definir una pila vacía; a continuación, se van introduciendo elementos en la pila (en el
array), de modo que el primer elemento añadido se introduce en una pila vacía y en la posición 0, el segundo elemento en
la posición 1, el siguiente en la posición 2 y así sucesivamente. Con estas operaciones, el índice que apunta a la cima de la
pila se va incrementando en 1 cada vez que se añade un nuevo elemento. Los algoritmos de introducir, “insertar” (push) y
“quitar”, sacar, (pop) datos de la pila son:
Insertar/apilar/push
1. Verificar si la pila no está llena.
2. Incrementar en 1 el puntero índice de la pila.
3. Almacenar elemento en la posición del puntero de la pila.
Quitar/desapilar/pop
1. Verificar si la pila no está vacía.
2. Leer el elemento de la posición del puntero de la pila.
3. Decrementar en 1 el puntero de la pila.
El rango de elementos que puede tener una pila varía de 0 a tamaño de pila -1 en el supuesto de que el array se
defina de tamaño tamaño de pila elementos. De modo que, en una pila llena, el puntero (índice del array) de la
pila tiene el valor TAMPILA-1, y en una pila vacía el puntero tendrá el valor -1 (el valor 0, teóricamente, es el índice
del primer elemento).
Estructra de dato Cola.

Una cola (queue en inglés) es una lista de elementos en donde siempre se insertan nuevos elementos al final de la lista y
se extraen elementos desde el inicio de la lista. También se conoce a las colas como listas FIFO(FIRST IN - FIRST OUT: el
primero que entra es el primero que sale).
Las operaciones básicas en una cola son:

encolar(x): inserta el elemento x al final de la cola (enqueue en inglés).
sacar(): retorna el elemento que se ubica al inicio de la cola (dequeue en inglés).
estaVacia(): retorna verdadero si la cola esta vacía, falso en caso contrario.
Al igual que con el TDA pila, una cola se puede implementar tanto con arreglos como con listas enlazadas. A continuación
se verá la implementación usando un arreglo.
Las variables de instancia necesarias en la implementación son:
primero: indica el índice de la posición del primer elemento de la cola, es decir, la posición el elemento a retornar
cuando se invoque sacar.
ultimo: indica el índice de la posición de último elemento de la cola. Si se invoca encolar, el elemento debe ser
insertado en el casillero siguiente al que indica la variable.
numElem: indica cuántos elementos posee la cola. Definiendo MAX_ELEM como el tamaño máximo del arreglo, y
por lo tanto de la cola, entonces la cola esta vacía si numElem==0 y está llena sinumElem==MAX_ELEM.
Un detalle faltante es el siguiente: ¿qué pasa si la variable ultimo sobrepasa el rango de índices del arreglo?
Esto se soluciona definiendo que si después de insertar un elemento el índice ultimo == MAX_ELEM, entonces se
asigna ultimo = 0 , y los siguientes elementos serán insertados al comienzo del arreglo. Esto no produce ningún efecto en
la lógica de las operaciones del TDA, pues siempre se saca el elemento referenciado por el índice primero, aunque en
valor absoluto primero > ultimo. Este enfoque es conocido como implementación con arreglo circular, y la forma más fácil
de implementarlo es haciendo la aritmética de subíndices móduloMAX_ELEM.

Ejemplo Java…. (no hubo tiempo de codificarlo en NET)
COLA ACOPLADA
Ejercicios Pilas y colas
Ejercicios TDA Pila
45. Escribir un método, copiarPila(), que copie el contenido de una pila en otra. El método tendrá dos argumentos de
tipo pila, uno para la pila fuente y otro para la pila destino. Utilizar las operaciones definidas sobre el TAD Pila.
46. Escribir un programa en el que se manejen un total de n = 3 pilas: P1, P2, P3

La entrada de datos serán pares de enteros (i,j) tal que 1 ≤ abs(i) ≤ n. De tal forma que el criterio de selección de
pila será:
• Si i es positivo, debe insertarse el elemento j en la pila Pi.
• Si i es negativo, debe eliminarse el elemento j de la pila Pi.
• Si i es cero, fin del proceso de entrada.
Los datos de entrada se introducen por teclado. Cuando termina el proceso el programa debe escribir el
contenido de la n Pilas en pantalla.
47. Escribir un método para determinar si una secuencia de caracteres de entrada es de la forma: X & Y siendo X
una cadena de caracteres e Y la cadena inversa. El carácter & es el separador.
El siguiente ejemplo corresponde a una cadena inversa correcta Ej: hola&aloh
Esta otra expresión no lo es: hola&ahol
Ejercicios TDA Cola
48. Suponga que tiene ya codificados los métodos que implementan las operaciones del TAD Cola. Escribir un
método para crear una copia de una cola determinada. Las operaciones que se han de utilizar serán únicamente
las del TAD Cola.
49. A la clase que representa una cola implementada con un array circular y dos variables, (similar al del apunte
teórico) frente y fin, se le añade una variable más que guarda el número de elementos de la cola. Escribir de
nuevo los métodos de manejo de colas considerando este campo contador.
50. Se tiene una pila de N enteros positivos como máximo 100. Con las operaciones básicas de pilas y colas escribir
un fragmento de código para poner todos los elementos que son par de la pila en la cola.
Trabajo Prá ctico 1– Algoritmos de ordenamiento
Lineamientos bá sicos
 El trabajo se realizará en grupos.

 La fecha de entrega es el miércoles 13 de noviembre de 2019.
 Se debe realizar una entrega en digital de código (.zip) e informe (.pdf), en formato digital o por mail a
ejtejerina@gmail.com.
 El lenguaje de implementación es .NET.
 Incluir en el informe los requisitos y procedimientos para su compilación y ejecución.
Cá lculo empírico de tiempos de ejecució n
Implementar los siguientes algoritmos de ordenamiento para números enteros positivos:
 Selección
 Inserción
 Burbujeo
 Shell
El informe debe tener lo siguiente:
a) Detallar el entorno donde se realizan las tomas de tiempo (hardware, Sistema operativo, etc)
b) Para cada uno de los algoritmos, realizar una breve descripcion, analizar su complejidad teórica y compararlos
(tiempo promedio y peor tiempo).
c) Construir 3 sets de números aleatorios con 100.000 números positivos (orden ascendente, orden descendente, orden
aleatorio).
d) Calcular los tiempos de ejecución de cada algoritmo utilizando los primeros: 1.000, 5.000, 10.000, 50.000 y 100.000
números de cada set.
e) Determinar los tiempos medios de ejecución para cada rango-algoritmo y graficar.
f) Determinar para cada algoritmo anterior las características que debe tener un set para que se comporte de la peor
forma posible (si el algoritmo lo permite).
GLOSARIO de .NET
El objetivo principal de este glosario es aclarar los significados de algunos de los términos y acrónimos que aparecen
frecuentemente en la documentación de .NET sin definiciones.
AOT
Compilador Ahead Of Time.
Similar a JIT, este compilador también convierte IL en código de máquina. A diferencia de la compilación JIT, la compilación AOT
ocurre antes de que la aplicación se ejecute y, normalmente, se realiza en un equipo diferente. Dado que las cadenas de la
herramienta de AOT no se compilan en tiempo de ejecución, no tienen que minimizar el tiempo dedicado a compilar. Esto significa
que pueden dedicar más tiempo a la optimización. Puesto que el contexto de AOT es toda la aplicación, el compilador AOT también
realiza vinculación entre módulos y el análisis de todo el programa, lo que significa que se siguen todas las referencias y se genera un
archivo ejecutable único.
ASP.NET
La implementación original de ASP.NET que se distribuye con .NET Framework.
A veces, ASP.NET es un término genérico que hace referencia a ambas implementaciones de ASP.NET, incluido ASP.NET Core. El
significado que lleva el término en una instancia específica se determina según el contexto. Haga referencia a ASP.NET 4.x cuando
desee dejar claro que no usa ASP.NET para indicar ambas implementaciones.
ASP.NET Core
Una implementación multiplataforma, de alto rendimiento y de código abierto de ASP.NET compilada en .NET Core.
ensamblado
Un archivo .dll/.exe que puede contener una colección de API a la que puede llamarse mediante aplicaciones u otros ensamblados.
Un ensamblado puede incluir tipos como interfaces, clases, estructuras, enumeraciones y delegados. A veces, se hace referencia a
los ensamblados de la carpeta bin de un proyecto como archivos binarios.
CLR
Common Language Runtime.
El significado exacto depende del contexto, pero normalmente hace referencia al entorno de ejecución de .NET Framework. CLR
controla la asignación y administración de memoria. CLR es también una máquina virtual que no solo ejecuta aplicaciones, sino que
también genera y compila código sobre la marcha mediante un compilador JIT. La implementación actual de Microsoft CLR es solo
Windows.
CoreCLR
.NET Core Common Language Runtime.
Este CLR se crea a partir del mismo código base que el CLR. Originalmente, CoreCLR era el entorno de ejecución de Silverlight y
estaba diseñado para ejecutarse en varias plataformas, concretamente Windows OS X. Ahora, CoreCLR forma parte de .NET Core y
representa una versión simplificada de CLR. Sigue siendo un entorno de ejecución multiplataforma y ahora incluye compatibilidad
con muchas distribuciones de Linux. CoreCLR es también una máquina virtual con funciones de ejecución de código y JIT.
GC
Recolector de elementos no utilizados.
El recolector de elementos no utilizados es una implementación de administración de memoria automática. GC libera la memoria
ocupada por objetos que ya no se usan.
IL
Lenguaje intermedio.
Los lenguajes .NET de nivel alto, como C#, compilan en un conjunto de instrucciones independiente del hardware, lo que se
denomina lenguaje intermedio (IL). A veces, se hace referencia al IL como MSIL (IL de Microsoft) o CIL (Common IL).
JIT
Compilador Just-In-Time.
Similar a AOT, este compilador convierte el IL en código de máquina que entienda el procesador. A diferencia de AOT, la
compilación JIT se produce a petición y se lleva a cabo en el mismo equipo en que debe ejecutarse el código. Puesto que la
compilación JIT tiene lugar durante la ejecución de la aplicación, el tiempo de compilación es parte del tiempo de ejecución. Por
tanto, los compiladores JIT tienen que compensar el tiempo invertido en optimizar el código con el ahorro que puede generar el
código resultante. Pero un JIT conoce el hardware real y puede liberar a los desarrolladores de tener que enviar diferentes
implementaciones.
implementació n de .NET
Una implementación de .NET incluye lo siguiente:
Uno o varios entornos de ejecución. Ejemplos: CLR, CoreCLR, CoreRT.
Una biblioteca de clases que implementa una versión de .NET Standard y puede incluir API adicionales. Ejemplos: biblioteca de clases
base de .NET Framework, biblioteca de clases base de .NET Core.
Opcionalmente, uno o varios marcos de trabajo de la aplicación. Ejemplos: ASP.NET, Windows Forms y WPF se incluyen en .NET
Framework.
Opcionalmente, herramientas de desarrollo. Algunas herramientas de desarrollo se comparten entre varias implementaciones.

Biblioteca
Una colección de API que pueden llamarse mediante aplicaciones u otras bibliotecas. Una biblioteca de .NET se compone de uno o
varios ensamblados.
Las palabras biblioteca y Framework se usan a menudo como sinónimos.
Metapaquete
Un paquete de NuGet que no tiene ninguna biblioteca propia pero es solo una lista de dependencias. Los paquetes incluidos pueden
establecer opcionalmente la API de una plataforma de destino.
Mono
Mono es una implementación de .NET multiplataforma y de código abierto que se usa principalmente cuando se requiere un
entorno de ejecución pequeño. Es el entorno de ejecución que activa las aplicaciones de Xamarin en Android, Mac, iOS, tvOS y
watchOS, y se centra principalmente en aplicaciones que requieren una superficie pequeña.
Admite todas las versiones de .NET Standard publicadas actualmente.
Históricamente, Mono implementaba la API de .NET Framework más grande y emulaba algunas de las funciones más populares en
Unix. A veces, se usa para ejecutar aplicaciones de .NET que se basan en estas capacidades en Unix.
Mono se suele usar con un compilador Just-In-Time, pero también incluye un compilador estático completo (compilación Ahead Of
Time) que se usa en plataformas como iOS.
El término que engloba .NET Standard y todas las cargas de trabajo e implementaciones de .NET. Siempre en mayúsculas,
nunca ".Net".
Nú cleo de .NET
Una implementación multiplataforma, de alto rendimiento y de código abierto de .NET. Incluye Core Common Language Runtime
(CoreCLR), el entorno de ejecución AOT de Core (CoreRT, en desarrollo), la biblioteca de clases base de Core y el SDK de Core.
CLI de .NET Core

Una cadena de herramientas multiplataforma para desarrollar aplicaciones de .NET Core.
SDK de .NET Core

Un conjunto de bibliotecas y herramientas que permiten a los desarrolladores crear aplicaciones y bibliotecas de .NET
Core. Incluye la CLI de .NET Core para compilar aplicaciones, el entorno de ejecución y las bibliotecas de .NET Core para
compilar y ejecutar aplicaciones, y el ejecutable dotnet (dotnet.exe) que ejecuta comandos de la CLI y ejecuta
aplicaciones.
.NET Framework
Una implementación de .NET que se ejecuta solo en Windows. Incluye Common Language Runtime (CLR), la biblioteca
de clases base y las bibliotecas de marco de trabajo de la aplicación, como ASP.NET, Windows Forms y WPF.
.NET Native
Una cadena de herramientas del compilador que genera código nativo Ahead Of Time (AOT), en lugar de Just-In-Time
(JIT).
La compilación se produce en el equipo del desarrollador, de forma similar a cómo funcionan el compilador y el
enlazador de C++.Quita el código que no se usa y emplea más tiempo en optimizarlo. Extrae código de bibliotecas y lo
combina en el archivo ejecutable. El resultado es un módulo único que representa toda la aplicación.
Un sistema operativo y el hardware en que se ejecuta, como Windows, macOS, Linux, iOS y Android.
Aquí tiene ejemplos de uso en frases:
".NET Core es una implementación multiplataforma de .NET".
"Los perfiles de PCL representan plataformas de Microsoft, mientras que .NET Standard es independiente de la
plataforma".
La documentación de .NET usa con frecuencia "plataforma de .NET" para indicar una implementación de .NET o la pila
de .NET que incluye todas las implementaciones. Estos dos usos tienden a confundirse con el significado principal
(sistema operativo o hardware), por tanto, tenemos previsto eliminar estos usos de la documentación.
motor en tiempo de ejecución
El entorno de ejecución de un programa administrado.
El sistema operativo forma parte del entorno de ejecución, pero no del entorno de ejecución .NET. Estos son algunos
ejemplos de los entornos de ejecución .NET:
Common Language Runtime (CLR)
Core Common Language Runtime (CoreCLR)
.NET Native (para UWP)
Entorno de ejecución Mono
A veces, la documentación de .NET usa "entorno de ejecución" para indicar una implementación de .NET. Por ejemplo,
en las siguientes frases "entorno de ejecución" debe reemplazarse por "implementación":
"Los diversos entornos de ejecución .NET implementan versiones concretas de .NET Standard".
"Las bibliotecas diseñadas para ejecutarse en varios entornos de ejecución deben tener como destino este marco de
trabajo".(Hace referencia a .NET Standard).
"Los diversos entornos de ejecución .NET implementan versiones concretas de .NET Standard. … Cada versión del
entorno de ejecución de .NET anuncia la última versión de .NET Standard que admite...".
Tenemos previsto eliminar este uso incoherente.
pila
Un conjunto de tecnologías de programación que se usan para compilar y ejecutar aplicaciones.
La "pila de .NET" hace referencia a .NET Standard y a todas las implementaciones de .NET. La frase "una pila de .NET"
puede hacer referencia a una implementación de .NET.
versión de .NET Framework de destino
La colección de API de las que depende una aplicación o biblioteca de .NET.
Una aplicación o biblioteca puede tener como destino una versión de .NET Standard (por ejemplo, .NET Standard 2.0),
que es la especificación de un conjunto estándar de API de todas las implementaciones de .NET. Una aplicación o
biblioteca también puede tener como destino una versión de una implementación específica de .NET; en este caso,
obtiene acceso a las API específicas de la implementación. Por ejemplo, una aplicación que tenga como destino
Xamarin.iOS obtiene acceso a contenedores de la API de iOS proporcionados por Xamarin.
Para algunas plataformas de destino (por ejemplo, .NET Framework), las API disponibles se definen mediante los
ensamblados que una implementación de .NET instala en un sistema y pueden incluir las API del marco de trabajo de la
aplicación (por ejemplo, ASP.NET o Windows Forms). Para plataformas de destino basadas en paquetes (por ejemplo,
.NET Standard y .NET Core), las API se definen mediante los paquetes instalados en la aplicación o biblioteca. En ese
caso, la plataforma de destino especifica implícitamente un metapaquete que hace referencia a todos los paquetes que
forman el marco de trabajo.
Fuentes:
Cuadernillo de programación JAVA programación aplicada
https://docs.microsoft.com
https://msdn.microsoft.com/es-ar
https://es.stackoverflow.com/

Introducción a .NET Core y C# con ejemplos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introducción a .NET Core y C# con ejemplos

Cargado por

Copyright:

Formatos disponibles

Materia: Paradigmas Año 2019 Docente Lic.

Versión del documento 6.2 20190525

UNIDAD 1– INTRODUCCION A NET CORE

Informació n general acerca de .NET Framework

.NET Core tiene las siguientes características:

 Multiplataforma: se ejecuta en los sistemas operativos Windows, macOS y Linux.

Palabras reservadas o clave

El sistema de tipos de C# contiene las siguientes categorías:

Todos los tipos de valor se derivan implícitamente de System.ValueType.

Las variables de tipo de valor no pueden ser null de forma predeterminada.

Tipos de datos integrados

Tipo Intervalo Tamaño

sbyte De -128 a 127 Entero de 8 bits con signo

byte De 0 a 255 Entero de 8 bits sin signo

char U+0000 a U+ffff Carácter Unicode de 16 bits

short De -32 768 a 32 767 Entero de 16 bits con signo

ushort De 0 a 65.535 Entero de 16 bits sin signo

int De -2.147.483.648 a 2.147.483.647 Entero de 32 bits con signo

uint De 0 a 4.294.967.295 Entero de 32 bits sin signo

Tabla de conversiones numéricas implícitas

Operadores de aritméticos – multiplicació n

x < y: menor que (true si x es menor que y).

Operador condicional AND

Estructura general de un programa de C# (Guía de programació n de C#

Las instrucciones de declaración se usan para declarar variables locales y constantes.

Hay otras pero no las incluiremos.

Declaraciones de variable locales

Declaración de constante local

static void Main() {

static void Main() {

Aplicación Hola mundo “sencilla”

1. Inicie Visual Studio 2017. Seleccione Archivo > Nuevo > Proyecto de la barra de menús. En el cuadro de

La plantilla crea una aplicación "Hola mundo" sencilla. Llama al método Console.WriteLine(String) para mostrar la

Console.Write("Press any key to continue...");

4. En la barra de menús, seleccione Compilar > Compilar solución. De esta forma, el programa se compila en un

5. Seleccione el botón HelloWorld con la flecha verde en la barra de herramientas para ejecutar el programa.

6. Presione cualquier tecla para cerrar la ventana de consola.

Mejorar la aplicación Hola mundo

Console.WriteLine("\nWhat is your name? ");

Este código reemplaza las instrucciones Console.WriteLine, Console.Write y Console.ReadKey existentes.

2. Compile el programa; para ello, seleccione Generar > Compilar solución.

4. Presione cualquier tecla para cerrar la ventana de consola.

El modo de depuración y versión son dos de las configuraciones de compilación predeterminadas de Visual Studio. La

Ejecute su programa en el modo de depuración y pruebe algunas características de depuración:

1. Un punto de interrupción interrumpe temporalmente la ejecución de la aplicación antes de que se ejecute la línea

Establezca un punto de interrupción en la línea que dice Console.WriteLine($"\nHello, {name}, on {date:d} at

2. Ejecute el programa en el modo de depuración seleccionando el botón HelloWorld con la flecha verde en la

7. Escriba date = new DateTime(2016,11,01,11,59,00) en la ventana Inmediato y presione la tecla Entrar.

La ventana Inmediato muestra el valor de la variable de cadena y las propiedades del valor DateTime. Además, el

9. Presione cualquier tecla para salir de la aplicación y finalice el modo de depuración.

2. Para la expresión condicional, reemplace "por ejemplo, x == 5" por lo siguiente:

Se está probando una condición de código, en la que la llamada al

3. Seleccione el botón Cerrar para cerrar el cuadro de diálogo.

4. Ejecute el programa en modo de depuración.

6. Como la condición que hemos especificado, name es null o String.Empty, se ha cumplido, la ejecución del

9. Seleccione el botón Continuar en la barra de herramientas para continuar la ejecución del programa.

6. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. La ventana Automático muestra el

7. Seleccione Depurar > Paso a paso por instrucciones o presione la tecla F11. Visual Studio llama al

Ejercicios estructuras de secuencia:

2. Leer 4 números enteros, calcular la suma e informar el resultado.

7. Dados 6 números reales, informar el promedio de los mismos.

Ejemplo de clase if-switch

Ejercicios Estructuras de decisió n (IF /Switch)