Volver
09/08/2023 09:42

csharp resumido al máximo

C# (pronunciado cii sharp en inglés) es un lenguaje de programación multiparadigma desarrollado y estandarizado por la empresa Microsoft como parte de su plataforma .NET, que después fue aprobado como un estándar por la ECMA (ECMA-334) e ISO (ISO/IEC 23270). C# es uno de los lenguajes de programación diseñados para la infraestructura de lenguaje común, C# combina características de lenguajes como C++ y Java.


ALOJAMIENTO CÓDIGO

using System;

 

class Program {

   static void Main() {

       Console.WriteLine("Hola Mundo");

   }

}

 

ALGUNAS CARACTERISTICAS DE C#


  • Seguridad y Verificación de Tipos: C# incluye características de seguridad de tipos que ayudan a prevenir errores comunes y a garantizar la robustez del código es decir un lenguaje de tipado estático, lo que significa que los tipos de datos deben declararse y se verifican en tiempo de compilación, reduciendo errores y mejorando la robustez del código.
  • Plataforma Integral: C# se integra estrechamente con la plataforma .NET de Microsoft, permitiendo desarrollar aplicaciones para Windows, web, móviles y más. También es el lenguaje principal para el framework de desarrollo de videojuegos Unity.
  • Sintaxis Moderna: C# ofrece una sintaxis clara y concisa, incluyendo características como propiedades automáticas, expresiones lambda y manejo simplificado de excepciones.
  • Recolector de Basura (Garbage Collector): C# gestiona automáticamente la memoria a través del recolector de basura, liberando a los desarrolladores de la responsabilidad de administrar la memoria manualmente.
  • Programación Orientada a Objetos: C# es un lenguaje orientado a objetos, lo que permite organizar el código en clases y objetos reutilizables, facilitando el diseño modular y escalable.
  • Asincronía y Paralelismo: C# proporciona soporte integrado para programación asíncrona y paralela, lo que facilita la escritura de aplicaciones que pueden manejar múltiples tareas concurrentes.
  • LINQ y Consultas Integradas: Language Integrated Query (LINQ) permite realizar consultas y operaciones en colecciones de datos directamente en la sintaxis del lenguaje, mejorando la manipulación de datos.
  • Seguridad y Verificación de Tipos: C# incluye características de seguridad de tipos que ayudan a prevenir errores comunes y a garantizar la robustez del código.
  • Tipo de Dato Nullable: C# permite que los tipos de datos primitivos, como int, float, etc., puedan ser nulos. Se logra mediante el uso de Nullable<T> o simplemente añadiendo un ? después del tipo de dato (por ejemplo, int?).
  • Propiedades Automáticas: C# simplifica la definición de propiedades mediante las propiedades automáticas. Esto permite que la implementación básica del get y set sea manejada automáticamente por el compilador.
  • Gestión de Memoria Controlada: C# utiliza el recolector de basura (garbage collector) para gestionar la memoria, lo que permite a los desarrolladores centrarse en la lógica del programa sin preocuparse por la liberación manual de memoria.
  • LINQ (Language Integrated Query): C# introduce LINQ, que permite realizar consultas directamente en colecciones (listas, matrices, bases de datos, etc.) utilizando una sintaxis similar a SQL.
  • Delegados y Eventos: C# ofrece soporte para delegados y eventos, permitiendo la implementación de patrones de programación orientada a eventos de manera más sencilla y estructurada.
  • Clases Parciales: C# permite dividir la definición de una clase en varias partes, lo que es especialmente útil para separar la generación automática de código (por ejemplo, desde un diseñador visual) y el código personalizado.
  • Async/Await: C# ofrece un enfoque más sencillo para la programación asíncrona mediante las palabras clave async y await. Esto facilita la escritura de código que maneja operaciones asíncronas de manera más legible.
  • Indexadores: Al igual que las propiedades, C# permite definir indexadores que permiten acceder a objetos utilizando una sintaxis similar a la de los arrays.
  • Expresiones Lambda: Las expresiones lambda permiten escribir funciones anónimas de una manera concisa. Son útiles para pasarse como argumentos en métodos o para trabajar con LINQ.
  • Anotaciones y Metadatos: C# permite agregar atributos (anotaciones) a las clases y métodos para proporcionar información adicional a tiempo de ejecución. Esto es útil para tareas como serialización, validación y más.
  • Herencia Múltiple a través de Interfaces: C# no permite la herencia múltiple de clases, pero ofrece la posibilidad de implementar múltiples interfaces en una sola clase para lograr un comportamiento similar.
  • Palabras Clave using y IDisposable: El patrón using en C# permite gestionar automáticamente la liberación de recursos no administrados. La interfaz IDisposable se utiliza para implementar la liberación personalizada de recursos.


