# C

------------------------------------------------------------------------------------------------Introducing C# and the .NET Platform

The Philosophy of .NET

very few years or so, the modern-day programmer must be willing to perform a self-inflicted

knowledge transplant to stay current with the new technologies of the day. The languages (C++, Visual Basic 6.0, Java), frameworks (OWL, MFC, ATL, STL), architectures (COM, CORBA, EJB), and APIs (such as .NETs Windows Forms and GDI+ libraries) that were touted as the silver bullets of software development eventually become overshadowed by something better or at the very least something new. Regardless of the frustration you can feel when upgrading your internal knowledge base, it is frankly unavoidable. To this end, the goal of this book is to examine the details of Microsofts current offering within the landscape of software engineering: the .NET platform and the C# programming language. The point of this chapter is to lay the conceptual groundwork for the remainder of the book. Here you will find a high-level discussion of a number of .NET-related topics such as assemblies, the common intermediate language (CIL), and just-in-time (JIT) compilation. In addition to previewing some key features of the C# programming language, you will also come to understand the relationship between various aspects of the .NET Framework, such as the common language runtime (CLR), the Common Type System (CTS), and the Common Language Specification (CLS). This chapter also provides you with a survey of the functionality supplied by the .NET base class libraries, sometimes abbreviated as the BCL or alternatively as the FCL (being the Framework class libraries). Finally, this chapter overviews the language-agnostic and platformindependent nature of the .NET platform(yes its true, .NET is not confined to the Windows operating system). As you would hope, all of these topics are explored in further detail throughout the remainder of this text.

Understanding the Previous State of Affairs

Before examining the specifics of the .NET universe, its helpful to consider some of the issues that motivated the genesis of Microsofts current platform. To get in the proper mind-set, lets begin this chapter with a brief and painless history lesson to remember our roots and understand the limitations of the previous state of affairs (after all, admitting you have a problem is the first step toward finding a solution). After completing this quick tour of life as we knew it, we turn our attention to the numerous benefits provided by C# and the .NET platform.

Life As a C/Win32 API Programmer

Traditionally speaking, developing software for the Windows family of operating systems involved using the C programming language in conjunction with the Windows application programming interface (API). While it is true that numerous applications have been successfully created using this time-honored approach, few of us would disagree that building applications using the raw API is a complex undertaking. The first obvious problem is that C is a very terse language. C developers are forced to contend

with manual memory management, ugly pointer arithmetic, and ugly syntactical constructs. Furthermore, given that C is a structured language, it lacks the benefits provided by the object-oriented approach (can anyone say spaghetti code?). When you combine the thousands of global functions and data types defined by the Win32 API to an already formidable language, it is little wonder that there are so many buggy applications floating around today.

Life As a C++/MFC Programmer

One vast improvement over raw C/API development is the use of the C++ programming language. In many ways, C++ can be thought of as an object-oriented layer on top of C. Thus, even though C++ programmers benefit from the famed pillars of OOP (encapsulation, inheritance, and polymorphism), they are still at the mercy of the painful aspects of the C language (e.g., manual memory management, ugly pointer arithmetic, and ugly syntactical constructs). Despite its complexity, many C++ frameworks exist today. For example, the Microsoft Foundation Classes (MFC) provide the developer with a set of C++ classes that facilitate the construction of Win32 applications. The main role of MFC is to wrap a sane subset of the raw Win32 API behind a number of classes, magic macros, and numerous code-generation tools (a.k.a. wizards). Regardless of the helpful assistance offered by the MFC framework (as well as many other C++-based windowing toolkits), the fact of the matter is that C++ programming remains a difficult and error-prone experience, given its historical roots in C.

Life As a Visual Basic 6.0 Programmer

Due to a heartfelt desire to enjoy a simpler lifestyle, many programmers have shifted away from the world of C(++)-based frameworks to kinder, gentler languages such as Visual Basic 6.0 (VB6). VB6 is popular due to its ability to build complex user interfaces, code libraries (e.g., COM servers), and data access logic with minimal fuss and bother. Even more than MFC, VB6 hides the complexities of the raw Win32 API from view using a number of integrated code wizards, intrinsic data types, classes, and VB-specific functions. The major downfall of VB6 (which has been rectified given the advent of the .NET platform) is that it is not a fully object-oriented language; rather, it is object aware. For example, VB6 does not allow the programmer to establish is-a relationships between types (i.e., no classical inheritance) and has no intrinsic support for parameterized class construction. Moreover, VB6 doesnt provide the ability to build multithreaded applications unless you are willing to drop down to low-level Win32 API calls (which is complex at best and dangerous at worst).

Life As a Java/J2EE Programmer

Enter Java. Java is an object-oriented programming language that has its syntactic roots in C++. As many of you are aware, Javas strengths are far greater than its support for platform independence. Java (as a language) cleans up many unsavory syntactical aspects of C++. Java (as a platform) provides programmers with a large number of predefined packages that contain various type definitions. Using these types, Java programmers are able to build 100% Pure Java applications complete with database connectivity, messaging support, web-enabled front ends, and a rich desktop user interface. Although Java is a very elegant language, one potential problem is that using Java typically means that you must use Java front-to-back during the development cycle. In effect, Java offers little hope of language integration, as this goes against the grain of Javas primary goal (a single programming language for every need). In reality, however, there are millions of lines of existing code out there in the world that would ideally like to commingle with newer Java code. Sadly, Java makes this task problematic. While Java does provide a limited ability to access non-Java APIs, there is little support for true cross-language integration.

Life As a COM Developer

The Component Object Model (COM) was Microsofts previous application development framework. COM is an architecture that says in effect, If you build your classes in accordance with the rules of COM, you end up with a block of reusable binary code. The beauty of a binary COM server is that it can be accessed in a language-independent manner. Thus, C++ programmers can build COM classes that can be used by VB6. Delphi programmers can use COM classes built using C, and so forth. However, as you may be aware, COMs language independence is somewhat limited. For example, there is no way to derive a new COM class using an existing COM class (as COM has no support for classical inheritance). Rather, you must make use of the more cumbersome has-a relationship to reuse COM class types.

Another benefit of COM is its location-transparent nature. Using constructs such as application identifiers (AppIDs), stubs, proxies, and the COM runtime environment, programmers can avoid the need to work with raw sockets, RPC calls, and other low-level details. For example, consider the following VB6 COM client code: ' The MyCOMClass type could be written in ' any COM-aware language, and may be located anywhere ' on the network (including your local machine). Dim obj as MyCOMClass Set obj = New MyCOMClass ' Location resolved using AppID. obj.DoSomeWork Although COM can be considered a very successful object model, it is extremely complex under the hood (at least until you have spent many months exploring its plumbingespecially if you happen to be a C++ programmer). To help simplify the development of COM binaries, numerous COM-aware frameworks have come into existence. For example, the Active Template Library (ATL) provides another set of C++ classes, templates, and macros to ease the creation of COM types. Many other languages also hide a good part of the COM infrastructure from view. However, language support alone is not enough to hide the complexity of COM. Even when you choose a relatively simply COM-aware language such as VB6, you are still forced to contend with fragile registration entries and numerous deployment-related issues (collectively, and somewhat comically, termed DLL hell).

Life As a Windows DNA Programmer

To further complicate matters, there is a little thing called the Internet. Over the last several years, Microsoft has been adding more Internet-aware features into its family of operating systems and products. Sadly, building a web application using COM-based Windows Distributed interNet Applications Architecture (DNA) is also quite complex. Some of this complexity is due to the simple fact that Windows DNA requires the use of numerous technologies and languages (ASP, HTML, XML, JScript, VBScript, and COM[+], as well as a data access API such as ADO). One problem is that many of these technologies are completely unrelated from a syntactic point of view. For example, JScript has a syntax much like C, while VBScript is a subset of VB6. The COM servers that are created to run under the COM+ runtime have an entirely different look and feel from the ASP pages that invoke them. The result is a highly confused mishmash of technologies. Furthermore, and perhaps more important, each language and/or technology has its own type system (that may look nothing like anothers type system). Beyond the fact that each API ships with its own collection of prefabricated code, even basic data types cannot always be treated identically. A CComBSTR in ATL is not quite the same as a String in VB6, both of which have nothing to do with a char* in C.

The .NET Solution

So much for the brief history lesson. The bottom line is that life as a Windows programmer has been tough. The .NET Framework is a rather radical and brute-force approach to making our lives easier. The solution proposed by .NET is Change everything (sorry, you cant blame the messenger for the message). As you will see during the remainder of this book, the .NET Framework is a completely new model for building systems on the Windows family of operating systems, as well as on numerous non-Microsoft operating systems such as Mac OS X and various Unix/Linux distributions. To set the stage, here is a quick rundown of some core features provided courtesy of .NET: Comprehensive interoperability with existing code: This is (of course) a good thing. Existing COM binaries can commingle (i.e., interop) with newer .NET binaries and vice versa. Also, PlatformInvocation Services (PInvoke) allows you to call C-based libraries (including the underlying API of the operating system) from .NET code. Complete and total language integration: .NET supports cross-language inheritance, crosslanguage exception handling, and cross-language debugging of code. A common runtime engine shared by all .NET-aware languages: One aspect of this engine is a well-defined set of types that each .NET-aware language understands. A comprehensive base class library: This library provides shelter from the complexities of raw API calls and offers a consistent object model used by all .NET-aware languages.

 No more COM plumbing: IClassFactory, IUnknown, IDispatch, IDL code, and the evil variantcompliant data types (BSTR, SAFEARRAY, and so forth) have no place in a .NET binary. A truly simplified deployment model: Under .NET, there is no need to register a binary unit into the system registry. Furthermore, .NET allows multiple versions of the same *.dll to exist in harmony on a single machine. As you can most likely gather from the previous bullet points, the .NET platform has nothing to do with COM (beyond the fact that both frameworks originated from Microsoft). In fact, the only way .NET and COM types can interact with each other is using the interoperability layer.

COM and .NET Interoperability T

he goal of this book was to provide you with a solid foundation in the C# language and the

core services provided by the .NET platform. I suspect that when you contrast the object model provided by .NET to that of Microsofts previous component architecture (COM), youll no doubt be convinced that these are two entirely unique systems. Regardless of the fact that COM is now considered to be a legacy framework, you may have existing COM-based systems that you would like to integrate into your new .NET applications. Thankfully, the .NET platformprovides various types, tools, and namespaces that make the process of COM and .NET interoperability quite straightforward. This appendix begins by examining the process of .NET to COM interoperability and the related Runtime Callable Wrapper (RCW). The latter part of this appendix examines the opposite situation: a COM type communicating with a .NET type using a COM Callable Wrapper (CCW).

s Note A full examination of the .NET interoperability layer would require a book unto itself.
If you require more details than presented in this appendix, check out my book COM and .NET Interoperability (Apress, 2002).

The Scope of .NET Interoperability

Recall that when you build assemblies using a .NET-aware compiler, you are creating managed code that can be hosted by the common language runtime (CLR). Managed code offers a number of benefits such as automatic memory management, a unified type system (the CTS), self-describing assemblies, and so forth. As you have also seen, .NET assemblies have a particular internal composition. In addition to CIL instructions and type metadata, assemblies contain a manifest that fully documents any required external assemblies as well as other file-related details (strong naming, version number, etc.). On the other side of the spectrum are legacy COM servers (which are, of course, unmanaged code). These binaries bear no relationship to .NET assemblies beyond a shared file extension (*.dll or *.exe). First of all, COM servers contain platform-specific machine code, not platform-agnostic CIL instructions, and work with a unique set of data types (often termed oleautomation or variantcompliant data types), none of which are directly understood by the CLR. In addition to the necessary COM-centric infrastructure required by all COM binaries (such as registry entries and support for core COM interfaces like IUnknown) is the fact that COM types demand to be reference counted in order to correctly control the lifetime of a COM object. This is in stark contrast, of course, to a .NET object, which is allocated on a managed heap and handled by the CLR garbage collector. Given that .NET types and COM types have so little in common, you may wonder how these two architectures can make use of each others services. Unless you are lucky enough to work for a company dedicated to 100% Pure .NET development, you will most likely need to build .NET solutions that use legacy COM types. As well, you may find that a legacy COM server might like to communicate with the types contained within a shiny new .NET assembly. The bottom line is that for some time to come, COM and .NET must learn how to get along. This appendix examines the process of managed and unmanaged types living together in harmony using the .NET interoperability layer. In general, the .NET Framework supports two core flavors of interoperability: .NET applications using COM types

 COM applications using .NET types As youll see throughout this appendix, the .NET Framework 3.5 SDK and Visual Studio 2008 supply a number of tools that help bridge the gap between these unique architectures. As well, the .NET base class library defines a namespace (System.Runtime.InteropServices) dedicated solely to the issue of interoperability. However, before diving in too far under the hood, lets look at a very simple example of a .NET class communicating with a COM server.

-------------------------------------------------------------------------------------------------

