Modulo Programacion I

UNIVERSIDAD REGIONAL AUTONOMA DE LOS ANDES
FACULTAD DE: SISTEMAS MERCANTILES.

ESCUELA DE: SISTEMAS INFORMATICOS.
MODULO
1. DATOS INFORMATIVOS:
1. Carrera: Sistemas e Informática.
2. Modalidad: Presencial.
3. Periodo Académico: Abril-Octubre del 2010.
4. Semestre/Paralelo(s): Segundo
5. N° Horas(semanales): 5
6. Tutor:
2. INTRODUCCION AL MODULO:
C# o C Sharp es un lenguaje de programación que está incluido en la Plataforma .NET y corre en el
Lenguaje Común en Tiempo de Ejecución (CLR, Common Language Runtime). El primer lenguaje
en importancia para el CLR es C#, mucho de lo que soporta la Plataforma .NET está escrito en C#.
C# intenta ser el lenguaje base para escribir aplicaciones .NET
C# deriva de C y C++, es moderno, simple y enteramente orientado a objetos, simplifica y
moderniza a C++ en las áreas de clases, namespaces, sobrecarga de métodos y manejo de
excepciones. Se elimino la complejidad de C++ para hacerlo más fácil de utilizar y menos propenso
a errores.
3. COMPETENCIAS:
1. Competencias Globales:
• Implementar aplicaciones informáticas para solucionar problemas relacionados con
la captura, procesamiento, recuperación y salida de la información, en función de
los requerimientos de las organizaciones y, aplicando criterios de ingeniería de
software admitidos internacionalmente con responsabilidad y compromiso de
garantizarlo.
2. Competencias Especifica del Modulo que tributara a las competencias.
• Desarrollar programas para solucionar problemas de manejo de información
con criterios de precisión y exactitud.
• Diseñar algoritmos para solucionar problemas lógicos matemáticos
en forma eficiente y precisa.
• Aplicar técnicas propias de la programación de
sistemas, para resolver problemas básicos utilizando adecuadamente Visual
Studio.Net.
• Generar programas de cómputo para convertir estas herramientas en
eje fundamental para el adecuado uso y administración de la información.
• Desarrollar programas para solucionar requerimientos de usuarios
con precisión y exactitud.
4. OBJETIVOS:
1. Objetivo General:
Aplicar técnicas de tratamiento de la información para una eficiente resolución de
problemas a través de la computadora, con la aplicación de técnicas y procedimientos
adecuados, demostrando intuición, lógica decisión y seguridad.
2. Objetivos Específicos:
• Comprender y utilizar el método de resolución de problemas mediante el uso de
algoritmos.
• Resolver problemas mediante pseudocódigo.
• Representar los problemas mediante diagramas de flujo.
• Resolver problemas computaciones con diversos métodos de ordenamiento y
búsqueda de información.
5. PROGRAMACION CURRICULAR DEL MODULO:
Parcial:
Primero.
Contenido programático:
1 Metodología de la Programación
1.1 Definición
1.2 La Resolución de Problemas utilizando la Computadora
1.3 El Algoritmo
1.4 Características del Algoritmo
1.5 Fases para la resolución de Problemas
1.6 Herramientas de Programación
1.7 Tipos de Datos
1.8 Identificadores
1.9 Constantes
1.10 Variables
1.11 Sentencia de Asignación
1.12 Reglas de Asignación
1.13 Operadores utilizados en Programación
1.14 Precedencia de Operadores
1.15 Reglas de Evaluación
1.16 Escritura de fórmulas
1.17 Operaciones de Entrada y Salida (I/O) de Datos
1.18 Programación Interactiva
Competencia:
• Diseñar algoritmos para solucionar problemas lógicos matemáticos en forma
eficiente y precisa.
Forma organizativa Docente.
CONTENIDOS N° HORAS DE N° HORAS DE

TEORIA PRACTICA
1 Metodología de la Programación
1
2 1.1 Definición.
1
1
1.3 El Algoritmo
1
1
1
1
1.7 Tipos de Datos
1
1.8 Identificadores
1
1.9 Constantes
1
1.10 Variables
1 1
1 1
1
1
1 1
1 1
1
1 1
Metodología:
Exposición magistral.
Inductivo-deductivo.
A.B.P.
Recursos Didácticos:
Se describen al final.
Evaluación de la Competencia:
Se evidenciara en la solución que de el estudiante a los problemas planteados.
Tarea Autónoma:
Desarrollar ejercicios.
Redactar un glosario de términos informáticos.
Investigación bibliográfica de los temas de la articulación.
Parcial:
Segundo.
2. Introducción a C#
2.1 Origen y necesidad de un nuevo Lenguaje.
2.2 Características de C#.
2.3 Escritura de aplicaciones.
2.4 Punto de entrada.
2.5 Compilación en linea de comandos.
2.6 Compilación con Visual Studio.net.
Competencia:
• Aplicar técnicas propias de la programación de sistemas, para resolver problemas básicos
utilizando adecuadamente Visual Studio.Net.

TEORIA PRACTICA
2. 2. Introducción a C#
2.1 2.1 Origen y necesidad de un nuevo Lenguaje. 2 2
2.2 Características de C#. 2 2
2.3 Escritura de aplicaciones. 2 2
2.4 Punto de entrada. 2 2
2.5 Compilación en linea de comandos. 2 2
2.6 Compilación con Visual Studio.net. 2 3
Metodología:
Inductivo deductivo.
A.B.P.
En la generación de nuevas formas de resolver los ejercicios.
Tarea Autónoma:
Parcial:
Tercero.
3. El Preprocesador
2.1 3.1 Concepto de preprocesador
3.2 Directivas de preprocesador
3.2.1 Concepto de directiva. Sintaxis.
3.2.2 Definición de identificadores de preprocesador
3.2.3 Eliminación de identificadores de preprocesador
3.2.4 Compilación condicional.
3.2.5 Generación de avisos y errores.
3.2.6 Cambios en la numeración de líneas
3.2.7 Mercado de regiones de código.
3.3 Aspectos léxicos.
3.3.1 Comentarios.
3.3.2 Identificadores
3.3.3 Palabra reservadas
3.3.4 Literales
Competencias:
• Generar programas de cómputo para convertir estas herramientas en eje fundamental para el
adecuado uso y administración de la información.

TEORIA PRACTICA
3. 3. El Preprocesador
2.1 3.1 Concepto de preprocesador 1 1
3.2 Directivas de preprocesador
3.2.1 Concepto de directiva. Sintaxis. 1 1
3.2.2 Definición de identificadores de preprocesador 1 1
3.2.3 Eliminación de identificadores de preprocesador 1 1
3.2.4 Compilación condicional. 1 2
3.2.5 Generación de avisos y errores. 1 1
3.2.6 Cambios en la numeración de líneas 1 1
3.2.7 Mercado de regiones de código. 1 1
3.3 Aspectos léxicos.
3.3.1 Comentarios. 1 1
3.3.2 Identificadores 1 2
3.3.3 Palabra reservadas 1 1
3.3.4 Literales 1 1
Metodología:
Ensayo error.
A.B.P.
En la forma de desarrollar lógicamente los algoritmos.
Tarea Autónoma:
Parcial:
Cuarto.
4. Bucles
4.1 Estructuras básicas
4.2 Estructura secuencias.
4.3 Estructura de decisión.
4.4 Estructura ciclo.
4.5 Ciclo Mientras.
Competencias:
• Desarrollar programas para solucionar requerimientos de usuarios con precisión y exactitud.

TEORIA PRACTICA
4. Bucles
4.1 Estructuras básicas 1 4
4.2 Estructura secuencias. 1 4
4.3 Estructura de decisión. 1 4
4.4 Estructura ciclo. 1 4
4.5 Ciclo Mientras. 1 4
Metodología:
Ensayo error.
A.B.P.
Buscar nuevas soluciones en el análisis de problemas reales.
Tarea Autónoma:
1. CONTENIDOS CIENTIFICOS POR ARTICULACION:

