TALLER DEL BUEN PROGRAMADOR (PARA DESCARGAR)

TALLER DEL BUEN PROGRAMADOR

TODAS LAS HERRAMIENTAS NECESARIAS PARA SU BUEN DESEMPEÑO

Profesor: MSc. A. Boente

boentes@gmail.com

COMPILADORES

FreePascal-2.4.0.i386-win32.exe 34.6 Mb

Compilador C_Standar.exe 6.27 Mb

Dev-C- 4.9.9.2_setup.exe 8.88 Mb

DevC++-4.9.9.2_setup.exe 4.55 Mb

VisualCv_6_V.7.4 Potente.exe 19.9 Mb

Visual C++ v.9.030 setup.exe 2.61 Mb

Visual Basic 2008 en .NET 2.6 Mb

PLATAFORMAS

Java jdk-6u11-windows-i586-p.exe 72.9 Mb

Plataforma para Java 6,5ml-windows.exe 248 Mb

Plataforma para Java 6,5 javafx-windows.exe 62.1 Mb

PHP php-5.2.8-Win32_Plataforma.zip 9.87 Mb

Framework 11.4 Mb

FrameWork2.exe 22.4 Mb

Editor_HTML.exe 40.6 Mb

Editor HTML Muy Bueno 9.44 Mb

Editor WEB Amaya 7.73 Mb

HERRAMIENTA CASE (Diseño Orientado a Objeto)

EcoSetup_5.0.0.4754_2010-01-10_b980.exe

UTILIDADES

NOD-32 Antivirus

Claves de desbloqueo para el Nod-32 Mensuales Debe poner la URL como epcección en el NOD-32 para que no bloquee su acceso

Freespyware 23.4 Mb

MX One Guardian AV para USB

USB Doctor

Cliente correo para USB NEW

Los Mejores link de la Red Para la descarga de Softwares FREE

Páginas Web Recomendadas sobre C y C++

IDE de desarrollo en lenguaje C

http://www.bloodshed.net/dev/devcpp.html

Descarga alternativa del IDE de desarrollo de lenguaje C

http://sourceforge.net/project/downloading.php?groupname=dev-cpp&filename=devcpp-

4.9.9.2_setup.exe&use_mirror=dfn

Site con información sobre programación en C y C++

http://www.cprogramming.com/

Página con compiladores de C y C++

http://www.thefreecountry.com/compilers/cpp.shtml

"El Rincón del C"

Todo tipo de información relacionada con el lenguaje C

http://www.elrincondelc.com/nuevorincon/index.php

Nota:
Clickee encima de un enlace (Link) y descargará el Software seleccionado...

PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

PROGRAMACIÓN ORIENTADA A OBJETOS (POO).

En Pascal, los Objetos son perecidos a los registros, con la diferencia de que los Objetos además de incluir datos, incluyen rutinas para la manipulación de dichos datos.
Para trabajar con objetos deberíamos comenzar diseñando las diversas estructuras entresacando de todas ellas las características comunes e implementando un tipo objeto genérico del cual descendieran los demás.

Declaración de objetos :
Type
Nombre=OBJECT
dato1 :tipo1 ;
dato2 :tipo2 ;
procedure procedimiento1 ;
Procedure procedimiento2[(parámetros)] :
end ;

Dentor del tipo, se incluyen cabeceras de procedimientos y funciones. La implementación de estos procedimientos y funciones dentro del objeto se efectúa de forma independiente, y a estos procedimientos y funciones dentro del objeto se les denomina Métodos.

Declaración de métodos :

Procedure Nombre.procedimiento1 ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Procedure Nombre.procedimiento2[(lista parámetros formales)] ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Los datos de un objeto son siempre accesibles para los métodos a pesar de que estén declarados en lugares diferentes (de forma independiente) .Ejemplo :

Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;

Procedure Persona.Inicializar(n :string ;de :integer ;d :string) ;
Begin
nombre :=n ;
edad := ed ;
domicilio :=d ;
End ;

{Para trabajar con objetos, necesitamos variables de tipo objeto llamadas Instancias del objeto.}
{A los diferentes tipos se les denomina Clases}

Var
p :Persona ;
n,d :string :
ed :integer ;

BEGIN
WriteLn(‘Nombre :’) ;
ReadLn(n) ;
WriteLn( ‘Edad :’) ;
ReadLn(ed) ;
WriteLn(‘Domicilio :’) ;
ReadLn(d) ;
p.inicializar(n,ed,d) ;
END.

Los objetos pueden heredar campos y métodos de otros objetos. Cuando esto sucede lo declararemos de la siguiente manera :

Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
procedure Inicializar(n :string ;de :integer ;d :string) ;
end ;

Alumno=OBJECT (Persona) { Hereda Persona}
nota :real ;
Procedure Inicializar(n :string ; ed :integer ; d :string ; no :real) ;
end ;

Procedure Persona.Inicializar.....
Begin
...............
End ;

Procedure Alumno.Inicialzar(n :string ; ed :integer ; d :string ; no :real) ;
Begin
nombre :=n ;
edad :=ed ;
domicilio :=d ;
nota :=no ;
End ;

Var a :Alumno ;

El objeto descendiente hereda los campos y métodos del objeto padre, y puede tener más campos y métodos nuevos y también puede redefinirlos.

Todos los métodos vistos hasta ahora eran ESTÁTICOS (las referencias se resuelven en tiempo de compilación), pero los métodos también pueden ser VIRTUALES (las referencias se resuelven en tiempo de ejecución). Cuando el compilador detecta la compilación de un método virtual, crea una Tabla de Métodos Virtuales. Las instancias (variables) declaradas de un tipo objeto con métodos virtuales (tipo método virtual), necesitan inicializarse a través de unCONSTRUCTOR, que enlaza la instancia con la Tabla de Métodos Virtuales.
Para eliminar la conexión se emplean DESTRUCTORES (sólo cuando se trabaja con estructuras dinámicas(punteros)), necesarios siempre que usamos métodos virtuales.
Para que un método sea un constructor, habrá que sustituir la palabra ‘procedure’ por ‘constructor’.
Para que un método sea un destructor, habrá que sustituir la palabra ‘procedure’ por ‘destructor’.
Un método es virtual cuando su cabecera acaba en ‘virtual ;’.
Los métodos virtuales son el instrumento adecuado para el POLIMORFISMO. Un método es polimórfico cuando se ejecuta de diferente forma segús el objeto desde el cual se le llame.

CARACTERÍSTICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS.

• Encapsulación.
• Herencia.
• Polimorfismo.

La Encapsulación consiste en que los objetos agrupan tanto los datos como los procedimientos necesarios para su manipulación. No se debe acceder a los datos de un objeto directamente, sino que siempre se debe hacer a través de los métodos correspondientes. (Ejemplo : En lugar de referenciar area, referenciaríamos figura.area, siendo figura el objeto).
Cuando trabajamos con unidades es posible declarar tipos de objeto en dichas unidades. Si se desea que el usuario de una unidad (que use objetos) no pueda acceder a los campos o a determinados métodos del objeto, habrá que declararlos como privados, para lo cual la declaración de objeto se hará en la sección de Interface, pero los métodos tendrán que ser implementados en la sección de Implementation.Ejemplo :

Unit ; {De 8 caracteres máximo}

INTERFACE
Type
Persona=OBJECT
nombre :string ;
edad :integer ;
domicilio :string ;
Procedure Inicializar(n :string ; de :integer ; d :string) ;
end ;
Alumno=OBJECT (Persona)
nota :real ;
procedure Inicializar(n :string ; de :integer ; d :string ;no :real) ;
end ;
IMPLEMENTATION
Procedure persona.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Procedure alumno.Inicializar(-------------------) ;
Begin
------------------ ;
------------------ ;
------------------ ;
End ;