1. Introduction
C# (pronounced See Sharp) is a simple, modern, object-oriented, and type-safe programming language. C# has its roots in the C family of languages and will be immediately familiar to C, C++, and Java programmers. C# is standardized by ECMA International as the ECMA-334 standard and by ISO/IEC as the ISO/IEC 23270 standard. Microsofts C# compiler for the .NET Framework is a conforming implementation of both of these standards. C# is an object-oriented language, but C# further includes support for componentoriented programming. Contemporary software design increasingly relies on software components in the form of self-contained and self-describing packages of functionality. Key to such components is that they present a programming model with properties, methods, and events; they have attributes that provide declarative information about the component; and they incorporate their own documentation. C# provides language constructs to directly support these concepts, making C# a very natural language in which to create and use software components. Several C# features aid in the construction of robust and durable applications: Garbage collection automatically reclaims memory occupied by unused objects; exception handling provides a structured and extensible approach to error detection and recovery; and the type-safe design of the language makes it impossible to read from uninitialized variables, to index arrays beyond their bounds, or to perform unchecked type casts. C# has a unified type system. All C# types, including primitive types such as int and double, inherit from a single root object type. Thus, all types share a set of common operations, and values of any type can be stored, transported, and operated upon in a consistent manner. Furthermore, C# supports both user-defined reference types and value types, allowing dynamic allocation of objects as well as in-line storage of lightweight structures. To ensure that C# programs and libraries can evolve over time in a compatible manner, much emphasis has been placed on versioning in C#s design. Many programming languages pay little attention to this issue, and, as a result, programs written in those languages break more often than necessary when newer versions of dependent libraries are introduced. Aspects of C#s design that were directly influenced by versioning considerations include the separate virtual and override modifiers, the rules for method overload resolution, and support for explicit interface member declarations. The rest of this chapter describes the essential features of the C# language. Although later chapters describe rules and exceptions in a detail-oriented and sometimes mathematical manner, this chapter strives for clarity and brevity at the expense of completeness. The intent is to provide the reader with an introduction to the language that will facilitate the writing of early programs and the reading of later chapters.

-------------------------------------------------------------------------------------------------

C# isa language targeted at developersfor the Microsoft .NET platform who have already worked with a C-like language such as C, C++, or Java. Unlike previous versions of C or C++ for the Microsoft Windows platform, C# code runs under a managed execution environment. Microsoft portrays C# as a modern and innovative language for .NET development and continuesto deliver on that with new features such as Language Integrated Query (LINQ). The new features in C# 3.0 allow for more of a declarative and functional style of programming, when that is appropriate, while it still hasgreat object-oriented featuresaswell. The main idea isto use the style of programming that fits your problem, and C# will support your endeavor. C# allows you to perform many C/C++-like functions, such as direct memory access via pointers and operator overloading, that are not supported in Visual Basic .NET. C# is the system-level programming language for .NET. You can still do great applicationlevel work in C#, but it really shines when you need to build code a little closer to the Framework. If you have seen C#, you may have noticed that it looks a lot like Java; Java programmerswill feel very much at home in C# once they learn the Framework SDK. C# can also be a great language for Visual Basic .NET programmers when they need a little more control over what the code isdoing and dont want to have to write C++ to gain an advantage. On the Web, youll find a large community of people doing really neat things with C# and tons of sample code on sites such as http:// www.codeplex.com and http://www.codeproject.com. We started writing this book together based on programming problems we ran into when we were first learning C# and have continued to expand it based on new challengesand capabilitiesin the language. In thisedition, we have reworked the approach of many solutions to take advantage of LINQ and have also created entirely new solutions based on LINQ and the other new features in C# 3.0. We hope that it will help you get past some of the common (and not-so-common) pitfallsand initial questionseveryone haswhen learning a new language aswell asthe slightly off-the-beaten-path items that come up during a development cycle. There are recipes addressing things we found missing from the .NET Framework Class Library (FCL), even though Microsoft has provided tons of functionality to keep folks from reinventing the wheel. Some of these solutions you might immediately use, and some may never darken your door, but we hope this book helps you get the most out of C# and the .NET Framework. The book is laid out with respect to the types of problems you will solve as you progress through your life as a C# programmer. These solutions are called recipes; each recipe consists of a single problem, its solution, a discussion of the solution and other relevant related information, and finally, where you can look for more information about the classes used from the FCL, other books addressing this topic, related articles, and other recipes. The question-answer format provides complete solutions to problems, making the book easy to read and use. Nearly every recipe contains a complete, documented code sample, showing you how to solve the specific problem, as well as a discussion of how the underlying technology works and a list of alternatives, limitations, and other considerations when appropriate.

-------------------------------------------------------------------------------------------------

C# o C Sharp es un lenguaje orientado a objetos desarrollado por Microsoft Corporation basndose en el C++, pero siendo 100% orientado a objetos. Generalmente se usa para desarrollar programas en la plataforma .NET siendo portable a todos los sistemas operativos con la plataforma .NET instalada.

Introduccion a C# 1.1 Origen y necesidad de un nuevo lenguaje 1.2 C# (ledo en ingls C Sharp y en espaol C Almohadilla) es el nuevo lenguaje de propsito general diseado por Microsoft para su plataforma .NET. Sus principales creadores son Scott Wiltamuth y Anders Hejlsberg, ste ltimo tambin conocido por haber sido el diseador del lenguaje Turbo Pascal y la herramienta RAD Delphi. Aunque es posible escribir cdigo para la plataforma .NET en muchos otros lenguajes, C# es el nico que ha sido diseado especficamente para ser utilizado en ella, por lo que programarla usando C# es mucho ms sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes ya que C# carece de elementos heredados innecesarios en .NET. Por esta razn, se suele decir que C# es el lenguaje nativo de .NET La sintaxis y estructuracin de C# es muy parecida a la de C++ o Java, puesto que la intencin de Microsoft es facilitar la migracin de cdigos 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 aadiese a las ya probadas virtudes de Java las modificaciones que Microsoft tena pensado aadirle para mejorarlo an ms y hacerlo un lenguaje orientado al desarrollo de componentes. En resumen, C# es un lenguaje de programacin que toma las mejores caractersticas 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 usndolo, por lo que su compilador es el ms depurado y optimizado de los incluidos en el .NET Framework SDK 1.3 Caractersticas de C# Con la idea de que los programadores ms experimentados puedan obtener una visin general del lenguaje, a continuacin se recoge de manera resumida las principales caractersticas de C# Alguna de las caractersticas aqu sealadas no son exactamente propias del lenguaje sino de la plataforma .NET en general, y si aqu se comentan es porque tienen una repercusin directa en el lenguaje:

Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son innecesarios en .NET. Por ejemplo:
o

El cdigo escrito en C# es autocontenido, lo que significa que no necesita de ficheros adicionales al propio fuente tales como ficheros de cabecera o ficheros IDL

El tamao de los tipos de datos bsicos es fijo e independiente del compilador, sistema operativo o mquina para quienes se compile (no como en C++), lo que facilita la portabilidad del cdigo. No se incluyen elementos poco tiles de lenguajes como C++ tales como macros, herencia mltiple o la necesidad de un operador diferente del punto (.) acceder a miembros de espacios de nombres (::)

Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los aos ha ido demostrndose son muy tiles para el desarrollo de aplicaciones y que en otros lenguajes como Java o C++ hay que simular, como un tipo bsico decimal que permita realizar operaciones de alta precisin con reales de 128 bits (muy til en el mundo financiero), la inclusin de una instruccin foreach que permita recorrer colecciones con facilidad y es ampliable a tipos definidos por el usuario, la inclusin de un tipo bsico string para representar cadenas o la distincin de un tipo bool especfico para representar valores lgicos. Orientacin a objetos: Como todo lenguaje de programacin de propsito general actual, C# es un lenguaje orientado a objetos, aunque eso es ms bien una caracterstica del CTS que de C#. Una diferencia de este enfoque orientado a objetos respecto al de otros lenguajes como C++ es que el de C# es ms puro en tanto que no admiten ni funciones ni variables globales sino que todo el cdigo y datos han de definirse dentro de definiciones de tipos de datos, lo que reduce problemas por conflictos de nombres y facilita la legibilidad del cdigo. C# soporta todas las caractersticas propias del paradigma de programacin orientada a objetos: encapsulacin, herencia y polimorfismo. En lo referente a la encapsulacin es importante sealar que aparte de los tpicos modificadores public, private y protected, C# aade un cuarto modificador llamado internal, que puede combinarse con protected e indica que al elemento a cuya definicin precede slo puede accederse desde su mismo ensamblado. Respecto a la herencia -a diferencia de C++ y al igual que Java- C# slo admite herencia simple de clases ya que la mltiple provoca ms quebraderos de cabeza que facilidades y en la mayora de los casos su utilidad puede ser simulada con facilidad mediante herencia mltiple de interfaces. De todos modos, esto vuelve a ser ms bien una caracterstica propia del CTS que de C#. Por otro lado y a diferencia de Java, en C# se ha optado por hacer que todos los mtodos sean por defecto sellados y que los redefinibles hayan de marcarse con el modificador virtual (como en C++), lo que permite evitar errores derivados de redefiniciones accidentales. Adems, un efecto secundario de esto es que las llamadas a los mtodos sern ms eficientes por defecto al no tenerse que buscar en la tabla de funciones virtuales la implementacin de los mismos a la que se ha de llamar. Otro efecto secundario es que permite que las llamadas a los mtodos virtuales se puedan hacer ms eficientemente al contribuir a que el tamao de dicha tabla se reduzca.

Orientacin a componentes: La propia sintaxis de C# incluye elementos propios del diseo de componentes que otros lenguajes tienen que simular mediante construcciones ms o menos complejas. Es decir, la sintaxis de C# permite definir cmodamente propiedades (similares a campos de acceso controlado), eventos (asociacin controlada de funciones de respuesta a notificaciones) o atributos (informacin sobre un tipo o sus miembros) Gestin automtica de memoria: Como ya se coment, todo lenguaje de .NET tiene a su disposicin el recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destruccin de objetos. Sin embargo, dado que la destruccin de los objetos a travs del recolector de basura es indeterminista y slo se realiza cuando ste se active ya sea por falta de memoria, finalizacin de la aplicacin o solicitud explcita en el fuente-, C# tambin proporciona un mecanismo de liberacin de recursos determinista a travs de la instruccin using. Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos siempre se realicen correctamente, lo que permite evita que se produzcan errores difciles de detectar por acceso a memoria no perteneciente a ningn objeto y es especialmente necesario en un entorno gestionado por un recolector de basura. Para ello se toman medidas del tipo:
o

Slo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y antecesores suyos, entre tipos para los que explcitamente se haya definido un operador de conversin, y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente, lo ltimo slo puede comprobarlo en tiempo de ejecucin el CLR y no el compilador, por lo que en realidad el CLR y el compilador colaboran para asegurar la correccin de las conversiones. No se pueden usar variables no inicializadas. El compilador da a los campos un valor por defecto consistente en ponerlos a cero y controla mediante anlisis del flujo de control del fuente que no se lea ninguna variable local sin que se le haya asignado previamente algn valor. Se comprueba que todo acceso a los elementos de una tabla se realice con ndices que se encuentren dentro del rango de la misma. Se puede controlar la produccin de desbordamientos en operaciones aritmticas, informndose de ello con una excepcin cuando ocurra. Sin embargo, para conseguirse un mayor rendimiento en la aritmtica estas comprobaciones no se hacen por defecto al operar con variables sino slo con constantes (se pueden detectar en tiempo de compilacin) A diferencia de Java, C# incluye delegados, que son similares a los punteros a funciones de C++ pero siguen un enfoque orientado a objetos, pueden almacenar referencias a varios mtodos simultneamente, y se comprueba que los mtodos a los que apunten tengan parmetros y valor de retorno del tipo indicado al definirlos.

Pueden definirse mtodos que admitan un nmero indefinido de parmetros de un cierto tipo, y a diferencia lenguajes como C/C++, en C# siempre se comprueba que los valores que se les pasen en cada llamada sean de los tipos apropiados.

Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie de restricciones en el uso de las instrucciones de control ms comunes. Por ejemplo, la guarda de toda condicin ha de ser una expresin condicional y no aritmtica, con lo que se evitan errores por confusin del operador de igualdad (==) con el de asignacin (=); y todo caso de un switch ha de terminar en un break o goto que indique cul es la siguiente accin a realizar, lo que evita la ejecucin accidental de casos y facilita su reordenacin. Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos que se definan siempre derivarn, aunque sea de manera implcita, de una clase base comn llamada System.Object, por lo que dispondrn de todos los miembros definidos en sta clase (es decir, sern objetos) A diferencia de Java, en C# esto tambin es aplicable a los tipos de datos bsicos Adems, para conseguir que ello no tenga una repercusin negativa en su nivel de rendimiento, se ha incluido un mecanismo transparente de boxing y unboxing con el que se consigue que slo sean tratados como objetos cuando la situacin lo requiera, y mientras tanto puede aplicrseles optimizaciones especficas. El hecho de que todos los tipos del lenguaje deriven de una clase comn facilita enormemente el diseo de colecciones genricas que puedan almacenar objetos de cualquier tipo.