ARTICULACION 1
Tema METODOLOGIA DE LA PROGRAMACION
Contenidos
1. Metodología de la Programación
1.1 Definición
La informática nació como respuesta a la necesidad de procesar grandes cantidades de
información y automatizar una serie de tareas repetitivas, obteniendo mejores resultados en
menos tiempo.
Con la aparición del microprocesador aparecieron los primeros lenguajes de programación.
Estos lenguajes están estrechamente ligados a las instrucciones que ofrece el procesador. Son
los lenguajes de bajo nivel, y están constituidos por instrucciones equivalentes a las
instrucciones del procesador. Actualmente se siguen utilizando para realizar determinadas
tareas, bajo la forma de lenguajes ensambladores.
Más tarde nacieron los lenguajes de alto nivel, como el Pascal, Basic, C y un largo etcétera, que
ya ofrecen sentencias de control y permiten estructurar los programas en diferentes módulos o
bloques funcionales. Además de la programación imperativa tradicional, aparecieron nuevas
formas de comprender la programación adaptada a otro tipo de requisitos, como son la
programación concurrente y la programación declarativa.
Por último, con el auge de las interfaces gráficas nacieron los lenguajes visuales y orientados a
eventos como Visual Basic, y los también orientados a objetos como Java. En definitiva, existe
una amplia gama de lenguajes de programación aplicables en multitud de áreas dentro de la
informática. La programación no es cosa de 'gurús'. Cualquier usuario puede necesitar
automatizar una tarea mediante un archivo por lotes, una macro, un script... y es preciso saber
programar. Una vez se tiene una base y una metodología de programación es fácil aprender
cualquier lenguaje.
La metodología de la programación es un conjunto de conceptos que nos enseña a combinar los
diferentes elementos presentes en un lenguaje de programación para obtener una resolución a
un problema dado de forma que dicha resolución sea lo más eficaz posible.
Habiendo adquirido una buena formación y conociendo la base de la programación, será más
fácil y ameno elaborar un programa, ya que sólo habrá que habituarse a las características que
ofrezca el lenguaje de programación que se esté usando, centrándose únicamente en cómo
resolver el problema, y no en qué pasa si pongo esto aquí o si pruebo esto.
El ratón y el teclado introducen datos en la memoria central cuando se ejecuta el programa. Los
datos intermedios o auxiliares se transfieren desde la unidad de disco (archivo) a la pantalla y a
la unidad de disco, a medida que se ejecuta el programa.
Cuando un programa se ejecuta, se debe situar primero en memoria central de igual modo que
los datos. Sin embargo, la información almacenada en la memoria se pierde (borra) cuando se
apaga (desconecta de la red eléctrica) la computadora, y por otra parte le memoria central es
limitada en capacidad.
Por esta razón, para poder disponer de almacenamiento permanente, tanto para programas como
para datos, se necesitan dispositivos de almacenamiento secundario, auxiliar o masivo (mass
storage, o secondary storage).
En el campo de las computadoras es frecuente utilizar la palabra memoria y almacenamiento o
memoria externa, indistintamente. En este documento se utilizará el término memoria sólo para
referirse a la memoria central.
1.3 El Algoritmo
Para que la solución de un problema sea llevada hasta un lenguaje de programación, los
pasos expresados en el algoritmo deben ser lo más detallados posible, de manera que cada
uno de ellos implique una operación trivial; es decir, que los pasos no impliquen procesos
que requieran de una solución algorítmica. En caso de presentarse esta situación, el
algoritmo debe ser refinado, lo que equivale a desarrollar nuevamente el algoritmo para la
tarea concreta a la que se hace mención.
Si el problema que se desea solucionar es muy grande o complejo, es recomendable
dividirlo en tareas que se puedan abordar independientemente y que resulten más sencillas
de solucionar. A esto se le llama diseño modular.
"Un algoritmo se define como un método que se realiza paso a paso para solucionar un
problema que termina en un número finito de pasos".
Un algoritmo debe tener al menos las siguientes características:
Ser preciso: esto significa que las operaciones o pasos del algoritmo deben desarrollarse en
un orden estricto, ya que el desarrollo de cada paso debe obedecer a un orden lógico.
Ser definido. Ya que en el área de programación, el algoritmo se desarrolla como paso
fundamental para desarrollar un programa, es necesario tener en cuenta que el computador
solo desarrollará las tareas programadas y con los datos suministrados; es decir, no puede
improvisar y tampoco se inventará o adivinará el dato que necesite para realizar un proceso.
Por eso, el algoritmo debe estar plenamente definido; esto es, que cuantas veces se ejecute,
el resultado depende estrictamente de los datos suministrados. Si se ejecuta con un mismo
conjunto de datos de entrada, el resultado será siempre el mismo.
Ser finito: esta característica implica que el número de pasos de un algoritmo, por grande y
complicado que sea el problema que soluciona, debe ser limitado. Todo algoritmo, sin
importar el número de pasos que incluya, debe llegar a un final. Para hacer evidente esta
característica, en la representación de un algoritmo siempre se incluyen los pasos inicio y
fin.
Presentación formal: para que el algoritmo sea entendido por cualquier persona interesada
es necesario que se exprese en alguna de las formas comúnmente aceptadas; pues, si se
describe de cualquier forma puede no ser muy útil ya que solo lo entenderá quien lo diseñó.
Las formas de presentación de algoritmos son: el pseudocódigo, diagrama de flujo y
diagramas de Nassi/Schneiderman, entre otras.
Corrección: el algoritmo debe ser correcto, es decir debe satisfacer la necesidad o
solucionar el problema para el cual fue diseñado. Para garantizar que el algoritmo logre el
objetivo, es necesario ponerlo a prueba; a esto se le llama verificación o prueba de
escritorio.
Eficiencia: hablar de eficiencia o complejidad de un algoritmo es evaluar los recursos de
cómputo que requiere para almacenar datos y para ejecutar operaciones frente al beneficio
que ofrece. En cuanto menos recursos requiere será más eficiente el algoritmo.
Muchos de los procedimientos utilizados para desarrollar tareas cotidianas son algorítmicos,
sin embargo, esto no significa que todo lo que se hace está determinado por un algoritmo.
El cumplimiento de las características mencionadas anteriormente permitirá determinar si
un procedimiento es o no es algorítmico.
El primer paso en el diseño de un algoritmo es conocer la temática a tratar, el segundo será
pensar en las actividades a realizar y el orden en que deben ejecutarse para lograr el
objetivo, el tercero y no menos importante es la presentación formal.
Definición del Problema
Esta fase está dada por el enunciado del problema, el cual requiere una definición clara y
precisa.
Es importante que se conozca lo que se desea que realice la computadora; mientras esto no se
conozca del todo no tiene mucho caso continuar con la siguiente etapa.
Análisis del Problema
Una vez que se ha comprendido lo que se desea de la computadora, es necesario definir:
• Los datos de entrada.
• Cuál es la información que se desea producir (salida)
• Los métodos y fórmulas que se necesitan para procesar los datos.
Una recomendación muy practica es el que nos pongamos en el lugar de la computadora y
analicemos que es lo que necesitamos que nos ordenen y en que secuencia para producir los
resultados esperados.
Diseño del Algoritmo
Las características de un buen algoritmo son:
• Debe tener un punto particular de inicio.
• Debe ser definido, no debe permitir dobles interpretaciones.
• Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar
en la
• definición del problema.
• Debe ser finito en tamaño y tiempo de ejecución.
Implementación del algoritmo
La codificación es la operación de escribir la solución del problema (de acuerdo a la lógica del
diagrama de flujo o pseudo código), en una serie de instrucciones detalladas, en un código
reconocible por la computadora, la serie de instrucciones detalladas se le conoce como código
fuente, el cual se escribe en un lenguaje de programación o lenguaje de alto nivel.
Lenguajes de Programación
Es un conjunto de símbolos, caracteres y reglas (programas) que le permiten a las personas
comunicarse con la computadora.
Los lenguajes de programación tienen un conjunto de instrucciones que nos permiten realizar
operaciones de entrada/salida, calculo, manipulación de textos, lógica/comparación y
almacenamiento/recuperación.
Los lenguajes de programación se clasifican en:
• Lenguaje Maquina: Son aquellos cuyas instrucciones son directamente entendibles
por la computadora y no necesitan traducción posterior para que la CPU pueda comprender
y ejecutar el programa. Las instrucciones en lenguaje maquina se expresan en términos de
la unidad de memoria mas pequeña el bit (dígito binario 0 o 1).
• Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se
escriben en códigos alfabéticos conocidos como mnemotécnicos para las operaciones y
direcciones simbólicas.
• Lenguaje de Alto Nivel: Los lenguajes de programación de alto nivel (BASIC, pascal,
cobol, frotran, etc.) son aquellos en los que las instrucciones o sentencias a la
computadora son escritas con palabras similares a los lenguajes humanos (en general en
ingles), lo que facilita la escritura y comprensión del programa.
1.7 Tipos de Datos
Datos: es toda información que utiliza el ordenador. Tipos Numéricos, Alfanuméricos y
Booleanos (sólo puede tener dos valores verdad o falso).
1.8 Identificadores
Los identificadores representan los datos de un programa (constantes, variables, tipos de datos).
Un identificador es una secuencia de caracteres que sirve para identificar una posición en la
memoria de la computadora, que nos permite acceder a su contenido.
Ejemplo:
Nombre
Num_hrs
Calif2
Reglas para formar un Identificador
• Debe comenzar con una letra (A a Z, mayúsculas o minúsculas) y no deben
contener espacios en blanco.
• Letras, dígitos y caracteres como la subraya ( _ ) están permitidos después del
primer carácter.
• La longitud de identificadores puede ser de hasta 8 caracteres.
1.9 Constantes
La Constante es un dato cuyo valor permanece inalterado durante la ejecución de un programa.
Se emplea para definir aquellos datos que siempre van a mantenerse invariables. Por ejemplo,
se podría definir como valor constante el valor de PI o el número de meses que tiene un año-
Ejemplo:
La constante numérica Pi: 3.14
Número de meses de un año: «12»
1.10 Variables
La Variable es un dato cuyo valor puede ser modificado durante la ejecución del programa.
Una variable es una dirección de memoria y puede verse como una pequeña caja donde se
pueden guardar valores. Estos pueden ser de cualquiera de los tipos vistos anteriormente
(numéricos, alfabéticos, alfanuméricos, etc.).
Cuando se hace mención a una variable, se está refiriendo a una pequeña zona de la memoria
principal (conjunto de posiciones contiguas) donde se va a alojar un valor. Si este valor se
modifica en algún momento del programa, el nuevo valor sustituirá al que existía
anteriormente.
Al conjunto de posiciones contiguas de memoria se le da un nombre para poder identificarlo
(nombre de la variable) y se define su tipo (clase de caracteres que puede contener). A una
variable definida de un determinado tipo, no se le pueden asignar generalmente valores de otro
tipo.
Las sentencias son los elementos básicos en los que se divide el código en un lenguaje de
programación. Al fin y al cabo, un programa no es más que un conjunto de sentencias que se
ejecutan para realizar una cierta tarea. Además, como ya habrás visto, en Pascal el signo que las
separa es el punto y coma.
El párrafo anterior termina con una verdad a medias, ya que aunque generalmente una
sentencia debe ir seguida de un punto y coma para separarla de la siguiente, existen casos en
los que no es necesario incluirlo. Y estos casos se dan cuando después de la sentencia hay una
palabra reservada de las que delimitan de alguna forma un trozo de código.
Se utilizan para asignar un valor a una variable. Si la variable tenía previamente otro valor, éste
será sustituido por el nuevo.
Se puede representar una asignación mediante el signo « = », asignando a la variable situada a
la izquierda del signo lo que hay a la derecha del mismo.
Por ejemplo: B = 10 asigna a la variable B el valor 10. La asignación de un valor se puede
realizar mediante:
Para poder realizar operaciones matemáticas, lógicas, etc., con las variables, se necesita usar los
operadores. Principalmente, se utilizan de tres tipos: Aritméticos, Relaciónales y Lógicos.
Aritméticos: son utilizados para representar operaciones de tipo matemático.
+ Suma
- Resta
* Multiplicación
/ División
% Módulo. <da como resultado el resto de una división de x para y.
** Potenciación
Los operadores *', / y % tienen mayor prioridad que + y - . Sin embargo, se puede utilizar los
paréntesis para alterar el orden de la evaluación.
Relaciónales: sirven para representar condiciones de comparación entre valores, ya sean
numéricos o alfabéticos.
Operador Significado
== Igual a
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que
1= Distinto de
- Lógicos: se emplean para expresar la lógica de condiciones, que existen en un problema de
cualquier tipo.
Operador Significado
! NOT - NO
&& AND - Y
11 OR - O
La precedencia de operadores es un conjunto de reglas que controla el orden en que el
compilador realiza las operaciones cuando se evalúa una expresión. Las operaciones con mayor
precedencia se realizan antes que las de menor prioridad. Por ejemplo, la multiplicación se
realiza antes que la suma.
En una expresión, los operadores se evalúan según el siguiente orden de prioridad;
Paréntesis. Si hay paréntesis anidados se procede primero con los más internos.
Potenciación.
Producto y división.
Suma y resta,
Operadores Relacionales.
Para resolver una expresión aritmética se deben seguir las siguientes reglas:
• Primero se resuelven las expresiones que se encuentran entre paréntesis.
• Se procede aplicando la jerarquía de operadores.
• Al evaluar una expresión, si hay dos operadores con la misma jerarquía, se procede a
evaluar de izquierda a derecha.
• Si hay expresiones relacionales, se resuelven primero paréntesis, luego se encuentran los
valores de verdad de las expresiones relacionales y por último se aplica jerarquía de
operadores lógicos. En caso de haber iguales, proceder de izquierda a derecha.
Se puede representar una asignación mediante el signo « = », asignando a la variable situada
a la izquierda del signo lo que hay a la derecha del mismo.
Por ejemplo: B = 10 asigna a la variable B el valor 10. La asignación de un valor se puede
realizar mediante:
a) Una constante: por ejemplo, asignar el valor 2500000 a la variable Sueldo-Base. Sueldo-
Base = 2500000 A partir de ese momento, la variable Sueldo-Base tendrá un valor de
2500000.
b) El contenido de otra variable: por ejemplo, asignar el valor que contenga la variable Total-
Sumas a la variable Sueldo, suponiendo la variable Total-Sumas con un valor inicial de
3575000 y la variable Sueldo con un valor inicial nulo. Sueldo = Total-Sumas
Después de la asignación, el valor de Sueldo será igual que el de Total-Sumas, 3575000.
c) El resultado "de evaluar una expresión: por ejemplo, asignar a Total-Sueldo el resultado de la
expresión; Base + Horas-Extras * Precio-Hora.
Total-Sueldo = Base + Horas-Extras * Precio-Hora.
De esta forma, en la variable Total-Sueldo quedará guardado el valor del resultado de la
evaluación de esa expresión.
Tanto en la E/S programada como la basada en interrupciones, la UCP debe encargarse de la
transferencia de datos una vez que sabe que hay datos disponibles en el controlador. Una
mejora importante para incrementar la concurrencia entre la UCP y la E/S consiste en que el
controlador del dispositivo se pueda encargar de efectuar la transferencia de datos, liberando de
este trabajo a la UCP, e interrumpir a la UCP sólo cuando haya terminado la operación
completa de EIS. Esta técnica se denomina acceso directo a memoria (DMA, Direct Memory
Access).
Cuando se utiliza acceso directo a memoria, es el controlador el que se encarga directamente de
transferir los datos entre el periférico y la memoria principal, sin requerir intervención alguna
por parte del procesador. Esta técnica funciona de la siguiente manera: cuando el procesador
desea que se imprima un bloque de datos, envía una orden al controlador indicándole la
siguiente información:
• Tipo de operación: lectura o escritura.
• Periférico involucrado en la operación.
• La dirección de memoria desde la que se va a leer o a la que va a escribir directamente con
el controlador de dispositivo (dirección).
• El número de bytes a transferir (contador).
Existen varias operaciones, las más importantes son las siguientes:
Lectura: el canal transfiere a memoria principal un bloque de palabras de tamaño especificado
en el campo nº de palabras, en orden ascendente de direcciones, empezando en la dirección
especificada en el campo dirección del dato.
Escritura: el canal transfiere datos de memoria principal al dispositivo. Las palabras se
transfieren en el mismo orden que en la operación de lectura.
Control: se utiliza esta orden para enviar instrucciones específicas al dispositivo de E/S, como
rebobinar una cinta magnética, etc.
Bifurcación: cumple en el programa de canal la misma función que una instrucción de salto en
un programa normal. El canal ejecuta las CCW en secuencia, salvo cuando aparece una CCW
de este tipo, que utiliza el campo dirección del dato como la dirección de la siguiente CCW a
ejecutar.
Flags: Los bits de este campo indican lo siguiente:
CC (Encadenamiento de comando): cuando este bit está a 1, indica al canal que la siguiente
CCW especifica una nueva operación de E/S que debe realizarse con el mismo dispositivo. El
canal ejecuta primero la operación de E/S especificada en la CCW que tiene a 1 el flag CC.
Después ejecuta la siguiente sobre el mismo dispositivo. Desde el punto de vista del
dispositivo, las dos operaciones resultantes de la primera y segunda CCW aparecen como dos
comandos de E/S separados.
CD (Encadenamiento de datos): una CCW con el bit CD a 1, indica al canal que la siguiente
CCW contiene una nueva dirección del dato y un nuevo nº de palabras. Éstos deben utilizarse
para transferir un segundo bloque de datos hacia o desdeindicándole la siguiente información:
• Tipo de operación: lectura o escritura.
• Periférico involucrado en la operación.
• La dirección de memoria desde la que se va a leer o a la que va a escribir
directamente con el controlador de dispositivo (dirección).
• El número de bytes a transferir (contador).
La programación interactiva consiste en ir modificando un programa poco a poco mientras éste
se encuentra activo. Es decir, el termino de programación interactiva no tiene que ver con el
estilo en el que esta escrito un programa sino con el proceso de escritura del código.
En ambientes no interactivos los programadores trabajan intercalando dos tipos de actividades
bien separadas: la edición y la ejecución. La programación es entonces una secuencia de
sesiones de edición de código y de sesiones de ejecución (y a veces también de fases de
compilación). Al terminar una sesión de edición, se lanza el programa y se observan los efectos
sobre el comportamiento del programa. Una vez se ha observado el programa en ejecución, se
interrumpe el programa para empezar una nueva sesión de edición. Cada actividad esta
claramente delimitada e implica un tipo de gestos distinto. El cambio entre una actividad y otra
implica un cambio de contexto mental que se convierte en un esfuerzo adicional. El
programador tiende entonces a programar en sesiones de edición largas para evitar el tener que
cambiar frecuentemente de actividad.
En ambientes interactivos, el programa todo el tiempo esta en ejecución y el programador
modifica su comportamiento haciendo un pequeño cambio a la vez. El programador trabaja en
micro-sesiones de edición tras las cuales observa inmediatamente el resultado de la edición. La
sensación del programador es que las dos actividades, modificar el programa y observar el
resultado de las modificaciones, se funden en una sola actividad.
GUIA DE APRENDIZAJE 1
• Actividades.
Actividad 1.1. Diseñar un algoritmo que pregunte al usuario:
a) su nombre, y luego lo salude.
b) dos números y luego muestre el producto.
Actividad 1.2. Implementar algoritmos que permitan:
a) Calcular el perímetro y área de un rectángulo dada su base y su altura.
b) Calcular el perímetro y área de un círculo dado su radio.
c) Calcular el volumen de una esfera dado su radio.
d) Calcular el área de un rectángulo (alineado con los ejes x e y) dadas sus
coordenadas x1,x2,y1,y2.
e) Dados los catetos de un triángulo rectángulo, calcular su hipotenusa.
Actividad 1.3. Implementar algoritmos que resuelvan los siguientes problemas:
a) Dados dos números, indicar la suma, resta, división y multiplicación de ambos.
b) Dado un número entero N, imprimir su tabla de multiplicar.
c) Dado un número entero N, imprimir su factorial.
Actividad 1.4. Escribir un algoritmo que le pida una palabra al usuario, para luego
imprimirla 1000 veces, con espacios intermedios.
• Actividades integradoras.
Elaborar algoritmos utilizando diagrama de flujo, diagrama N-S y pseudocódigo. Se pueden
utilizar problemas presentados por el tutor o utilizar problemas presentados por los
estudiantes.
• Instrucciones.
Recomendaciones Generales:
Sea claro y prolijo. Es muy importante que el código sea lo más claro y legible posible.
Es muy importante que los identificadores de funciones y variables sean coherentes. El
identificador debe ser suficientemente descriptivo.
Ponga una línea en blanco entre las definiciones de función para simplificar la lectura del
programa.
Las expresiones matemáticas complejas pueden representarse en varios pasos.
Documentación:
Documente partes del algoritmo cuyo significado pudiera no quedar del todo claro.
No documente en exceso, pero tampoco ahorre documentación necesaria. La
documentación debe ser breve y concisa.
Leer los contenidos de la primera articulación. Después de esta lectura deberías ser capaz
de:
• Definir los conceptos de lenguaje de programación, programa y compilador.
• Enumerar las fases a seguir para el desarrollo de un programa.
• Escribir la declaración de una constante o variable.
• Evaluar el resultado de expresiones aritméticas, lógicas o relacionales.
• Escribir las sentencias necesarias para leer números introducidos por teclado e imprimir
información por pantalla.
• Usar correctamente la instrucción condicional para realizar algoritmos.
Cuando acabes la lectura, resuelve las tareas de la 1 a la 4. Fíjate que en los ejercicios,
algunas de las expresiones son aritméticas (dan como resultado un número) pero otras son
expresiones lógicas (dan como resultado verdadero o falso).
Anotar cualquier duda o problema que te surja realizando estos ejercicios, para poder
comentarla en la siguiente clase.
ARTICULACION 2
Tema INTRODUCCION A C#
Contenidos
2. Introducción a C#
C# o C Sharp es un lenguaje de programación que está incluido en la Plataforma .NET y corre
en el Lenguaje Común en Tiempo de Ejecución (CLR, Common Language Runtime). El primer
lenguaje en importancia para el CLR es C#, mucho de lo que soporta la Plataforma .NET está
escrito en C#.
C# intenta ser el lenguaje base para escribir aplicaciones .NET
C# deriva de C y C++, es moderno, simple y enteramente orientado a objetos, simplifica y
moderniza a C++ en las áreas de clases, namespaces, sobrecarga de métodos y manejo de
excepciones. Se elimino la complejidad de C++ para hacerlo más fácil de utilizar y menos
propenso a errores.
2.1 Origen y necesidad de un nuevo lenguaje.
Aunque es posible escribir código para la plataforma .NET en muchos otros lenguajes, C# es el
único que ha sido diseñado específicamente para ser utilizado en ella, por lo que programarla
usando C# es mucho más sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes
ya que C# carece de elementos heredados innecesarios en .NET. Por esta razón, se suele decir
que C# es el lenguaje nativo de .NET
La sintaxis y estructuración de C# es muy parecida a la de C++ o Java, puesto que la intención
de Microsoft es facilitar la migración de códigos escritos en estos lenguajes a C# y facilitar su
aprendizaje a los desarrolladores habituados a ellos. Sin embargo, su sencillez y el alto nivel de
productividad son comparables con los de Visual Basic.
Un lenguaje que hubiese sido ideal utilizar para estos menesteres es Java, pero debido a
problemas con la empresa creadora del mismo -Sun-, Microsoft ha tenido que desarrollar un
nuevo lenguaje que añadiese a las ya probadas virtudes de Java las modificaciones que
Microsoft tenía pensado añadirle para mejorarlo aún más y hacerlo un lenguaje orientado al
desarrollo de componentes.
En resumen, C# es un lenguaje de programación que toma las mejores características de
lenguajes preexistentes como Visual Basic, Java o C++ y las combina en uno solo. El hecho de
ser relativamente reciente no implica que sea inmaduro, pues Microsoft ha escrito la mayor
parte de la BCL usándolo, por lo que su compilador es el más depurado y optimizado de los
incluidos en el .NET Framework SDK
2.2 Características del C#.
• C# provee el beneficio de un ambiente elegante y unificado.
• No soporta herencia múltiple, solamente el runtime .NET permite la herencia múltiple en la
forma de interfaces, las cuales no pueden contener implementación.
• No maneja apuntadores, para emular la función de los apuntadores se utiliza delegates el
cual provee las bases para el .NET event model.
• Por default trabaja con código administrado.
• La Plataforma .NET provee un colector de basura que es responsable de administrar la
memoria en los programas C#.
• El manejo de errores está basado en excepciones.
• Soporta los conceptos como encapsulación, herencia y polimorfismo de la programación
orientada a objetos.
• El Modelo completo de clases está construido en la cima del .NET Virtual Object System
(VOS). El modelo de objetos es parte de la infraestructura y ya no forma parte del lenguaje
de programación.
• No existen funciones globales, variables o constantes. Todo deber ser encapsulado dentro
de la clase, como un miembro de la instancia (accesible vía una instancia de clase) o un
miembro estático (vía el tipo).
• Los métodos que se definen en las clases son por default no virtuales (no pueden ser sobre
escritos al derivar clases)
• Soporta los modificadores de acceso private, protected, public y agrega un cuarto
modificador internal.
• Solamente se permite una base clase, si se requiere herencia múltiple es posible
implementar interfaces.
• No es posible utilizar variables no inicializadas.
• No es posible hacer el cast de un entero a un tipo de referencia (objeto).
• Los parámetros que son pasados son type-safe.
• El soporte de versiones lo provee el CLR.
• Permite acceder a diferentes APIs a través de .NET Common Language Specification, el
cual define el estándar de interoperabilidad entre lenguajes que se adhieran a este estándar.
• La Plataforma .NET provee un acceso transparente a COM.
• Soporta OLE
• Permite la interoperabilidad con APIs al estilo C y DLLs, esta característica para acceder a
APIs nativas es llamada Platform Invocation Services (PInvoke)
• Por default el código es safe mode, pero es posible declarar clases o sólo métodos unsafe,
esta declaración permite utilizar apuntadores, estructuras y almacenamiento de arreglos
estáticos.
• C# depende del runtime que provee la Plataforma .NET, el runtime administra la ejecución
de código.
2.3 Escritura de una aplicación.
Básicamente una aplicación en C# puede verse como un conjunto de uno o más ficheros de
código fuente con las instrucciones necesarias para que la aplicación funcione como se desea y
que son pasados al compilador para que genere un ejecutable. Cada uno de estos ficheros no es
más que un fichero de texto plano escrito usando caracteres Unicode y siguiendo la sintaxis
propia de C#.
Como primer contacto con el lenguaje, nada mejor que el típico programa de iniciación “¡Hola
Mundo!” que lo único que hace al ejecutarse es mostrar por pantalla el mensaje ¡Hola Mundo!
Su código es:[2]
1: classHolaMundo
2: {
3: staticvoid Main()
4: {
5: System.Console.WriteLine("¡Hola Mundo!");
6: }
7: }
Todo el código escrito en C# se ha de escribir dentro de una definición de clase, y lo que en la

