C#
C#
C#
Asignatura: Algoritmia
Curso: 2°BTI
2019
Resumen
La mayoría de los lenguajes de programación de alto nivel que se construyen hoy en día, tiene
como propósito adaptarse a la forma en que piensan las personas desligar de la mejor manera
C# es un lenguaje elegante, con seguridad de tipos y orientado a objetos, que permite a los
desarrolladores crear una gran variedad de aplicaciones seguras y sólidas que se ejecutan
en .NET Framework.NET. Puede usar C# para crear aplicaciones cliente de Windows, servicios
datos y muchas, muchas más cosas. Visual C# proporciona un editor de código avanzado,
Índice
Introducción ------------------------------------------------------------------------------------------------------ 5
Historia ------------------------------------------------------------------------------------------------------------ 6
C# Versión1 ----------------------------------------------------------------------------------------------------- 8 C#
Versión 2 ---------------------------------------------------------------------------------------------------- 8 C#
Versión 3 ---------------------------------------------------------------------------------------------------- 9 C#
Versión 4 --------------------------------------------------------------------------------------------------- 10 C#
Versión 5 --------------------------------------------------------------------------------------------------- 11 C#
Versión 6 --------------------------------------------------------------------------------------------------- 11 C#
Versión 7 --------------------------------------------------------------------------------------------------- 12
Características--------------------------------------------------------------------------------------------------- 12
Tipos y variables ------------------------------------------------------------------------------------------------ 14
Visual C# ------------------------------------------------------------------------------------------------------- 14
Definición ------------------------------------------------------------------------------------------------------ 14
Visual Basic ---------------------------------------------------------------------------------------------------- 15
Visual Studio --------------------------------------------------------------------------------------------------- 15
Conclusión -------------------------------------------------------------------------------------------------------- 17
Anexos ------------------------------------------------------------------------------------------------------------- 18
Web grafía -------------------------------------------------------------------------------------------------------- 19
Bibliografía ------------------------------------------------------------------------------------------------------- 19
Introducción
Ante la pregunta qué es C# la respuesta más básica y sencilla es: un lenguaje de programación.
Pero como es lógico, esta explicación te sabrá a poco. C# ha sido desarrollado por Microsoft con
en .NET Framework ( una tecnología que admite la compilación y ejecución de aplicaciones y
C# es un lenguaje sencillo, con seguridad de tipos y orientado a objetivos. Su sintaxis es fácil de
aprender y muy intuitiva, lo que hace que cualquier persona familiarizada con algún otro tipo de
La sintaxis de C# es muy expresiva, pero también sencilla y fácil de aprender. Cualquier persona
familiarizada con C, C++ o Java, reconocerá al instante la sintaxis de llaves de C#. Los
desarrolladores que conocen cualquiera de estos lenguajes puede empezar normalmente a
tipos de valor que aceptan valores NULL, enumeraciones, delegados, expresiones lambda y
acceso directo a memoria, que no se encuentran en Java. C# admite métodos y tipo genéricos,
que proporcionan una mayor seguridad de tipos y rendimiento, e iteradores, que permiten a los
clase.
En cuanto lenguaje orientado a objetos, C# admite los conceptos de encapsulación, herencia y
polimorfismo. Todas las variables y métodos, incluido el método Main, el punto de entrada de la
aplicación, se encapsulan dentro de las definiciones de clase. Una clase puede heredar
directamente de una clase primaria, pero puede implementar cualquier número de interfaces. Los
métodos que invalidan los métodos virtuales en una clase primaria requieren la palabra clave
override como una manera de evitar redefiniciones accidentales. En C#, un struct es como una
clase sencilla; es un tipo asignado en la pila que puede implementar interfaces pero que no
admite herencia.
siguientes:
Si tiene que interactuar con otro software de Windows, como objetos COM o archivos DLL
interoperabilidad permite que los programas de C# hagan casi todo lo que puede hacer una
aplicación C++ nativa. C# admite incluso el uso de punteros y el concepto de código "no seguro"
en los casos en los que el acceso directo a memoria es absolutamente crítico.
El proceso de compilación de C# es simple en comparación con C y C++ y más flexible que en
Java. No hay ningún archivo de encabezado independiente y ningún requisito de declaración de
Historia
Anders Hejlsberg decidió formar un equipo de trabajo en 1999 para crear un nuevo lenguaje de
programación, que hoy conocemos como C#. En cambio, en sus inicios el nombre inicial que se
barajó fue Cool (C Object Oriented Language) , lo que en español traduciríamos con un lenguaje
C# tiene sus orígenes en la familia de lenguajes C y su primera versión, tal y como explica.
Microsoft, se parecía mucho a Java. De hecho, se creó con el fin de ser una alternativa viable en
este en Windows. Muchas de sus características fueron evolucionando y mejorando hasta llegar a
la versión actual.
Por ejemplo, ahora el lenguaje de C# admite los conceptos de encapsulación, herencia y
de lenguaje innovadoras.
Anders Hejlsberg que diseñó también los lenguajes Turbo Pascal y Delphi. El C# (pronunciado
objetos. Con este nuevo lenguaje se quiso mejorar con respecto de los dos lenguajes anteriores
renombrado a C# y todas las librerías de clases y el runtime de ASP.NET fueron portadas a C#.
Los creadores del lenguaje Java decían que C# era un clon de Java sin ninguna novedad ni
innovación a lo que Anders Hejlsberg contestó que “C# es „no un clon de Java‟ y es mucho más
Desde el lanzamiento de C# 2.0 en noviembre de 2005, los lenguajes C# y lenguajes Java hanevo
lucionado en trayectorias cada vez más divergentes, convirtiéndose en algo menos similares el
uno del otro. Una de las primeras diferencias principales vino con la adición de los genéricos en
empleo de tiposanónimos, métodos de extensión y expresiones lambda. Las extensiones LINQ a
yudan a los
desarrolladores a reducir mucha cantidad de código “repetitivo” que está incluido en las tareas
comunes como consultar una base de datos. Análisis de un archivo XML o búsqueda a
través de una estructura de datos, cambiando el énfasis sobre la lógica de programación real para
El lenguaje más popular de Microsoft siempre había sido Visual Basic, sobre todo con la versión
Pero Microsoft apostó por crear la plataforma Framework .NET para suplir las carencias y
Microsoft .NET es la tecnología por la que sigue apostando la compañía actualmente, y se ha
transformado en una de las más potentes hoy en día, abarcando diferentes ámbitos en la
Llevaban años desarrollándolo, bajo el nombre de COOL (C Object Oriented Language), pero al
final en su presentación cambió de nombre por C Sharp.
El nombre C# fue inspirado por la notación musical donde una almohadilla (#) indica que la nota
escrita debe hacerse un semitono más alto en el tono. Esto es similar al nombre del
lenguaje C++, donde “++” indica que una variable debe ser incrementada en 1. El símbolo de la
a una ligadura de los cuatro símbolos “+” (en unacuadrícula de dos en dos), lo que implica que el
Richards en la Universidad de Cambridge. Muchas de las ideas de ese lenguaje fueron utilizadas
por Ken Thompson, quien en 1970 crea el lenguaje B, para el primer sistema operativo UNIX.
Posteriormente Dennis Ritchie, que trabajaba con Thompson en Bell Laboratories, convierte el
En el año 1978 Brian Kernighan junto con Dennis Ritchie escriben y publican el libro The C
programming Languaje.
Ha habido muchísimos cambios en los últimos 15 años. Dudo de que nadie haga hoy en día una
valoración similar. En este tiempo, Java ha liberado 4 grandes versiones, mientras que C# ha
innovación. Hoy me gustaría echar la vista atrás a la historia de C# y destacar algunas de las
claves en su evolución.
¿Cómo era el lenguaje en sus versiones más tempranas? ¿Cómo ha evolucionado hasta la fecha?
C# Versión1 Cuando echas la vista atrás, la primera versión de C# sí que se parecía un montón a
Java. Como
parte de sus objetivos de diseño escritos para ECMA, buscaba ser un "lenguaje orientado a
objetos de uso general moderno y sencillo". En aquel momento, podría haber hecho algo peor
que mirar hacia Java para alcanzar dichos fines.
Pero si analizases la versión 1.0 de C# 1.0 hoy, te marearías. Carecía de capacidades asíncronas
sólidas y de muchas de las "pulidas" funcionalidades relacionadas con los genéricos que hoy en
día damos por sentadas. En realidad, carecía de genéricos en general. ¿Y LINQ? Nada. Eso
La versión 1 de C# parecía estar bastante desprovista de funcionalidad, comparado con hoy. Al
final te veías escribiendo código pesado. Pero bueno, como con cualquier versión 1.0: por algún
C# Versión 2 Aquí las cosas se empiezan a poner interesantes. Repasemos algunas de las
principales
características de C# 2.0, lanzado en 2005, junto con Visual Studio 2005 (no te olvides de
echarle un vistazo al libro escrito por el creador de NDepend, Patrick Smacchia, sobre .NET 2.0,
• Genéricos
• Tipos parciales
• Métodos anónimos
• Tipos anulables
• Iteradores
• Covarianza y contravarianza
Aunque Microsoft puede que haya empezado con un lenguaje orientado a objetos bastante
genérico, la versión 2 de C# lo cambió todo enseguida. Se pusieron a la tarea tras la salida de la
versión inicial y fueron a por varias de las frustraciones que causaba. Y lo hicieron muy en serio.
Con genéricos, tienes tipos y métodos que pueden operar sobre un tipo arbitrario mientras que
aún conservan seguridad de tipos. Así, por ejemplo, tener una List<T> te permite tener
una List<string> o una List<int> y realizar operaciones seguras de tipo en esas cadenas de
caracteres o ints mientras iteras por ellas. Esto es mucho mejor que crear clases derivadas de
¡Ah!, y hablando de iteradores, la versión 2 de C# los presentó. Para resumir, esto te permite
iterar por los ítems de una Lista (u otros tipos Enumerable) con un bucle foreach. Tener esto
como un elemento de primera clase del lenguaje mejoró ostensiblemente la legibilidad del
Y aun así, Microsoft seguía intentando ponerse a la altura de Java. Java ya había liberado
versiones que incluían genéricos e iteradores. Pero eso cambiaría pronto a medida que los
C# Versión 3 La versión 3 de C# apareció a finales de 2007, junto con Visual Studio 2008, aunque
la
funcionalidad completa aparecería con la versión 3.5 de C#. ¡Y menuda actualización resultó ser!
• Propiedades auto-implementadas
• Tipos anónimos
• Expresiones lambda
• Árboles de expresión
• Métodos de extensión
Con mirada retrospectiva, muchas de estas características parecen tanto inevitables como
inseparables. De hecho, no es fácil destacar una sobre otra ya que todas encajan estratégicamente
Otros haciendo este mismo análisis no tendrán ese problema, y dirán que, de largo, la novedad
más importante de la versión 3 de C# fue las expresiones de consulta, también conocidas como
LINQ (Language INtegrated Query).
Aprende con nosotros ASP.NET Core 2 MVC. A tu ritmo y sin horarios. ¡Empieza ahora! »
Yo creo que hay más matices y sutilezas puesto que, desde mi punto de vista, los árboles de
expresión, las expresiones lambda y los tipos anónimos fueron los cimientos sobre los que se
creó LINQ. Disertaciones aparte, lo cierto es que nos encontramos con un concepto realmente
En concreto, con esta versión ya se podían programar búsquedas declarativas tipo SQL para
llevar a cabo operaciones en colecciones, entre otras cosas. En vez de tener que crear un bucle
para computar la media de una lista de enteros, ahora se podía hacer con algo tan fácil
Llevó un tiempo hasta que los programadores realmente entendieron cómo integrar el concepto,
pero a la larga lo lograron. Y ahora, unos años más tarde, el código es mucho más conciso,
sencillo y funcional.
C# Versión 4 La versión 4 de C# nació con el estigma de no suponer una innovación rompedora
como sí lo
había sido su antecesora versión 3. Y es que con la versión 3, Microsoft hizo que el lenguaje
• Tipos dinámicos
contravarianza genéricas te dan mucha potencia, pero son demasiado académicas y
probablemente sean más valoradas entre los creadores de frameworks y bibliotecas. Los
argumentos opcionales y con nombre te permiten eliminar muchas sobrecargas de método y
ofrecen comodidad. Pero ninguna de estas cosas altera el paradigma propiamente dicho.
Esa distinción sí se la llevan los tipo dinámico. Con esta característica, Microsoft introdujo en la
decir, al usar el tipo de referencia dinámico, te puedes llegar a pegar un tiro en el pie como en los
lenguajes de tipado dinámico como JavaScript. Puedes crear una "x = cadena de caracteres"
dinámica y luego añadirle 6, dejando al tiempo de ejecución determinar qué diablos tiene que
pasar después.
Esto lo digo un poco de broma obviamente. Está claro que cabe la posibilidad de cometer
C# Versión 5 Con la versión 5 de C#, Microsoft liberó una versión con el foco muy puesto en la
innovación
No quiero que se me malinterprete. El atributo caller info está muy bien. Te permite recuperar
información sobre el contexto en el que estás sin tener que recurrir a un montón de código reflejo
Pero async y await son las verdaderas estrellas de esta versión. Cuando esto salió en 2012,
Microsoft cambió las reglas del juego nuevamente al meter la asincronía en el lenguaje como un
lenguaje orientado a objetos (la versión 2 también, pero estaban copiando conceptos de Java con
esas funciones que introdujeron). Con la versión 6 se alejaron de la idea de sacar una novedad
dominante estrella y, en vez de eso, liberaron muchas características para hacer felices a los
• Filtros de excepciones
• Inicializadores de propiedad
• Propagador null
• Cadenas interpoladas
• Operador nameof
Si las vemos de forma individual, todas estas características del lenguaje son muy interesantes.
Pero si las valoramos en conjunto, observamos un patrón que nos llama la atención. En esta
sea más ligero y legible. Así que para los aficionados del código escueto y limpio, esta versión
¡Ah!, e hicieron otra cosa con esta versión, aunque no se puede considerar como una función
tradicional del lenguaje, per se. Liberaron Roslyn, el compilador, como servicio. Microsoft ahora
usa C# para hacer C#, y te dejan usar el compilador como parte de tus esfuerzos de
programación.
versión 6, pero sin el compilador como servicio. Aquí van las novedades de esta versión:
• Variables out
• Tuplas y deconstrucción
• Coincidencia de patrones
• Funciones locales
• Extensión de la funcionalidad de miembros con una expresión como cuerpo aparecida en
C# 6
Todas ofrecen nuevas capacidades para que los desarrolladores puedan escribir código más
limpio que nunca. En concreto, creo que Microsoft ha dado solución a problemas que venían
desde muy lejos al condensar la declaración de variables que se pueden a usar con la palabra
Además, Microsoft le está dando un uso más amplio al lenguaje. .NET ahora va dirigido a
cualquier sistema operativo y tiene la vista puesta de forma firme en la nube y en la portabilidad.
• Sistema de tipo unificado, permitiendo realizar operaciones comunes y que los valores de
innecesarios en .NET.
• Modernidad: Incorpora en el propio lenguaje elementos que son muy útiles para el
desarrollo de aplicaciones y que en otros lenguajes como Java o C++ hay que simular,
como un tipo básico decimal que permita realizar operaciones de alta precisión con reales
de 128 bits, la inclusión de una instrucción foreach que permita recorrer colecciones con
string para representar cadenas o la distinción de un tipo bool específico para representar
valores lógicos.
actual, C# es un lenguaje orientado a objetos, aunque eso es más bien una característica
del CTS que de C#. Se diferencia en este enfoque OO respecto al de otros lenguajes
como C++, en que C# es más puro en tanto que no admiten ni funciones ni variables
globales sino que todo el código 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
código.
diseño de componentes que otros lenguajes tienen que simular mediante construcciones
• Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie
recuperación; y detección de errores y la con seguridad de tipos diseño del lenguaje hace
imposible leer desde las variables sin inicializar, para indizar matrices más allá de sus límites, o
C# tiene un sistema de tipo unificado. Todos los tipos de C#, incluidos los tipos primitivos
como int y double, se heredan de un único tipo object raíz. Por lo tanto, todos los tipos
comparten un conjunto de operaciones comunes, y los valores de todos los tipos se pueden
almacenar, transportar y utilizar de manera coherente. Además, C# admite tipos de valor y tipos
de referencia definidos por el usuario, lo que permite la asignación dinámica de objetos, así
Para asegurarse de que los programas de C# y las bibliotecas pueden evolucionar con el tiempo
lenguajes de programación prestan poca atención a este problema y, como resultado, los
cuando se introducen nuevas versiones de las bibliotecas dependientes. Aspectos de diseño de C#
los virtual y override modificadores, las reglas de resolución de sobrecarga del método y
Tipos y variables
Hay dos clases de tipos en C#: tipos de valor y tipos de referencia. Las variables de tipos de
valor contienen directamente los datos, mientras que las variables de los tipos de referencia
almacenan referencias a los datos, lo que se conoce como objetos. Con los tipos de referencia, es
posible que dos variables hagan referencia al mismo objeto y que, por tanto, las operaciones en
una variable afecten al objeto al que hace referencia la otra variable. Con los tipos de valor, cada
variable tiene su propia copia de los datos y no es posible que las operaciones en una variable
Los tipos de valor de C# se dividen en tipos simples, tipos enum, tipos struct, y tipos que aceptan
valores NULL y la referencia de C# los tipos se dividen en tipos de clase, tipos de interfaz, tipos
Visual C# El lenguaje Visual C# es actualmente uno de los lenguajes de programación más
populares, ya
tiempos C y C++ han sido los lenguajes más utilizados en el desarrollo de aplicación una
aplicación es. Ambos lenguajes proporcionan al programador el nivel de abstracción preciso para
abordar el desarrollo de cualquier aplicación por compleja que sea, así como mecanismos de bajo
nivel para utilizar las característica más avanzadas de las plataformas sobre las que se desarrolla
resalta largo comparado con otros lenguajes como Visual Basic, que ofrecen además de facilidad,
cuando la flexibilidad de los desarrolladores de C y C++ requieren. La solución que Microsoft da
a este problema des el lenguaje denominado C#. Se trata de un lenguaje moderno orientado a
objetos que permite desarrollar una amplia gama de aplicaciones para la nueva plataforma
Microsoft. Net, la cual se caracteriza por proporcionar utilidades y servicios para sacar un
provecho total tanto de la informática como de las comunicaciones.
Definición
fundamentalmente tres componentes: una máquina virtual (CL: Como Angula Rudimento= que
procesa código escrito en un lenguaje intermedio ) MIL: Microsoft Intermediaste Angula, una
biblioteca de clases )biblioteca. TEN Frambueso= y ASAINETEA que proporciona los servicios
necesarios para crear aplicaciones Web. Visual C# es uno de los lenguajes de programación de
alto nivel que pertenecen al paquete .TEN otros lenguajes son Visual Basilical, C/C++. Con él se
escrito en un lenguaje intermedio, común para todos los lenguajes de dicha plataforma, que será
el que la máquina virtual ejecutará) esto es, cada lenguaje de la plataforma tiene su compilador
Por lo tanto, MIL es un lenguaje máquina que no es específico de ningún procesador, sino de la
máquina virtual de .TEN En realidad se trata de un lenguaje de más alto nivel que otros
lenguajes máquina: trata directamente con objetos y tiene instrucciones para cargarlos,
guardarlos, iniciarlos, invocar a sus métodos, así como para realizar operaciones aritméticas y
lógicas, para controlar el flujo de ejecución, etc. A su vez, la máquina virtual posee un recolector
de basura (para eliminar los objetos cuando no estén reverenciados) y proporciona traductores
del lenguaje intermedio a código nativo para cada arquitectura soportada; se trata de
Una característica importante del por qué utilizamos el lenguaje C#, es que es un lenguaje de
programación orientado a objetos (PIO). Además es fácil de aprender. Tiene un tamaño pequeño
que favorece el desarrollo y reduce las posibilidades de cometer errores; a la vez es potente y
flexible.
Visual Basic Visual Basic es uno de los tantos lenguajes de programación que podemos
encontrar hoy en día.
Dicho lenguaje nace del BASIC (Beginner ́s All-purpose Symbolic Instruction Code) que fue creado en su
versión original en el Dartmouth College, con el propósito de servir a aquellas personas que estaban
interesadas en iniciarse en algún lenguaje de programación. Luego de sufrir varias modificaciones, en el año
1978 se estableció el BASIC estándar. La sencillez del lenguaje ganó el desprecio de los programadores
Visual Studio
Es un conjunto de herramientas y otras tecnologías de desarrollo de software basado en
desarrollo para la generación de aplicaciones web ASP.NET, Servicios Web XML, aplicaciones
de escritorio y aplicaciones móviles. Visual Basic, Visual C# y Visual C++ utilizan todos el
mismo entorno de desarrollo integrado (IDE), que habilita el uso compartido de herramientas y
facilita la creación de soluciones en varios lenguajes. Asimismo, dichos lenguajes utilizan las
funciones de .NET Framework, las cuales ofrecen acceso a tecnologías clave para simplificar el
con los años van evolucionando en pasos largos, comparando los primeros lenguajes con los de
ahora, incluyendo a C Sharp se podría decir que este es una de las mejores versiones de la fila de
los lenguajes de programación C, con un método sencillo de entendimiento, básicamente esa es
una característica suya así como su mejora a través de sus versiones con los siguientes años
• docs.microsoft.com
• ecured.cu
• campusmup.es
Bibliografía