C#

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 19

Ministerio de Educación y Ciencias  

Centro Educativo Ñande Roga  

Investigación acerca del lenguaje de programación C#  

Asignatura: ​Algoritmia  

Alumno/a: ​Celeste Arami Ortiz Ramírez  

Curso: ​2°BTI  

Docente: ​Ángel Gaona  


Limpio-Paraguay  

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  

posible aspectos referentes a la arquitectura del computador.  

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  

web XML, componentes distribuidos, aplicaciones cliente-servidor, aplicaciones de base de  

datos y muchas, muchas más cosas. Visual C# proporciona un editor de código avanzado,  

prácticos diseñadores de interfaz de usuario, un depurador integrado y muchas otras herramientas  

que facilitan el desarrollo de aplicaciones basadas en el lenguaje C# y .NET Framework.  

Í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  

el objetivo de permitir a los desarrolladores crear una multitud de aplicaciones ejecutadas  

en .NET ​Framework (​ una tecnología que admite la compilación y ejecución de aplicaciones y  

servicios web XML).  

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  

lenguaje de programación aprenda en poco tiempo a utilizarlo.  

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  

trabajar en C# de forma productiva en un espacio muy corto de tiempo. La sintaxis de C#  

simplifica muchas de las complejidades de C++ y proporciona características eficaces, como  

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  

implementa dores de clases de colecciones definir comportamientos de iteración personalizados  


que son fáciles de usar por el código de cliente. Las expresiones Language-Integrated Query  

(LINQ) convierten la consulta fuertemente tipada en una construcción de lenguaje de primera  

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.  

Además de estos principios básicos orientados a objetos, C# facilita el desarrollo de  

componentes de software mediante varias construcciones de lenguaje innovadoras, incluidas las  

siguientes:  

Signaturas de método encapsulado llamadas delegados, que permiten notificaciones de eventos  

con seguridad de tipos.  


• Propiedades, que actúan como descriptores de acceso para variables miembro privadas.  

• Atributos, que proporcionan metadatos declarativos sobre tipos en tiempo de ejecución.  

• Comentarios de documentación XML insertados  

• Language-Integrated Query (LINQ) que proporciona funcionalidades de consulta  

integradas en diversos orígenes de datos.  

Si tiene que interactuar con otro software de Windows, como objetos COM o archivos DLL  

nativos de Win32, puede hacerlo en C# mediante un proceso denominado "Interoperabilidad". La  

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  

métodos y tipos en un orden en particular. Un archivo de código fuente de C# puede definir  

cualquier número de clases, structs, interfaces y eventos.  

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  

de programación orientado a objetivos.  

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  

polimorfismo y facilita el desarrollo de componentes de software mediante varias construcciones  

de lenguaje innovadoras.  

Anders Hejlsberg que diseñó también los lenguajes Turbo Pascal y Delphi. El C# (pronunciado  

en inglés “C Sharp” o en español “C sostenido”) es un lenguaje de programación orientado a  

objetos. Con este nuevo lenguaje se quiso mejorar con respecto de los dos lenguajes anteriores  

de los que deriva el C, y el C++.  

En julio de 2000, durante la Professional Developers Conference, el lenguaje había sido  

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  

cercano a C++ en su diseño”.  

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  

ambos lenguajes, con implementaciones muy diferentes.  

Además, C# ha añadido varias características importantes para dar  

cabida a programación de estilo funcional, que  

culmina con las extensiones LINQ con C# 3.0 y el  

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  

ayudar a mejorar la legibilidad y mantenibilidad.  

¿Por qué Microsoft creó otro lenguaje de programación? ¿Era necesario?  

El lenguaje más popular de Microsoft siempre había sido Visual Basic, sobre todo con la versión  

Visual Basic 6.  

Pero Microsoft apostó por crear la plataforma Framework .NET para suplir las carencias y  

desventajas que tenían con VB6.  

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  

programación, desde las aplicaciones de escritorio hasta la creación de videojuegos.  

Cuando se presentó .NET en el 2003, lo hizo junto a un nuevo lenguaje de programación.  

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  