línea 1: se dice es que se va a definir una clase (class) de nombre HolaMundo1 cuya definición
estará comprendida entre la llave de apertura de la línea 2: y su correspondiente llave de cierre
en la línea línea 7:
Dentro de la definición de la clase (línea 3:) se define un método de nombre Main cuyo código
es el indicado entre la llave de apertura de la línea 4: y su respectiva llave de cierre (línea 6:)
Un método no es más que un conjunto de instrucciones a las que se les asocia un nombre, de
modo que para posteriormente ejecutarlas baste referenciarlas por su nombre en vez de tener
que rescribirlas.
La partícula que antecede al nombre del método indica cuál es el tipo de valor que se devuelve
tras la ejecución del método, y en este caso es void que significa que no se devuelve nada. Por
su parte, los paréntesis colocados tras el nombre del método indican cuáles son los parámetros
que éste toma, y el que estén vacíos significa que el método no toma ninguno. Los parámetros
de un método permiten modificar el resultado de su ejecución en función de los valores que se
les dé en cada llamada.
La palabra static que antecede a la declaración del tipo de valor devuelto es un modificador
del significado de la declaración de método que indica que el método está asociado a la clase
dentro de la que se define y no a los objetos que se creen a partir de ella. Main() es lo que se
denomina el punto de entrada de la aplicación, que no es más que el método por el que
comenzará su ejecución. Necesita del modificador static para evitar que para llamarlo haya que
crear algún objeto de la clase donde se haya definido.
Finalmente, la línea 5: contiene la instrucción con el código a ejecutar, que lo que se hace es
solicitar la ejecución del método WriteLine() de la clase Console definida en el espacio de
nombres System pasándole como parámetro la cadena de texto con el contenido ¡Hola Mundo!
Nótese que las cadenas de textos son secuencias de caracteres delimitadas por comillas dobles
aunque dichas comillas no forman parte de la cadena. Por su parte, un espacio de nombres
puede considerarse que es para las clases algo similar a lo que un directorio es para los ficheros:
una forma de agruparlas.
El método WriteLine() se usará muy a menudo en los próximos temas, por lo que es
conveniente señalar ahora que una forma de llamarlo que se utilizará en repetidas ocasiones
consiste en pasarle un número indefinido de otros parámetros de cualquier tipo e incluir en el
primero subcadenas de la forma {i}. Con ello se consigue que se muestre por la ventana de
consola la cadena que se le pasa como primer parámetro pero sustituyéndole las subcadenas {i}
por el valor convertido en cadena de texto del parámetro que ocupe la posición i+2 en la
llamada a WriteLine(). Por ejemplo, la siguiente instrucción mostraría Tengo 5 años por
pantalla si x valiese 5:
System.Console.WriteLine("Tengo {0} años", x);
Para indicar cómo convertir cada objeto en un cadena de texto basta redefinir su método
ToString(), aunque esto es algo que no se verá hasta el Tema 5: Clases.
Antes de seguir es importante resaltar que C# es sensible a las mayúsculas, los que significa que
no da igual la capitalización con la que se escriban los identificadores. Es decir, no es lo mismo
escribir Console que COnsole o CONSOLE, y si se hace de alguna de las dos últimas formas el
compilador producirá un error debido a que en el espacio de nombres System no existe ninguna
clase con dichos nombres. En este sentido, cabe señalar que un error común entre
programadores acostumbrados a Java es llamar al punto de entrada main en vez de Main, lo que
provoca un error al compilar ejecutables en tanto que el compilador no detectará ninguna
definición de punto de entrada.
2.4 Puntos de entrada.
Ya se ha dicho que el punto de entrada de una aplicación es un método de nombre Main que
contendrá el código por donde se ha de iniciar la ejecución de la misma. Hasta ahora sólo se ha
visto una versión de Main() que no toma parámetros y tiene como tipo de retorno void, pero en
realidad todas sus posibles versiones son:
static void Main()