Extensibilidad de tipos bsicos: C# permite definir, a travs de estructuras, tipos de datos para los que se apliquen las mismas optimizaciones que para los tipos de datos bsicos. Es decir, que se puedan almacenar directamente en pila (luego su creacin, destruccin y acceso sern ms rpidos) y se asignen por valor y no por referencia. Para conseguir que lo ltimo no tenga efectos negativos al pasar estructuras como parmetros de mtodos, se da la posibilidad de pasar referencias a pila a travs del modificador de parmetro ref. Extensibilidad de operadores: Para facilitar la legibilidad del cdigo y conseguir que los nuevos tipos de datos bsicos que se definan a travs de las estructuras estn al mismo nivel que los bsicos predefinidos en el lenguaje, al igual que C++ y a diferencia de Java, C# permite redefinir el significado de la mayora de los operadores -incluidos los de conversin, tanto para conversiones implcitas como explcitas- cuando se apliquen a diferentes tipos de objetos. Las redefiniciones de operadores se hacen de manera inteligente, de modo que a partir de una nica definicin de los operadores ++ y -- el compilador puede deducir automticamente como ejecutarlos de manera prefijas y postifja; y definiendo operadores simples (como +), el compilador deduce cmo aplicar su versin de asignacin compuesta (+=) Adems, para asegurar la consistencia, el compilador vigila que los operadores con opuesto siempre se redefinan por

parejas (por ejemplo, si se redefine ==, tambin hay que redefinir !=) Tambin se da la posibilidad, a travs del concepto de indizador, de redefinir el significado del operador [] para los tipos de dato definidos por el usuario, con lo que se consigue que se pueda acceder al mismo como si fuese una tabla. Esto es muy til para trabajar con tipos que acten como colecciones de objetos.

Extensibilidad de modificadores: C# ofrece, a travs del concepto de atributos, la posibilidad de aadir a los metadatos del mdulo resultante de la compilacin de cualquier fuente informacin adicional a la generada por el compilador que luego podr ser consultada en tiempo ejecucin a travs de la librera de reflexin de .NET . Esto, que ms bien es una caracterstica propia de la plataforma .NET y no de C#, puede usarse como un mecanismo para definir nuevos modificadores. Versionable: C# incluye una poltica de versionado que permite crear nuevas versiones de tipos sin temor a que la introduccin de nuevos miembros provoquen errores difciles de detectar en tipos hijos previamente desarrollados y ya extendidos con miembros de igual nombre a los recin introducidos. Si una clase introduce un nuevo mtodo cuyas redefiniciones deban seguir la regla de llamar a la versin de su padre en algn punto de su cdigo, difcilmente seguiran esta regla miembros de su misma signatura definidos en clases hijas previamente a la definicin del mismo en la clase padre; o si introduce un nuevo campo con el mismo nombre que algn mtodo de una clase hija, la clase hija dejar de funcionar. Para evitar que esto ocurra, en C# se toman dos medidas:
o

Se obliga a que toda redefinicin deba incluir el modificador override, con lo que la versin de la clase hija nunca sera considerada como una redefinicin de la versin de miembro en la clase padre ya que no incluira override. Para evitar que por accidente un programador incluya este modificador, slo se permite incluirlo en miembros que tengan la misma signatura que miembros marcados como redefinibles mediante el modificador virtual. As adems se evita el error tan frecuente en Java de creerse haber redefinido un miembro, pues si el miembro con override no existe en la clase padre se producir un error de compilacin. Si no se considera redefinicin, entonces se considera que lo que se desea es ocultar el mtodo de la clase padre, de modo que para la clase hija sea como si nunca hubiese existido. El compilador avisar de esta decisin a travs de un mensaje de aviso que puede suprimirse incluyendo el modificador new en la definicin del miembro en la clase hija para as indicarle explcitamente la intencin de ocultacin.

Eficiente: En principio, en C# todo el cdigo incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. Sin embargo, y a diferencia de Java, en C# es posible saltarse dichas restricciones manipulando objetos a travs de punteros. Para ello basta marcar regiones de cdigo como

inseguras (modificador unsafe) y podrn usarse en ellas punteros de forma similar a cmo se hace en C++, lo que puede resultar vital para situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes.

Compatible: Para facilitar la migracin de programadores, C# no slo mantiene una sintaxis muy similar a C, C++ o Java que permite incluir directamente en cdigo escrito en C# fragmentos de cdigo escrito en estos lenguajes, sino que el CLR tambin ofrece, a travs de los llamados Platform Invocation Services (PInvoke), la posibilidad de acceder a cdigo nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. Ntese que la capacidad de usar punteros en cdigo inseguro permite que se pueda acceder con facilidad a este tipo de funciones, ya que stas muchas veces esperan recibir o devuelven punteros. Tambin es posible acceder desde cdigo escrito en C# a objetos COM. Para facilitar esto, el .NET Framework SDK incluye una herramientas llamadas tlbimp y regasm mediante las que es posible generar automticamente clases proxy que permitan, respectivamente, usar objetos COM desde .NET como si de objetos .NET se tratase y registrar objetos .NET para su uso desde COM. Finalmente, tambin se da la posibilidad de usar controles ActiveX desde cdigo .NET y viceversa. Para lo primero se utiliza la utilidad aximp, mientras que para lo segundo se usa la ya mencionada regasm.

----------------------------------------------------------------------------------------------------------

Microsoft.NET es el conjunto de nuevas tecnologas en las que Microsoft ha estado trabajando durante los ltimos aos 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 programacin 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. Para crear aplicaciones para la plataforma .NET, tanto servicios Web como aplicaciones tradicionales (aplicaciones de consola, aplicaciones de ventanas, servicios de Windows NT, etc.), Microsoft ha publicado el denominado kit de desarrollo de software conocido como .NET Framework SDK, que incluye las herramientas necesarias tanto para su desarrollo como para su distribucin y ejecucin y Visual Studio.NET, que permite hacer todo la anterior desde una interfaz visual basada en ventanas. Ambas herramientas puede descargarse gratuitamente desde http://www.msdn.microsoft.com/net, aunque la ltima slo est disponible para subscriptores MSDN Universal (los no subscriptores pueden pedirlo desde dicha direccin y se les enviar gratis por correo ordinario) El concepto de Microsoft.NET tambin incluye al conjunto de nuevas aplicaciones que Microsoft y terceros han (o estn) 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.3.1 Common Language Runtime (CLR)

El Common Language Runtime (CLR) es el ncleo de la plataforma .NET. Es el motor encargado de gestionar la ejecucin de las aplicaciones para ella desarrolladas y a las que ofrece numerosos servicios que simplifican su desarrollo y favorecen su fiabilidad y seguridad. Las principales caractersticas y servicios que ofrece el CLR son:

Modelo de programacin consistente: A todos los servicios y facilidades ofrecidos por el CLR se accede de la misma forma: a travs de un modelo de programacin orientado a objetos. Esto es una diferencia importante respecto al modo de acceso a los servicios ofrecidos por los algunos sistemas operativos actuales (por ejemplo, los de la familia Windows), en los que a algunos servicios se les accede a travs de llamadas a funciones globales definidas en DLLs y a otros a travs de objetos (objetos COM en el caso de la familia Windows) Modelo de programacin sencillo: Con el CLR desaparecen muchos elementos complejos incluidos en los sistemas operativos actuales (registro de Windows, GUIDs, HRESULTS, IUnknown, etc.) El CLR no es que abstraiga al programador de estos conceptos, sino que son conceptos que no existen en la plataforma .NET Eliminacin del "infierno de las DLLs": En la plataforma .NET desaparece el problema conocido como "infierno de las DLLs" que se da en los sistemas operativos actuales de la familia Windows, problema que consiste en que al sustituirse versiones viejas de DLLs compartidas por versiones nuevas puede que aplicaciones que fueron diseadas para ser ejecutadas usando las viejas dejen de funcionar si las nuevas no son 100% compatibles con las anteriores. En la plataforma .NET las versiones nuevas de las DLLs pueden coexistir con las viejas, de modo que las aplicaciones diseadas para ejecutarse usando las viejas

podrn seguir usndolas tras instalacin de las nuevas. Esto, obviamente, simplifica mucho la instalacin y desinstalacin de software.

Ejecucin multiplataforma: El CLR acta como una mquina virtual, encargndose de ejecutar las aplicaciones diseadas para la plataforma .NET. Es decir, cualquier plataforma para la que exista una versin del CLR podr ejecutar cualquier aplicacin .NET. Microsoft ha desarrollado versiones del CLR para la mayora de las versiones de Windows: Windows 95, Windows 98, Windows ME, Windows NT 4.0, Windows 2000, Windows XP y Windows CE (que puede ser usado en CPUs que no sean de la familia x86) Por otro lado Microsoft ha firmado un acuerdo con Corel para portar el CLR a Linux y tambin hay terceros que estn desarrollando de manera independiente versiones de libre distribucin del CLR para Linux. Asmismo, dado que la arquitectura del CLR est totalmente abierta, es posible que en el futuro se diseen versiones del mismo para otros sistemas operativos. Integracin de lenguajes: Desde cualquier lenguaje para el que exista un compilador que genere cdigo para la plataforma .NET es posible utilizar cdigo generado para la misma usando cualquier otro lenguaje tal y como si de cdigo escrito usando el primero se tratase. Microsoft ha desarrollado un compilador de C# que genera cdigo de este tipo, as como versiones de sus compiladores de Visual Basic (Visual Basic.NET) y C++ (C++ con extensiones gestionadas) que tambin lo generan y una versin del intrprete de JScript (JScript.NET) que puede interpretarlo. La integracin de lenguajes esta que es posible escribir una clase en C# que herede de otra escrita en Visual Basic.NET que, a su vez, herede de otra escrita en C++ con extensiones gestionadas. Gestin de memoria: El CLR incluye un recolector de basura que evita que el programador tenga que tener en cuenta cundo ha de destruir los objetos que dejen de serle tiles. Este recolector es una aplicacin que se activa cuando se quiere crear algn objeto nuevo y se detecta que no queda memoria libre para hacerlo, caso en que el recolector recorre la memoria dinmica asociada a la aplicacin, detecta qu objetos hay en ella que no puedan ser accedidos por el cdigo de la aplicacin, y los elimina para limpiar la memoria de "objetos basura" y permitir la creacin de otros nuevos. Gracias a este recolector se evitan errores de programacin muy comunes como intentos de borrado de objetos ya borrados, agotamiento de memoria por olvido de eliminacin de objetos intiles o solicitud de acceso a miembros de objetos ya destruidos. Seguridad de tipos: El CLR facilita la deteccin de errores de programacin difciles de localizar comprobando que toda conversin de tipos que se realice durante la ejecucin de una aplicacin .NET se haga de modo que los tipos origen y destino sean compatibles. Aislamiento de procesos: El CLR asegura que desde cdigo perteneciente a un determinado proceso no se pueda acceder a cdigo o datos pertenecientes a otro, lo que evita errores de programacin muy frecuentes e impide que unos procesos puedan atacar a otros. Esto se consigue gracias al sistema de seguridad de tipos antes comentado, pues evita que se pueda convertir un objeto a un tipo de mayor tamao que el suyo propio, ya que al tratarlo como un objeto de mayor tamao

podra accederse a espacios en memoria ajenos a l que podran pertenecer a otro proceso. Tambin se consigue gracias a que no se permite acceder a posiciones arbitrarias de memoria.

Tratamiento de excepciones: En el CLR todo los errores que se puedan producir durante la ejecucin de una aplicacin se propagan de igual manera: mediante excepciones. Esto es muy diferente a como se vena haciendo en los sistemas Windows hasta la aparicin de la plataforma .NET, donde ciertos errores se transmitan mediante cdigos de error en formato Win32, otros mediante HRESULTs y otros mediante excepciones. El CLR permite que excepciones lanzadas desde cdigo para .NET escrito en un cierto lenguaje se puedan capturar en cdigo escrito usando otro lenguaje, e incluye mecanismos de depuracin que pueden saltar desde cdigo escrito para .NET en un determinado lenguaje a cdigo escrito en cualquier otro. Por ejemplo, se puede recorrer la pila de llamadas de una excepcin aunque sta incluya mtodos definidos en otros mdulos usando otros lenguajes.