almohadilla (#) también se asemeja  

a una ligadura de los cuatro símbolos “+” (en unacuadrícula de dos en dos), lo que implica que el  

lenguaje es un incremento de C++ tal y como se puede observar en la siguiente imagen.  


El primer lenguaje del cual se confirmaron estas características es el BCPL, creado por Martin  

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  

lenguaje B en C, el cual hereda muchas de las características originales del BCPL.  

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  

liberado 6. Los lenguajes han tomado caminos diferentes, y C# ha experimentado muchísima  

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  

tardaría aún unos cuantos años en salir.  

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  

lado hay que empezar...  

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,  

disponible en inglés y francés).  

• 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  

listas (ListInt?) o convertir a un Objeto para cada operación.  

¡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  

código y la capacidad para poder entenderlo.  

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  

lenguajes seguían una evolución diferente.  

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!  

Yo me atrevería a afirmar que ese momento consolidó a C# como un lenguaje de programación  

realmente formidable. Veamos algunas de sus características principales en esta versión:  

• Propiedades auto-implementadas  

• Tipos anónimos  

• Expresiones de consulta - LINQ  

• 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  

muy bien juntas.  

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  

revolucionario. Microsoft había empezado a allanar el terreno para hacer de C# un lenguaje  

funcional orientado a objetos híbrido.  

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  

como list.Average(). La combinación de expresiones de búsqueda y métodos de extensión hizo  

parecer que las listas de enteros se habían hecho más inteligentes.  

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  

dejase de estar a la sombra de Java y empezó a destacar. Rápidamente el lenguaje se estaba  

convirtiendo en una opción elegante.  

De todos modos, la versión 4 de C# sí introdujo alguna cosas chulas.  

• Tipos dinámicos  

• Argumentos opcionales y con nombre  

• Covarianza y contravarianza genérica  

• Tipos interop embebidos  


Los tipos interop embebidos aliviaron problemas a la hora del despliegue. La covarianza y  

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  

versión 4 de C# la capacidad de anular el compilador al tiparlo en tiempo de compilación. Es  

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  

errores, pero también otorga mucha potencia dentro del lenguaje.  

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  

del lenguaje. Esta es la lista de las características más importantes:  

• Programación asincrónica con Async y Await  

• Atributos Caller info  

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  

repetitivo. Me encanta esta funcionalidad en realidad.  

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  

participante de primera clase. Si ya has gestionado operaciones largas y la implementación de  

páginas web con retro-llamadas, probablemente adores esta funcionalidad.  


C# Versión 6 ​Con las versiones 3 y 5, Microsoft había hecho algunas cosas bastante impresionantes 
en 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  

usuarios del lenguaje de programación. Aquí enumero unas cuantas:  

• Importaciones estáticas (como en Java)  

• Filtros de excepciones  

• Inicializadores de propiedad  

• Miembros con una expresión como cuerpo  

• Propagador null  

• Cadenas interpoladas  

• Operador nameof  

• Inicializador del diccionario  

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  

versión, Microsoft se ha esforzado en eliminar repeticiones en el lenguaje y hacer que el código  

sea más ligero y legible. Así que para los aficionados del código escueto y limpio, esta versión  

del lenguaje fue una gran victoria.  

¡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.  

C# Versión 7 ​Finalmente hemos llegado ya a la versión 7 de C#. Es la versión actual en la fecha 


que se ha  
escrito este artículo. Tiene cosas muy chulas y revolucionarias que ya estaban en el ADN de la  

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  

• Referencias locales y devoluciones  

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  

clave ​out ​y al permitir valores de devolución múltiples vía tuplas.  

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.  

Características ​Estas son solo algunas de las muchas otras 


propiedades que tiene C#:  

• Sintaxis sencilla que facilita al desarrollador la escritura de código.  

• Sistema de tipo unificado, permitiendo realizar operaciones comunes y que los valores de  

todos los tipos se puedan almacenar, transportar y utilizar de manera coherente.  

• Orientación a componentes. Hemos dicho que C# es lenguaje orientado a objetos, pero  