static int Main()
static int Main(string[] args)
static void Main(string[] args)
Como se ve, hay versiones de Main() que devuelven un valor de tipo int. Un int no es más que
un tipo de datos capaz de almacenar valor enteros comprendidos entre –2.147 1483.648 y
2.1471483.647, y el número devuelto por Main() sería interpretado como código de retorno de
la aplicación. Éste valor suele usarse para indicar si la aplicación a terminado con éxito
(generalmente valor 0) o no (valor según la causa de la terminación anormal), y en el Tema 8:
Métodos se explicará como devolver valores.
También hay versiones de Main() que toman un parámetro donde se almacenará la lista de
argumentos con los que se llamó a la aplicación, por lo que sólo es útil usar estas versiones del
punto de entrada si la aplicación va a utilizar dichos argumentos para algo. El tipo de este
parámetro es string[], lo que significa que es una tabla de cadenas de texto (en el Tema 5:
Claes se explicará detenidamente qué son las tablas y las cadenas), y su nombre -que es el que
habrá de usarse dentro del código de Main() para hacerle referencia- es args en el ejemplo,
aunque podría dársele cualquier otro
2.5. Compilación en líneas de comando.
Una vez escrito el código anterior con algún editor de textos –como el Bloc de Notas de
Windows- y almacenado en formato de texto plano en un fichero HolaMundo.cs[3], para
compilarlo basta abrir una ventana de consola (MS-DOS en Windows), colocarse en el
directorio donde se encuentre y pasárselo como parámetro al compilador así:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc HolaMundo.cs
csc.exe es el compilador de C# incluido en el .NET Framework SDK para Windows de

Microsoft. Aunque en principio el programa de instalación del SDK lo añade automáticamente
al path para poder llamarlo sin problemas desde cualquier directorio, si lo ha instalado a través
de VS.NET esto no ocurrirá y deberá configurárselo ya sea manualmente, o bien ejecutando el
fichero por lotes Common7\Tools\vsvars32.bat que VS.NET incluye bajo su directorio de
instalación, o abriendo la ventana de consola desde el icono Herramientas de Visual
Studio.NET à Símbolo del sistema de Visual Studio.NET correspondiente al grupo de
programas de VS.NET en el menú Inicio de Windows que no hace más que abrir la ventana de
consola y llamar automáticamente a vsvars32.bat. En cualquier caso, si usa otros compiladores
de C# puede que varie la forma de realizar la compilación, por lo que lo que aquí se explica en
principio sólo será válido para los compiladores de C# de Microsoft para Windows.
Tras la compilación se obtendría un ejecutable llamado HolaMundo.exe cuya ejecución
produciría la siguiente salida por la ventana de consola:
Hola Mundo!
Si la aplicación que se vaya a compilar no utilizase la ventana de consola para mostrar su salida
sino una interfaz gráfica de ventanas, entonces habría que compilarla pasando al compilador la
opción /t con el valor winexe antes del nombre del fichero a compilar. Si no se hiciese así se
abríría la ventana de consola cada vez que ejecutase la aplicación de ventanas, lo que suele ser
indeseable en este tipo de aplicaciones. Así, para compilar Ventanas.cs como ejecutable de
ventanas sería conveniente escribir:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:winexe Ventanas.cs
Nótese que aunque el nombre winexe dé la sensación de que este valor para la opción /t sólo
permite generar ejecutables de ventanas, en realidad lo que permite es generar ejecutables sin
ventana de consola asociada. Por tanto, también puede usarse para generar ejecutables que no
tengan ninguna interfaz asociada, ni de consola ni gráfica.
Si en lugar de un ejecutable -ya sea de consola o de ventanas- se desea obtener una librería,
entonces al compilar hay que pasar al compilador la opción /t con el valor library. Por ejemplo,
siguiendo con el ejemplo inicial habría que escribir:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library HolaMundo.cs
En este caso se generaría un fichero HolaMundo.dll cuyos tipos de datos podrían utilizarse
desde otros fuentes pasando al compilador una referencia a los mismos mediante la opción /r.
Por ejemplo, para compilar como ejecutable un fuente A.cs que use la clase HolaMundo de la
librería HolaMundo.dll se escribiría:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /r:HolaMundo.dll A.cs
En general /r permite referenciar a tipos definidos en cualquier ensamblado, por lo que el valor
que se le indique también puede ser el nombre de un ejecutable. Además, en cada compilación
es posible referenciar múltiples ensamblados ya sea incluiyendo la opción /r una vez por cada
uno o incluiyendo múltiples referencias en una única opción /r usando comas o puntos y comas
como separadores. Por ejemplo, las siguientes tres llamadas al compilador son equivalentes:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc
/r:HolaMundo.dll;Otro.dll;OtroMás.exe A.cs
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc
/r:HolaMundo.dll,Otro.dll,OtroMás.exeA.cs
C:\WINDOWS\....\v2.0.50727>csc /t:HolaMundo.dll /r:Otro.dll /r:OtroMás.exe A.cs
Hay que señalar que aunque no se indique nada, en toda compilación siempre se referencia por
defecto a la librería mscorlib.dll de la BCL, que incluye los tipos de uso más frecuente. Si se
usan tipos de la BCL no incluidos en ella habrá que incluir al compilar referencias a las librerías
donde estén definidos (en la documentación del SDK sobre cada tipo de la BCL puede
encontrar información sobre donde se definió)
Tanto las librerías como los ejecutables son ensamblados. Para generar un módulo de código
que no forme parte de ningún ensamblado sino que contenga definiciones de tipos que puedan
añadirse a ensamblados que se compilen posteriormente, el valor que ha de darse al compilar a
la opción /t es module. Por ejemplo:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:module HolaMundo.cs
Con la instrucción anterior se generaría un módulo llamado HolaMundo.netmodule que podría

ser añadido a compilaciones de ensamblados incluyéndolo como valor de la opción
/addmodule. Por ejemplo, para añadir el módulo anterior a la compilación del fuente librería
Lib.cs como librería se escribiría:
C:\WINDOWS\...\v2.0.50727>csc /t:library /addmodule:HolaMundo.netmodule Lib.cs
Aunque hasta ahora todas las compilaciones de ejemplo se han realizado utilizando un único
fichero de código fuente, en realidad nada impide que se puedan utilizar más. Por ejemplo, para
compilar los ficheros A.cs y B.cs en una librería A.dll se ejecutaría:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library A.cs B.cs

Nótese que el nombre que por defecto se dé al ejecutable generado siempre es igual al del
primer fuente especificado pero con la extensión propia del tipo de compilación realizada (.exe
para ejecutables, .dll para librerías y .netmodule para módulos) Sin embargo, puede
especificarse como valor en la opción /out del compilador cualquier otro tal y como muestra el
siguiente ejemplo que compila el fichero A.cs como una librería de nombre Lib.exe:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library /out:Lib.exe A.cs
Véase que aunque se haya dado un nombre terminado en .exe al fichero resultante, éste sigue
siendo una librería y no un ejecutable e intentar ejecutarlo producirían un mensaje de error.
Obviamente no tiene mucho sentido darle esa extensión, y sólo se le ha dado en este ejemplo
para demostrar que, aunque recomendable, la extensión del fichero no tiene porqué
corresponderse realmente con el tipo de fichero del que se trate.
A la hora de especificar ficheros a compilar también se pueden utilizar los caracteres de
comodín típicos del sistema operativo. Por ejemplo, para compilar todos los ficheros con
extensión .cs del directorio actual en una librería llamada Varios.dll se haría:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library /out:varios.dll *.cs
Con lo que hay que tener cuidado, y en especial al compilar varios fuentes, es con que no se
compilen a la vez más de un tipo de dato con punto de entrada, pues entonces el compilador no
sabría cuál usar como inicio de la aplicación. Para orientarlo, puede especificarse como valor de
la opción /main el nombre del tipo que contenga el Main() ha usar como punto de entrada. Así,
para compilar los ficheros A.cs y B.cs en un ejecutable cuyo punto de entrada sea el definido en
el tipo Principal, habría que escribir:
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /main:Principal A.cs B.cs
Lógicamente, para que esto funcione A.cs o B.cs tiene que contener alguna definición de algún
tipo llamado Principal con un único método válido como punto de entrada (obviamente, si
contiene varios se volvería a tener el problema de no saber cuál utilizar)
2.6. Compilación con Visual Basic.Net.
Para compilar una aplicación en Visual Studio.NET primero hay que incluirla dentro de algún
proyecto. Para ello basta pulsar el botón New Project en la página de inicio que se muestra
nada más arrancar dicha herramienta, tras lo que se obtendrá una pantalla con el aspecto
mostrado en la Ilustración 1.
En el recuadro de la ventana mostrada etiquetado como Project Types se ha de seleccionar el
tipo de proyecto a crear. Obviamente, si se va a trabajar en C# la opción que habrá que escoger
en la misma será siempre Visual C# Projects.
En el recuadro Templates se ha de seleccionar la plantilla correspondiente al subtipo de
proyecto dentro del tipo indicado en Project Types que se va a realizar. Para realizar un
ejecutable de consola, como es nuestro caso, hay que seleccionar el icono etiquetado como
Console Application. Si se quisiese realizar una librería habría que seleccionar Class Library, y
si se quisies realizar un ejecutable de ventanas habría que seleccionar Windows Application.
Nótese que no se ofrece ninguna plantilla para realizar módulos, lo que se debe a que desde
Visual Studio.NET no pueden crearse.
Por último, en el recuadro de texto Name se ha de escribir el nombre a dar al proyecto y en
Location el del directorio base asociado al mismo. Nótese que bajo de Location aparecerá un
mensaje informando sobre cual será el directorio donde finalmente se almacenarán los archivos
del proyecto, que será el resultante de concatenar la ruta especificada para el directorio base y el
nombre del proyecto.
Grafico 1 : Ventana de creación de nuevo proyecto en Visual Studio.NET