Soporte multihilo: El CLR es capaz de trabajar con aplicaciones divididas en mltiples hilos de ejecucin que pueden ir evolucionando por separado en paralelo o intercalndose, segn el nmero de procesadores de la mquina sobre la que se ejecuten. Las aplicaciones pueden lanzar nuevos hilos, destruirlos, suspenderlos por un tiempo o hasta que les llegue una notificacin, enviarles notificaciones, sincronizarlos, etc. Distribucin transparente: El CLR ofrece la infraestructura necesaria para crear objetos remotos y acceder a ellos de manera completamente transparente a su localizacin real, tal y como si se encontrasen en la mquina que los utiliza. Seguridad avanzada: El CLR proporciona mecanismos para restringir la ejecucin de ciertos cdigos o los permisos asignados a los mismos segn su procedendecia o el usuario que los ejecute. Es decir, puede no darse el mismo nivel de confianza a cdigo procedente de Internet que a cdigo instalado localmente o procedente de una red local; puede no darse los mismos permisos a cdigo procedente de un determinado fabricante que a cdigo de otro; y puede no darse los mismos permisos a un mismo cdigos segn el usuario que lo est ejecutando o segn el rol que ste desempee. Esto permite asegurar al administrador de un sistema que el cdigo que se est ejecutando no pueda poner en peligro la integridad de sus archivos, la del registro de Windows, etc. Interoperabilidad con cdigo antiguo: El CLR incorpora los mecanismos necesarios para poder acceder desde cdigo escrito para la plataforma .NET a cdigo escrito previamente a la aparicin de la misma y, por tanto, no preparado para ser ejecutando dentro de ella. Estos mecanismos permiten tanto el acceso a objetos COM como el acceso a funciones sueltas de DLLs preexistentes (como la API Win32)

Como se puede deducir de las caractersticas comentadas, el CLR lo que hace es gestionar la ejecucin de las aplicaciones diseadas para la plataforma .NET. Por esta razn, al cdigo de estas aplicaciones se le suele llamar cdigo gestionado, y al cdigo

no escrito para ser ejecutado directamente en la plataforma .NET se le suele llamar cdigo no gestionado.
1.3.2 Microsoft Intermediate Language (MSIL)

Todos los compiladores que generan cdigo para la plataforma .NET no generan cdigo mquina para CPUs x86 ni para ningn otro tipo de CPU concreta, sino que generan cdigo escrito en el lenguaje intermedio conocido como Microsoft Intermediate Lenguage (MSIL) El CLR da a las aplicaciones las sensacin de que se estn ejecutando sobre una mquina virtual, y precisamente MSIL es el cdigo mquina de esa mquina virtual. Es decir, MSIL es el nico cdigo que es capaz de interpretar el CLR, y por tanto cuando se dice que un compilador genera cdigo para la plataforma .NET lo que se est diciendo es que genera MSIL. MSIL ha sido creado por Microsoft tras consultar a numerosos especialistas en la escritura de compiladores y lenguajes tanto del mundo acadmico como empresarial. Es un lenguaje de un nivel de abstraccin mucho ms alto que el de la mayora de los cdigos mquina de las CPUs existentes, e incluye instrucciones que permiten trabajar directamente con objetos (crearlos, destruirlos, inicializarlos, llamar a mtodos virtuales, etc.), tablas y excepciones (lanzarlas, capturarlas y tratarlas) Ya se coment que el compilador de C# compila directamente el cdigo fuente a MSIL, que Microsoft ha desarrollado nuevas versiones de sus lenguajes Visual Basic (Visual Basic.NET) y C++ (C++ con extensiones gestionadas) cuyos compiladores generan MSIL, y que ha desarrollado un intrprete de JScript (JScript.NET) que genera cdigo MSIL. Pues bien, tambin hay numerosos terceros que han anunciado estar realizando versiones para la plataforma .NET de otros lenguajes como APL, CAML, Cobol, Eiffel, Fortran, Haskell, Java (J#), Mercury, ML, Mondrian, Oberon, Oz, Pascal, Perl, Python, RPG, Scheme y Smalltalk. La principal ventaja del MSIL es que facilita la ejecucin multiplataforma y la integracin entre lenguajes al ser independiente de la CPU y proporcionar un formato comn para el cdigo mquina generado por todos los compiladores que generen cdigo para .NET. Sin embargo, dado que las CPUs no pueden ejecutar directamente MSIL, antes de ejecutarlo habr que convertirlo al cdigo nativo de la CPU sobre la que se vaya a ejecutar. De esto se encarga un componente del CLR conocido como compilador JIT (Just-In-Time) o jitter que va convirtiendo dinmicamente el cdigo MSIL a ejecutar en cdigo nativo segn sea necesario. Este jitter se distribuye en tres versiones:

jitter normal: Es el que se suele usar por defecto, y slo compila el cdigo MSIL a cdigo nativo a medida que va siendo necesario, pues as se ahorra tiempo y memoria al evitarse tener que compilar innecesariamente cdigo que nunca se ejecute. Para conseguir esto, el cargador de clases del CLR sustituye inicialmente las llamadas a mtodos de las nuevas clases que vaya cargando por llamadas a funciones auxiliares (stubs) que se encarguen de compilar el verdadero cdigo del mtodo. Una vez compilado, la llamada al stub es sustituida por una llamada directa al cdigo ya compilado, con lo que posteriores llamadas al mismo no necesitarn compilacin.

jitter econmico: Funciona de forma similar al jitter normal solo que no realiza ninguna optimizacin de cdigo al compilar sino que traduce cada instruccin MSIL por su equivalente en el cdigo mquina sobre la que se ejecute. Esta especialmente pensado para ser usado en dispositivos empotrados que dispongan de poca potencia de CPU y poca memoria, pues aunque genere cdigo ms ineficiente es menor el tiempo y memoria que necesita para compilar. Es ms, para ahorrar memoria este jitter puede descargar cdigo ya compilado que lleve cierto tiempo sin ejecutarse y sustituirlo de nuevo por el stub apropiado. Por estas razones, este es el jitter usado por defecto en Windows CE, sistema operativo que se suele incluir en los dispositivos empotrados antes mencionados. Otra utilidad del jitter econmico es que facilita la adaptacin de la plataforma .NET a nuevos sistemas porque es mucho ms sencillo de implementar que el normal. De este modo, gracias a l es posible desarrollar rpidamente una versin del CLR que pueda ejecutar aplicaciones gestionadas aunque sea de una forma poco eficiente, y una vez desarrollada es posible centrarse en desarrollar el jitter normal para optimizar la ejecucin de las mismas.

prejitter: Se distribuye como una aplicacin en lnea de comandos llamada ngen.exe mediante la que es posible compilar completamente cualquier ejecutable o librera (cualquier ensamblado en general, aunque este concepto se ver ms adelante) que contenga cdigo gestionado y convertirlo a cdigo nativo, de modo que posteriores ejecuciones del mismo se harn usando esta versin ya compilada y no se perder tiempo en hacer la compilacin dinmica.

La actuacin de un jitter durante la ejecucin de una aplicacin gestionada puede dar la sensacin de hacer que sta se ejecute ms lentamente debido a que ha de invertirse tiempo en las compilaciones dinmicas. Esto es cierto, pero hay que tener en cuenta que es una solucin mucho ms eficiente que la usada en otras plataformas como Java, ya que en .NET cada cdigo no es interpretado cada vez que se ejecuta sino que slo es compilado la primera vez que se llama al mtodo al que pertenece. Es ms, el hecho de que la compilacin se realice dinmicamente permite que el jitter tenga acceso a mucha ms informacin sobre la mquina en que se ejecutar la aplicacin del que tendra cualquier compilador tradicional, con lo que puede optimizar el cdigo para ella generado (por ejemplo, usando las instrucciones especiales del Pentium III si la mquina las admite, usando registros extra, incluyendo cdigo inline, etc.) Adems, como el recolector de basura de .NET mantiene siempre compactada la memoria dinmica las reservas de memoria se harn ms rpido, sobre todo en aplicaciones que no agoten la memoria y, por tanto, no necesiten de una recoleccin de basura. Por estas razones, los ingenieros de Microsoft piensan que futuras versiones de sus jitters podrn incluso conseguir que el cdigo gestionado se ejecute ms rpido que el no gestionado.
1.3.3 Metadatos

En la plataforma .NET se distinguen dos tipos de mdulos de cdigo compilado: ejecutables (extensin .exe) y libreras de enlace dinmico (extensin .dll generalmente) Ambos son ficheros que contienen definiciones de tipos de datos, y la diferencia entre ellos es que slo los primeros disponen de un mtodo especial que sirve de punto de entrada a partir del que es posible ejecutar el cdigo que contienen haciendo

una llamada desde la lnea de comandos del sistema operativo. A ambos tipos de mdulos se les suele llamar ejecutables portables (PE), ya que su cdigo puede ejecutarse en cualquiera de los diferentes sistemas operativos de la familia Windows para los que existe alguna versin del CLR. El contenido de un mdulo no slo MSIL, sino que tambin consta de otras dos reas muy importantes: la cabecera de CLR y los metadatos: La cabecera de CLR es un pequeo bloque de informacin que indica que se trata de un mdulo gestionado e indica es la versin del CLR que necesita, cul es su firma digital, cul es su punto de entrada (si es un ejecutable), etc. Los metadatos son un conjunto de datos organizados en forma de tablas que almacenan informacin sobre los tipos definidos en el mdulo, los miembros de stos y sobre cules son los tipos externos al mdulo a los que se les referencia en el mdulo. Los metadatos de cada modulo los genera automticamente el compilador al crearlo, y entre sus tablas se incluyen: Descripcin Define las caractersticas del mdulo. Consta de un nico elemento que almacena un identificador de versin de mdulo (GUID creado por el ModuleDef compilador) y el nombre de fichero que se dio al mdulo al compilarlo (as este nombre siempre estar disponible, aunque se renombre el fichero) Define las caractersticas de los tipos definidos en el mdulo. De cada tipo se almacena su nombre, su tipo padre, sus modificadores de acceso y TypeDef referencias a los elementos de las tablas de miembros correspondientes a sus miembros. Define las caractersticas de los mtodos definidos en el mdulo. De cada mtodo se guarda su nombre, signatura (por cada parmetro se incluye MethodDef una referencia al elemento apropiado en la tabla ParamDef), modificadores y posicin del mdulo donde comienza el cdigo MSIL de su cuerpo. Define las caractersticas de los parmetros definidos en el mdulo. De ParamDef cada parmetro se guarda su nombre y modificadores. Define las caractersticas de los campos definidos en el mdulo. De cada FieldDef uno se almacena informacin sobre cul es su nombre, tipo y modificadores. Define las caractersticas de las propiedades definidas en el mdulo. De PropertyDef cada una se indica su nombre, tipo, modificadores y referencias a los elementos de la tabla MethodDef correspondientes a sus mtodos set/get. Define las caractersticas de los eventos definidos en el mdulo. De cada uno se indica su nombre, tipo, modificadores. y referencias a los EventDef elementos de la tabla MethodDef correspondientes a sus mtodos add/remove. Indica cules son los ensamblados externos a los que se referencia en el AssemblyRef mdulo. De cada uno se indica cul es su nombre de fichero (sin extensin), versin, idioma y marca de clave pblica. Tabla

ModuleRef

TypeRef

MemberRef

Indica cules son los otros mdulos del mismo ensamblado a los que referencia el mdulo. De cada uno se indica cul es su nombre de fichero. Indica cules son los tipos externos a los que se referencia en el mdulo. De cada uno se indica cul es su nombre y, segn donde estn definidos, una referencia a la posicin adecuada en la tabla AssemblyRef o en la tabla ModuleRef. Indican cules son los miembros definidos externamente a los que se referencia en el mdulo. Estos miembros pueden ser campos, mtodos, propiedades o eventos; y de cada uno de ellos se almacena informacin sobre su nombre y signatura, as como una referencia a la posicin de la tabla TypeRef donde se almacena informacin relativa al tipo del que es miembro.

Tabla 1: Principales tablas de metadatos Ntese que el significado de los metadatos es similar al de otras tecnologas previas a la plataforma .NET como lo son los ficheros IDL. Sin embargo, los metadatos tienen dos ventajas importantes sobre stas: contiene ms informacin y siempre se almacenan incrustados en el mdulo al que describen, haciendo imposible la separacin entre ambos. Adems, como se ver ms adelante, es posible tanto consultar los metadatos de cualquier mdulo a travs de las clases del espacio de nombres System.Reflection de la BCL como aadirles informacin adicional mediante atributos (se ver ms adelante)
1.3.4 Ensamblados

Un ensamblado es una agrupacin lgica de uno o ms mdulos o ficheros de recursos (ficheros .GIF, .HTML, etc.) que se engloban bajo un nombre comn. Un programa puede acceder a informacin o cdigo almacenados en un ensamblado sin tener porqu sabe cul es el fichero en concreto donde se encuentran, por lo que los ensamblados nos permiten abstraernos de la ubicacin fsica del cdigo que ejecutemos o de los recursos que usemos. Por ejemplo, podemos incluir todos los tipos de una aplicacin en un mismo ensamblado pero colocando los ms frecuentemente usados en un cierto mdulo y los menos usados en otro, de modo que slo se descarguen de Internet los ltimos si es que se van a usar. Todo ensamblado contiene un manifiesto, que son metadatos con informacin sobre las caractersticas del ensamblado. Este manifiesto puede almacenarse cualquiera de los mdulos que formen el ensamblado o en uno especficamente creado para ello, caso ste ltimo necesario cuando es un ensamblado satlite (slo contiene recursos) Las principales tablas incluidas en los manifiestos son las siguientes: Tabla Descripcin Define las caractersticas del ensamblado. Consta de un nico elemento que almacena el nombre del ensamblado sin extensin, versin, idioma, clave pblica y tipo de algoritmo de dispersin usado para hallar los valores de dispersin de la tabla FileDef.