Para declarar las partes privadas :

1. Declaramos las partes PUBLICAS : 1º datos y luego métodos.
2. Declaramos las partes PRIVADAS poniendo ántes ‘PRIVATE’ :1º datos y luego métodos.
Ejemplo :
Type Persona=OBJECT
domicilio :string ; {Partes}
procedure Inicializar (--------------------------) ; {Públicas}
PRIVATE
nombre :string ; {Partes}
edad ;integer ; {Privadas}
end ;

En un tipo objeto la declaración de los métodos debe ir después de los datos (excepto cuandoy parte privada).
Es posible utilizar punteros con los objetos de la forma habitual :
Type
puntero=^Persona ;
Persona=OBJECT
------------- ;
------------- ;
end ;
Variable
p :puntero ;
Begin
New(p) ;
p^.Inicializar(‘Pedro’,5,’Goya’) ;
------------------- ;
------------------- ;
------------------- ;
Dispose(p) ;
end ;


Type
figura=OBJECT
nombre :string ;
area :real ;
perimetro :real ;
Constructor Inicializar ;{Para llamar a virtuales}
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
Procedure Visualizar ;
end ;
Rectangulo=OBJECT (figura)
base :real ;
altura :real ;
{Si se redefine virtual se amntiene la cabecera}
Constructor Inicializar(d,a :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Circulo=OBJECT (figura)
radio :real ;
Constructor Inicializar(r :real) ;
Procedure CalcularArea ;VIRTUAL ;
Procedure CalcularPerimetro ;VIRTUAL ;
end ;
Constructor figura.Inicializar ;
Begin
WriteLn(‘Indique la figura :’) ;
ReadLn(nombre) ;
End ;
Procedure figura.CalcularArea ;
Begin
area :=0 ;
End ;

Procedure figura.CalcularPerimetro ;
Begin
perimetro :=0 ;
End ;

Procedure figura.Visualizar ;
Begin
CalcularArea ;
CalcularPerimetro ;
WriteLn(‘La figura es’,nombre) ;
WriteLn(‘El area es’,area) ;
WriteLn(‘El perimetro es’,perimetro) ;
end ;

Constructor Rectangulo.Inicializar(b,a :real) ;
Begin
base :=b ;
altura :=a ;
nombre :=’Rectangulo’ ;
End ;

Procedure Rectangulo.CalcularArea ;
Begin
area :=base*altura ;
End ;

Procedure Rectangulo.CalcularPerimetro ;
Begin
perimetro:=2*(base+altura) ;
End ;

Constructor Circulo.Inicializar(r:real) ;
Begin
radio :=r ;
nombre :=’Circulo’ ;
End ;

Procedure Circulo.CalcularArea ;
Begin
area :=3.141592*radio*radio;
End ;

Procedure Circulo.CalcularPerimetro ;
Begin
perimetro:=2*3.141592*radio;
End ;

Var
f :figura ;
c :Circulo ;
rec :Rectangulo ;
a,b :real ;
r :real ;

Begin
WriteLn(‘Deme Radio’) ;
ReadLn(r) ;
c.Inicializar(r) ;
c.Visualizar ; {Es polimórfico:se comporta de una manera o de otra según desde donde se le llame
Sin virtual, nos pasa en Visualizar 0,0 (lo que había en compilación).Con virtual pasa lo que hay en ejecución).}
WriteLn(‘Deme Base y Altura :’) ;
ReadLn(b,a) ;
rec.Inicializar(r) ;
rec.visualizar ;





Con punteros :

Type
rt=^Rectangulo ;
cr=^Circulo ;
Var
c :cr ;
rec :rt ;
a,b,r :real ;
Begin
WriteLn....... ;
ReadLn(r) ;
New(c) ;
c^.Inicializar(r) ;
c^.Visualizar ;
WriteLn........ ;
New(rec) ;
rec^.Inicializar(b,a) ;
rec^.Visualizar ;

C# EN VISUAL STUDIO.NET

Programación Orientada a Objetos
Preprocesador y compilador de C#
Mayo, 2003
INTRODUCCIÓN AL COMPILADOR Y
PREPROCESADOR DE C# EN VISUAL
STUDIO.NET

Bueno Martín, Francisco Javier
Cambronero Sánchez, Mª Ángeles
Departamento de Informática y Automática
Universidad de Salamanca

Bueno y Cambronero
i
Resumen
Este documento trata de introducir al lector en el uso del preprocesador y del compilador de C#
en la herramienta Visual Studio.NET. Así mismo se hace una pequeña introducción a la reciente
plataforma.NET y al nuevo lenguaje diseñado por la empresa Microsoft®.
Se ha intentado en todo momento presentar similitudes y diferencias del lenguaje C# con
otros lenguajes del paradigma orientado a objetos, en concreto, con C++ y con Java.
Abstract
This document is about the introduction to the reader in the use of C# pre-processor and
compiler in Visual Studio.NET. Also an introduction of platform.NET and the new language
designed by Microsoft® are made.
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
ii
Tabla de Contenidos
1. Microsoft.NET 1
1.1. Introducción a Microsoft.NET 1
1.1.1. ¿Qué es? 1
1.1.2. Primeros objetivos 1
1.2. CLR, el núcleo de la plataforma .NET 2
1.3. MSIL, el código intermedio 2
1.4. Metadatos, ensamblados,… 2
2. Introducción a C# 4
2.1. Origen del lenguaje 4
2.2. Características generales 4
2.3. Primera toma de contacto 6
3. El preprocesador 8
3.1. Concepto general 8
3.2. Función del preprocesador 8
3.2.1. Directivas generales 8
3.2.2. Compilación condicional 10
3.2.3. Generación de errores y avisos 11
3.2.4. Renumeración de líneas 11
3.2.5. Creación de regiones de código 11
Bueno y Cambronero
iii
4. El compilador de Microsoft 13
4.1. Introducción 13
4.2. El compilador desde la línea de comandos 13
4.2.1. Sintaxis y opciones de compilador 13
4.2.2. Compilación de ficheros de recursos 14
4.2.3. Depurador 15
4.3. Creación y compilación de una aplicación con
Visual Studio.NET 15
5. Últimas tendencias 19
6. Conclusiones 20
7. Bibliografía 20
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
iv
Índice de figuras y tablas
Figura 1. Código programa Holamundo Pág. 7
Figura 2. Introducción de variables de preprocesado Pág. 9
Figura 3. Ejemplo de creación de regiones Pág. 12
Figura 4. Ejemplo de región contraída Pág. 12
Figura 5. Creación de un proyecto de Visual C# Pág. 16
Figura 6. Documento generado automáticamente por Visual C#
para una aplicación de consola Pág. 16
Figura 7. Opciones del compilador en el Visual C# ( I ) Pág. 17
Figura 8. Opciones del compilador en el Visual C# ( II ) Pág. 18
Tabla 1. Correspondencias de opciones de compilación
por línea de ordenes con las opciones del Visual C# Pág. 18
Bueno y Cambronero
v