también a componentes porque permite definir propiedades sin necesidad de crear  

métodos o usar eventos sin tratar con punteros a funciones.  

• Espacio de nombres. Se puede aislar o agrupar código mediante  


• Bibliotecas. Todos los compiladores de C# tienen un mínimo de biblioteca de clases  

disponibles para usar.  

• Integración con otros lenguajes.  

• Multi-hilo. En C# puedes dividir el código en múltiples hilos de ejecución, trabajar en  

paralelo y sincronizarlos al final.  


• Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son  

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  

facilidad y es ampliable a tipos definidos por el usuario, la inclusión de un tipo básico  

string para representar cadenas o la distinción de un tipo bool específico para representar  

valores lógicos.  

• Orientación a objetos (OO): Como todo lenguaje de programación de propósito general  

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.  

• Orientación a componentes: La propia sintaxis de C# incluye elementos propios del  

diseño de componentes que otros lenguajes tienen que simular mediante construcciones  

más o menos complejas. Es decir, C# permite definir cómodamente propiedades  

(similares a campos de acceso controlado), eventos (asociación controlada de funciones  


de respuesta a notificaciones) o atributos (información sobre un tipo o sus miembros).  

• Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie  

de restricciones en el uso de las instrucciones de control más comunes.  

Varias características de C# ayudan en la construcción de aplicaciones sólidas y duraderas:  

Recolección de elementos automáticamente reclama la memoria ocupada por objetos no  

utilizados; control de excepciones proporciona un enfoque estructurado y extensible para la  

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  

para realizar la existencia de las conversiones de tipo.  

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í  

como almacenamiento en línea de estructuras ligeras.  

Para asegurarse de que los programas de C# y las bibliotecas pueden evolucionar con el tiempo  

de manera compatible, se ha puesto mucho énfasis en versiones en diseño de C#. Muchos  

lenguajes de programación prestan poca atención a este problema y, como resultado, los  

programas escritos en dichos lenguajes se interrumpen con más frecuencia de lo necesario  

cuando se introducen nuevas versiones de las bibliotecas dependientes. Aspectos de diseño de C#  

afectados directamente por las consideraciones de versionamiento incluyen  

los virtual y override modificadores, las reglas de resolución de sobrecarga del método y  

soporte técnico para las declaraciones de miembro de interfaz explícita.  

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  

afecten a la otra (excepto en el caso de las variables de parámetro ref y out).  

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  

de matriz, y tipos de delegado.  

Visual C# ​El lenguaje Visual C# es actualmente uno de los lenguajes de programación más 
populares, ya  

que es un lenguaje de para el desarrollo de sistemas d el propósito general. En los últimos  

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  

Microsoft.Net se trata de un entorno de desarrollo metalenguaje diseñado por Microsoft para  


simplificar la construcción, distribución y ejecución de aplicaciones para Internet. Tiene  

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  

pueden escribir tanto programas convencionales como para Internet.  

El paquete .TEN incluye un compilador (programa traductor= de C# que produce un código  

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  

que produce código correspondiente a un único lenguaje: MIL.  

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  

compiladores JI (Justa in Time: al instante).  

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  

avanzados por considerarlo "un lenguaje para principiantes".  

Visual Studio  
Es un conjunto de herramientas y otras tecnologías de desarrollo de software basado en  

componentes para crear aplicaciones eficaces y de alto rendimiento, permitiendo a los  


desarrolladores crear sitios y aplicaciones web, así como otros servicios web en cualquier  

entorno que soporte la plataforma.  

En palabras más específicas, Visual Studio es un conjunto completo de herramientas de  

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  

desarrollo de aplicaciones web ASP y Servicios Web XML.  


Conclusión  

Los lenguajes de programación son sumamente importantes a la hora de hablar de programación,  

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  

luego de su primer lanzamiento.  


Anexos  

Origen del C#  


Logo del lenguaje C#  

Logo del Visual C#  


Web grafía  

• ​docs.microsoft.com  

• ​ecured.cu  

• ​campusmup.es  

Bibliografía  

• ​Enciclopedia de la Micro Computación.  

También podría gustarte