AssemblyDef

Define cules son los archivos que forman el ensamblado. De cada uno se da su nombre y valor de dispersin. Ntese que slo el mdulo que contiene el manifiesto sabr qu ficheros que FileDef forman el ensamblado, pero el resto de ficheros del mismo no sabrn si pertenecen o no a un ensamblado (no contienen metadatos que les indique si pertenecen a un ensamblado) Define las caractersticas de los recursos incluidos en el mdulo. De cada uno se indica su nombre y modificadores de acceso. Si es un recurso incrustado se indica dnde empieza dentro del PE ManifestResourceDef que lo contiene, y si es un fichero independiente se indica cul es el elemento de la tabla FileDef correspondiente a dicho fichero. Indica cules son los tipos definidos en el ensamblado y accesibles desde fuera del mismo. Para ahorrar espacio slo recogen los que no pertenezcan al mdulo donde se incluye el ExportedTypesDef manifiesto, y de cada uno se indica su nombre, la posicin en la tabla FileDef del fichero donde se ha implementado y la posicin en la tabla TypeDef correspondiente a su definicin. Indica en qu procesadores se puede ejecutar el ensamblado, lo que puede ser til saberlo si el ensamblado contiene mdulos con cdigo nativo (podra hacerse usando C++ con extensiones gestionadas) Suele estar vaca, lo que indica que se puede AssemblyProccesorDef ejecutar en cualquier procesador; pero si estuviese llena, cada elemento indicara un tipo de procesador admitido segn el formato de identificadores de procesador del fichero WinNT.h incluido con Visual Studio.NET (por ejemplo, 586 = Pentium, 2200 = Arquitectura IA64, etc.) Indica bajo qu sistemas operativos se puede ejecutar el ensamblado, lo que puede ser til si contiene mdulos con tipos o mtodos disponibles slo en ciertos sistemas. Suele estar vaca, lo que indica que se puede ejecutar en cualquier AssemblyOSDef procesador; pero si estuviese llena, indicara el identificador de cada uno de los sistemas admitidos siguiendo el formato del WinNT.h de Visual Studio.NET (por ejemplo, 0 = familia Windows 9X, 1 = familia Windows NT, etc.) y el nmero de la versin del mismo a partir de la que se admite. Tabla 2:Principales tablas de un manifiesto Para asegurar que no se haya alterado la informacin de ningn ensamblado se usa el criptosistema de clave pblica RSA. Lo que se hace es calcular el cdigo de dispersin SHA-1 del mdulo que contenga el manifiesto e incluir tanto este valor cifrado con RSA (firma digital) como la clave pblica necesaria para descifrarlo en algn lugar del mdulo que se indicar en la cabecera de CLR. Cada vez que se vaya a cargar en memoria el ensamblado se calcular su valor de dispersin de nuevo y se comprobar que es igual al resultado de descifrar el original usando su clave pblica. Si no fuese as se detectara que se ha adulterado su contenido.

Para asegurar tambin que los contenidos del resto de ficheros que formen un ensamblado no hayan sido alterados lo que se hace es calcular el cdigo de dispersin de stos antes de cifrar el ensamblado y guardarlo en el elemento correspondiente a cada fichero en la tabla FileDef del manifiesto. El algoritmo de cifrado usado por defecto es SHA-1, aunque en este caso tambin se da la posibilidad de usar MD5. En ambos casos, cada vez que se accede al fichero para acceder a un tipo o recurso se calcular de nuevo su valor de dispersin y se comprobar que coincida con el almacenado en FileDef. Dado que las claves pblicas son valores que ocupan muchos bytes (2048 bits), lo que se hace para evitar que los metadatos sean excesivamente grandes es no incluir en las referencias a ensamblados externos de la tabla AssemblyRef las claves pblicas de dichos ensamblados, sino slo los 64 ltimos bits resultantes de aplicar un algoritmo de dispersin a dichas claves. A este valor recortado se le llama marca de clave pblica. Hay dos tipos de ensamblados: ensamblados privados y ensamblados compartidos. Los privados se almacenan en el mismo directorio que la aplicacin que los usa y slo puede usarlos sta, mientras que los compartidos se almacenan en un cach de ensamblado global (GAC) y pueden usarlos cualquiera que haya sido compilada referencindolos. Los compartidos han de cifrase con RSA ya que lo que los identifica es en el GAC es su nombre (sin extensin) ms su clave pblica, lo que permite que en el GAC puedan instalarse varios ensamblados con el mismo nombre y diferentes claves pblicas. Es decir, es como si la clave pblica formase parte del nombre del ensamblado, razn por la que a los ensamblados as cifrados se les llama ensamblados de nombre fuerte. Esta poltica permite resolver los conflictos derivados de que se intente instalar en un mismo equipo varios ensamblados compartidos con el mismo nombre pero procedentes de distintas empresas, pues stas tendrn distintas claves pblicas. Tambin para evitar problemas, en el GAC se pueden mantener mltiples versiones de un mismo ensamblado. As, si una aplicacin fue compilada usando una cierta versin de un determinado ensamblado compartido, cuando se ejecute slo podr hacer uso de esa versin del ensamblado y no de alguna otra ms moderna que se hubiese instalado en el GAC. De esta forma se soluciona el problema del infierno de las DLL comentado al principio del tema. En realidad es posible modificar tanto las polticas de bsqueda de ensamblados (por ejemplo, para buscar ensamblados privados fuera del directorio de la aplicacin) como la poltica de aceptacin de ensamblados compartidos (por ejemplo, para que se haga automticamente uso de las nuevas versiones que se instalen de DLLs compartidas) incluyendo en el directorio de instalacin de la aplicacin un fichero de configuracin en formato XML con las nuevas reglas para las mismas. Este fichero ha de llamarse igual que el ejecutable de la aplicacin pero ha de tener extensin .cfg.
1.3.5 Librera de clase base (BCL)

La Librera de Clase Base (BCL) es una librera incluida en el .NET Framework formada por cientos de tipos de datos que permiten acceder a los servicios ofrecidos por el CLR y a las funcionalidades ms frecuentemente usadas a la hora de escribir programas. Adems, a partir de estas clases prefabricadas el programador puede crear

nuevas clases que mediante herencia extiendan su funcionalidad y se integren a la perfeccin con el resto de clases de la BCL. Por ejemplo, implementando ciertos interfaces podemos crear nuevos tipos de colecciones que sern tratadas exactamente igual que cualquiera de las colecciones incluidas en la BCL. Esta librera est escrita en MSIL, por lo que puede usarse desde cualquier lenguaje cuyo compilador genere MSIL. A travs de las clases suministradas en ella es posible desarrollar cualquier tipo de aplicacin, desde las tradicionales aplicaciones de ventanas, consola o servicio de Windows NT hasta los novedosos servicios Web y pginas ASP.NET. Es tal la riqueza de servicios que ofrece que puede crearse lenguajes que carezcan de librera de clases propia y slo usen la BCL -como C#. Dado la amplitud de la BCL, ha sido necesario organizar las clases en ella incluida en espacios de nombres que agrupen clases con funcionalidades similares. Por ejemplo, los espacios de nombres ms usados son: Utilidad de los tipos de datos que contiene Tipos muy frecuentemente usados, como los los tipos System bsicos, tablas, excepciones, fechas, nmeros aleatorios, recolector de basura, entrada/salida en consola, etc. Colecciones de datos de uso comn como pilas, colas, System.Collections listas, diccionarios, etc. Manipulacin de bases de datos. Forman la denominada System.Data arquitectura ADO.NET. System.IO Manipulacin de ficheros y otros flujos de datos. System.Net Realizacin de comunicaciones en red. Acceso a los metadatos que acompaan a los mdulos de System.Reflection cdigo. System.Runtime.Remoting Acceso a objetos remotos. System.Security Acceso a la poltica de seguridad en que se basa el CLR. System.Threading Manipulacin de hilos. Creacin de interfaces de usuario basadas en ventanas System.Web.UI.WebControls para aplicaciones Web. Creacin de interfaces de usuario basadas en ventanas System.Winforms para aplicaciones estndar. System.XML Acceso a datos en formato XML. Tabla 3: Espacios de nombres de la BCL ms usados
1.3.6 Common Type System (CTS)

Espacio de nombres

El Common Type System (CTS) o Sistema de Tipo Comn es el conjunto de reglas que han de seguir las definiciones de tipos de datos para que el CLR las acepte. Es decir, aunque cada lenguaje gestionado disponga de sus propia sintaxis para definir tipos de datos, en el MSIL resultante de la compilacin de sus cdigos fuente se ha de cumplir las reglas del CTS. Algunos ejemplos de estas reglas son:

Cada tipo de dato puede constar de cero o ms miembros. Cada uno de estos miembros puede ser un campo, un mtodo una propiedad o un evento. No puede haber herencia mltiple, y todo tipo de dato ha de heredar directa o indirectamente de System.Object. Los modificadores de acceso admitidos son:

Modificador public private family assembly family and assembly

Cdigo desde el que es accesible el miembro Cualquier cdigo Cdigo del mismo tipo de dato Cdigo del mismo tipo de dato o de hijos de ste. Cdigo del mismo ensamblado Cdigo del mismo tipo o de hijos de ste ubicado en el mismo ensamblado Cdigo del mismo tipo o de hijos de ste, o cdigo ubicado en el family or assembly mismo ensamblado Tabla 4: Modificadores de acceso a miembros admitidos por el CTS
1.3.7 Common Language Specification (CLS)

El Common Language Specification (CLS) o Especificacin del Lenguaje Comn es un conjunto de reglas que han de seguir las definiciones de tipos que se hagan usando un determinado lenguaje gestionado si se desea que sean accesibles desde cualquier otro lenguaje gestionado. Obviamente, slo es necesario seguir estas reglas en las definiciones de tipos y miembros que sean accesibles externamente, y no la en las de los privados. Adems, si no importa la interoperabilidad entre lenguajes tampoco es necesario seguirlas. A continuacin se listan algunas de reglas significativas del CLS:

Los tipos de datos bsicos admitidos son bool, char, byte, short, int, long, float, double, string y object Ntese pues que no todos los lenguajes tienen porqu admitir los tipos bsicos enteros sin signo o el tipo decimal como lo hace C#. Las tablas han de tener una o ms dimensiones, y el nmero de dimensiones de cada tabla ha de ser fijo. Adems, han de indexarse empezando a contar desde 0. Se pueden definir tipos abstractos y tipos sellados. Los tipos sellados no pueden tener miembros abstractos. Las excepciones han de derivar de System.Exception, los delegados de System.Delegate, las enumeraciones de System.Enum, y los tipos por valor que no sean enumeraciones de System.ValueType. Los mtodos de acceso a propiedades en que se traduzcan las definiciones get/set de stas han de llamarse de la forma get_X y set_X respectivamente, donde X es el nombre de la propiedad; los de acceso a indizadores han de

traducirse en mtodos get_Item y setItem; y en el caso de los eventos, sus definiciones add/remove han de traducirse en mtodos de add_X y remove_X.

En las definiciones de atributos slo pueden usarse enumeraciones o datos de los siguientes tipos: System.Type, string, char, bool, byte, short, int, long, float, double y object. En un mismo mbito no se pueden definir varios identificadores cuyos nombres slo difieran en la capitalizacin usada. De este modo se evitan problemas al acceder a ellos usando lenguajes no sensibles a maysculas. Las enumeraciones no pueden implementar interfaces, y todos sus campos han de ser estticos y del mismo tipo. El tipo de los campos de una enumeracin slo puede ser uno de estos cuatro tipos bsicos: byte, short, int o long.

1.3.8 Origen y necesidad de un nuevo lenguaje

C# (ledo en ingls "C Sharp" y en espaol "C Almohadilla") es el nuevo lenguaje de propsito general diseado por Microsoft para su plataforma .NET. Sus principales creadores son Scott Wiltamuth y Anders Hejlsberg, ste ltimo tambin conocido por haber sido el diseador del lenguaje Turbo Pascal y la herramienta RAD Delphi. Aunque es posible escribir cdigo para la plataforma .NET en muchos otros lenguajes, C# es el nico que ha sido diseado especficamente para ser utilizado en ella, por lo que programarla usando C# es mucho ms sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes ya que C# carece de elementos heredados innecesarios en .NET. Por esta razn, se suele decir que C# es el lenguaje nativo de .NET La sintaxis y estructuracin de C# es muy similar a la C++, ya que la intencin de Microsoft con C# es facilitar la migracin de cdigos 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 equiparables a 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 aadiese a las ya probadas virtudes de Java las modificaciones que Microsoft tena pensado aadirle para mejorarlo an ms y hacerlo un lenguaje orientado al desarrollo de componentes. En resumen, C# es un lenguaje de programacin que toma las mejores caractersticas 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 usndolo, por lo que su compilador es el ms depurado y optimizado de los incluidos en el .NET Framework SDK
1.3.9 Caractersticas de C#

