C# - Lenguaje de Programación Moderno

Bienvenido al Mundo de C#

Descubre el poder de uno de los lenguajes de programación más populares y versátiles

🚀 Alto Rendimiento

C# ofrece un rendimiento excepcional gracias a su compilación y optimizaciones del runtime de .NET.

🎯 Tipado Fuerte

El sistema de tipos robusto de C# ayuda a prevenir errores en tiempo de compilación.

🌐 Multiplataforma

Desarrolla aplicaciones que funcionen en Windows, macOS, Linux y dispositivos móviles.

💼 Orientado a Objetos

Paradigma de programación moderno con soporte completo para POO y programación funcional.

using System;

class Program 
{
    static void Main(string[] args) 
    {
        Console.WriteLine("¡Hola Mundo desde C#!");
        
        // Ejemplo de LINQ
        var numeros = new[] { 1, 2, 3, 4, 5 };
        var pares = numeros.Where(n => n % 2 == 0);
        
        Console.WriteLine($"Números pares: {string.Join(", ", pares)}");
    }
}
                

Historia de C#

2000 - Los Inicios

Microsoft anuncia C# como parte de su plataforma .NET. Anders Hejlsberg lidera el desarrollo del lenguaje.

2002 - C# 1.0

Primera versión oficial de C# junto con .NET Framework 1.0. Introduce conceptos básicos de POO.

2005 - C# 2.0

Introduce genéricos, tipos parciales, métodos anónimos y tipos nullable.

2007 - C# 3.0

Revolución con LINQ, expresiones lambda, tipos anónimos y métodos de extensión.

2010 - C# 4.0

Introducción de programación dinámica, parámetros opcionales y argumentos nombrados.

2012 - C# 5.0

Async/await revoluciona la programación asíncrona.

2015 - C# 6.0

Nuevas características de sintaxis como string interpolation y null-conditional operators.

2017 - C# 7.0+

Pattern matching, tuplas, deconstrucción y muchas mejoras en la sintaxis.

C# en Videojuegos con Unity

🎮 Unity & C#

La combinación perfecta para el desarrollo de videojuegos

🎯 MonoBehaviour

Clase base para scripts en Unity que proporciona métodos del ciclo de vida del juego.

⚡ Performance

C# ofrece un equilibrio perfecto entre facilidad de uso y rendimiento para juegos.

🌟 Ecosistema

Amplia comunidad y recursos para aprender desarrollo de juegos con Unity.

using UnityEngine;

public class PlayerController : MonoBehaviour 
{
    [SerializeField] private float speed = 5.0f;
    [SerializeField] private float jumpForce = 10.0f;
    
    private Rigidbody2D rb;
    private bool isGrounded;
    
    void Start() 
    {
        rb = GetComponent<Rigidbody2D>();
    }
    
    void Update() 
    {
        // Movimiento horizontal
        float horizontal = Input.GetAxis("Horizontal");
        transform.Translate(Vector3.right * horizontal * speed * Time.deltaTime);
        
        // Salto
        if (Input.GetKeyDown(KeyCode.Space) && isGrounded) 
        {
            rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
        }
    }
    
    void OnCollisionEnter2D(Collision2D collision) 
    {
        if (collision.gameObject.CompareTag("Ground")) 
        {
            isGrounded = true;
        }
    }
}
                

Juegos Famosos Desarrollados con Unity y C#:

Hearthstone - Juego de cartas de Blizzard
Monument Valley - Puzzle game premiado
Ori and the Blind Forest - Plataformas atmosférico
Cities: Skylines - Simulador de construcción de ciudades
Cuphead - Juego de plataformas con arte único

C# + Python en Inteligencia Artificial

🤖 IA con C# y Python

Combinando lo mejor de ambos mundos para proyectos de IA

ML.NET

Framework de Microsoft para machine learning en .NET

Python.NET

Biblioteca que permite usar Python desde C#

TensorFlow.NET

Binding de TensorFlow para C#

Interop Services

Comunicación entre C# y Python via API

Ejemplo usando ML.NET:

using Microsoft.ML;
using Microsoft.ML.Data;

// Modelo de datos
public class HouseData 
{
    [LoadColumn(0)]
    public float Size { get; set; }
    
    [LoadColumn(1)]
    public float Price { get; set; }
}

public class Prediction 
{
    [ColumnName("Score")]
    public float Price { get; set; }
}

// Entrenamiento del modelo
var context = new MLContext();
var data = context.Data.LoadFromTextFile<HouseData>("data.csv", separatorChar: ',');

var pipeline = context.Transforms
    .CopyColumns(outputColumnName: "Label", inputColumnName: "Price")
    .Append(context.Transforms.Categorical.OneHotEncoding("Size"))
    .Append(context.Regression.Trainers.Sdca());

var model = pipeline.Fit(data);
                

Integración con Python:

// Usando Python.NET
using Python.Runtime;

