198 lines
10 KiB
Markdown
198 lines
10 KiB
Markdown
|
---
|
||
|
|
title: The C Programming Language
|
||
|
|
localeTitle: El lenguaje de programación C
|
||
|
|
---
|
||
|
|
## Lo esencial
|
||
|
|
|
||
|
|
* Preparar
|
||
|
|
* Su primer programa de C #
|
||
|
|
* Tipos y variables
|
||
|
|
* Declaraciones de control de flujo
|
||
|
|
* Los operadores
|
||
|
|
* Instrumentos de cuerda
|
||
|
|
* Clases, objetos, interfaz y métodos principales
|
||
|
|
* Campos y propiedades
|
||
|
|
* Alcance y modificadores de accesibilidad
|
||
|
|
* Manejo de excepciones
|
||
|
|
|
||
|
|
## Intermedio
|
||
|
|
|
||
|
|
* Genéricos
|
||
|
|
* Eventos, Delegados y Expresiones Lambda.
|
||
|
|
* Marco de la colección
|
||
|
|
* LINQ
|
||
|
|
|
||
|
|
## Avanzado
|
||
|
|
|
||
|
|
* Programación asíncrona (asíncrona y espera)
|
||
|
|
* Biblioteca paralela de tareas
|
||
|
|
|
||
|
|
## ¿Qué hay de nuevo en C # 6?
|
||
|
|
|
||
|
|
* Operador condicional nulo
|
||
|
|
* Inicializadores de propiedad automática
|
||
|
|
* Nombre de Expresiones
|
||
|
|
* Funciones y propiedades corporales de expresión
|
||
|
|
* Otras características
|
||
|
|
|
||
|
|
## Principios orientados a objetos (OOP)
|
||
|
|
|
||
|
|
* Encapsulacion
|
||
|
|
* Abstracción
|
||
|
|
* Herencia
|
||
|
|
* Polimorfismo
|
||
|
|
|
||
|
|
## Principios sólidos
|
||
|
|
|
||
|
|
* Principio de responsabilidad única
|
||
|
|
* Principio cerrado abierto
|
||
|
|
* Principio de sustitución de Liskov
|
||
|
|
* Principio de Segregación de Interfaz
|
||
|
|
* Principio de inversión de dependencia
|
||
|
|
|
||
|
|
## C # Mejores prácticas, patrones de diseño y desarrollo guiado por pruebas (TDD)
|
||
|
|
|
||
|
|
## Preparar
|
||
|
|
|
||
|
|
[LinqPad](http://www.linqpad.net/) es un bloc de notas .NET para probar rápidamente sus fragmentos de código C #. La edición estándar es gratuita y una herramienta perfecta para que los principiantes ejecuten declaraciones de lenguaje, expresiones y programas.
|
||
|
|
|
||
|
|
Alternativamente, también puede descargar [Visual Studio Community 2015,](https://www.visualstudio.com/en-us/products/visual-studio-community-vs.aspx) que es un [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) extensible utilizado por la mayoría de los profesionales para crear aplicaciones empresariales.
|
||
|
|
|
||
|
|
## Su primer programa de C #
|
||
|
|
```
|
||
|
|
//this is the single line comment
|
||
|
|
|
||
|
|
/** This is multiline comment,
|
||
|
|
compiler ignores any code inside comment blocks.
|
||
|
|
**/
|
||
|
|
|
||
|
|
//This is the namespace, part of the standard .NET Framework Class Library
|
||
|
|
using System;
|
||
|
|
// namespace defines the scope of related objects into packages
|
||
|
|
namespace Learning.CSharp
|
||
|
|
{
|
||
|
|
// name of the class, should be same as of .cs file
|
||
|
|
public class Program
|
||
|
|
{
|
||
|
|
//entry point method for console applications
|
||
|
|
public static void Main()
|
||
|
|
{
|
||
|
|
//print lines on console
|
||
|
|
Console.WriteLine("Hello, World!");
|
||
|
|
//Reads the next line of characters from the standard input stream.Most common use is to pause program execution before clearing the console.
|
||
|
|
Console.ReadLine();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
Cada aplicación de consola C # debe tener un [método principal](https://msdn.microsoft.com/en-gb/library/acy3edy3.aspx) que es el punto de entrada del programa.
|
||
|
|
|
||
|
|
Edite [HelloWorld](https://dotnetfiddle.net/kY7QRm) en .NET Fiddle, una herramienta inspirada en [JSFiddle](http://jsfiddle.net) donde puede modificar los fragmentos de código y comprobar la salida por sí mismo. Tenga en cuenta que esto es solo para compartir y probar los fragmentos de código, no para utilizarlos en el desarrollo de aplicaciones.
|
||
|
|
|
||
|
|
Si está utilizando Visual Studio, siga este [tutorial](https://msdn.microsoft.com/en-us/library/k1sx6ed2.aspx) para crear una aplicación de consola y comprender su primer programa de C #.
|
||
|
|
|
||
|
|
## Tipos y variables
|
||
|
|
|
||
|
|
C # es un lenguaje fuertemente tipado. Cada variable tiene un tipo. Cada expresión o declaración se evalúa a un valor. Hay dos tipos de tipos en C #
|
||
|
|
|
||
|
|
* Tipos de valor
|
||
|
|
* Tipos de referencia.
|
||
|
|
|
||
|
|
**Tipos de valor** : las variables que son tipos de valor contienen directamente valores. Al asignar una variable de tipo de valor a otra, se copia el valor contenido.
|
||
|
|
|
||
|
|
[Editar en .NET Fiddle](https://dotnetfiddle.net/JCkTxb)
|
||
|
|
```
|
||
|
|
int a = 10;
|
||
|
|
int b = 20;
|
||
|
|
a=b;
|
||
|
|
Console.WriteLine(a); //prints 20
|
||
|
|
Console.WriteLine(b); //prints 20
|
||
|
|
```
|
||
|
|
|
||
|
|
Tenga en cuenta que en otros idiomas dinámicos esto podría ser diferente, pero en C # siempre es una copia de valor. Cuando se crea el tipo de valor, se crea un único espacio en la [pila](http://gribblelab.org/CBootcamp/7_Memory_Stack_vs_Heap.html#orgheadline2) , que es una estructura de datos "LIFO" (último en entrar, primero en salir). La pila tiene límites de tamaño y las operaciones de memoria son eficientes. Algunos ejemplos de tipos de datos incorporados son `int, float, double, decimal, char and string` .
|
||
|
|
|
||
|
|
Tipo | Ejemplo | Descripción
|
||
|
|
\--------- | -------------------------------------------------- --------------------------- | -------------------------------------------------- -------------------------------------------------- -----------------------------
|
||
|
|
_Entero_ `int fooInt = 7;` | Entero de **32 bits firmado**
|
||
|
|
_Largo_ | `long fooLong = 3000L;` | Entero de **64 bits firmado** . **L se utiliza para especificar que este valor de variable es de tipo long / ulong**
|
||
|
|
_Doble_ | `double fooDouble = 20.99;` | Precisión: **15-16 dígitos.**
|
||
|
|
_Flotar_ `float fooFloat = 314.5f;` | Precisión: **7 dígitos** . **F se utiliza para especificar que este valor de variable es de tipo float**
|
||
|
|
_Decimal_ | `decimal fooDecimal = 23.3m;` | Precisión: **28-29 dígitos.** Su mayor precisión y menor alcance lo hace apropiado para **cálculos financieros y monetarios**
|
||
|
|
_Char_ | `char fooChar = 'Z';` | Un solo **carácter Unicode de 16 bits.**
|
||
|
|
_Booleano_ | `bool fooBoolean = false;` | Booleano - **verdadero y falso**
|
||
|
|
_Cadena_ `string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs);` | **Una cadena de caracteres Unicode.**
|
||
|
|
|
||
|
|
Para obtener una lista completa de todos los tipos de datos incorporados, consulte [aquí](https://msdn.microsoft.com/en-us/library/ms228360)
|
||
|
|
|
||
|
|
[**Tipos de referencia**](https://msdn.microsoft.com/en-us/library/490f96s2.aspx) : las variables de los tipos de referencia almacenan referencias a sus objetos, lo que significa que almacenan la dirección en la ubicación de los datos en la [pila](http://gribblelab.org/CBootcamp/7_Memory_Stack_vs_Heap.html#orgheadline2) , también conocidos como punteros. Los datos reales se almacenan en la memoria del [montón](http://gribblelab.org/CBootcamp/7_Memory_Stack_vs_Heap.html#orgheadline3) . La asignación de un tipo de referencia a otro no copia los datos, en su lugar crea la segunda copia de referencia que apunta a la misma ubicación en el montón.
|
||
|
|
|
||
|
|
En el montón, los objetos se asignan y se desasignan en orden aleatorio, por lo que esto requiere la sobrecarga de administración de memoria y [recolección de basura](https://msdn.microsoft.com/en-us/library/hh156531(v=vs.110) .aspx).
|
||
|
|
|
||
|
|
A menos que escriba [un código inseguro](https://msdn.microsoft.com/en-us/library/t2yzs44b.aspx) o trate con un [código no administrado (](https://msdn.microsoft.com/en-us/library/sd10k43k(v=vs.100) .aspx), no necesita preocuparse por la vida útil de sus ubicaciones de memoria. El compilador .NET y CLR se encargarán de esto, pero aún así es bueno tener esto en cuenta para optimizar el rendimiento de sus aplicaciones.
|
||
|
|
|
||
|
|
Mas informacion [aqui](http://www.c-sharpcorner.com/UploadFile/rmcochran/csharp_memory01122006130034PM/csharp_memory.aspx?ArticleID=9adb0e3c-b3f6-40b5-98b5-413b6d348b91)
|
||
|
|
|
||
|
|
## Declaraciones de control de flujo
|
||
|
|
|
||
|
|
* [Si otra cosa](https://msdn.microsoft.com/en-us/library/5011f09h.aspx) : [Editar en .NET Fiddle](https://dotnetfiddle.net/IFVB33)
|
||
|
|
|
||
|
|
```
|
||
|
|
int myScore = 700;
|
||
|
|
if (myScore == 700)
|
||
|
|
{
|
||
|
|
Console.WriteLine("I get printed on the console");
|
||
|
|
}
|
||
|
|
else if (myScore > 10)
|
||
|
|
{
|
||
|
|
Console.WriteLine("I don't");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Console.WriteLine("I also don't");
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
* [Cambiar](https://msdn.microsoft.com/en-GB/library/06tc147t.aspx) declaración: [Editar en .NET Fiddle](https://dotnetfiddle.net/lPZftO)
|
||
|
|
|
||
|
|
utilizando el sistema;
|
||
|
|
|
||
|
|
programa de clase publica { vacío estático público principal () { int myNumber = 0; interruptor (myNumber) { // Una sección de cambio puede tener más de una etiqueta de caso. caso 0: caso 1: { Console.WriteLine ("Caso 0 o 1"); descanso; }
|
||
|
|
|
||
|
|
```
|
||
|
|
// Most switch sections contain a jump statement, such as a break, goto, or return.;
|
||
|
|
case 2:
|
||
|
|
Console.WriteLine("Case 2");
|
||
|
|
break;
|
||
|
|
// 7 - 4 in the following line evaluates to 3.
|
||
|
|
case 7 - 4:
|
||
|
|
Console.WriteLine("Case 3");
|
||
|
|
break;
|
||
|
|
// If the value of myNumber is not 0, 1, 2, or 3 the
|
||
|
|
//default case is executed.*
|
||
|
|
default:
|
||
|
|
Console.WriteLine("Default case. This is also optional");
|
||
|
|
break; // could also throw new Exception() instead
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
```
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
* [Para](https://msdn.microsoft.com/en-us/library/ch45axte.aspx) & [Foreach](https://msdn.microsoft.com/en-gb/library/ttw7t8t6.aspx) : [Editar en .NET Fiddle](https://dotnetfiddle.net/edxtvq)
|
||
|
|
|
||
|
|
para (int i = 0; i <10; i ++) { Console.WriteLine (i); // imprime 0-9 }
|
||
|
|
|
||
|
|
Console.WriteLine (Environment.NewLine); para (int i = 0; i <= 10; i ++) { Console.WriteLine (i); // imprime 0-10 }
|
||
|
|
|
||
|
|
Console.WriteLine (Environment.NewLine); para (int i = 10 - 1; i> = 0; i--) // bucle de decremento { Console.WriteLine (i); // imprime 9-0 }
|
||
|
|
|
||
|
|
Console.WriteLine (Environment.NewLine); //para (; ; ) { // Todas las expresiones son opcionales. Esta declaración // crea un bucle infinito. \* //
|
||
|
|
}
|
||
|
|
|
||
|
|
* [While](https://msdn.microsoft.com/en-us/library/2aeyhxcd.aspx) & [do-while](https://msdn.microsoft.com/en-us/library/370s1zax.aspx) : [Editar en .NET Fiddle](https://dotnetfiddle.net/O5hOF1)
|
||
|
|
|
||
|
|
// Continuar el ciclo while hasta que el índice sea igual a 10. int i = 0; mientras (i <10) { Console.Write ("While statement"); Console.WriteLine (i); // Escriba el índice en la pantalla. i ++; // Incrementar la variable. }
|
||
|
|
|
||
|
|
número int = 0; // funciona primero, hasta que se cumpla la condición, es decir, termina cuando el número es 4. hacer { Console.WriteLine (número); // imprime el valor de 0-4 numero ++; // Añadir uno al número. } while (número <= 4);
|