Con la idea de que los programadores ms experimentados puedan obtener una visin general del lenguaje, a continuacin se recoge de manera resumida las principales caractersticas de C# Alguna de las caractersticas aqu sealadas no son exactamente propias del lenguaje sino de la plataforma .NET en general. Sin embargo, tambin se

comentan aqu tambin en tanto que tienen repercusin directa en el lenguaje, aunque se indicar explcitamente cules son este tipo de caractersticas cada vez que se toquen:

Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son innecesarios en .NET. Por ejemplo: o El cdigo escrito en C# es autocontenido, lo que significa que no necesita de ficheros adicionales al propio fuente tales como ficheros de cabecera o ficheros IDL o El tamao de los tipos de datos bsicos es fijo e independiente del compilador, sistema operativo o mquina para quienes se compile (no como en C++), lo que facilita la portabilidad del cdigo. o No se incluyen elementos poco tiles de lenguajes como C++ tales como macros, herencia mltiple o la necesidad de un operador diferente del punto (.) acceder a miembros de espacios de nombres (::) Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los aos ha ido demostrndose son muy tiles para el desarrollo de aplicaciones y que en otros lenguajes como Java o C++ hay que simular, como un tipo bsico decimal que permita realizar operaciones de alta precisin con reales de 128 bits (muy til en el mundo financiero), la inclusin de una instruccin foreach que permita recorrer colecciones con facilidad y es ampliable a tipos definidos por el usuario, la inclusin de un tipo bsico string para representar cadenas o la distincin de un tipo bool especfico para representar valores lgicos. Orientacin a objetos: Como todo lenguaje de programacin de propsito general actual, C# es un lenguaje orientado a objetos, aunque eso es ms bien una caracterstica del CTS que de C#. Una diferencia de este enfoque orientado a objetos respecto al de otros lenguajes como C++ es que el de C# es ms puro en tanto que no admiten ni funciones ni variables globales sino que todo el cdigo y datos han de definirse dentro de definiciones de tipos de datos, lo que reduce problemas por conflictos de nombres y facilita la legibilidad del cdigo. C# soporta todas las caractersticas propias del paradigma de programacin orientada a objetos: encapsulacin, herencia y polimorfismo. En lo referente a la encapsulacin es importante sealar que aparte de los tpicos modificadores public, private y protected, C# aade un cuarto modificador llamado internal, que puede combinarse con protected e indica que al elemento a cuya definicin precede slo puede accederse desde su mismo ensamblado. Respecto a la herencia -a diferencia de C++ y al igual que Java- C# slo admite herencia simple de clases ya que la mltiple provoca ms quebraderos de cabeza que facilidades y en la mayora de los casos su utilidad puede ser simulada con facilidad mediante herencia mltiple de interfaces. De todos modos, esto vuelve a ser ms bien una caracterstica propia del CTS que de C#. Por otro lado y a diferencia de Java, en C# se ha optado por hacer que todos los mtodos sean por defecto sellados y que los redefinibles hayan de marcarse con el modificador virtual (como en C++), lo que permite evitar errores derivados

de redefiniciones accidentales. Adems, un efecto secundario de esto es que las llamadas a los mtodos sern ms eficientes por defecto al no tenerse que buscar en la tabla de funciones virtuales la implementacin de los mismos a la que se ha de llamar. Otro efecto secundario es que permite que las llamadas a los mtodos virtuales se puedan hacer ms eficientemente al contribuir a que el tamao de dicha tabla se reduzca.

Orientacin a componentes: La propia sintaxis de C# incluye elementos propios del diseo de componentes que otros lenguajes tienen que simular mediante construcciones ms o menos complejas. Es decir, la sintaxis de C# permite definir cmodamente propiedades (similares a campos de acceso controlado), eventos (asociacin controlada de funciones de respuesta a notificaciones) o atributos (informacin sobre un tipo o sus miembros) Gestin automtica de memoria: Como ya se coment, todo lenguaje de .NET tiene a su disposicin el recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destruccin de objetos. Sin embargo, dado que la destruccin de los objetos a travs del recolector de basura es indeterminista y slo se realiza cuando ste se active -ya sea por falta de memoria, finalizacin de la aplicacin o solicitud explcita en el fuente-, C# tambin proporciona un mecanismo de liberacin de recursos determinista a travs de la instruccin using. Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos siempre se realicen correctamente, lo que permite evita que se produzcan errores difciles de detectar por acceso a memoria no perteneciente a ningn objeto y es especialmente necesario en un entorno gestionado por un recolector de basura. Para ello se toman medidas del tipo: o Slo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y antecesores suyos, entre tipos para los que explcitamente se haya definido un operador de conversin, y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente, lo ltimo slo puede comprobarlo en tiempo de ejecucin el CLR y no el compilador, por lo que en realidad el CLR y el compilador colaboran para asegurar la correccin de las conversiones. o No se pueden usar variables no inicializadas. El compilador da a los campos un valor por defecto consistente en ponerlos a cero y controla mediante anlisis del flujo de control del fuente que no se lea ninguna variable local sin que se le haya asignado previamente algn valor. o Se comprueba que todo acceso a los elementos de una tabla se realice con ndices que se encuentren dentro del rango de la misma. o Se puede controlar la produccin de desbordamientos en operaciones aritmticas, informndose de ello con una excepcin cuando ocurra. Sin embargo, para conseguirse un mayor rendimiento en la aritmtica estas comprobaciones no se hacen por defecto al operar con variables sino slo con constantes (se pueden detectar en tiempo de compilacin) o A diferencia de Java, C# incluye delegados, que son similares a los punteros a funciones de C++ pero siguen un enfoque orientado a objetos, pueden almacenar referencias a varios mtodos simultneamente, y se

comprueba que los mtodos a los que apunten tengan parmetros y valor de retorno del tipo indicado al definirlos. Pueden definirse mtodos que admitan un nmero indefinido de parmetros de un cierto tipo, y a diferencia lenguajes como C/C++, en C# siempre se comprueba que los valores que se les pasen en cada llamada sean de los tipos apropiados.

Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie de restricciones en el uso de las instrucciones de control ms comunes. Por ejemplo, la guarda de toda condicin ha de ser una expresin condicional y no aritmtica, con lo que se evitan errores por confusin del operador de igualdad (==) con el de asignacin (=); y todo caso de un switch ha de terminar en un break o goto que indique cul es la siguiente accin a realizar, lo que evita la ejecucin accidental de casos y facilita su reordenacin. Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos que se definan siempre derivarn, aunque sea de manera implcita, de una clase base comn llamada System.Object, por lo que dispondrn de todos los miembros definidos en sta clase (es decir, sern "objetos") A diferencia de Java, en C# esto tambin es aplicable a los tipos de datos bsicos Adems, para conseguir que ello no tenga una repercusin negativa en su nivel de rendimiento, se ha incluido un mecanismo transparente de boxing y unboxing con el que se consigue que slo sean tratados como objetos cuando la situacin lo requiera, y mientras tanto puede aplicrseles optimizaciones especficas. El hecho de que todos los tipos del lenguaje deriven de una clase comn facilita enormemente el diseo de colecciones genricas que puedan almacenar objetos de cualquier tipo.

Extensibilidad de tipos bsicos: C# permite definir, a travs de estructuras, tipos de datos para los que se apliquen las mismas optimizaciones que para los tipos de datos bsicos. Es decir, que se puedan almacenar directamente en pila (luego su creacin, destruccin y acceso sern ms rpidos) y se asignen por valor y no por referencia. Para conseguir que lo ltimo no tenga efectos negativos al pasar estructuras como parmetros de mtodos, se da la posibilidad de pasar referencias a pila a travs del modificador de parmetro ref. Extensibilidad de operadores: Para facilitar la legibilidad del cdigo y conseguir que los nuevos tipos de datos bsicos que se definan a travs de las estructuras estn al mismo nivel que los bsicos predefinidos en el lenguaje, al igual que C++ y a diferencia de Java, C# permite redefinir el significado de la mayora de los operadores -incluidos los de conversin, tanto para conversiones implcitas como explcitas- cuando se apliquen a diferentes tipos de objetos. Las redefiniciones de operadores se hacen de manera inteligente, de modo que a partir de una nica definicin de los operadores ++ y -- el compilador puede deducir automticamente como ejecutarlos de manera prefijas y postifja; y definiendo operadores simples (como +), el compilador deduce cmo aplicar su

versin de asignacin compuesta (+=) Adems, para asegurar la consistencia, el compilador vigila que los operadores con opuesto siempre se redefinan por parejas (por ejemplo, si se redefine ==, tambin hay que redefinir !=) Tambin se da la posibilidad, a travs del concepto de indizador, de redefinir el significado del operador [] para los tipos de dato definidos por el usuario, con lo que se consigue que se pueda acceder al mismo como si fuese una tabla. Esto es muy til para trabajar con tipos que acten como colecciones de objetos. Extensibilidad de modificadores: C# ofrece, a travs del concepto de atributos, la posibilidad de aadir a los metadatos del mdulo resultante de la compilacin de cualquier fuente informacin adicional a la generada por el compilador que luego podr ser consultada en tiempo ejecucin a travs de la librera de reflexin de .NET . Esto, que ms bien es una caracterstica propia de la plataforma .NET y no de C#, puede usarse como un mecanismo para definir nuevos modificadores.

Versionable: C# incluye una poltica de versionado que permite crear nuevas versiones de tipos sin temor a que la introduccin de nuevos miembros provoquen errores difciles de detectar en tipos hijos previamente desarrollados y ya extendidos con miembros de igual nombre a los recin introducidos. Si una clase introduce un nuevo mtodo cuyas redefiniciones deban seguir la regla de llamar a la versin de su padre en algn punto de su cdigo, difcilmente seguiran esta regla miembros de su misma signatura definidos en clases hijas previamente a la definicin del mismo en la clase padre; o si introduce un nuevo campo con el mismo nombre que algn mtodo de una clase hija, la clase hija dejar de funcionar. Para evitar que esto ocurra, en C# se toman dos medidas:
o

Se obliga a que toda redefinicin deba incluir el modificador override, con lo que la versin de la clase hija nunca sera considerada como una redefinicin de la versin de miembro en la clase padre ya que no incluira override. Para evitar que por accidente un programador incluya este modificador, slo se permite incluirlo en miembros que tengan la misma signatura que miembros marcados como redefinibles mediante el modificador virtual. As adems se evita el error tan frecuente en Java de creerse haber redefinido un miembro, pues si el miembro con override no existe en la clase padre se producir un error de compilacin. Si no se considera redefinicin, entonces se considera que lo que se desea es ocultar el mtodo de la clase padre, de modo que para la clase hija sea como si nunca hubiese existido. El compilador avisar de esta decisin a travs de un mensaje de aviso que puede suprimirse incluyendo el modificador new en la definicin del miembro en la clase hija para as indicarle explcitamente la intencin de ocultacin.

Eficiente: En principio, en C# todo el cdigo incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. Sin embargo, y a diferencia de Java, en C# es posible saltarse dichas restricciones manipulando

objetos a travs de punteros. Para ello basta marcar regiones de cdigo como inseguras (modificador unsafe) y podrn usarse en ellas punteros de forma similar a cmo se hace en C++, lo que puede resultar vital para situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes.

Compatible: Para facilitar la migracin de programadores, C# no slo mantiene una sintaxis muy similar a C, C++ o Java que permite incluir directamente en cdigo escrito en C# fragmentos de cdigo escrito en estos lenguajes, sino que el CLR tambin ofrece, a travs de los llamados Platform Invocation Services (PInvoke), la posibilidad de acceder a cdigo nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. Ntese que la capacidad de usar punteros en cdigo inseguro permite que se pueda acceder con facilidad a este tipo de funciones, ya que stas muchas veces esperan recibir o devuelven punteros. Tambin es posible acceder desde cdigo escrito en C# a objetos COM. Para facilitar esto, el .NET Framework SDK incluye una herramientas llamadas tlbimp y regasm mediante las que es posible generar automticamente clases proxy que permitan, respectivamente, usar objetos COM desde .NET como si de objetos .NET se tratase y registrar objetos .NET para su uso desde COM. Finalmente, tambin se da la posibilidad de usar controles ActiveX desde cdigo .NET y viceversa. Para lo primero se utiliza la utilidad aximp, mientras que para lo segundo se usa la ya mencionada regasm.

----------------------------------------------------------------------------------------------------------

2. C Sharp
2.1.1 De Wikipedia, la enciclopedia libre

Saltar a navegacin, bsqueda C Sharp