static void Main() 
{
    // Inicializar Python
    PythonEngine.Initialize();
    
    using (Py.GIL()) 
    {
        // Importar módulos de Python
        dynamic np = Py.Import("numpy");
        dynamic sklearn = Py.Import("sklearn.linear_model");
        
        // Crear datos
        var X = np.array(new[,] { {1, 2}, {2, 3}, {3, 4} });
        var y = np.array(new[] { 1, 2, 3 });
        
        // Entrenar modelo
        var model = sklearn.LinearRegression();
        model.fit(X, y);
        
        // Predicción
        var prediction = model.predict(np.array(new[,] { {4, 5} }));
        Console.WriteLine($"Predicción: {prediction}");
    }
}
                

C# con MVC (Model-View-Controller)

🏗️ ASP.NET Core MVC

Desarrollo web robusto y escalable

📋 Modelo (Model)

Representa los datos y la lógica de negocio de la aplicación.

👁️ Vista (View)

Interfaz de usuario que presenta los datos al usuario.

🎮 Controlador (Controller)

Maneja las interacciones del usuario y coordina Model y View.

Ejemplo de Controlador:

using Microsoft.AspNetCore.Mvc;

public class ProductosController : Controller
{
    private readonly IProductService _productService;
    
    public ProductosController(IProductService productService)
    {
        _productService = productService;
    }
    
    // GET: /Productos
    public async Task<IActionResult> Index()
    {
        var productos = await _productService.GetAllAsync();
        return View(productos);
    }
    
    // GET: /Productos/Details/5
    public async Task<IActionResult> Details(int id)
    {
        var producto = await _productService.GetByIdAsync(id);
        if (producto == null)
            return NotFound();
        
        return View(producto);
    }
    
    // POST: /Productos/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(Producto producto)
    {
        if (ModelState.IsValid)
        {
            await _productService.CreateAsync(producto);
            return RedirectToAction(nameof(Index));
        }
        return View(producto);
    }
}
                

Ejemplo de Modelo:

using System.ComponentModel.DataAnnotations;

public class Producto
{
    public int Id { get; set; }
    
    [Required(ErrorMessage = "El nombre es obligatorio")]
    [StringLength(100, ErrorMessage = "Máximo 100 caracteres")]
    public string Nombre { get; set; }
    
    [Required(ErrorMessage = "El precio es obligatorio")]
    [Range(0.01, double.MaxValue, ErrorMessage = "El precio debe ser mayor a 0")]
    public decimal Precio { get; set; }
    
    [StringLength(500, ErrorMessage = "Máximo 500 caracteres")]
    public string Descripcion { get; set; }
    
    public DateTime FechaCreacion { get; set; } = DateTime.Now;
}
                

C# con Blazor

⚡ Blazor

Desarrollo web moderno con C# en el cliente y servidor

Blazor Server

Aplicaciones interactivas ejecutadas en el servidor

Blazor WebAssembly

C# ejecutándose directamente en el navegador

Blazor Hybrid

Aplicaciones nativas con tecnología web

Ejemplo de Componente Blazor:

@page "/contador"
@using System

<h3>Contador</h3>

<p>Valor actual: <strong>@currentCount</strong></p>

<button class="btn btn-primary" @onclick="IncrementCount">
    Incrementar
</button>

<button class="btn btn-secondary" @onclick="DecrementCount">
    Decrementar  
</button>

<button class="btn btn-warning" @onclick="Reset">
    Reiniciar
</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
    
    private void DecrementCount()
    {
        currentCount--;
    }
    
    private void Reset()
    {
        currentCount = 0;
    }
}
                

Componente con Parámetros:

@* TaskItem.razor *@
<div class="task-item @(IsCompleted ? "completed" : "")">
    <input type="checkbox" @bind="IsCompleted" @onchange="OnToggle" />
    <span>@Title</span>
    <button @onclick="OnDelete">Eliminar</button>
</div>

@code {
    [Parameter] public string Title { get; set; } = string.Empty;
    [Parameter] public bool IsCompleted { get; set; }
    [Parameter] public EventCallback<bool> OnToggle { get; set; }
    [Parameter] public EventCallback OnDelete { get; set; }
}

@* Uso del componente *@
<TaskItem Title="Aprender Blazor" 
          IsCompleted="false"
          OnToggle="HandleToggle"
          OnDelete="HandleDelete" />
                

Ventajas de Blazor:

Un solo lenguaje: C# para frontend y backend
Reutilización de código: Compartir lógica entre cliente y servidor
Ecosistema .NET: Acceso a todas las bibliotecas de .NET
Productividad: Desarrollo más rápido para equipos .NET

Contacto

✉️ Hablemos

¿Tienes preguntas o quieres colaborar?

📧 Email

Envíanos un correo a sr.dyaelgm@gmail.com

🐙 GitHub

Explora nuestros proyectos en GitHub