OPERADORES


EJEMPLOS



using System;


class Program {

   static void Main() {

       Console.WriteLine("Hola mundo");


       bool condicion = true;

       string resultado = condicion ? "verdadero" : "falso";


       int var = 13;

       var = "trece";


       const string VAR = "PI";


       if (condicion) {

       }


       for (int i = 1; i <= 10; i++) {

           Console.WriteLine(i);

       }


       string[] cars = {"Volvo", "BMW", "Toyota"};

       Console.WriteLine(cars[0]);


       void foo(int arg_1, int arg_2) {

           Console.WriteLine("Función de ejemplo.");

       }


       string query = "SELECT * FROM `tabla` WHERE colum = 1 ORDER BY `colum` DESC LIMIT 1";

       using (SqlConnection connection = new SqlConnection(connectionString)) {

           connection.Open();

           SqlCommand command = new SqlCommand(query, connection);

           SqlDataReader reader = command.ExecuteReader();

           while (reader.Read()) {

               Console.WriteLine(reader["colum"]);

           }

       }

   }

}

 

BUCLES


  1. Bucle for:

for (inicialización; condición; incremento) {

   // Código a repetir

}


  1. Bucle while:

while (condición) {

   // Código a repetir

}


  1. Bucle do-while:

do {

   // Código a repetir

} while (condición);


  1. Bucle foreach (para iterar en colecciones):

foreach (var elemento in coleccion) {

   // Código a repetir con "elemento"

}


  1. Bucle foreach (con indexador):

for (int i = 0; i < coleccion.Length; i++) {

   var elemento = coleccion[i];

   // Código a repetir con "elemento"

}


  1. Bucle foreach (utilizando índice y elemento):

foreach (var (indice, elemento) in coleccion.Select((value, index) => (index, value))) {

   // Código a repetir con "indice" y "elemento"

}

 

CONDICIONALES


  1. Condicional if:

if (condición) {

   // Código a ejecutar si la condición es verdadera

}


  1. Condicional if-else:

if (condición) {

   // Código a ejecutar si la condición es verdadera

} else {

   // Código a ejecutar si la condición es falsa

}


  1. Condicional if-else if-else:

if (condición1) {

   // Código a ejecutar si la condición1 es verdadera

} else if (condición2) {

   // Código a ejecutar si la condición2 es verdadera

} else {

   // Código a ejecutar si ninguna de las condiciones es verdadera

}


  1. Operador ternario (con asignación):

var resultado = (condición) ? valorSiVerdadero : valorSiFalso;


  1. Switch (con casos y default):

switch (variable) {

   case valor1:

       // Código a ejecutar si la variable es igual a valor1

       break;

   case valor2:

       // Código a ejecutar si la variable es igual a valor2

       break;

   default:

       // Código a ejecutar si la variable no coincide con ningún caso

       break;

}

 

FUNCIONES


  1. Función básica sin retorno ni parámetros:

void MiFuncion() {

   // Código de la función

}


  1. Función con retorno y parámetros:

tipoDeRetorno MiFuncion(parametro1, parametro2) {

   // Código de la función

   return valorDeRetorno;

}


  1. Función con parámetros opcionales:

tipoDeRetorno MiFuncion(parametro1, parametro2 = valorPredeterminado) {

   // Código de la función

   return valorDeRetorno;

}


  1. Función con número variable de argumentos:

tipoDeRetorno MiFuncion(params tipo[] argumentos) {

   // Código de la función

   return valorDeRetorno;

}


  1. Función con valor de retorno temprano:

tipoDeRetorno MiFuncion(parametro) {

   if (condición) {

       return valorDeRetorno;

   }

   // Código de la función si la condición es falsa

}


  1. Función con expresión lambda:

tipoDeDelegado MiFuncion = (parametros) => expresion;


  1. Función anónima:

tipoDeDelegado MiFuncion = delegate(parametros) {

   // Código de la función

   return valorDeRetorno;

};


  1. Función con parámetros de salida:

void MiFuncion(parametroEntrada, out parametroSalida) {

   // Código de la función

   parametroSalida = valorDeSalida;

}


  1. Función con delegados como parámetros:

void MiFuncion(Func<tipo1, tipo2, tipoDeRetorno> delegado, parametro1, parametro2) {

   // Código de la función

}