Paradigma: Apareci en: Diseado por: ltima versin: Tipo de dato: Implementaciones: Influido por: Ha influido: Sistema operativo: Web: Orientado a objetos 2001 Microsoft Corporation 3.5 (19 de noviembre 2007) Fuerte, Esttico Visual Studio .NET, Mono Java, C++, C, Delphi, Eiffel Nemerle, Boo, F# Multiplataforma http://www.microsoft.com/net

C# (pronunciado "ci sharp") es un lenguaje de programacin orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET, que despus fue aprobado como un estndar por la ECMA e ISO. Su sintaxis bsica deriva de C/C++ y utiliza el modelo de objetos de la plataforma.NET el cual es similar al de Java aunque incluye mejoras derivadas de otros lenguajes (entre ellos Delphi). En el caso del lenguaje C#, la intencin original de los creadores del lenguaje fue llamarlo "C en re bemol", para denotar belleza e inteligencia en el diseo de tal lenguaje. Debido a que se encontr parecido el smbolo "sharp" o "numeral" en espaol, al correspondiente de Do sostenido mayor, el nombre del lenguaje qued como C#. C#, como parte de la plataforma.NET, est normalizado por ECMA desde diciembre de 2001 (ECMA-334 "Especificacin del Lenguaje C#"). El 7 de noviembre de 2005 sali la versin 2.0 del lenguaje que inclua mejoras tales como tipos genricos, mtodos annimos, iteradores, tipos parciales y tipos anulables. El 19 de noviembre de 2007 sali la versin 3.0 de C# destacando entre las mejoras los tipos implcitos, tipos annimos y el LINQ (Language Integrated Query). Aunque C# forma parte de la plataforma.NET, sta es una interfaz de programacin de aplicaciones (API); mientras que C# es un lenguaje de programacin independiente diseado para generar programas sobre dicha plataforma. Ya existe un compilador implementado que provee el Framework de DotGNU - Mono que genera programas para distintas plataformas como Win32, UNIX y Linux.

Captulo 1 - Fundamentos de programacin en .NET con C#

Que es C# La plataforma .NET Lo necesario para programar .NET con C# La linea de comandos Estructura de una aplicacin La consola

Descargar archivo PDF

Que es C#
C# (lase, en ingls C sharp, y en espaol C almohadilla) es un lenguaje de programacin que permite el desarrollo de aplicaciones para Internet, para mviles y aplicaciones de propsito general. Inicialmente se desarroll para programar en la plataforma .NET, pero dadas las caractersticas de esta y la estandarizacin que se ha hecho de su estructura por parte de su empresa creadora, Microsoft, ante las principales entidades de estndares internacionales, se han desarrollado otras plataformas que cumplen con dicha estructura y por lo tanto C# puede ser utilizado como lenguaje de programacin en ellas. Entre estas plataformas se destaca el Proyecto MONO, desarrollado para Linux y Mac. El lenguaje C# es orientado a objetos y se ha creado basndose en la estructura de C y C++, especialmente su sintaxis y potencia, y adoptando el estilo y metodologa de la programacin en Visual Basic. Sin embargo, es importante aclarar que C# no es el resultado de la evolucin directa de ninguno de estos lenguajes, sino que ha sido creado desde cero, para programar sobre la plataforma .NET. Es un lenguaje que fue concebido con el objetivo de programar esta plataforma y por lo tanto se puede decir que es el lenguaje natural de .NET. La empresa Microsoft, creadora de C#, en un intento de superar a otras plataformas que estn imponindose en el soporte a aplicaciones que trabajan en red, especialmente sobre Internet, decidi estandarizar la plataforma .NET y con ella el lenguaje base de la misma, C#. Con esta decisin se ha logrado que Microsoft d a conocer las especificaciones tanto de la plataforma como del lenguaje de programacin, y de esta manera permitir que terceros desarrollen implementaciones de .NET para el mismo Windows o para sistemas operativos diferentes.

3. La Plataforma .NET

Para comenzar no entraremos en muchos detalles sobre la plataforma .NET, y evitar de esta manera confundir al lector poco experimentado, con tecnicismos que cuando se tenga una mejor familiaridad se pueden abordar con mayor propiedad. .NET, en esencia es una librera de clases que contienen o encapsulan una gran cantidad de funciones que trabajan sobre el sistema operativo. La caracterstica fundamental de este aspecto, es que dichas clases tienen una estructura comn para todos los lenguajes que trabajen sobre esta plataforma. Esto trae como consecuencia que una clase que sea programada en C#, podr ser heredada o utilizada en cualquier lenguaje de la plataforma, como pueden ser Visual Basic .NET o JScript, para comenzar. Desde la perspectiva del programador el aspecto ms importante, es que .NET pone a su disposicin un marco o entorno de trabajo, llamado .NET Framework, el cual le permite acceder a una infraestructura dotada con lenguajes de programacin como C#, Visual Basic .NET, C++ y JScript, y con la posibilidad de acceder a infinidad de servicios tiles para desarrollar cualquier tipo de aplicacin.

4. Lo necesario para programar .NET con C#

El objetivo inicial de este curso es conocer los fundamentos bsicos de la programacin C# para aplicaciones de propsito general en .NET, y no el manejo de una herramienta especifica de software. Sin embargo, en el transcurso del mismo, y para hacer ms fcil la tarea de programacin, se recomienda utilizar software asistente que se encargue de administrar los detalles tcnicos repetitivos y nos permite concentrarnos en los detalles de nuestro inters. Para iniciar a programar en C# y .NET, tan solo se necesita el entorno de trabajo, conocido como .NET Framework, el cual incluye la plataforma de desarrollo y ejecucin de las aplicaciones .NET. Actualmente est a disposicin del pblico la versin 3.5 de este entorno, que puede ser descargada gratuitamente desde la pgina de Microsoft, pero para efectos de este curso se utilizar la versin 2.0, para la cual existe mayor soporte y documentacin. Sin embargo, se sugiere descargar el kit de desarrollo de software de Microsoft .NET 2.0, que contiene adems del .NET Framework una serie de herramientas y archivos de ayuda tiles a la hora de programar. Se sugiere que las prcticas iniciales se programen utilizando nicamente un editor de texto sencillo, como el Bloc de notas, y se realice la compilacin mediante la lnea de comandos. Esto con el fin de que tengamos la posibilidad de comprender al detalle aquellos aspectos que un entorno de desarrollo integrado, como el Visual Studio, no nos permite observar, pero cuya comprensin y familiaridad resultan muy importantes a la hora de desarrollar aplicaciones que requieren programacin avanzada. Superada la primera etapa del aprendizaje, y con el objetivo de agilizar el proceso de programacin, se utilizar un entorno de programacin integrado como el Sharpdevelop (versines 2.2 o 3.0). Esta herramienta de software es de distribucin gratuita y se puede descargar desde la pgina de sus creadores, http://www.icsharpcode.net/OpenSource/SD.

Sharpdevelop es un entorno de programacin diseado bsicamente para programar con C#, pero adaptado tambin a Visual Basic .NET. La versin 2.2 trabaja bsicamente sobre la versin 2.0 del .NET Framework. Su diseo, al menos en lo bsico, es muy parecido a Visual C#, pero es open-source y por lo tanto se puede obtener una copia gratuitamente. Sin embargo, en este curso no se trata de asumir posiciones fundamentalistas y poco coherentes sobre la grandeza o debilidades del open-source, sino ms bien de examinar una herramienta de desarrillo bastante buena y de fcil acceso, que est disponible a todos los interesados en este campo, pero sin desconocer la potencia que pueden ofrecer otros entornos de desarrollo, comerciales o no comerciales.

La lnea de comandos
Para compilar nuestras aplicaciones a travs de la lnea de comandos, lo primero que se debe hacer es configurar adecuadamente este entorno. Cualquier aplicacin de .NET depende para su ejecucin de una serie de libreras propias de la plataforma, las cuales le suministran la comunicacin necesaria con el sistema operativo. Por lo tanto para compilar un archivo es necesario poner a disposicin del compilador las direcciones donde posiblemente pueda encontrar algn componente que requiera o que se est utilizando en la aplicacin. Para facilitar esta tarea vamos a definir algunas variables de entorno que facilitan el trabajo de indicar las direcciones bsicas del marco de trabajo del .NET. Lo primero que se debe crear es una carpeta, donde se guardarn los archivos fuente y sus correspondientes compilados. Para facilitar la coherencia entre este escrito y las prcticas que se desarrollen se sugiere crear la carpeta c:\CSCurso. Para evitar tener que crear manualmente las variables de entorno con las direcciones necesarias para su ubicacin por parte del compilador, vamos a crear

un archivo de procesamiento por lotes, *.BAT, que realice este trabajo en forma rpida y automtica. Vaya al Bloc de notas, copie las lneas siguientes y guarde el archivo en el directorio c:\CSCurso, nombrndolo como cmdSharp.bat: @echo off Echo Lnea de comandos para el compilador de .NET Framework 2.0 Echo. rem Ejecute este archivo con la instruccin: %comspec% /k cmdSharp.bat @SET DirFramework=C:\WINDOWS\Microsoft.NET\Framework @SET VerFramework=v2.0.50727 @set PATH=%DirFramework%\v2.0;%DirFramework%\%VerFramework%;%PATH% @set LIBPATH=%DirFramework%\v2.0;%DirFramework%\%VerFramework%;%LIBPATH % cd c:\cscurso
Contenido del archivo cmdSharp.bat

A continuacin abra la ventana Ejecutar (puede hacerse mediante la combinacin de teclas WINDOWS+R) y ejecute la siguiente instruccin: %comspec% /k c:\cscurso\cmdsharp.bat

5. Ejemplo 01: Mi primer programa con C#

El primer programa que vamos a desarrollar es el clsico Hola Mundo!. Este programa al ejecutarse mostrar en la ventana de comandos el mensaje de texto Hola mundo C#...! Es un programa muy simple y elemental, adems utiliza un medio de salida en formato texto, poco usual en los programas modernos, que todo lo hacen a travs de ventanas, pero para comenzar est bien, luego nos preocuparemos por ir mejorando para mostrar mensajes ms sofisticados y a travs de las ya tradicionales ventanas. Al igual que sus hermanos, C y C++, el lenguaje C# exige que todo programa ejecutable (*.EXE) debe incluir un punto de acceso, el cual se debe identificar con la funcin Main(). Adems como C# es un lenguaje totalmente orientado a objetos, cualquier funcin que se desee implementar debe estar inmersa dentro de una clase y la funcin Main() no es la excepcin. Inicie un nuevo archivo de texto en el Bloc de notas y digite las siguientes lneas de cdigo C#: public class PrimerPrograma { static void Main() { System.Console.WriteLine("Hola mundo C#...!"); } } Guarde el archivo en la carpeta de trabajo, \CSCurso, y asignele el nombre ejemplo01.cs. El compilador de C# se identifica como csc.exe (C Sharp Compiler), y tiene una diversidad de opciones, dependiendo del tipo de compilacin que se desee realizar. Para este caso, basta con ejecutar el compilador seguido del nombre del archivo fuente que se desea compilar. Por defecto se genera un archivo ejecutable, *.EXE. La instruccin de compilacin es la siguiente: > csc ejemplo01.cs Compruebe la generacin del archivo ejemplo01.EXE y pruebe a ejecutarlo desde la misma linea de comandos, para observar los resultados. Y listo, ya sabemos programar en C# y compilar desde la linea de comandos.

Estructura de un programa C#
Como se ha dicho, C# es un lenguaje de programacin orientada a objetos y todo en l son clases. La clase es el concepto fundamental de esta metodologa de programacin y es quin identifica a los componentes que constituyen un programa. En un sencillo programa como el del ejemplo 1, el programador solo escribe una clase, pero en la prctica existen muchas clases trabajando para permitir que el programa se ejecute. Todo programa C# est constituido por ms de una clase, aunque el programador tan solo deba escribir una de ellas.