Una vez configuradas todas estas opciones, al pulsar botón OK Visual Studio creará toda la
infraestructura adecuada para empezar a trabajar cómodamente en el proyecto. Como puede
apreciarse en la Ilustración 2 , esta infraestructura consistirá en la generación de un fuente que
servirá de plantilla para la realización de proyectos del tipo elegido (en nuestro caso,
aplicaciones de consola en C#):
Grafico 2 : Plantilla para aplicaciones de consola generada por Visual Studio.NET

A partir de esta plantilla, escribir el código de la aplicación de ejemplo es tan sencillo con
simplemente teclear System.Console.WriteLine(“¡Hola Mundo!”) dentro de la definición del
método Main() creada por Visual Studio.NET. Claro está, otra posibilidad es borrar toda la
plantilla y sustituirla por el código para HolaMundo mostrado anteriormente.
Sea haga como se haga, para compilar y ejecutar tras ello la aplicación sólo hay que pulsar
CTRL+F5 o seleccionar Debug à Start Without Debugging en el menú principal de Visual
Studio.NET. Para sólo compilar el proyecto, entonces hay que seleccionar Build à Rebuild All.
De todas formas, en ambos casos el ejecutable generado se almacenará en el subdirectorio
Bin\Debug del directorio del proyecto.
En el extremo derecho de la ventana principal de Visual Studio.NET puede encontrar el
denominado Solution Explorer (si no lo encuentra, seleccione View à Solution Explorer), que
es una herramienta que permite consultar cuáles son los archivos que forman el proyecto. Si
selecciona en él el icono correspondiente al proyecto en que estamos trabajando y pulsa View à
Property Pages obtendrá una hoja de propiedades del proyecto con el aspecto mostrado en la
Ilustración 3 :
Grafico 3 : Hoja de propiedades del proyecto en Visual Studio.NET
Esta ventana permite configurar de manera visual la mayoría de opciones con las que se llamará
al compilador en línea de comandos. Por ejemplo, para cambiar el nombre del fichero de salida
(opción /out) se indica su nuevo nombre en el cuadro de texto Common Properties à General
à Assembly Name, para cambiar el tipo de proyecto a generar (opción /t) se utiliza Common
Properties à General à Output Type (como verá si intenta cambiarlo, no es posible generar
módulos desde Visual Studio.NET), y el tipo que contiene el punto de entrada a utilizar (opción
/main) se indica en Common Properties à General à Startup Object
Finalmente, para añadir al proyecto referencias a ensamblados externos (opción /r) basta
seleccionar Project à Add Reference en el menú principal de VS.NET.
• Actividades.
Actividad 1. Describir las principales características del Lenguaje C Sharp.
Actividad 2. Realice un esquema de las partes que conforman un programa en C Sharp y
explique cada una.
Actividad 3. Realice un gráfico para representar como se compila un programa en C
Sharp
• Instrucciones.
Sea claro y prolijo. Es muy importante que la explicación sea lo más claro y legible posible,
evitando la redundancia.
Documentación:
Leer los contenidos de la Segunda Articulación. Después de esta lectura deberías ser capaz
de:
• Identificar las características del lenguaje de programación.
• Escribir programas básicos en el lenguaje.
• Evaluar el resultado de la programación.
• Escribir las sentencias secuenciales necesarias para leer números introducidos por
teclado e imprimir la información por pantalla.
Cuando acabes la lectura, resuelve las tareas de la 1 a la 3. Fíjate que en las actividades se
solicita algo concreto, para tener mayor certeza, visita la página:
http://www.devjoker.com/html/Introduccion-a-C.html
Anotar cualquier duda o problema que te surja realizando las actividades, para poder
ARTICULACION 3
Tema PREPROCESADOR
Contenidos
2. El Preprocesador.
3.1. Concepto de preprocesador.
El preprocesador es un paso previo a la compilación mediante el que es posible controlar la
forma en que se realizará ésta. El preprocesador es el módulo auxiliar que utiliza el
compilador para realizar estas tareas, y lo que finalmente el compilador compila es el resultado
de aplicar el preprocesador al fichero de texto fuente, resultado que también es un fichero de
texto. Nótese pues, que mientras que el compilador hace una traducción de texto a binario, lo
que el preprocesador hace es una traducción de texto a texto.
Aquellos que tengan experiencia en el uso del preprocesador en lenguajes como C++ y
conozcan los problemas que implica el uso del mismo pueden respirar tranquilos, ya que en C#
se han eliminado la mayoría de características de éste que provocaban errores difíciles de
detectar (macros, directivas de inclusión, etc.) y prácticamente sólo se usa para permitir realizar
compilaciones condicionales de código.
3.2. Directivas de preprocesador.
3.2.1. Concepto de directiva. Sintaxis.
El preprocesador no interpreta de ninguna manera el código fuente del fichero, sino que sólo
interpreta de dicho fichero lo que se denominan directivas de preprocesador. Estas directivas
son líneas de texto del fichero fuente que se caracterizan porque en ellas el primer carácter no
blanco que aparece es una almohadilla (carácter #) Por ejemplo:
#define TEST
#error Ha habido un error fatal
No se preocupe ahora si no entiendo el significado de estas directivas, ya que se explicarán más
adelante. Lo único debe saber es que el nombre que se indica tras el símbolo # es el nombre de
la directiva, y el texto que se incluye tras él (no todas las directivas tienen porqué incluirlo) es el
valor que se le da. Por tanto, la sintaxis de una directiva es:
#<nombreDirectiva> <valorDirectiva>
Es posible incluir comentarios en la misma línea en que se declara una directiva, aunque estos
sólo pueden ser comentarios de una línea que empiecen con // Por ejemplo, el siguiente
comentario es válido:
#define TEST // Ha habido algún error durante el preprocesado
Pero este otro no, pues aunque ocupa una línea tiene la sintaxis de los comentarios que pueden
ocupar varias líneas:
#define TEST /* Ha habido algún error durante el preprocesado */
3.2.2. Definición de identificadores de preprocesador.
Como ya se ha comentado, la principal utilidad del preprocesador en C# es la de permitir
determinar cuáles regiones de código de un fichero fuente se han de compilar. Para ello, lo que
se hace es encerrar las secciones de código opcionales dentro de directivas de compilación
condicional, de modo que sólo se compilarán si determinados identificadores de preprocesado
están definidos. Para definir un identificador de este tipo la directiva que se usa sigue esta
sintaxis:
#define <nombreIdentificador>
Esta directiva define un identificador de preprocesado <nombreIdentificador>. Aunque más
adelante estudiaremos detalladamente cuáles son los nombres válidos como identificadores en
C#, por ahora podemos considerar que son válidos aquellos formados por uno o más caracteres
alfanuméricos tales que no sean ni true ni false y no empiecen con un numero. Por ejemplo,
para definir un identificador de preprocesado de nombre PRUEBA se haría:
#define PRUEBA
Por convenio se da a estos identificadores nombres en los que todas las letras se escriben en
mayúsculas, como en el ejemplo anterior. Aunque es sólo un convenio y nada obliga a usarlo,
ésta será la nomenclatura que usaremos en el presente documento, que es la usada por
Microsoft en sus códigos de ejemplo. Conviene familiarizarse con ella porque por un lado hay
mucho código escrito que la usa y por otro usarla facilita la lectura de nuestro código a los
demás al ser la notación que esperarán encontrar.
Es importante señalar que cualquier definición de identificador ha de preceder a cualquier
aparición de código en el fichero fuente. Por ejemplo, el siguiente código no es válido, pues
antes del #define se ha incluido código fuente (el class A):
class A
#define PRUEBA
{}
Sin embargo, aunque no pueda haber código antes de un #define, sí que es posible incluir antes
de él otras directivas de preprocesado con total libertad.
Existe una forma alternativa de definir un identificador de preprocesado y que además permite
que dicha definición sólo sea válida en una compilación en concreto. Esta forma consiste en
pasarle al compilador en su llamada la opción /d:<nombreIdentificador> (forma abreviada de
/define:<nombreIdentificador>), caso en que durante la compilación se considerará que al
principio de todos los ficheros fuente a compilar se encuentra definido el identificador indicado.
Las siguientes tres formas de llamar al compilador son equivalentes y definen identificadores de
preprocesado de nombres PRUEBA y TRAZA durante la compilación de un fichero fuente de
nombre ejemplo.cs:
csc /d:PRUEBA /d:TRAZA ejemplo.cs
csc /d:PRUEBA,TRAZA ejemplo.cs
csc /d:PRUEBA;TRAZA ejemplo.cs
Nótese en el ejemplo que si queremos definir más de un identificador usando esta técnica
tenemos dos alternativas: incluir varias opciones /d en la llamada al compilador o definir varios
de estos identificadores en una misma opción /d separándolos mediante caracteres de coma (,) o
punto y coma (;)
Si se trabaja con Visual Studio.NET en lugar de directamente con el compilador en línea de
comandos, entonces puede conseguir mismo efecto a través de View  Property Pages 
Configuration Options  Build  Conditional Compilation Constants, donde nuevamente
usado el punto y coma (;) o la coma (,) como separadores, puede definir varias constantes. Para
que todo funcione bien, antes de seleccionar View ha de seleccionar en el Solution Explorer
(se abre con View  Solution Explorer) el proyecto al que aplicar la definición de las
constantes.
Finalmente, respecto al uso de #define sólo queda comentar que es posible definir varias veces
una misma directiva sin que ello provoque ningún tipo de error en el compilador, lo que permite
que podamos pasar tantos valores a la opción /d del compilador como queramos sin temor a que
entren en conflicto con identificadores de preprocesado ya incluidos en los fuentes a compilar.
3.2.3. Eliminación de identificadores de preprocesador.
Del mismo modo que es posible definir identificadores de preprocesado, también es posible
eliminar definiciones de este tipo de identificadores previamente realizadas. Para ello la
directiva que se usa tiene la siguiente sintaxis:
#undef <nombreIdentificador>
En caso de que se intente eliminar con esta directiva un identificador que no haya sido definido
o cuya definición ya haya sido eliminada no se producirá error alguna, sino que simplemente la
directiva de eliminación será ignorada. El siguiente ejemplo muestra un ejemplo de esto en el
que el segundo #undef es ignorado:
#define VERSION1
#undef VERSION1
#undef VERSION1
Al igual que ocurría con las directivas #define, no se puede incluir código fuente antes de las
directivas #undef, sino que, todo lo más, lo único que podrían incluirse antes que ellas serían
directivas de preprocesado.
3.2.4. Compilación condicional.
Como se ha repetido varias veces a lo largo del tema, la principal utilidad del preprocesador en
C# es la de permitir la compilación de código condicional, lo que consiste en sólo permitir que
se compile determinadas regiones de código fuente si las variables de preprocesado definidas
cumplen alguna condición determinada. Para conseguir esto se utiliza el siguiente juego de
directivas:
#if <condición1>
<código1>
#elif <condición2>
<código2>
...
#else
<códigoElse>
#endif
El significado de una estructura como esta es que si se cumple <condición1> entonces se pasa
al compilador el <código1>, si no ocurre esto pero se cumple <condición2> entonces lo que se
pasaría al compilador sería <código2>, y así continuamente hasta que se llegue a una rama #elif
cuya condición se cumpla. Si no se cumple ninguna pero hay una rama #else se pasará al
compilador el <códigoElse>, pero si dicha rama no existiese entonces no se le pasaría código
alguno y se continuaría preprocesando el código siguiente al #endif en el fuente original.
Aunque las ramas #else y #endif son opcionales, hay que tener cuidado y no mezclarlas ya que
la rama #else sólo puede aparecer como última rama del bloque #if...#endif.
Es posible anidar varias estructuras #if...#endif, como muestra el siguiente código:
#define PRUEBA
using System;
class A
{
public static void Main()
{
#if PRUEBA
Console.Write (“Esto es una prueba”);
#if TRAZA
Console.Write(“ con traza”);
#elif !TRAZA
Console.Write(“ sin traza”);
#endif
#endif
}
}
Como se ve en el ejemplo, las condiciones especificadas son nombres de identificadores de
preprocesado, considerándose que cada condición sólo se cumple si el identificador que se
indica en ella está definido. O lo que es lo mismo: un identificador de preprocesado vale cierto
(true en C#) si está definido y falso (false en C#) si no.
El símbolo ! incluido en junto al valor de la directiva #elif es el símbolo de “no” lógico, y el
#elif en el que se usa lo que nos permite es indicar que en caso de que no se encuentre definido
el identificador de preprocesado TRAZA se han de pasar al compilador las instrucciones a
continuación indicadas (o sea, el Console.Write(“sin traza”);)
El código fuente que el preprocesador pasará al compilador en caso de que compilemos sin
especificar ninguna opción /d en la llamada al compilador será:
using System;
class A
{
{
Console.Write(“Esto es una prueba”);
}
}
Nótese como en el código que se pasa al compilador ya no aparece ninguna directiva de
preprocesado, pues lo que el preprocesador le pasa es el código resultante de aplicar al original
las directivas de preprocesado que contuviese.
Asimismo, si compilásemos el código fuente original llamando al compilador con /d:TRAZA,
lo que el preprocesador pasaría al compilador sería:
using System;
class A
{
{
Console.Write (“Esto es una prueba”);
}
}
Hasta ahora solo hemos visto que la condición de un #if o #elif puede ser un identificador de
preprocesado, y que este valdrá true o false según esté o no definido. Pues bien, estos no son el
único tipo de condiciones válidas en C#, sino que también es posible incluir condiciones que
contengan expresiones lógicas formadas por identificadores de preprocesado, operadores
lógicos (! para “not”, && para “and” y || para “or”), operadores relacionales de igualdad (==) y
desigualdad (!=), paréntesis (( y )) y los identificadores especiales true y false. Por ejemplo:
#if TRAZA // Se cumple si TRAZA está definido.
#if TRAZA==true // Ídem al ejemplo anterior aunque con una sintaxis menos cómoda
#if !TRAZA // Sólo se cumple si TRAZA no está definido.
#if TRAZA==false // Ídem al ejemplo anterior aunque con una sintaxis menos cómoda
#if TRAZA == PRUEBA // Solo se cumple si tanto TRAZA como PRUEBA están
// definidos o si no ninguno lo está.
#if TRAZA != PRUEBA // Solo se cumple si TRAZA esta definido y PRUEBA no o
// viceversa
#if TRAZA && PRUEBA // Solo se cumple si están definidos TRAZA y PRUEBA.
#if TRAZA || PRUEBA // Solo se cumple si están definidos TRAZA o PRUEBA.
#if false // Nunca se cumple (por lo que es absurdo ponerlo)
#if true // Siempre se cumple (por lo que es absurdo ponerlo)
Es fácil ver que la causa de la restricción antes comentada de que no es válido dar un como
nombre true o false a un identificador de preprocesador se debe al significado especial que
estos tienen en las condiciones de los #if y #elif
3.2.5. Generación de avisos y errores.
El preprocesador de C# también ofrece directivas que permiten generar avisos y errores durante
el proceso de preprocesado en caso de que ser interpretadas por el preprocesador. Estas
directivas tienen la siguiente sintaxis:
#warning <mensajeAviso>
#error <mensajeError>
La directiva #warning lo que hace al ser procesada es provocar que el compilador produzca un
mensaje de aviso que siga el formato estándar usado por éste para ello y cuyo texto descriptivo
tenga el contenido indicado en <mensajeAviso>; y #error hace lo mismo pero provocando un
mensaje de error en vez de uno de aviso.
Usando directivas de compilación condicional se puede controlar cuando se han de producir
estos mensajes, cuando se han de procesar estas directivas. De hecho la principal utilidad de
estas directivas es permitir controlar errores de asignación de valores a los diferentes
identificadores de preprocesado de un código, y un ejemplo de ello es el siguiente:
#warning Código aun no revisado
#define PRUEBA
#if PRUEBA && FINAL
#error Un código no puede ser simultáneamente de prueba y versión final
#endif
class A
{}
En este código siempre se producirá el mensaje de aviso, pero el #if indica que sólo se
producirá el mensaje de error si se han definido simultáneamente los identificadores de
preprocesado PRUEBA y FINAL
Como puede deducirse del ejemplo, el preprocesador de C# considera que los mensajes
asociados a directivas #warning o #error son todo el texto que se encuentra tras el nombre de
dichas directivas y hasta el final de la línea donde éstas aparecen. Por tanto, todo comentario
que se incluya en una línea de este tipo será considerado como parte del mensaje a mostrar, y no
como comentario como tal. Por ejemplo, ante la directiva:
#error La compilación ha fallado // Error
Lo que se mostrará en pantalla es un mensaje de la siguiente forma:
Fichero.cs(3,5): error CS1029: La compilación ha fallado // Error
3.2.6. Cambios en la numeración de líneas.
Por defecto el compilador enumera las líneas de cada fichero fuente según el orden normal en
que estas aparecen en el mismo, y este orden es el que sigue a la hora de informar de errores o
de avisos durante la compilación. Sin embargo, hay situaciones en las que interesa cambiar esta
numeración, y para ello se ofrece una directiva con la siguiente sintaxis:
#line <número> “<nombreFichero>”
Esta directiva indica al preprocesador que ha de considerar que la siguiente línea del fichero
fuente en que aparece es la línea cuyo número se le indica, independientemente del valor que
tuviese según la numeración usada en ese momento. El valor indicado en “<nombreFichero>”
es opcional, y en caso de aparecer indica el nombre que se ha de considerar que tiene el fichero
a la hora de dar mensajes de error. Un ejemplo:
#line 127 “csmace.cs”
Este uso de #line indica que el compilador ha de considerar que la línea siguiente es la línea
127 del fichero csmace.cs. A partir de ella se seguirá usando el sistema de numeración normal
(la siguiente a esa será la 128 de csmace.cs, la próxima la 129, etc.) salvo que más adelante se
vuelva a cambiar la numeración con otra directiva #line.
Aunque en principio puede parecer que esta directiva es de escasa utilidad, lo cierto es que
suele venir bastante bien para la escritura de compiladores y otras herramientas que generen
código en C# a partir de código escrito en otros lenguajes.
3.2.7. Marcado de regiones de código.
Es posible marcar regiones de código y asociarles un nombre usando el juego de directivas
#region y #endregion. Estas directivas se usan así:
#region <nombreRegión>
<código>
#endregion
La utilidad que se dé a estas marcaciones depende de cada herramienta, pero en el momento de
escribir estas líneas la única herramienta disponible que hacía uso de ellas era Visual
Studio.NET, donde se usa para marcar código de modo que desde la ventana de código
podamos expandirlo y contraerlo con una única pulsación de ratón. En concreto, en la ventana
de código de Visual Studio aparecerá un símbolo [-] junto a las regiones de código así marcadas
de manera que pulsando sobre él todo el código contenido en la región se comprimirá y será
sustituido por el nombre dado en <nombreRegión>. Tras ello, el [-] se convertirá en un [+] y si
volvemos a pulsarlo el código contraído se expandirá y recuperará su aspecto original. A
continuación se muestra un ejemplo de cada caso:
Código de región contraído
Hay que tener cuidado al anidar regiones con directivas de compilación condicional, ya que
todo bloque #if...#endif que comience dentro de una región ha de terminar también dentro de
ella. Por tanto, el siguiente uso de la directiva #region no es valido ya que RegiónErrónea
termina estando el bloque #if...#endif abierto:
#region RegiónErrónea
#if A
#endregion
#endif
3.3. Aspectos léxicos.
3.3.1. Comentarios.
Un comentario es texto que incluido en el código fuente de un programa con la idea de facilitar
su legibilidad a los programadores y cuyo contenido es, por defecto, completamente ignorado
por el compilador. Suelen usarse para incluir información sobre el autor del código, para aclarar
el significado o el porqué de determinadas secciones de código, para describir el
funcionamiento de los métodos de las clases, etc.
En C# hay dos formas de escribir comentarios. La primera consiste en encerrar todo el texto que
se desee comentar entre caracteres /* y */ siguiendo la siguiente sintaxis:
/*<texto>*/
Estos comentarios pueden abarcar tantas líneas como sea necesario. Po ejemplo:
/* Esto es un comentario que ejemplifica cómo se escribe comentarios que ocupen varias
líneas */
Ahora bien, hay que tener cuidado con el hecho de que no es posible anidar comentarios de
este tipo. Es decir, no vale escribir comentarios como el siguiente:
/* Comentario contenedor /* Comentario contenido */ */
Esto se debe a que como el compilador ignora todo el texto contenido en un comentario y sólo
busca la secuencia */ que marca su final, ignorará el segundo /* y cuando llegue al primer */
considerará que ha acabado el comentario abierto con el primer /* (no el abierto con el
segundo) y pasará a buscar código. Como el */ sólo lo admite si ha detectado antes algún
comentario abierto y aún no cerrado (no mientras busca código), cuando llegue al segundo */
considerará que ha habido un error ya que encontrará el */ donde esperaba encontrar código
Dado que muchas veces los comentarios que se escriben son muy cortos y no suelen ocupar
más de una línea, C# ofrece una sintaxis alternativa más compacta para la escritura este tipo de
comentarios en las que se considera como indicador del comienzo del comentario la pareja de
caracteres // y como indicador de su final el fin de línea. Por tanto, la sintaxis que siguen estos
comentarios es:
// <texto>
Y un ejemplo de su uso es:
// Este comentario ejemplifica como escribir comentarios abreviados de una sola línea
Estos comentarios de una sola línea sí que pueden anidarse sin ningún problema. Por ejemplo,
el siguiente comentario es perfectamente válido:
// Comentario contenedor // Comentario contenido
3.3.2. Identificadores.
Al igual que en cualquier lenguaje de programación, en C# un identificador no es más que,
como su propio nombre indica, un nombre con el que identificaremos algún elemento de
nuestro código, ya sea una clase, una variable, un método, etc.
Típicamente el nombre de un identificador será una secuencia de cualquier número de
caracteres alfanuméricos –incluidas vocales acentuadas y eñes- tales que el primero de ellos no
sea un número. Por ejemplo, identificadores válidos serían: Arriba, caña, C3P0, áëÎò, etc; pero
no lo serían 3com, 127, etc.
Sin embargo, y aunque por motivos de legibilidad del código no se recomienda, C# también
permite incluir dentro de un identificador caracteres especiales imprimibles tales como
símbolos de diéresis, subrayados, etc. siempre y cuando estos no tengan un significado especial
dentro del lenguaje. Por ejemplo, también serían identificadores válidos, _barco_, c¨k y A·B;
pero no C# (# indica inicio de directiva de preprocesado) o a!b (! indica operación lógica “not”)
Finalmente, C# da la posibilidad de poder escribir identificadores que incluyan caracteres
Unicode que no se puedan imprimir usando el teclado de la máquina del programador o que no
sean directamente válidos debido a que tengan un significado especial en el lenguaje. Para ello,
lo que permite es escribir estos caracteres usando secuencias de escape, que no son más que
secuencias de caracteres con las sintaxis:
\u<dígito><dígito><dígito><dígito>
ó \U<dígito><dígito><dígito><dígito><dígito><dígito><dígito><dígito>
Estos dígitos indican es el código Unicode del carácter que se desea incluir como parte del
identificador, y cada uno de ellos ha de ser un dígito hexadecimal válido. (0-9, a-f ó A-F) Hay
que señalar que el carácter u ha de escribise en minúscula cuando se indiquen caracteres
Unicode con 4 dígitos y en mayúscula cuando se indiquen con caracteres de ocho. Ejemplos de
identificadores válidos son C\u0064 (equivale a C#, pues 64 es el código de # en Unicode) ó
a\U00000033b (equivale a a!b)
3.3.3. Palabras reservadas.
Aunque antes se han dado una serie de restricciones sobre cuáles son los nombres válidos que
se pueden dar en C# a los identificadores, falta todavía por dar una: los siguientes nombres no
son válidos como identificadores ya que tienen un significado especial en el lenguaje:
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, lock, is, 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, virtual, void, while
Aparte de estas palabras reservadas, si en futuras implementaciones del lenguaje se decidiese
incluir nuevas palabras reservadas, Microsoft dice que dichas palabras habrían de incluir al
menos dos símbolos de subrayado consecutivos (__) Por tanto, para evitar posibles conflictos
futuros no se recomienda dar a nuestros identificadores nombres que contengan dicha secuencia
de símbolos.
Aunque directamente no podemos dar estos nombres a nuestros identificadores, C# proporciona
un mecanismo para hacerlo indirectamente y de una forma mucho más legible que usando
secuencias de escape. Este mecanismo consiste en usar el carácter @ para prefijar el nombre
coincidente con el de una palabra reservada que queramos dar a nuestra variable. Por ejemplo,
el siguiente código es válido:
class @class
{
static void @static(bool @bool)
{
if (@bool)
Console.WriteLine("cierto");
else
Console.WriteLine("falso");
}
}
Lo que se ha hecho en el código anterior ha sido usar @ para declarar una clase de nombre class
con un método de nombre static que toma un parámetro de nombre bool, aún cuando todos
estos nombres son palabras reservadas en C#.
Hay que precisar que aunque el nombre que nosotros escribamos sea por ejemplo @class, el
nombre con el que el compilador va a tratar internamente al identificador es solamente class. De
hecho, si desde código escrito en otro lenguaje adaptado a .NET distinto a C# hacemos
referencia a éste identificador y en ese lenguaje su nombre no es una palabra reservada, el
nombre con el que deberemos referenciarlo es class, y no @class (si también fuese en ese
lenguaje palabra reservada habría que referenciarlo con el mecanismo que el lenguaje incluyese
para ello, que quizás también podría consistir en usar @ como en C#)
En realidad, el uso de @ no se tiene porqué limitar a preceder palabras reservadas en C#, sino
que podemos preceder cualquier nombre con él. Sin embargo, hacer esto no se recomienda,
pues es considerado como un mal hábito de programación y puede provocar errores muy sutiles
como el que muestra el siguiente ejemplo:
class A
{
int a; // (1)
int @a; // (2)

{}
}
Si intentamos compilar este código se producirá un error que nos informará de que el campo de
nombre a ha sido declarado múltiples veces en la clase A. Esto se debe a que como @ no forma
parte en realidad del nombre del identificador al que precede, las declaraciones marcadas con
comentarios como (1) y (2) son equivalentes.
Hay que señalar por último una cosa respecto al carácter @: sólo puede preceder al nombre de
un identificador, pero no puede estar contenido dentro del mismo. Es decir, identificadores
como i5322@fie.us.es no son válidos.
3.3.4. Literales.
Un literal es la representación explícita de los valores que pueden tomar los tipos básicos del
lenguaje. A continuación se explica cuál es la sintaxis con que se escriben los literales en C#
desglosándolos según el tipo de valores que representan:
• Literales enteros: Un número entero se puede representar en C# tanto en
formato decimal como hexadecimal. En el primer caso basta escribir los dígitos
decimales (0-9) del número unos tras otros, mientras que en el segundo hay que
preceder los dígitos hexadecimales (0-9, a-f, A-F) con el prefijo 0x. En ambos casos es
posible preceder el número de los operadores + ó – para indicar si es positivo o
negativo, aunque si no se pone nada se considerará que es positivo. Ejemplos de
literales enteros son 0, 5, +15, -23, 0x1A, -0x1a, etc
En realidad, la sintaxis completa para la escritura de literales enteros también puede
incluir un sufijo que indique el tipo de dato entero al que ha de pertenecer el literal.
Esto no lo veremos hasta el Tema 7: Variables y tipos de datos.
• Literales reales: Los números reales se escriben de forma similar a los enteros, aunque
sólo se pueden escribir en forma decimal y para separar la parte entera de la real usan
el tradicional punto decimal (carácter .) También es posible representar los reales en
formato científico, usándose para indicar el exponente los caracteres e ó E. Ejemplos
de literales reales son 0.0, 5.1, -5.1, +15.21, 3.02e10, 2.02e-2, 98.8E+1, etc.
Al igual que ocurría con los literales enteros, los literales reales también pueden incluir
sufijos que indiquen el tipo de dato real al que pertenecen, aunque nuevamente no los
veremos hasta el Tema 7: Variables y tipos de datos
• Literales lógicos: Los únicos literales lógicos válidos son true y false, que
respectivamente representan los valores lógicos cierto y falso.
• Literales de carácter: Prácticamente cualquier carácter se puede representar
encerrándolo entre comillas simples. Por ejemplo, 'a' (letra a), ' ' (carácter de espacio),
'?' (símbolo de interrogación), etc. Las únicas excepciones a esto son los caracteres que
se muestran en la Tabla 4.1, que han de representarse con secuencias de escape que
indiquen su valor como código Unicode o mediante un formato especial tal y como se
indica a continuación:
Ca CÓDIGO DE ESCAPE UNICODE Código de

escape especial
Comilla simple \u0027 \'
Comilla doble \u0022 \″
Carácter nulo \u0000 \0
Alarma \u0007 \a
Retroceso \u0008 \b
Salto de \u000C \f
página
Nueva línea \u000A \n
Retorno de \u000D \r
carro
Tabulación \u0009 \t
horizontal
Tabulación \u000B \v
vertical
Barra invertida \u005C \\
Códigos de escape especiales
En realidad, de la tabla anterior hay que matizar que el carácter de comilla doble
también puede aparecer dentro de un literal de cadena directamente, sin necesidad de
usar secuencias de escape. Por tanto, otros ejemplos de literales de carácter válidos
serán '\″', '″', '\f', '\u0000', '\\', '\'', etc.
Aparte de para representar los caracteres de la tabla anterior, también es posible usar los
códigos de escape Unicode para representar cualquier código Unicode, lo que suele
usarse para representar literales de caracteres no incluidos en los teclados estándares.
Junto al formato de representación de códigos de escape Unicode ya visto, C# incluye
un formato abreviado para representar estos códigos en los literales de carácter si
necesidad de escribir siempre cuatro dígitos aún cuando el código a representar tenga
muchos ceros en su parte izquierda. Este formato consiste en preceder el código de \x
en vez de \u. De este modo, los literales de carácter ‘\U00000008’, '\u0008', '\x0008',
'\x008', '\x08' y '\x8' son todos equivalentes. Hay que tener en cuenta que este formato
abreviado sólo es válido en los literales de carácter, y no a la hora de dar nombres a los
identificadores.
• Literales de cadena: Una cadena no es más que una secuencia de caracteres
encerrados entre comillas dobles. Por ejemplo ″Hola, mundo″, ″camión″, etc. El texto
contenido dentro estos literales puede estar formado por cualquier número de literales
de carácter concatenados y sin las comillas simples, aunque si incluye comillas dobles
éstas han de escribirse usando secuencias de escape porque si no el compilador las
interpretaría como el final de la cadena.
Aparte del formato de escritura de literales de cadenas antes comentado, que es el
comúnmente usado en la mayoría de lenguajes de programación, C# también admite un
nuevo formato para la escritura estos literales tipo de literales consistente en precederlas
de un símbolo @, caso en que todo el contenido de la cadena sería interpretado tal cual,
sin considerar la existencia de secuencias de escape. A este tipo de literales se les
conoce como literales de cadena planos y pueden incluso ocupar múltiples líneas. La
siguiente tabla recoge algunos ejemplos de cómo se interpretan:
Literal de cadena Interpretado como...

″Hola\tMundo″ Hola Mundo
@”Hola\tMundo″ Hola\tMundo
@″Hola Hola
Mundo″ Mundo
@”””Hola Mundo””″ “Hola Mundo”
Ejemplos de literales de cadena planos
El último ejemplo de la tabla se ha aprovechado para mostrar que si dentro de un literal de
cadena plano se desea incluir caracteres de comilla doble sin que sean confundidos con el final
de la cadena basta duplicarlos.
• Literal nulo: El literal nulo es un valor especial que se representa en C# con la
palabra reservada null y se usa como valor de las variables de objeto no inicializadas
para así indicar que contienen referencias nulas.
• Actividades.
Actividad 1. Escriba una definición de Preprocesador en un máximo de 5 líneas.
Actividad 2. Determine como se definen y se eliminan los identificadores de
preprocesador, acompáñelos con un ejemplo de cada uno.
Actividad 3. Realice un listado de las palabras reservadas en C# y argumente porque no
se las pude utilizar como identificadores. Como soporte de sus argumentos represéntelos
con ejemplos.
• Instrucciones.
Sea claro y prolijo. Es muy importante que la explicación sea lo más claro y legible posible,
evitando la redundancia.
Documentación:
Leer los contenidos de la Tercera Articulación. Después de esta lectura deberías ser capaz
de:
• Definir lo que es el preprocesador.
• Definir y eliminar identificadores de preprocesador.
• Realizar una compilación condicional.
• Escribir comentarios y definir identificadores adecuadamente.
Cuando acabes la lectura, resuelve las tareas de la 1 a la 3. Fíjate que en las actividades se
solicita algo concreto, para tener mayor argumentación, visita la pagina:
http://www.clikear.com/manuales/csharp/index.aspx
Anota cualquier duda o problema que te surja realizando las actividades, para poder
ARTICULACION 4
Tema BUCLES
Contenidos.
4.- Bucles.
4.1. Estructuras básicas.
Una estructura es un tipo especial de clase pensada para representar objetos ligeros. Es decir,
que ocupen poca memoria y deban ser manipulados con velocidad, como objetos que
representen puntos, fechas, etc. Ejemplos de estructuras incluidas en la BCL son la mayoría de
los tipos básicos (excepto string y object), y de hecho las estructuras junto con la redefinición
de operadores son la forma ideal de definir nuevos tipos básicos a los que se apliquen las
mismas optimizaciones que a los predefinidos.
4.2. Estructura de decisión.
C# ofrece una serie de instrucciones que permiten ejecutar bloques de código sólo si se da una
determinada condición. Estas son:
Intrucción If  Como la mayoría de los lenguajes de programación, C# incluye la instrucción
condicional if, cuya forma de uso es:
if (condición)
intruccionesIf
else
intruccionesElse
El significado de esta instrucción es el siguiente: se evalúa la condición indicada, y en caso de
ser cierta se ejecutan las instruccionesIf; mientras que si no lo es se ejecutan las
instruccionesElse La rama else es opcional, y si se omite y la condición es falsa se seguiría
ejecutando a partir de la siguiente instrucción al if. Si las intruccionesIf o las instruccionesElse
constan de más de una instrucción es necesario encerrar el conjunto de instrucciones de las que
constan entre llaves ({...})
Un ejemplo de aplicación de esta instrucción es esta variante del HolaMundo:
using System;
class HolaMundo5
{
public static void Main(String[] args)
{
if (args.Length > 0)
Console.WriteLine(“¡Hola {0}!”, args[0]);
else
Console.WriteLine(“¡Hola mundo!”);
}
}
En este caso, si ejecutamos el programa sin indicar ningún argumento al lanzarlo veremos que
el mensaje que se imprime es ¡Hola Mundo!, mientras que si lo ejecutamos indicando algún
argumento se mostrará un mensaje de bienvenida personalizado (del mismo tipo que en el
HolaMundo2)
Nótese que para saber si se han pasado argumentos en la llamada al programa y tomar una u
otra decisión según el caso, lo que se hace en la condición del if es comprobar si la longitud de
la tabla de argumentos es superior a 0. Para conocer esta longitud se utiliza la propiedad Length
que toda tabla tiene definida. Recuérdese que el tamaño de una tabla es fijo, por lo que esta
propiedad es de sólo lectura y no es válido intentar escribir en ella (como por ejemplo, haciendo
args.Length = 2)
Instrucción Switch  Para aquellos casos en los haya que ejecutar unos u otros bloques de
instrucciones según el valor de una determinada expresión C# proporciona la instrucción
condicional switch, cuya forma de uso es:
switch(condición)
{
case caso1: instrucciones1: break;
case caso2: instrucciones2: break;
...
default: instruccionesDefecto; break;
}
El significado de esta instrucción es el siguiente: se evalúa la condición, y si su valor coincide
con el de caso1, se ejecutan las instruciones1; si coincide con el de caso2 se ejecutan las
instrucciones2; y así para cada caso mientras no se encuentra alguno que coincida con el valor
resultante de la evaluación. La rama default es opcional, y en caso de agotarse todos los casos y
no encontrarse coincidencia, entonces se pasaría a ejecutar las intruccionesDefault en caso de
que dicha rama apareciese; y si no apareciese, se pasaría directamente a ejecutar la instrucción
siguiente al switch
En realidad, la rama default, si se usa, no tiene porqué aparecer la última, aunque se
recomienda que lo haga porque ello facilita la legibilidad del código.
Un ejemplo de uso de esta instrucción es el siguiente:
using System;
class HolaMundo6
{
{
switch(args[0])
{
case “José”: Console.WriteLine(“Hola José. Buenos días”);
break;
case “Paco”: Console.WriteLine(“Hola Paco. Me alegro de verte”);
break;
default: Console.WriteLine(“Hola {0}”, args[0]);
}
else
Console.WriteLine(“Hola Mundo”);
}
}
Ahora, nuestro programa reconoce a algunas personas y les saluda de forma especial. Nótese
que al final de cada grupo de instrucciones se ha de incluir una instrucción break que indique el
final de la lista de instrucciones asociadas a esa rama del switch En realidad, esta instrucción
puede ser sustituida por una instrucción goto usada de la forma goto casoi (o goto default) que
indique qué otras ramas del switch han de ejecutarse tras llegar a ella. Además, en la última
rama del switch no tiene porqué aparecer obligatoriamente ninguna de estas dos sentencias.
Para los programadores habituados a lenguajes como C++ es importante resaltarles el hecho de
que, a diferencia de dicho lenguaje, C# obliga a incluir una sentencia break o una sentencia
goto al final de cada rama del switch, con la idea de evitar errores muy comunes en éste
lenguaje, donde no es forzoso hacerlo.
4.4. Estructura de ciclo.
C# ofrece un buen número de instrucciones que permiten la ejecución de bloques de
códigos repetidas veces
4.5. Ciclos.
Instrucción While  Es la instrucción iterativa más común en los lenguajes de programación,
y en C# se usa de la siguiente forma:
while (condición)
instrucciones
El significado de esta instrucción es el siguiente: se evalúa la condición, y en caso de ser cierta
se ejecutan las instrucciones. Tras ejecutarlas, se repite el proceso de evaluar la condición y
ejecutar las instrucciones en caso de seguir siendo cierta. Este proceso se repite continuamente
hasta que la condición deje de verificarse. Si las instrucciones constan de más de una
instrucción es necesario encerrarlas entre llaves, del mismo modo que se comentó para el caso
del if.
Un ejemplo de aplicación de esta sentencia es:
using System;
class HolaMundo7
{
{
int actual = 0;
while (actual < args.Length)
{
Console.WriteLine(“¡Hola {0}!”, args[actual]);
actual = actual + 1;
}
else
}
}
En este caso, si se indica más de un argumento en la llamada a nuestro programa se mostrará
por pantalla un mensaje de saludo para cada uno de ellos.
Puede observarse que la primera línea del método Main() no contiene ahora una instrucción,
sino que contiene una declaración de una variable de tipo int, nombre actual y valor inicial 0
que usaremos en la sentencia iterativa para saber cuál es la posición del argumento a mostrar en
cada ejecución de la misma. El valor de esta variable se irá aumentando en una unidad, para así
asegurar que siempre mantiene el valor adecuado para ir mostrando cada uno de los argumentos
de llamada y para asegurar que la instrucción while termine de ejecutarse alguna vez, lo cual
ocurrirá cuando se hallan mostrado todos los argumentos.
Es importante señalar que C# no proporciona ningún valor inicial a las variables locales de los
métodos, por lo que es tarea del programador proporcionárselos antes de ser leídos. En
cualquier caso, si el compilador detecta que en el código hay alguna posibilidad de que se lea
algún parámetro no inicializado informará al programador de ello dando error. La idea detrás de
todo esto es conseguir evitar errores comunes y difíciles de detectar que se dan en otros
lenguajes cuando se olvida inicializar un parámetro y su valor por defecto no es el esperado.
Instrucción Do...while  Es una variante del while que se usa así:
do
instrucciones
while (condición);
En este caso, el significado de la instrucción es ahora el siguiente: se ejecutan las instrucciones
(que en caso de ser varias habrán de ir encerradas entre llaves), y tras ello se evalúa la
condición. Si el resultado de evaluarla es cierto se vuelve a repetir el proceso, mientras que si
no lo es se continúa ejecutando a partir de la instrucción siguiente al do ... while Es importante
resaltar que en esta instrucción es obligatorio incluir el punto y coma (;) al final del paréntesis
de cierre de la condición, ya es un error frecuente entre novatos olvidar incluirlos.
Como se ve, do ... while especialmente útil para aquellos casos en los que hay que asegurar que
las instrucciones en él contenidas se ejecuten al menos una vez, aún cuando la condición sea
falsa desde el principio. Un ejemplo de su uso es este código:
using System;
class HolaMundo8
{
{
String leído;
do
{
Console.WriteLine(“Clave: “);
leído = Console.ReadLine();
}
while (leído != “José”);
Console.WriteLine(“Hola José”);
}
}
Al ejecutarse la aplicación puede observarse que lo que se hace es preguntar al usuario una
clave, de modo que mientras no se introduzca la clave correcta (que es José), no se continuará
con la ejecución de la aplicación; y una vez que se introduzca correctamente se dará un mensaje
de bienvenida al usuario.
Aparte de la instrucción do ... while, en este ejemplo se ha introducido un nuevo elemento en el
ejemplo: una llamada al método ReadLine() de la clase Console Este método detiene la
ejecución de la aplicación y la deja en espera de que el usuario introduzca una cadena de
caracteres y pulse la tecla ENTER, cadena que es devuelta por el método ReadLine() y que en
la aplicación se guarda en la variable de tipo cadena llamada leído para comprobar
posteriormente, en la condición del do ... while, si coincide con la clave esperada (José)
Instrucción For  Es otra variante del while que permite compactar el código de este tipo de
bloques. Su forma de uso es:
for (inicialización; condición; incremento)
instrucciones
El significado de esta instrucción es el siguiente1: se realizan las inicializaciones de variables
indicadas en inicialización y luego se evalúa la condición; si es cierta, se ejecutan las
instrucciones indicadas (entre llaves si son varias) Tras ello se ejecutan las operaciones de
incremento (o decremento) indicadas y se reevalúa la condición. Mientras ésta sea cierta se irá
repitiendo el proceso de ejecución de instrucciones, incremento de variables y reevaluación de
la condición hasta que deje de serlo. En caso de que se desee inicializar o declarar varias
variables en el campo de inicialización o de que se realizar varias operaciones
incremento/decremento en el campo decremento habría que separarlas mediante comas (,)
Como se ve, la instrucción for recoge de una forma muy compacta el uso principal de la
instrucción while normal, siendo un ejemplo de su uso:
using System;
class HolaMundo9
{
{
for (int actual = 0; actual < args.Length; actual++)
Console.WriteLine(“¡Hola {0}!”, args[actual]);
else
}
1 En realidad, los campos de inicialización e incremento pueden contener
cualquier tipo de instrucción, aunque no suele ser habituar usarlos en unos
sentidos diferentes al descrito.
}
El funcionamiento de este ejemplo es exactamente el mismo que el del HolaMundo5, sólo que
en este caso se ha aprovechado la eficacia de la instrucción for para hacer reducir mucho más el
tamaño del código. Si acaso, cabría señalar la utilización del operador ++ en el campo de
incremento, cuyo significado es sumar 1 a la variable sobre la que se aplica. Simétricamente,
también está definido el operador --, cuyo significado es restar 1 a la variable sobre la que es
aplicado.
• Actividades.
Actividad 1. Describir las principales características de los bifurcadores simples y
múltiples y aplicarlos en los siguientes ejercicios (realice el análisis y diseñe el algoritmo).
1. Introducir dos números enteros por teclado. Si los dos son positivos, indicar si los dos
son pares o si los dos son impares. En caso contrario, no indicar nada.
2. Dado un número entero por teclado que se supone corresponde a un día de la semana,
mostrar el nombre del correspondiente día si el número está comprendido entre el 0 y el 6,
ambos inclusive. Al Domingo le corresponde el valor 0, al Lunes el 1, y así sucesivamente,
hasta llegar al Sábado que le corresponde el valor 6.
Actividad 2. Realice un cuadro comparativo de los diferentes bucles y desarrolle los
siguientes ejercicios (realice el análisis y diseñe el algoritmo).
1. Introducir una serie de números enteros por teclado. La serie termina al introducir un 0.
Indicar la suma de todos ellos, y cuántos han sido positivos y cuántos negativos.
2. Dados dos números enteros (un dividendo y un divisor distinto de 0) obtener su cociente
y el resto mediante restas sucesivas.
3. Dado un número entero positivo hallar los números perfectos menores que él. Un número
es perfecto si la suma de sus divisores, excepto él mismo, es igual al propio número.
4. Introducido por teclado un número entero mayor que 2, visualizarlo de todas las formas
posibles como producto de dos factores (no es válido el número 1 como factor). Por
ejemplo: Dado el número 36, habría que visualizar: 18 * 2, 12 * 3, 9 * 4, 6 * 6, 3 * 12, 4 *
9, 2 * 18
• Instrucciones.
Sea claro y prolijo. Es muy importante que el algoritmo sea lo más preciso posible, para
evitar pasos innecesarios.
Documentación:
Leer los contenidos de la Cuarta Articulación. Después de esta lectura deberías ser capaz
de:
• Desarrollar programas en C Sharp.
• Aplicar los bifurcadores simple y múltiple.
• Utilizar adecuadamente los bucles de repetición en ejercicios prácticos.
Cuando acabes la lectura, resuelve las tareas de la 1 y 2. Fíjate que en las actividades se
solicita algo concreto, para consultas se puede visitar las páginas:
http://www.clikear.com/manuales/csharp/index.aspx
Anotar cualquier duda o problema que te surja realizando las actividades, para poder
Investigación:
La investigación será empleada en los trabajos que se pedirá al estudiante sobre temas de actualidad
o sobre temas que se verán en clase. El propósito de estos trabajos es que el estudiante aprenda
hacer investigación en medios electrónicos, libros y revistas sobre temas de la asignatura. Los
reportes deberán contener imprescindiblemente una conclusión personal acerca de la investigación.
El maestro debe enfatizar en los reportes escritos.
Exposición oral:
El alumno debe ser capaz de desenvolverse oralmente al exponer un tema o al establecer una
discusión sobre una temática en particular del curso. El maestro debe involucrar a los estudiantes en
la exposición oral ya sea de una noticia reciente o de un tema particular y que el alumno haya tenido
tiempo para investigarlo.
Practicas de laboratorio:
De requerir la asignatura, los maestros llevaran a la practica los conocimientos teóricos vistos en
clase, pues es el mejor método de enseñanza - aprendizaje, por eso es importante que el estudiante
desarrolle habilidades que le permitan resolver problemas reales.
3. RECURSOS
Materiales:
Proyector.
Laboratorio de informática.
Software DFD.
Visio.
Regla de diagramación.
Proyector
Pedagógicos:
Manuales.
Módulo.
Métodos y Técnicas activas de enseñanza aprendizaje.
4. EVALUACION
Evaluación:
La evaluación será frecuente y permanente a más de ser una actividad continúa y sistemática,
servirá para conocer cómo se desarrolla el proceso de aprendizaje por parte de nuestros
estudiantes
Criterio de acreditación:
Los alumnos recibirán 6 créditos al aprobar y evaluar satisfactoriamente los contenidos de la
asignatura.
Criterio de evaluación:
Cada articulación será evaluada sobre diez puntos, de los cuales cinco corresponden a las
actividades de cada articulación (evaluación continua) y cinco a la evaluación final de la misma.
Tutor.

Modulo Programacion I

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Modulo Programacion I

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD REGIONAL AUTONOMA DE LOS ANDES

FACULTAD DE: SISTEMAS MERCANTILES.

CONTENIDOS N° HORAS DE N° HORAS DE

CONTENIDOS N° HORAS DE N° HORAS DE

CONTENIDOS N° HORAS DE N° HORAS DE

CONTENIDOS N° HORAS DE N° HORAS DE

1. CONTENIDOS CIENTIFICOS POR ARTICULACION:

Todo el código escrito en C# se ha de escribir dentro de una definición de clase, y lo que en la

static void Main()

csc.exe es el compilador de C# incluido en el .NET Framework SDK para Windows de

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:winexe Ventanas.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library HolaMundo.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /r:HolaMundo.dll A.cs

C:\WINDOWS\....\v2.0.50727>csc /t:HolaMundo.dll /r:Otro.dll /r:OtroMás.exe A.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:module HolaMundo.cs

Con la instrucción anterior se generaría un módulo llamado HolaMundo.netmodule que podría

C:\WINDOWS\...\v2.0.50727>csc /t:library /addmodule:HolaMundo.netmodule Lib.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library A.cs B.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library /out:Lib.exe A.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /t:library /out:varios.dll *.cs

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>csc /main:Principal A.cs B.cs

Grafico 1 : Ventana de creación de nuevo proyecto en Visual Studio.NET

Grafico 2 : Plantilla para aplicaciones de consola generada por Visual Studio.NET

public static void Main()

Ca CÓDIGO DE ESCAPE UNICODE Código de

Literal de cadena Interpretado como...

Potrebbero piacerti anche