CONSULTAS / DATOS


  1. Consultas SQL con ADO.NET:

using (SqlConnection connection = new SqlConnection(connectionString)) {

   connection.Open();

   string query = "SELECT columna1, columna2 FROM tabla WHERE condicion";

   SqlCommand command = new SqlCommand(query, connection);

   SqlDataReader reader = command.ExecuteReader();

   while (reader.Read()) {

       var columna1 = reader["columna1"];

       var columna2 = reader["columna2"];

       // Trabajar con los valores

   }

}


  1. LINQ to Objects (consulta en colecciones):

var resultados = from elemento in coleccion

                where elemento.Propiedad == valor

                select elemento;


  1. LINQ to Entities (consulta en bases de datos usando Entity Framework):

var resultados = from entidad in dbContext.Tabla

                where entidad.Propiedad == valor

                select entidad;


  1. Métodos de extensión y LINQ (sintaxis fluida):

var resultados = coleccion.Where(elemento => elemento.Propiedad == valor)

                         .Select(elemento => elemento);


  1. Métodos de extensión para manipulación de colecciones:

var resultadoFiltrado = coleccion.Where(condicion);

var resultadoProyectado = coleccion.Select(proyeccion);

var resultadoOrdenado = coleccion.OrderBy(orden);

var resultadoAgrupado = coleccion.GroupBy(clave);


  1. Métodos Find y FindAll (para listas):

var elementoEncontrado = lista.Find(condicion);

var elementosEncontrados = lista.FindAll(condicion);


  1. Consultas con Entity Framework Core (para bases de datos):

var resultados = dbContext.Tabla.Where(entidad => entidad.Propiedad == valor);


  1. Consultas con Dapper (micro ORM para bases de datos):

var resultados = connection.Query<Tipo>("SELECT columna1, columna2 FROM tabla WHERE condicion", new { parametro = valor });

 

REPASANDO COSAS DE C#

  1. Programación Orientada a Objetos (POO): Comprender los conceptos fundamentales de la POO, como clases, objetos, herencia, encapsulación y polimorfismo, para construir estructuras de código reutilizables y mantenibles.
  2. Delegados y Eventos: Aprender cómo utilizar delegados y eventos para implementar patrones de programación orientados a eventos y crear sistemas de manejo de eventos flexibles.
  3. Expresiones Lambda y Funciones Anónimas: Utilizar expresiones lambda y funciones anónimas para escribir código más conciso y funcional, especialmente en contextos como LINQ y manejadores de eventos.
  4. Async/Await y Programación Asíncrona: Entender cómo funciona la programación asíncrona en C# utilizando las palabras clave async y await, permitiendo una mejor gestión de tareas concurrentes sin bloquear hilos.
  5. Manejo de Excepciones: Aprender a manejar las excepciones de manera adecuada para mejorar la robustez y confiabilidad de tus programas, utilizando bloques try, catch, finally, y creando excepciones personalizadas.
  6. Interfases e Interfaces Implícitas: Utilizar interfaces para definir contratos entre clases y permitir la implementación de múltiples comportamientos en diferentes clases.
  7. Propiedades Automáticas y Getters/Setters: Comprender cómo usar propiedades automáticas para simplificar la definición de miembros de clase con acceso controlado.
  8. Namespace y Usings: Organizar el código en espacios de nombres (namespaces) y utilizar declaraciones using para simplificar el acceso a clases y tipos definidos en otros espacios de nombres.
  9. Enums y Tipos Enumerados: Utilizar enumeraciones (enums) para definir conjuntos de valores constantes que pueden representar estados, opciones o categorías.
  10. Preprocesador y Directivas de Compilación: Familiarizarse con las directivas de preprocesador como #define, #if, #else, #endif, etc., para condicionar la compilación del código según diferentes escenarios.
  11. Diseño de Patrones de Software: Aprender sobre patrones de diseño de software como Singleton, Factory, Observer, y más, para mejorar la estructura y mantenibilidad de tu código.
  12. Serialización y Deserialización de Objetos: Comprender cómo convertir objetos en estructuras serializadas (por ejemplo, JSON o XML) y viceversa para intercambio de datos y persistencia.
  13. Propiedades y Campos Constantes: Utilizar campos y propiedades constantes para definir valores que no cambian durante la vida útil de la aplicación.
  14. Coalescencia Nula (Null Coalescing): Emplear el operador ?? para manejar valores nulos de manera más eficiente y segura.
Neftalí Castañeda