El ejemplo 1 muestra una estructura bsica de un sencillo programa que se ejecutar en una consola de comandos, o al menos la parte que debe construir el programador, pero permite visualizar con detalle los elementos esenciales que soportan a cualquier aplicacin de software, sin importar el entorno donde vaya a ejecutarse. public class PrimerPrograma { static void Main() { // Instrucciones del mtodo } } La clase es algo as como la estructura o molde de un componente de software, y se define con la palabra clave class. El trmino public le informa al sistema que dicha clase y sus componentes estn disponibles para ser vistos desde afuera del componente de software que la contiene, en este caso el propio programa. El programa en s, observe, es una clase, pero no se puede perder de vista que en la prctica el programa necesita otros componentes de software para poder ejecutarse, y lo ms seguro es que estos ltimos de alguna manera dependan de una o ms clases. Cuando se ejecuta el programa, el sistema operativo a travs de la plataforma de ejecucin, .NET, crea una instancia (para comenzar entindase, un componente de software basado en ese molde) de esta clase e interpreta las ordenes contenidas en ella. En este caso el nombre que se ha colocado a la clase, PrimerPrograma, es una cadena de texto tomado arbitrariamente e indiferente a como se lo escriba, lo importante es tener en cuenta las reglas que la mayora de lenguajes imponen a los nombres de sus elementos. Como regla general se ha establecido que los nombres de los elementos de programacin deben iniciar por un carcter alfabtico (letra) o por una raya abajo (_). Sin embargo, se sugiere no utilizar esta ltima forma de iniciar el nombre de un elemento, ya que le hace perder esttica al contenido y sobre todo dificulta su lectura por parte del programador. As, por ejemplo, son vlidos nombres como: CProgramaDibujo, programadibujo, programa_dibujo, etc. Pero no es correcto llamar a una clase, como: 5CProgramaDibujo, programa#dibujo, programa-dibujo. Adems, un buen programador debe manejar un estilo de escritura de cdigo que haga clara su interpretacin, no solo por l mismo, sino por otras personas a quienes les puede interesar revisarlo. Como sugerencia de estilo, la cual manejaremos en este escrito, se recomienda nombrar a una clase con la letra inicial C, seguida de una cadena de texto lo ms explicativa posible de su razn de ser. Es mejor evitar el uso de abreviaturas, ya que con el tiempo podemos olvidar su significado y cuando el programador debe volver a revisar su cdigo, despus de algunos meses o aos, le complicar su interpretacin. Talvez, despus de algn tiempo, sea ms fcil interpretar para que sirva una clase llamada CIdentidadTrabajador, que una con el nombre CITra. Todo programa desarrollado en C# debe incluir un mtodo Main(), el cual le informa al compilador por donde debe iniciar y tambin terminar un programa. Este mtodo o funcin siempre se define antecedida de la palabra clave static, cuyo significado se describir con mayor detalle cuando hablemos del concepto de programacin orientada a objetos. La palabra clave void le dice al sistema que la funcin que viene en seguida no retornar ningn valor y que por lo tanto no espere nada.

La funcin Main() puede ir como se mostr en el ejemplo 1, o tambin incluir argumentos de tipo cadena de texto. Dichos argumentos se identifican por un arreglo o vector del tipo string (cadena), como en la siguiente forma, static void Main(string[] argumentos) { // Instrucciones } En apariencia, los argumentos de inicio de ejecucin solo son vlidos para programas de consola, y no para programas que manejan un sistema grfico de ventanas, como las aplicaciones tipo Windows. Pero esto no es muy exacto, los programas tipo Windows, o en general que manejan ventanas, tambin pueden requerir argumentos de entrada en el instante en que inician su ejecucin. Un buen ejemplo son los programas que manejan algn formato de archivo especifico, como puede ser el Bloc de notas que genera archivo de texto que se identifican con la extensin *.TXT y los cuales, generalmente, el sistema operativo asocia con este editor. Esto trae como consecuencia dos forma de iniciar la ejecucin del Bloc de notas: una, a travs de su acceso directo en el men de Programas, y la otra haciendo doble clic en el archivo de texto. En este ltimo caso el sistema operativo enva un argumento al programa informndole que su ejecucin la inicio un archivo y no el acceso directo del men de programas. El argumento que se enva contiene el nombre completo del archivo que lo llam, y de esta forma el programa se ejecuta y realiza su apertura. Ejemplo2: Un programa con argumentos de entrada El siguiente programa, que se identificar con la clase Bienvenidos, recibe una cadena de texto como argumento, que bien podra ser el nombre de una persona, y lo muestra en pantalla haciendo parte de un mensaje de bienvenida. Escriba este programa en el Bloc de notas y gurdelo con el nombre ejemplo02.cs: public class Bienvenida { static void Main(string[] sNombre) { System.Console.WriteLine("Bienvenido(a) " + sNombre[0]); } } Compile el programa con la instruccin, > csc ejemplo02.cs En seguida realice la ejecucin del programa llamando a ejemplo02 seguido de un nombre, como por ejemplo: > ejemplo02 Homero Si todo ha salido bien, la salida que muestra el programa despus de teclear ENTER es, Bienvenido(a) Homero Pruebe a ejecutar el programa sin enviarle un argumento. Observar que se produce un error, el cual es informado por la plataforma de ejecucin del .NET

La consola
Este es el nombre como en Windows, e incluso en otros sistemas operativos, se conoce a la interfaz que permite enviar rdenes al sistema operativo a travs de comandos escritos. Tales comandos, no son otra cosa sino programas desarrollados para este entorno de ejecucin. Para .NET la consola de Windows se manipula a travs de un objeto que se identifica con el nombre Console, el cual incluye todas las funciones bsicas para manejar este elemento del sistema operativo. Una de esas funciones es WriteLine que se encarga de enviar a la pantalla, o tambin a otros dispositivos de salida, el argumento que se le asigne, ya sea una cadena de texto o un valor numrico. En la instruccin que hemos utilizado en el anterior ejemplo, System.Console.WriteLine("Bienvenido(a) " + sNombre[0]); se observa que el objeto Console esta antecedido por el identificador System. Este en realidad es lo que se denomina espacio de nombres, que no es ms que el nombre de un conjunto que agrupa a una serie de clases, que por lo general el programador considera guardan alguna relacin entre s. En este caso la clase Console pertenece al conjunto o espacio de nombres llamado System. Ejemplo 3: Programa de consola para ingresar datos Vamos a desarrollar un programa que lee dos datos a travs de la consola, el nombre y el documento de identidad, utilizando el mtodo ReadLine del objeto Console. Para mostrar las etiquetas y los mensajes se utilizarn los mtodos WriteLine y Write. La diferencia entre estos mtodos es que el primero escribe el mensaje y pasa el cursor a la siguiente lnea, mientras que Write mantiene el cursor al final de la lnea escrita. Adicional a lo anterior, y para recrearnos un poco en medio de tanta oscuridad de la consola, vamos a asignar color al texto. Para esta tarea el objeto Console cuenta con la propiedad ForegroundColor, que permite asignar un color al texto de la consola. La plataforma de desarrollo de .NET pone a disposicin del programador un coleccin de colores, mediante la enumeracin ConsoleColors, para asignarlos tanto al color de fondo como al texto de la consola. public class LecturaDatos { static void Main() { System.Console.ForegroundColor = System.ConsoleColor.Green; System.Console.WriteLine("------------------------------"); System.Console.Write("Nombre del usuario color: "); System.Console.ReadLine(); System.Console.Write("Nmero de indentificacin: "); System.Console.ReadLine(); System.Console.WriteLine("Acceso permitido"); System.Console.WriteLine("=============================="); System.Console.ResetColor(); // Reestablece las opciones de color }

} Inicie un nuevo archivo de texto en el Bloc de notas, incluya las siguientes lneas y gurdelo con el nombre ejemplo03.cs. En los ejemplos anteriores la compilacin se realiz utilizando la opcin bsica que ofrece el compilador de C#, llamando al compilador y asignandole el nombre del archivo fuente que se desea compilar. Por defecto, el compilador asigna al archivo compilado el mismo nombre del archivo fuente, pero en un momento dado el programador puede desear asignar un nombre conveniente al archivo ejecutable. Como cualquiera de los compiladores antecesores a C#, este cuenta con una serie de parmetros bsicos que permiten obtener diferentes salidas en el proceso de compilacin. Para este caso en particular, se puede utilizar el parmetro out, que permite asignar un nombre al archivo compilado, diferente al de su fuente. Se aplica siguiendo la sintaxis, csc /out:ArchivoCompilado ArchivoFuente Teniendo en cuenta lo anterior compile el programa con la instruccin, > csc /out:lectura.exe ejemplo03.cs y ejectelo mediante la llamada, > lectura En la programacin de este ejemplo nos hemos dado cuenta que las instrucciones pueden ser un tanto complejas de escribir, dada la necesidad de tener que incluir el espacio de nombres en las llamadas a las clases y sus mtodos. Si tenemos en cuenta que la programacin en .NET se hace a base de objetos, cuyas clases hacen parte de espacios de nombres, y que muchos de estos espacios de nombres a su vez hacen parte de otros espacios de nombres, el grado de dificultad parece aumentarse innecesariamente para el programador de C#, a causa de estos mtodos de asignacin de nombres. Sin embargo, esta forma de identificar las clases y sus objetos tiene una poderosa razn de ser y, en vez de perjudicar, ms bien es un beneficio para el programador. En el pdf adjunto a esta pgina se describe con mayor detalle la importancia de esta metodologa, de agrupamiento de clases, y la forma como podemos evitar las dificultades que ofrece el manejo de los espacios de nombres.

----------------------------------------------------------------------------------------------------------

6. C sharp NET / Captulo 0

6.1.1 De C# Online.NET (CSharp-Online.NET)su enciclopedia libre de C# y .NET

Saltar a navegacin, bsqueda [editar] 6.2 Una Breve Introduccin a los Lenguajes de Programacin Los lenguajes modernos de programacin no son tan distintos a los lenguajes hablados como el Espaol, el Ingls, o cualquier otro; ya que al igual que en la comunicacin oral, los leguajes de programacin tienen un vocabulario definido, adems de reglas ortogrficas, de estructura, de puntuacin y de sintaxis que se deben seguir. Como en los lenguajes hablados, estas reglas deben tomarse en cuenta para que las ideas que tratamos de expresar tengan sentido. Tambin, un lenguaje de programacin al igual que un lenguaje hablado cambia con el tiempo. Si t eres un hispano-hablante sabrs que en cada pas latinoamericano se usan palabras que en otros pases no se utilizan o las mismas palabras tienen un significado distinto entre pases: el idioma Espaol ha venido evolucionando con el tiempo y se adaptado a la geografa. En este mismo sentido, el lenguaje de programacin C#.NET es la evolucin de otros lenguajes de programacin ms antiguos como lo son el C, C++ y Java. [editar]
6.2.1 Historia y Evolucin

Debido a que los ordenadores (computadores) no son ms que aparatos electrnicos, stos funcionan a partir de seales electricas. Cientficos encontraron la forma ms simple de generar un lenguage para el computador utilizando algo tecnicamente parecido al cdigo morse: el cdigo binario. El cdigo binario se compone de 0 y 1. El diseo es muy simple: en algunos ordenadores (computadores) cuando existe corriente en el cable esto representa al nmero 1 y cuando no existe corriente en el cable esto representa al nmero 0. De sta forma es que el computador opera, internamente tiene todo un lenguage para comunicarse y saber que hacer en base de 1s y 0s. Los cientficos se dieron cuenta de que cualquier cosa se puede representar binariamente y es as como nace el mundo digital. A partir de este lenguage bsico interno del computador se ha tratado de disear varios formas para que el ser humano pueda comunicarse o dar instrucciones al computador de una forma sencilla. La evolucin de los ordenadores (computadores) y de los lenguajes de programacin ha sido grandsima. No hace muchos aos existan personas que tenan que hacer agujeros en una cartulina para poder dar instrucciones al ordenador: eran las tarjetas perforadas. Pocos aos despes de esos das existan personas (y hasta ahora existen aquellos) que pueden hablar con el ordenador directamente en su idioma (en 1s y 0s). Despus se cre el assembler que le permita al programador dar instrucciones directas al computador con un archivo de texto. El archivo tenia instrucciones de como mover la informacin internamente, hacer calculos, etc. A pesar de que assembler era una solucin muchsimo ms conveniente que perforar tarjetas o escribir 1s y 0s, aun era una tarea extremadamente dificil. A partir de esta necesidad es que se crearon los primeros lenguages de programacin de

alto nivel. Estos lenguages de programacin se los llama de alto nivel ya que utilizan un idioma humano para dar instrucciones al ordenador. Estos lenguages utilizan "traductores" que convierten un lenguage de alto nivel a un lenguage de bajo nivel y despues un lenguage de bajo nivel a codigo de mquina (1s y 0s que el computador entiende). Despus estos lenguages de alto nivel evolucionaron a lo que se conoce como lenguages manejados. Los lenguages manejados (como es el caso de C#) son lenguages de alto nivel que son procesados traducidos a un lenguage intermedio el cual es interpretado o compilado en una mquina virtual que es la encargada de traducir el lenguage intermedio a lenguage de mquina. La ventaja de tener un lenguage intermedio es que varios lenguages pueden ser compilados a este lenguage y ser interpretados por la misma mquina virtual. C# es solo uno de varios lenguages que pueden ser compilados en este lenguage intermedio. Ya que hemos recalcado las similitudes entre los lenguajes de programacin y los lenguajes hablados tambin hay que tener presente que un lenguaje de programacin es mucho ms estricto que uno hablado en el sentido de que no pueden existir ambigedades. Es muy fcil en el idioma Espaol tener frases que impliquen algo que ya conocemos o que signifiquen cosas diferentes. Por el contrario los lenguajes de programacin son claros, especficos y directos, no se admiten ambigedades ni suposiciones. Para poder dominar un lenguaje de programacin (al igual que con los lenguajes hablados) se requiere mucho estudio pero por sobre todo muchsima prctica. Vosotros podris leer este manual una 500 veces pero si no ponis en prctica ni investigis por vosotros mismos, nnca podris llegar a dominar este maravilloso lenguaje de programacin. As que a practicar se ha dicho!