Bueno y Cambronero
1
1. Microsoft .NET
1.1. Introducción a Microsoft .NET
1.1.1. ¿Qué es?
Microsoft.NET es el conjunto de nuevas tecnologías en las que Microsoft ha estado trabajando
durante los últimos años con el objetivo de obtener una plataforma sencilla y potente para
distribuir el software en forma de servicios que puedan ser suministrados remotamente y que
puedan comunicarse y combinarse unos con otros de manera totalmente independiente de la
plataforma, lenguaje de programación y modelo de componentes con los que hayan sido
desarrollados. Ésta es la llamada plataforma .NET, y a los servicios antes comentados se les
denomina servicios Web.
El concepto de Microsoft.NET también incluye al conjunto de nuevas aplicaciones que
Microsoft y terceros han (o están) desarrollando para ser utilizadas en la plataforma .NET. Entre
ellas podemos destacar aplicaciones desarrolladas por Microsoft tales como Windows.NET,
Hailstorm, Visual Studio.NET, MSN.NET, Office.NET, y los nuevos servidores para empresas
de Microsoft (SQL Server.NET, Exchange.NET, etc.)
1.1.2. Primeros objetivos
􀂾 Proporcionar un entorno de programación coherente y orientado a objetos, bien sea que
el código se almacene y ejecute de manera local, se ejecute localmente pero esté
distribuido en Internet o se ejecute de manera remota.
􀂾 Proporcionar un entorno de ejecución de código que minimice la distribución de
software y los conflictos de versiones.
􀂾 Proporcionar un entorno de ejecución de código que garantice la ejecución segura del
mismo, incluido el código creado por una empresa desconocida o parcialmente fiable.
􀂾 Proporcionar un entorno de ejecución de código que elimine los problemas de
rendimiento de los entornos de script o interpretados.
􀂾 Conseguir que la interacción con el programador sea semejante ante una variada gama
de aplicaciones, como aplicaciones basadas en Windows y aplicaciones basadas en la
Web.
􀂾 Construir toda la comunicación sobre estándares de la industria para garantizar que el
código basado en la estructura .NET pueda integrarse con cualquier otro código.
1.2. CLR, el núcleo de la plataforma .NET
El corazón de la plataforma.NET es el CLR (Common Language Runtime), que es una
aplicación similar a una máquina virtual que se encarga de gestionar la ejecución de las
aplicaciones para ella escritas. A estas aplicaciones les ofrece numerosos servicios que facilitan
su desarrollo y mantenimiento y favorecen su fiabilidad y seguridad. Entre ellos los principales
son:
􀂾 Modelo de programación consistente y sencillo, completamente orientado a objetos.
􀂾 Eliminación del temido problema de compatibilidad entre DLLs conocido como
"infierno de las DLLs"
􀂾 Ejecución multiplataforma
􀂾 Ejecución multilenguaje, hasta el punto de que es posible hacer cosas como capturar en
un programa escrito en C# una excepción escrita en Visual Basic.NET que a su vez
hereda de un tipo de excepción escrita en Cobol.NET. Aunque más arriba se ha dicho
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
2
que en el .NET Framework sólo se ofrecen compiladores de C#, MC++, VB.NET y
JScript.NET, lo cierto es que aparte Microsoft y terceros han -o están- desarrollado
versiones adaptadas a .NET de muchísimos otros lenguajes como APL, CAML, Cobol,
Eiffel, Fortran, Haskell, Java, Mercury, ML, Mondrian, Oberon, Oz, Pascal, Perl,
Python, RPG, Scheme o Smalltalk
􀂾 Recolección de basura
􀂾 Aislamiento de memoria entre procesos y comprobaciones automáticas de seguridad de
tipos en las conversiones
􀂾 Soporte multihilo
􀂾 Gestión del acceso a objetos remotos que permite el desarrollo de aplicaciones
distribuidas de manera transparente a la ubicación real de cada uno de los objetos
utilizados en las mismas.
􀂾 Seguridad avanzada, hasta el punto de que es posible limitar los permisos de ejecución
del código en función de su procedencia (Internet, red local, CD-ROM, etc.), el usuario
que lo ejecuta o la empresa que lo creó.
􀂾 Interoperabilidad con código preexistente, de manera que es posible utilizar con
facilidad cualquier biblioteca de funciones u objetos COM y COM+ creados con
anterioridad a la aparición de la plataforma .NET
􀂾 Adecuación automática de la eficiencia de las aplicaciones a las características
concretas de cada máquina donde se vaya a ejecutar.
1.3. MSIL, el código intermedio
El código MSIL (Microsoft Intermediate Language) es un conjunto de instrucciones
independiente del procesador. Antes de que el código MSIL pueda ejecutarse, el CLR debe
convertirlo en código específico de la CPU, generalmente mediante un compilador instantáneo
(JIT). La compilación JIT tiene en cuenta que es posible que el motor de ejecución no ejecute
nunca ciertas partes del código.
Por lo tanto, en lugar de ocupar tiempo de procesador y memoria en convertir de un golpe todo
el código MSIL en código nativo (específico de la CPU), el compilador JIT convierte el código
MISL según se necesita durante la ejecución. El compilador almacena el código nativo
resultante para que pueda ser utilizado por llamadas posteriores. Dado que el CLR suministra
compiladores JIT para cada arquitectura de compilador con la que sea compatible, el mismo
código MSIL puede ejecutarse en cualquier arquitectura compatible.
1.4. Metadatos, ensamblados...
En la plataforma .NET se distinguen dos tipos de módulos de código compilado: ejecutables
(extensión .exe) y bibliotecas de enlace dinámico (extensión .dll generalmente) Ambos son
ficheros que contienen definiciones de tipos de datos, y la diferencia entre ellos es que sólo los
primeros disponen de un método especial que sirve de punto de entrada a partir del que es
posible ejecutar el código que contienen haciendo una llamada desde la línea de comandos del
sistema operativo. A ambos tipos de módulos se les suele llamar ejecutables portables (PE), ya
que su código puede ejecutarse en cualquiera de los diferentes sistemas operativos de la familia
Windows para los que existe alguna versión del CLR.
El contenido de un módulo no sólo MSIL, sino que también consta de otras dos áreas muy
importantes: la cabecera de CLR y los metadatos:
􀂾 La cabecera de CLR es un pequeño bloque de información que indica que se trata
de un módulo gestionado e indica es la versión del CLR que necesita, cuál es su
firma digital, cuál es su punto de entrada (si es un ejecutable), etc.
􀂾 Los metadatos son un conjunto de datos organizados en forma de tablas que
almacenan información sobre los tipos definidos en el módulo, los miembros de
Bueno y Cambronero
3
éstos y sobre cuáles son los tipos externos al módulo a los que se les referencia en
el módulo.
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
4
2. Introducción a C#
2.1. Origen del lenguaje
C#, leído en inglés como “C Sharp” (sisarp) y en castellano como “C Almohadilla”, es el nuevo
lenguaje de programación diseñado por la empresa Microsoft. C# ha sido creado por grandes
programadores como Scott Wiltamuth y Anders Hejlsberg, éste último también conocido por
haber creado el lenguaje Turbo Pascal y la herramienta RAD Delphi.
C# ha sido diseñado específicamente para trabajar sobre la plataforma .NET por tanto va a
resultar mucho más sencillo programar usando este lenguaje que usando cualquier otro (que
también pueda escribir código en esta plataforma). Por esta razón se dice que C# es el único
lenguaje nativo de .NET.
Uno de los motivos que impulsaron a Microsoft a la creación de este nuevo lenguaje fue la
consolidación de Java como lenguaje de programación dentro del ámbito de Internet, puesto que
proporcionaba la flexibilidad, la potencia y la portabilidad que necesitan las aplicaciones web.
Por otro lado debido a la gran cantidad de programadores que utilizaban sus anteriores
lenguajes, C y C++, debían crear un lenguaje que ofreciese mecanismos de bajo nivel para que
los programadores pudiesen sacar todo el partido de la nueva plataforma .NET.
Es por esto que C# se creo como un lenguaje orientado a objetos que recoge las
características más avanzadas de Java, así como las más potentes de C++. Esto permitirá
acceder con C# a todos los servicios que brinde la plataforma .NET, al igual que permitirá crear
código muy eficiente en aquellos puntos de la aplicación que sean críticos, así como acceder a
las interfaces de programación de las aplicaciones (APIs) existentes.
En concreto, C# está especialmente preparado para acceder a la API de Windows y a los
objetos COM+ y DLL del sistema, por lo que las aplicaciones escritas en este lenguaje podrán
aprovechar todas las características de este popular sistema operativo y de .NET.
La sintaxis y estructuración de C# es similar a la de C++, ya que Microsoft pretende con
esto facilitar la migración de los programadores en C y C++ al nuevo lenguaje. Así mismo C#
ofrece también la sencillez y productividad propias de Visual Basic.
Con respecto a Java, también hay un cierto parecido sintáctico si se habla de programas
sencillos hasta el punto de poder confundirlos. Sin embargo las diferencias en este campo se
hacen notables según se profundiza en el lenguaje. Alguno de los parecidos con Java y que no
contiene C++ sería el contar con un recolector de basura, manejar excepciones, no soportar
herencia múltiple o ser un leguaje orientado a objetos puro.
2.2. Características generales
Entre las características que se presentan a continuación algunas son propias de la plataforma
.NET más que del propio lenguaje.
􀂾 Orientación a objetos: C# es un lenguaje de programación orientado a objetos puro,
es decir, no admite funciones ni variables globales, todo el código debe definirse
dentro de tipos de datos (clases, estructuras...). Esto reduce los conflictos de
nombres y facilita la legibilidad del código.
C# soporta las características principales del paradigma orientado a objetos:
• Encapsulación: además de los modificadores public, private y
protected se añade uno nuevo: internal. Internal indica que el
elemento sólo podrá ser accedido desde su propio ensamblado.
• Herencia: C#, al igual que Java, sólo soporta herencia simple debido a
las ambigüedades que produce la herencia múltiple. La diferencia con
Bueno y Cambronero
5
Java, está en que para C# todos los métodos serán sellados y para poder
redefinir alguno habrá que usar el modificador virtual (como en
C++). Con esto las llamadas a los métodos será más rápida, ya que si no
está presente el modificador virtual se tomará la llamada al método
de la clase base.
• Polimorfismo.
􀂾 Seguridad de tipos: C# es un lenguaje fuertemente tipado, esto evita cometer errores
que son difíciles de detectar.
• Sólo se pueden realizar conversiones entre tipos que sean compatibles.
• No se pueden usar variables sin inicializar, ya que no tendrían un estado
inicial seguro.
• En los accesos a elementos de tablas (arrays, matrices,…) se comprueba
que los índices no se salgan de rango.
• Se informa con excepciones cuando se producen desbordamientos en
operaciones aritméticas.
• Aunque un método posea un número indeterminado de parámetros de un
tipo, se comprueban.
􀂾 Sistema de tipos unificado: en C# todos los tipos de datos que se definan deben
derivar de una clase base común llamada System.Object. Esto facilita la
creación de colecciones genéricas ya que pueden almacenar objetos de cualquier
tipo.
􀂾 Sencillez: en C# se eliminan elementos incluidos en otros lenguajes y que son
innecesarios en .NET, como por ejemplo:
• No necesita ficheros adicionales al código fuente como son los ficheros de
cabecera o los ficheros IDL ya que el código escrito es autocontenido.
• El tamaño de los tipos de datos básicos es fijo e independiente del
compilador, sistema operativo o máquina utilizada; esto fomenta la
portabilidad. Es una de las mejoras con respecto a C++.
• No se incluyen elementos como las macros, herencia múltiple… de otros
lenguajes.
􀂾 Modernidad: en C# se han incluido elementos nuevos que a lo largo de los años se
ha comprobado que son muy útiles para ciertas aplicaciones y que en otros
lenguajes como Java y C++ hay que simularlos. Por ejemplo:
• Creación del tipo básico decimal para permitir realizar operaciones de
alta precisión con reales de 128 bits.
• Creación de la instrucción foreach para recorrer colecciones con
facilidad y que además se puede ampliar para tipos definidos por el
usuario.
• Creación del tipo básico string para la representación de cadenas.
􀂾 Orientación a componentes: se incluyen en la sintaxis elementos del diseño de
componentes. Con lo cual se pueden definir de una forma sencilla propiedades,
eventos o atributos.
􀂾 Gestión automática de memoria: C# dispone de recolector de basura, lo cual evita al
programador el tener que preocuparse de destruir objetos, liberar memoria. Sin
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
6
embargo, también se dispone de un método manual para liberar recursos, usando la
instrucción using.
􀂾 Instrucciones seguras: se evitan errores comunes cometidos en otros lenguajes
imponiendo una serie de restricciones en algunas instrucciones, como obligar que
todos los casos de un switch terminen con un break o un goto.
􀂾 Extensibilidad de tipos básicos: a través de estructuras se permite definir tipos de
datos que tengan las mismas optimizaciones que los tipos de datos básicos, esto es,
que se puedan almacenar en pila directamente.
􀂾 Extensibilidad de operadores: al igual que C++ y a diferencia de Java, se puede
redefinir el significado por defecto de gran parte de los operadores.
􀂾 Eficiencia: en C# el código incluye muchas restricciones por seguridad, como no
permitir el uso de punteros; sin embargo, a través del modificador unsafe se
pueden crear unas regiones de código inseguras donde saltarse dichas restricciones.
􀂾 Compatibilidad: se permite incluir en códigos escritos en C# fragmentos de códigos
escritos en otros lenguajes, así como acceder a funciones sueltas no orientadas a
objetos (entendiendo orientado a objetos en el sentido de ser puro, es decir de que
todo código debe estar definido en un tipo de datos) como las DLLs. Esto es posible
debido a la característica anterior y a los Platform Invocation Services (PInvoke)
que nos ofrece el CLR (Common Language Runtime)
􀂾 Soporte de XML: el compilador de C# es capaz de generar la documentación en
XML a partir de los comentarios que el programador haya escrito en su código
fuente. Esto es de gran ayuda puesto que código y documentación estarán en el
mismo documento. Para generar la documentación XML se debe usar la opción de
compilación /doc y habrá que darle el nombre que va a tener dicho documento.
Esto se explicará más adelante al tratar el compilador.
Al crearse la documentación XML se usan una serie de etiquetas que forman un
conjunto inteligible para otras herramientas de Visual.NET
􀂾 Espacio de nombres: es un novedad de C# que ayuda a tener ordenados los tipos de
datos. Se podría comparar con los ficheros que se organizan por directorios. Una de
las ventajas más obvias es que se pueden declarar dos clases distintas con el mismo
nombre sin más que hacerlas pertenecer a espacios de nombres diferentes.
2.3. Primera toma de contacto
A continuación, a través de uno de los ejemplos más simples como puede ser la aplicación Hola
mundo!, se van a observar algunas de las características del lenguaje C# antes citadas.
También nos sirve de referencia la figura (Figura 1) que representa el mismo código pero
ya dentro de un proyecto en Visual C# para una aplicación de consola.
class HolaMundo
{
static void Main()
{
System.Console.WriteLine(“¡Hola Mundo!”);
}
}
A simple vista, se observa como todo el código escrito en C# debe estar definido dentro de
un tipo de datos. En la aplicación se está definiendo una clase de nombre HolaMundo.
Bueno y Cambronero
7
Como se vio anteriormente, en C# no se pueden usar variables globales ni funciones que no
estén definidas dentro de algún tipo de datos. Por tanto, incluso la función o método Main
debe encontrarse en algún tipo de datos, como en este caso en una clase.
El modificador static que antecede al método indica que dicho método va a estar
asociado a la clase y no a los objetos que se creen posteriormente. Es una forma de poder
utilizar métodos que sean independientes de cualquier objeto; como es de suponer al usar el
modificador Main no será llamada cada vez que se cree un objeto de la clase HolaMundo.
El cuerpo del método Main es lo que se va a ejecutar. WriteLine() es un método de
la clase Console definida en el especio de nombres System, que imprime por pantalla la
cadena que se le pasa por parámetro.
Al trabajar con C# hay que poner atención en la escritura del código pues es sensible a las
mayúsculas.
Para ver un ejemplo de cómo se vería esto en la aplicación Visual Studio C# al crear un
nuevo proyecto se muestra la siguiente figura (Figura 1):
Figura 1. Código programa Holamundo
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
8
3. El preprocesador
3.1. Concepto general
El preprocesado se realiza previamente a la compilación para controlar la forma en que se
realizará ésta. El módulo auxiliar que se utiliza para estas tareas es el preprocesador. El
preprocesador hace una traducción del texto que se le pasa a texto, que finalmente será
compilado por el compilador.
En C# preprocesado y análisis léxico del código fuente se realizan al mismo tiempo. El
preprocesado se usa prácticamente para permitir realizar compilaciones condicionales de
código.
3.2. Función del preprocesador
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 preprocesado. 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 #).
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:
#
3.2.1. Directivas generales
En C# el preprocesador se usa prácticamente para permitir realizar compilaciones condicionales
de código según se cumplan o no ciertas condiciones. Para evaluar estas condiciones se utilizan
los identificadores de preprocesado. Un identificador de preprocesado vale cierto (true en C#)
si está definido y falso (false en C#) si no lo está. Para definir y eliminar identificadores de
preprocesado se utilizan la s directivas define y undef.
􀂾 Directiva #define:
Sirve para definir un identificador de preprocesado. Sigue esta sintaxis:
#define
Se considera como nombre de identificador válido en C# a aquellos identificadores
formados por uno o más caracteres alfanuméricos tales que no sean ni true ni false
y no empiecen con un número. Por convenio se da a estos identificadores nombres en
los que todas las letras se escriben en mayúsculas.
Por ejemplo, para definir un identificador de preprocesado de nombre EJEMPLO
se haría:
#define EJEMPLO
Cualquier definición de identificador ha de preceder a cualquier aparición de
código en el fichero fuente. 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.
Bueno y Cambronero
9
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:
(forma abreviada de /define:
), 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:METODO /d:LINEA ejemplo.cs
csc /d:METODO, LINEA ejemplo.cs
csc /d:METODO; LINEA ejemplo.cs
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 utiliza el compilador de Visual Studio.NET para definir estos identificadores
de preprocesado en una determinada compilación se puede realizar acudiendo a Ver 􀃆
Página de Propiedades 􀃆 Propiedades de Configuración 􀃆 Generar 􀃆
Constantes de compilación Condicional, (como muestra la Figura 2) donde se puede
usar el punto y coma (;) o la coma (,) como separadores para definir varias constantes.
Figura2. Introducción de variables de preprocesado
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
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
10
compilador como queramos sin temor a que entren en conflicto con identificadores de
preprocesado ya incluidos en los fuentes a compilar.
􀂾 Directiva #undef:
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
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 alguno,
sino que simplemente la directiva de eliminación será ignorada.
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.2. Compilación condicional
La principal utilidad del preprocesador en C# es la de permitir la compilación de código
condicional. La compilación condicional consiste en permitir que se compilen sólamente
determinadas regiones de código fuente si las variables de preprocesado definidas cumplen
alguna condición determinada. Se utiliza la siguiente combinación de directivas para lograr
esto:
#if

#elif

...
#else

#endif
Lo que significa una estructura como esta es que si se verifica lo expresado en
entonces al compilador se le pasa , si esto no ocurre pero se
cumple entonces lo que se pasaría al compilador sería , y así
repetidamente 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 , 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. Es posible anidar varias estructuras
#if...#endif.
La condición de un #if o #elif puede ser un identificador de preprocesado, y este
valdrá true o false según esté o no definido. También es posible en C# incluir condiciones
en las que aparezcan 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 LINEA // Se cumple si LINEA esta definido.
#if LINEA==true // Ídem al ejemplo anterior aunque con una sintaxis
//menos cómoda
Bueno y Cambronero
11
#if !LINEA // Sólo se cumple si LINEA no está definido.
#if LINEA==false // Ídem al ejemplo anterior aunque con una sintaxis
//menos cómoda
#if LINEA == METODO // Solo se cumple si tanto LINEA como METODO //están
definidos o si no ninguno lo está.
#if LINEA!=METODO // Solo se cumple si LINEA esta definido y //METODO no
o viceversa
#if LINEA && METODO // Solo se cumple si están definidos LINEA y //METODO.
#if LINEA || METODO // Solo se cumple si están definidos LINEA o //METODO.
#if false // Nunca se cumple (por lo que es absurdo ponerlo)
#if true // Siempre se cumple (por lo que es absurdo ponerlo)
3.2.3. Generación de errores y avisos:
Durante el preprocesado se puede provocar que el compilador genere mensajes de aviso o de
error. Para ello se hace uso de dos directivas cuya sintaxis es la que sigue:
#warning
#error
En ambos casos el mensaje seguirá el formato estándar usado por el compilador y el texto
descriptivo del mensaje será el contenido en y según el caso.
El uso de estas directivas junto con las directivas de compilación condicional permite
controlar cuando se han de producir estos mensajes.
3.2.4. Renumeración de líneas:
Las líneas de cada fichero fuente son numeradas por el compilador en el mismo orden en que
aparecen. Para cambiar este comportamiento por defecto del compilador se puede hacer uso de
la directiva line, ya que puede interesar cambiar la numeración en determinadas situaciones.
La sintaxis de dicha directiva es:
#line “”
Se indica al preprocesador con esta directiva que la siguiente línea del fichero fuente es la
línea cuyo número se indica en . El valor de “” no es
obligatorio, pero en caso de aparecer indica el nombre de fichero que se ha de proporcionar en
caso de emitir mensajes de error.
A partir de una directiva line se seguirá la numeración normal. Es decir, si aparece en
una línea la directiva
#line 79
la línea que seguiría a esta sería la 79, la siguiente la 80 y así sucesivamente a no ser que
aparezca otra directiva line.
3.2.5. Creación de regiones de código:
Es posible crear regiones de código identificadas por un nombre mediante el uso de las
directivas #region y #endregion.
El uso de estas directivas es el siguiente:
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
12
#region

#endregion
Cada herramienta puede darle distinta utilidad a estas marcaciones de código. En Visual
Estudio .NET se usa para marcar código de modo que éste se pueda expandir o contraer desde la
ventana de código con el manejo del ratón. Cuando el código de la región se encuentre
expandido se visualizará dicho código junto con el símbolo [-] (Como se puede observar en la
figura 3). Si por el contrario se encuentra contraído aparecerá el símbolo [+] junto con el
nombre dado en (Figura 4).
Figura3. Ejemplo de creación de regiones
Figura4. Ejemplo de región contraída
Bueno y Cambronero
13
4. El compilador de Microsoft
4.1. Introducción
El compilador de Microsoft incluido en el .NET Framework SDK puede ser ejecutado desde la
línea de comandos o desde la aplicación Visual Studio.NET; por tanto, se tratará de explicar
como compilar los ficheros fuente creados por los programadores en ambos casos.
Las opciones del compilador que se van a presentar suelen ser las más comunes a la hora
de compilar aplicaciones.
4.2. El compilador desde la línea de comandos
4.2.1. Sintaxis y opciones de compilador
Para compilar código fuente habría que ejecutar el compilador de C#, o lo que es lo mismo
csc.exe; si, como es este caso, se está tratando con el compilador incluido en el .NET
Framework SDK.
La forma más sencilla de llamar al compilador es pasándole como argumentos aquellos
ficheros que se desean compilar; el resultado será un ejecutable .exe con el mismo nombre que
el primer fichero de código fuente pasado. Así:
csc FuenteA.cs FuenteB.cs FuenteC.cs
compilaría estos tres ficheros y crearía un ejecutable denominado FuenteA.exe.
Como es obvio, para que se pueda compilar alguno de los tres ficheros deben tener un
punto de entrada o lo que es lo mismo tener declarado un método Main.
Con las opciones que acepta el compilador se puede utilizar toda la potencia que éste
ofrece. La sintaxis de las opciones es la siguiente:
<>
El indicador_opción suele ser como en otros compiladores el carácter ‘-‘, pero es
bastante usual encontrarse con el carácter ‘/’; en cuanto a opción puede ser de dos tipos:
􀂾 Flags: indican si la característica a la que se refieren está activada o no. En algunos
casos para indicar que un flag está activado se usa el carácter ‘+’ nombre_flag+ y
‘-‘ para indicar que está desactivado. El ‘+’ apenas se utiliza puesto que es la opción por
defecto.
En otros casos, con poner el nombre del flan es suficiente pues se interpreta que se
desea activar.
􀂾 Opciones con valores: en este caso, el nombre de la opción debe ir siempre acompañada
de uno o varios valores, además deben ir separados el nombre de los valores por ‘:’. Si
se dan varios valores se separaran por ‘,’ o ‘;’.
La sintaxis en este caso sería:
:
En los valores no está permitido el uso de espacios pues se interpretarían como
separadores de argumentos, solamente se permiten si éstos van entre comillas dobles.
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
14
Como es lógico no se pueden usar las comillas dobles en los valores encerrados entre
ellas; para solucionar esto se usa el mismo método que en otros casos, el carácter ‘\’.
/recourse: con esta opción se indica al compilador que el fichero fuente a compilar se
encuentra en la ruta que se pasa como valor o en algún subdirectorio de la misma.
csc /recurse:”Programa”\fuenteA.cs
/target: (/t) se usa para variar la ejecución del ejecutable resultante que por
defecto es la apertura de una ventana de consola. Los posibles valores que acepta son:
􀂾 winexe: el ejecutable no abre una ventana de consola, este valor es
interesante si se quieren usar aplicaciones de ventanas o no se requiere interfaz.
􀂾 library: en vez de generar un ejecutable se crea un biblioteca .dll
􀂾 module: se usa para generar un módulo de código sin ensamblar, que puede
servir para ensamblarlos a ficheros ya ensamblados posteriormente. El fichero que se
crea tiene extensión .netmodule.
􀂾 Si no se añade nada o exe se toma el comportamiento por defecto.
/addmodule: es útil para añadir los módulos creados con /t:module a otras
compilaciones.
/main: como ya se dijo, una de las exigencias para que se compile cierto código es que
en alguno de los ficheros fuente a compilar haya un punto de entrada. También se puede dar el
caso en el que si se pasan varios ficheros, más de uno tenga una función miembro Main
declarada; en este caso con esta opción se indica al compilador que fichero posee el punto de
entrada a utilizar.
/out (/o): sirve para cambiar el nombre del fichero por defecto que resultaría de la
compilación.
/referente (/r): está opción es muy útil para añadir a la compilación tipos de
datos que se encuentren definidos en ensamblados diferentes del que se carga por defecto
mscorlib.dll, éste contiene los tipos de datos más frecuentes.
/define (/d): se utiliza cuando se desea introducir elementos de preprocesado como
#define,… al compilar.
/checked: si se añade como opción, se está indicando que se debe dar la excepción
System.OverflowException si se produjese un desbordamiento en alguna operación
aritmética.
/unsafe: sirve para indicar al compilador que va a compilar código con punteros
introducido por el usuario conscientemente. Si no se hiciese daría error.
/doc: se utiliza para indicar al compilador que se debe generar la documentación XML
con el contenido de los comentarios de documentación incluidos en los ficheros fuentes a
compilar. El valor de esta opción será el nombre de este fichero.
4.2.2. Compilación de ficheros de recursos
Los ficheros de recursos son aquéllos que están formados por datos como cadenas de texto,
imágenes, sonidos… su utilidad principal es la de poder separar el código de las aplicaciones de
estos datos; de esta forma, es posible modificar estos ficheros de recursos sin cambiar el código.
Así, resultaría muy sencillo traducir una aplicación a otro idioma sin más que cambiar el fichero
de recursos donde estén alojadas las cadenas de texto que aparezcan en la interfaz de la
aplicación.
Bueno y Cambronero
15
En la plataforma .NET se pueden crear archivos de recursos con dos extensiones diferentes
.txt y .resx, sin embargo el compilador de C# por su parte sólo admite archivos de
recursos con extensión .resource. Para realizar el cambio de un tipo de fichero al otro se
puede usar la herramienta que proporciona el SDK llamada resten.exe.
Para compilar los ficheros de recursos se puede usar la opción del compilador
/linkresource (/linkres) o bien esta otra /resource (/res). La diferencia
está en que si se usa la primera el fichero de recursos formará parte del ensamblado que se
genera pero permanecerá en un fichero separado, pero con la segunda opción se consigue
incrustar el fichero de recursos en el ensamblado.
Debido a que los ficheros de recursos ya se usaban en anteriores lenguajes, el compilador
contempla el uso de estos para las aplicaciones creadas en C#, para incrustar estos ficheros de
recursos .res hay que usar la opción del compilador /win32res.
4.2.3. Depurador
Al compilar se le puede indicar al compilador con el flag /debug que genere un fichero que
contenga información sobre la relación entre el fichero binario generado y el fichero fuente a
partir del cual se generó.
Esto es muy útil a la hora de depurar, ya que en dicho fichero se van a mostrar las líneas
del código fuente en las que se ha producido alguna excepción, no las líneas del código binario.
Gracias a esta información se pueden crear herramientas de depuración, de ejecución paso
a paso indicando en cada momento el estado de la ejecución,…
4.3 Creación y compilación de una aplicación con Visual Studio.NET
A continuación se muestran los pasos generales a seguir para crear una sencilla aplicación en
Visual Studio.NET y su posterior compilación y ejecución todo desde la misma herramienta.
Para empezar, Visual Studio.NET al igual que su antecesor el Visual Studio trabajan a nivel
de proyecto, por tanto aún para una aplicación tan sencilla como la vista anteriormente hay que
crear un proyecto. Para ello se debe pulsar en el botón Nuevo proyecto que aparece nada más
arrancar la aplicación. Al pulsar el botón debe aparecer una pantalla como la mostrada en la
Figura 5. A continuación en el apartado Tipo de proyecto se muestra una lista con los diversos
proyectos que se pueden crear. En el caso que se está estudiando se elige Proyectos de Visual
C#.
Una vez hecho esto se debe elegir en el recuadro Plantillas el tipo de proyecto que se va a
desarrollar dentro del proyecto ya elegido. Se tienen diversas posibilidades como la creación de
una aplicación de consola (Aplicación de consola), la creación de una biblioteca (Biblioteca de
clases), una aplicación que haga uso de ventanas (Aplicación Windows)… Una vez hecho esto,
en los cuadros de edición que aparecen debajo de los recuadros con los proyectos, se decide la
ruta y el nombre del proyecto y se acepta.
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
16
Figura5. Creación de un proyecto de Visual C#
Dependiendo del tipo de proyecto escogido, Visual Studio.NET generará una plantilla con
el código mínimo (como el reflejado en la Figura 6) para que el programa se pueda ejecutar sin
hacer nada, (también se tiene la opción de empezar desde cero). Esta ayuda es semejante a la
que ofrecía Visual Studio con C++, indicando luego con comentarios las regiones donde insertar
el código propio de la aplicación que se va a crear.
Figura6. Documento generado automáticamente por Visual C# para una aplicación de consola
Bueno y Cambronero
17
Una vez se ha escrito todo el código, si desea comprobar lo implementado se pasa a
compilar y ejecutar. Si se pulsa Ctrl+F5 o se selecciona Depurar → Iniciar sin depurar se
compila y acto seguido se ejecuta la aplicación, claro está si el compilador no ha encontrado
errores. Si se desea solamente compilar se selecciona Generar → Generar solución.
Todo esto parece muy sencillo si se compara con la compilación por la línea de comandos,
en un primer momento se puede llegar a pensar que compilar a través de Visual Studio limita al
usuario las opciones de compilación. Sin embargo, en la parte derecha de la pantalla si se pulsa
en Explorador de soluciones o bien se hace clic a través de Ver → Explorador de soluciones
aparece una nueva ventana que muestra información del proyecto que se está realizando.
Para visualizar las opciones del compilador se pulsa sobre el proyecto en el que se esté
trabajando, en la ventana que aparece (reflejado en la figuras 7 y 8) se pueden ir configurando
de forma visual las diferentes opciones que se veían en el apartado 2.
Figura7. Opciones del compilador en el Visual C# ( I )
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
18
Figura8. Opciones del compilador en el Visual C# ( II )
Debido a que los nombres de las opciones no concuerdan con los nombres de los flags que
se usaban en la línea de comandos se muestra a continuación la relación de alguna de las
opciones (Tabla 1).
Opción Control visual
/checked Propiedades de configuración 􀃆 Generar 􀃆 Check for Arithmetic
Overflow/Underflow
/debug Propiedades de configuración 􀃆 Generar 􀃆 Generate Debugging
Information
/define Propiedades de configuración 􀃆 Generar 􀃆 Conditional Compilation
Constants
/doc Propiedades de configuración 􀃆 Generar 􀃆 XML Documentation File
/main Propiedades comunes 􀃆 General 􀃆 Objeto inicial
/out Propiedades comunes 􀃆 General 􀃆 Nombre del ensamblado
/target Propiedades comunes 􀃆 General 􀃆 Tipo de resultado
/unsafe Propiedades de configuración 􀃆 Generar 􀃆 Allow unsafe code blocks
/win32icon Propiedades comunes 􀃆 General 􀃆 Icono de aplicación
Tabla1. Correspondencias de opciones de compilación por línea de ordenes con las opciones del Visual C#
Al igual que estas, también existen opciones del compilador no soportadas desde Visual
Studio.NET como: /help, /recourse , /linkresource…
Bueno y Cambronero
19
5. Últimas tendencias
Como ya se ha visto en este trabajo una de las herramientas que incorpora C# es Visual C#
incluido en Visual Studio.NET, pero ya hay proyectos en marcha para llevar la plataforma .NET
a otros sistemas operativos así como el lenguaje C#, un ejemplo de ello es el proyecto MONO.
El proyecto MONO, propuesto por Miguel de Icaza, trata de crear un entorno de desarrollo
basado en algunas de las tecnologías propuestas en la arquitectura.NET para Linux. Sus tres
primeras áreas de trabajo son:
􀂾 la creación de un compilador de C# implementado en el propio C#
􀂾 la creación de clases de bibliotecas
􀂾 la creación de una máquina virtual para atajar los problemas de portabilidad e
integración entre los lenguajes que van surgiendo
También se pueden encontrar diversos editores para C# como el CSharpEd, con el que
podemos compilar los programas creados, es sí, siempre que se tenga instalado el compilador de
Microsoft. Otro posible editor es Code Wright.
Asi mismo, se dispone de algún entorno de desarrollo más, como Antechinus C# Editor,
(incluye editor y compilador) o el entorno IC#SharpCode que es de código abierto.
INTRODUCCIÓN AL COMPILADOR Y PREPROCESADOR DE C# EN VISUAL STUDIO.NET
20
6. Conclusiones

C# es un lenguaje moderno, creado para implementar aplicaciones de última generación como
pueden ser los servicios web. Al ser un lenguaje tan reciente aún no se encuentran muchos
productos para trabajar con él, le falta un poco más de madurez. A pesar de ello, ya se encuentra
estandarizado por la ECMA en diciembre de 2001 y se presenta como uno de los principales
lenguajes de programación de los próximos años.

7. Bibliografía

Eric Butow & Tommy Ryan. “C#. Your Visual blueprint for building .NET applications”.
Hungry Minds, Inc, 2002.
Adrian Turtschi, DotThatCom.com, Jason Werry, Greg Hack, Joseph Albahari. “C# .NET.
Web Developer´s guide”. Syngress Publishing, Inc.
Derek Beyer. “C# COM+ Programming”. Hungry Minds, Inc., 2001
Robin A. Reynolds-Haertle. “OOP with Microsoft Visual Basic .NET and Microsoft Visual C#
Step by Step”. Microsoft Press, 2002
Jesse Liberty. “Programming C#”. O'Reilly Second Edition February 2002.
Jose Antonio González Seco. “El lenguaje de programación C#”
http://www.josanguapo.com/
Joaquín Peña. El Rincón en español de C#. http://tdg.lsi.us.es/~csharp/
C Almohadilla. http://usuarios.lycos.es/somm2000/
Web del proyecto MONO en castellano. http://mono.es.gnome.org/
Web en inglés del proyecto MONO. http://www.go-mono.com/
Web del editor de C# Antichinus. http://www.c-point.com
Web del entorno IC#SharpCode. http://www.icsharpcode.net/
Página principal de Visual Studio.NET en castellano.
http://www.microsoft.com/spanish/msdn/vstudio/default.asp
Web con enlaces a los editores de C# presentados.
http://www.iespana.es/alrebujon/lenguajec.html

Fundamentos de la programación orientada a objetos.

Fundamentos de la programación orientada a objetos.

1. Resumen

2. Introducción
3. Desarrollo

4. Conclusiones

5. Bibliografía

Resumen:

En este artículo el autor hace una sucinta descripción de los fundamentos de la programación orientada a objetos, necesaria para aquellos que no poseen nociones sobre esta materia, y material de consulta para los que la conocen o dominan.

Introducción:

En el universo de la programación actual, es de amplio consenso que la programación orientada a objetos es el mejor paradigma disponible para enfrentar las cada vez más complejas tareas de la programación. Sin embargo, no todos los programadores tienen claro los fundamentos de este paradigma, y tienden a confundir la programación usando objetos con la programación orientada a objetos.

En Visual Basic, por ejemplo, se usan objetos (componentes) sin que ello implique que estemos en presencia de un lenguaje orientado a objetos.

Programamos orientado a objetos cuando, usando un lenguaje de programación, somos capaces de modelar el problema en términos de objetos y sus relaciones.

Es decir cuando cada entidad en el programa es un objeto que brinda determinados servicios.

En este trabajo se hace una sucinta descripción de los fundamentos de la programación orientada a objetos, necesaria para aquellos que no poseen nociones sobre esta materia, y material de consulta para los que la conocen o dominan.

Desarrollo:

La programación orientada a objetos es la expresión de uno de los más avanzados paradigmas en el campo de la programación, y es, al mismo tiempo, el resultado de la evolución experimentada por los paradigmas anteriores.

A diferencia de otros paradigmas de programación, que intentan, al abordar un problema, representarlo o modelarlo empleando entidades cercanas a la computadora (arreglos, subrutinas, módulos) la programación orientada a objetos se propone emplear entidades lo más cercanas posibles a la realidad.

La programación orientada a objetos tiene como conceptos fundamentales los conceptos de objeto y clase.

Un objeto es un ente que posee sus características propias (propiedades) y un conjunto de acciones que es capaz de realizar (métodos).

Una clase es un ente abstracto que permite declarar las propiedades y los métodos de objetos similares.

Un lenguaje de programación orientado a objetos debe permitir al programador realizar definiciones de clases, y construir objetos a partir de esas clases.

Para resolver un problema bajo el paradigma de la programación orientada a objetos basta con determinar y caracterizar los diferentes objetos que intervienen en el problema, definir sus propiedades y métodos y ponerlos a interactuar entre sí.

Ejemplo:

Supongamos que se desea diseñar una aplicación para controlar a todo el personal que estudia o trabaja en el Instituto Superior Pedagógico conociendo la información correspondiente a cada uno de ellos.

Trabajadores Docentes	Trabajadores de Servicio	Estudiantes
Nombre	Nombre	Nombre
Dirección	Dirección	Dirección
Número de Identidad	Número de Identidad	Número de Identidad
Sexo	Sexo	Sexo
Fecha de Ingreso	Fecha de Ingreso	Año
Cargo	Cargo	Especialidad
Salario	Salario
Departamento	Área
Asignatura

Tabla #1

Inicialmente podríamos pensar en declarar tres clases : TDocente, TServicio y Estudiante; pero si analizamos la información observamos que hay propiedades que se repiten en las tres clases como son: Nombre, Dirección, Número de Identidad y Sexo por lo que se pudiera declarar una clase Persona que agrupe estas propiedades comunes y así no tener que repetirlas en cada una de las clases por lo que tendríamos ahora cuatro clases:

pero aún quedan, en las clase TDocente y TServicio propiedades comunes por lo que se pudiera declarar una clase Trabajador con las propiedades Fecha Ingreso, cargo y Salario quedando finalmente cinco clases:

De acuerdo a las clase que hemos concebido podemos decir que un Estudiante es una Persona que tiene un año y una especialidad; un Trabajador es una Persona que tiene una fecha de ingreso, un cargo y un salario; un Trabajador docente es un Trabajador que tiene un departamento y una asignatura y un Trabajador de servicio es un Trabajador que tiene área.

Los Estudiantes y los Trabajadores forman subconjuntos de las Personas. La clase Persona es la Clase Base de las clases Estudiante y Trabajador por lo que estas clases heredan las propiedades y los métodos de la clase Persona.

De manera similar los Trabajadores Docentes y los Trabajadores de Servicio son subconjuntos de los Trabajadores por lo que la clase Trabajador es Clase Base de las clases TDocente y TServicio y por tanto heredan las propiedades y los métodos de la clase Trabajador.

Luego las cinco clases serían:

Clase Persona

Propiedades: Nombre Dirección Número de Identidad Sexo

Métodos: Entrar Dirección Visualizar Nombre Visualizar Dirección Visualizar Número Identidad Visualizar Sexo

Tabla #2

Puedes constatar que no hemos definido métodos para Entrar nombre, Entrar número de identidad, ni Entrar sexo porque no tienen sentido; la persona no puede cambiar su nombre, número de carné de identidad, ni sexo ella misma.

Nuestra persona tiene la posibilidad de cambiar de dirección y de visualizar su nombre, dirección, número de identidad y sexo.

Clase Trabajador

Propiedades y métodos de la clase Persona

Propiedades: Fecha de Ingreso Cargo Salario

Métodos: Entrar Cargo Entrar Salario Visualizar Fecha de Ingreso Visualizar Cargo Visualizar Salario

Tabla #3

Nuestro trabajador tiene la posibilidad de cambiar de cargo y de salario y de visualizar su cargo, salario y fecha de ingreso; pero también puede cambiar su dirección y visualizar su nombre, dirección, número de carné de identidad y sexo porque es a la vez un trabajador y una persona.

Clase Estudiante

Propiedades y métodos de la clase Persona

Propiedades: Año Especialidad

Métodos: Entrar Año Visualizar Año Visualizar Especialidad

Tabla #4

Nuestro estudiante tiene la posibilidad de cambiar de año y de visualizar el año que cursa y su especialidad; pero también puede cambiar su dirección y visualizar se nombre, dirección, número de carné de identidad y sexo porque es a la vez un estudiante y una persona.

Clase TDocente

Propiedades y métodos de la clase Trabajador

Propiedades: Departamento Asignatura

Métodos: Entrar Departamento Entrar Asignatura Visualizar Departamento Visualizar Asignatura

Tabla #5

Nuestro trabajador docente tiene la posibilidad de cambiar de departamento y de asignatura y de visualizar el departamento y la asignatura a la que pertenece; pero también puede cambiar su dirección, cargo y salario y visualizar su nombre, dirección, número de carné de identidad, sexo y fecha de ingreso porque es a la vez un trabajador docente y un trabajador que es a su vez una persona.

Clase TServicio

Propiedades y métodos de la clase Trabajador

Propiedades: Área

Métodos: Entrar Área Visualizar Área

Tabla #6

Nuestro trabajador de servicio tiene la posibilidad de cambiar de área y de visualizar el área donde trabaja; pero también puede cambiar su dirección, cargo y salario y visualizar su nombre, dirección, número de carné de identidad, sexo y fecha de ingreso porque es a la vez un trabajador de servicio y un trabajador que es a su vez una persona.

Los objetos que intervienen en la solución de este problema son las instancias de las clases TDocente, TServicio y Estudiante que se llenan con datos reales. Por ejemplo:

El trabajador docente Juan, que vive en la Calle 5 # 29, con número de carné de identidad 57062406503, del sexo masculino, con fecha de ingreso 1/9/94, que ocupa el cargo de profesor, con salario de 620 pesos, perteneciente al departamento de Informática, y que imparte la asignatura de Programación.

El trabajador de servicio Pedro, que vive en Maceo # 39, con número de carné de identidad 61120306325, del sexo masculino, con fecha de ingreso 2/7/91, que ocupa el cargo de electricista, con salario de 230 pesos, y que pertenece al área de mantenimiento.

La estudiante María, que vive en el Edificio # 78, con número de carné de identidad 65082706224, del sexo femenino, que está en primer año, y es de la especialidad de Inglés.

Como ya se dijo, en la programación orientada a objetos, un programa no es más que una colección de objetos interactuando entre sí.

Esa interacción se produce a través de mensajes.

Un mensaje es un pedido al objeto de que ejecute uno de sus métodos y consta del nombre del objeto y el nombre del método a ejecutar. Un mensaje podría ser “Estudiante dígame su especialidad”.

Como se explicó anteriormente, puede considerarse a un estudiante como una persona y en consecuencia solicitarle los mismos servicios que a una persona por lo que también podríamos pedirle al estudiante que nos diga su nombre, dirección, carne de identidad y sexo.

A esta posibilidad de considerar una instancia de una clase como instancia de la clase base se le conoce con el nombre de polimorfismo.

Conclusiones:

Para entender cómo funciona el paradigma de la programación orientada a objetos es necesario ver un programa como una colección de objetos que interactúan entre sí enviándose mensajes y cambiando su estado durante la ejecución.

Resolver un problema bajo el paradigma de la programación orientada a objetos implica determinar y caracterizar los diferentes objetos que intervienen en el problema, definir sus propiedades y métodos y ponerlos a interactuar.

Bibliografía:

Rivero Errico, Alfonso J. Introducción a la programación para Windows con Visual Basic.-- Ciudad de la Habana : Editorial Pueblo y Educación, 2001

Díaz Iglesias, Jack y Pérez González, Franklin. Delphi 5 Básico.-- Ciudad de la Habana : Editorial Pueblo y Educación, 2001

Curso por correo electrónico sobre Borland Delphi.

Autor:

Asistente Juan Antonio Fonseca Hernández.

jfonseca@ispgrm.rimed.cu