Ten wpis to roadmapa dalszego rozwoju! C# to tylko początek - teraz możesz tworzyć web apps (ASP.NET Core), aplikacje mobilne (MAUI), frontendowe aplikacje (Blazor), AI/ML (ML.NET), i cloud-native solutions!

Co to ASP.NET Core?

// ASP.NET Core - framework do web development
// - REST APIs
// - MVC web applications
// - Real-time apps (SignalR)
// - gRPC services
// - Minimal APIs

// Minimal API - najszybszy start
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Endpoint
app.MapGet("/api/users/{id}", async (int id, UserService userService) =>
{
    var user = await userService.GetUserAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
});

app.Run();

// To już działająca REST API! ✨

Roadmapa ASP.NET Core

// Level 1: Podstawy (1 miesiąc)
// ✅ Routing, Controllers, Actions
// ✅ Dependency Injection
// ✅ Middleware pipeline
// ✅ Configuration (appsettings.json)
// ✅ Logging

// Level 2: REST APIs (1 miesiąc)
// ✅ CRUD operations
// ✅ Model validation
// ✅ Error handling
// ✅ Authentication (JWT)
// ✅ Authorization (policies)
// ✅ Swagger/OpenAPI

// Level 3: Advanced (1 miesiąc)
// ✅ Entity Framework Core (database)
// ✅ Caching (Redis)
// ✅ Background services
// ✅ Health checks
// ✅ Rate limiting
// ✅ Docker deployment

// Przykładowy projekt: Blog API
// - User registration/login (JWT)
// - CRUD posts, comments
// - Image upload
// - Pagination, filtering
// - Admin panel

Co to Entity Framework Core?

// Entity Framework Core - ORM (Object-Relational Mapper)
// Pracujesz z C# obiektami, nie SQL!

// Model
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public List<Order> Orders { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public decimal Total { get; set; }
    public int UserId { get; set; }
    public User User { get; set; }
}

// DbContext
public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }
}

// Query - LINQ, nie SQL!
var users = await dbContext.Users
    .Where(u => u.Orders.Count > 5)
    .OrderByDescending(u => u.Orders.Sum(o => o.Total))
    .Take(10)
    .ToListAsync();

// EF Core generuje SQL automatycznie! ✨

Roadmapa EF Core

// Level 1: Podstawy (2 tygodnie)
// ✅ DbContext, DbSet
// ✅ CRUD operations
// ✅ Migrations
// ✅ Relationships (1-to-many, many-to-many)

// Level 2: Querying (2 tygodnie)
// ✅ LINQ queries
// ✅ Include/ThenInclude (eager loading)
// ✅ AsNoTracking (read-only queries)
// ✅ Projections (Select)
// ✅ Grouping, aggregations

// Level 3: Advanced (1 miesiąc)
// ✅ Raw SQL queries
// ✅ Global query filters
// ✅ Owned entities
// ✅ Table splitting
// ✅ Performance optimization
// ✅ Connection resiliency

// Providers:
// - SQL Server
// - PostgreSQL
// - MySQL
// - SQLite
// - InMemory (testing)

Co to Blazor?

// Blazor - frontend w C#, nie JavaScript!
// Dwa tryby:
// 1. Blazor Server - działa na serwerze, SignalR do przeglądarki
// 2. Blazor WebAssembly - działa W PRZEGLĄDARCE (WebAssembly)

// Komponent Blazor (Counter.razor)
@page "/counter"

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}

// C# w przeglądarce! ✨

Blazor vs React/Angular/Vue

// Blazor pros:
// ✅ Jeden język (C#) na frontend i backend
// ✅ Reuse code między serwerem a klientem
// ✅ Silne typowanie (TypeScript isn't enough)
// ✅ Całe .NET ecosystem dostępne
// ✅ Component model podobny do React

// Blazor cons:
// ❌ Mniejsza społeczność niż React/Angular
// ❌ Blazor WASM - większy initial download
// ❌ Mniej third-party componentów

// Blazor WebAssembly bundle size:
// Initial: ~2-3 MB (gzipped)
// React: ~100-200 KB
// Ale: masz CAŁY .NET runtime w przeglądarce!

// Kiedy Blazor?
// ✅ .NET shop (już znasz C#)
// ✅ Internal business apps
// ✅ Full-stack .NET developer
// ✅ Nie chcesz uczyć się JavaScript

Roadmapa Blazor

// Level 1: Podstawy (1 miesiąc)
// ✅ Components, parameters
// ✅ Data binding
// ✅ Event handling
// ✅ Forms, validation
// ✅ Routing

// Level 2: State management (1 miesiąc)
// ✅ Component communication
// ✅ Cascading parameters
// ✅ State containers
// ✅ Local storage
// ✅ HTTP calls do API

// Level 3: Advanced (1 miesiąc)
// ✅ Authentication/Authorization
// ✅ JavaScript interop
// ✅ Component libraries (MudBlazor, Radzen)
// ✅ PWA (Progressive Web App)
// ✅ Performance optimization

// Przykładowy projekt: E-commerce app
// - Product catalog
// - Shopping cart
// - Checkout
// - User authentication
// - Admin panel

Co to .NET MAUI?

// .NET MAUI (Multi-platform App UI)
// Jeden kod → wiele platform:
// - Android
// - iOS
// - macOS
// - Windows

// Przykład: MainPage.xaml.cs
public partial class MainPage : ContentPage
{
    int count = 0;

    public MainPage()
    {
        InitializeComponent();
    }

    private void OnCounterClicked(object sender, EventArgs e)
    {
        count++;
        CounterBtn.Text = $"Clicked {count} times";
    }
}

// Deploy na:
// ✅ Google Play Store
// ✅ Apple App Store
// ✅ Microsoft Store
// ✅ macOS App Store

// Jeden codebase! ✨

MAUI vs Flutter vs React Native

// MAUI pros:
// ✅ Native performance (nie webview)
// ✅ C# i .NET ecosystem
// ✅ Shared code z ASP.NET backend
// ✅ Windows-first support (WinUI 3)

// MAUI cons:
// ❌ Młodszy niż Flutter/React Native (2022)
// ❌ Mniejsza społeczność
// ❌ iOS development wymaga Mac

// MAUI use cases:
// ✅ Business apps (LOB - Line of Business)
// ✅ Internal employee apps
// ✅ .NET developers chcący mobile
// ✅ Cross-platform desktop apps

// MAUI NIE dla:
// ❌ High-performance games (użyj Unity z C#)
// ❌ Consumer apps z milionami użytkowników (Flutter/React Native bezpieczniejsze)

Co to ML.NET?

// ML.NET - Machine Learning w .NET
// - Classification (spam detection, sentiment analysis)
// - Regression (price prediction)
// - Clustering (customer segmentation)
// - Anomaly detection
// - Recommendation systems

// Przykład: Sentiment analysis
var mlContext = new MLContext();

// Load data
var data = mlContext.Data.LoadFromTextFile<SentimentData>("reviews.csv");

// Train model
var pipeline = mlContext.Transforms.Text
    .FeaturizeText("Features", nameof(SentimentData.Text))
    .Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression());

var model = pipeline.Fit(data);

// Predict
var predictionEngine = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);

var result = predictionEngine.Predict(new SentimentData 
{ 
    Text = "This product is amazing!" 
});

Console.WriteLine($"Sentiment: {(result.Prediction ? "Positive" : "Negative")}");
// Sentiment: Positive ✨

ML.NET vs Python (TensorFlow/PyTorch)

// ML.NET pros:
// ✅ Integration z .NET apps (no separate Python service)
// ✅ Deploy z aplikacją (no Python runtime)
// ✅ Performance (compiled, not interpreted)
// ✅ Strong typing

// ML.NET cons:
// ❌ Mniejsza społeczność niż Python
// ❌ Mniej pre-trained models
// ❌ Research = Python (cutting edge)

// Kiedy ML.NET?
// ✅ Już masz .NET app, chcesz dodać ML
// ✅ Business scenarios (fraud detection, churn prediction)
// ✅ Nie chcesz Python microservice
// ✅ Windows-first deployment

// Kiedy Python?
// ✅ Research, eksperymentowanie
// ✅ Deep learning, computer vision
// ✅ Dostęp do najnowszych modeli
// ✅ Ogromna społeczność, tutorials

Cloud-native technologies

// Cloud-native stack w .NET:

// 1. Containers (Docker)
// Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:8.0
COPY bin/Release/net8.0/publish/ App/
WORKDIR /App
ENTRYPOINT ["dotnet", "MyApp.dll"]

// 2. Kubernetes deployment
// deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:latest

// 3. Service mesh (Dapr)
// Distributed Application Runtime
// - Service discovery
// - Pub/Sub
// - State management
// - Observability

// 4. Serverless (Azure Functions)
[FunctionName("ProcessOrder")]
public async Task Run(
    [QueueTrigger("orders")] Order order,
    ILogger log)
{
    await ProcessOrderAsync(order);
}

// 5. Microservices communication
// - gRPC (high performance)
// - REST APIs
// - Message queues (RabbitMQ, Azure Service Bus)

Cloud providers

// Azure (Microsoft)
// ✅ Best .NET integration
// ✅ Azure App Service (PaaS dla ASP.NET)
// ✅ Azure Functions (serverless)
// ✅ Azure SQL Database
// ✅ Cosmos DB (NoSQL)

// AWS (Amazon)
// ✅ Największy provider
// ✅ Elastic Beanstalk (.NET support)
// ✅ Lambda (.NET runtime)
// ✅ RDS (SQL Server support)

// GCP (Google)
// ✅ Cloud Run (.NET containers)
// ✅ Cloud Functions (.NET support)
// ✅ Kubernetes (GKE)

// Wszystkie wspierają .NET! ✨

Roadmapa Cloud-Native

// Level 1: Containers (1 miesiąc)
// ✅ Docker basics
// ✅ Dockerfile dla .NET apps
// ✅ Docker Compose
// ✅ Container registries

// Level 2: Kubernetes (2 miesiące)
// ✅ Pods, Services, Deployments
// ✅ ConfigMaps, Secrets
// ✅ Ingress, Load balancing
// ✅ Helm charts

// Level 3: Cloud platform (2-3 miesiące)
// ✅ Azure/AWS basics
// ✅ Managed services
// ✅ CI/CD pipelines (GitHub Actions, Azure DevOps)
// ✅ Monitoring (Application Insights, CloudWatch)
// ✅ Cost optimization

📚 Dokumentacja i kursy

👥 Społeczność

🛠️ Narzędzia development

// IDE:
// ✅ Visual Studio (Windows/Mac) - najpotężniejsze
// ✅ Visual Studio Code - lekkie, cross-platform
// ✅ JetBrains Rider - płatne, excellent

// Extensions VS Code:
// - C# Dev Kit
// - IntelliCode
// - GitLens
// - REST Client
// - Thunder Client

// Tools:
// - LINQPad - LINQ playground
// - dotnet CLI - command-line
// - NuGet - package manager
// - Git - version control
// - Docker Desktop
// - Postman/Insomnia - API testing

Junior Developer (0-2 lata)

// Technologie:
✅ C# fundamentals (opanowane w tym kursie!)
✅ ASP.NET Core basics
✅ Entity Framework Core
✅ SQL basics
✅ Git version control
✅ REST API concepts
✅ Unit testing (xUnit)

// Projekty:
📦 TODO List API
📦 Blog/CMS
📦 E-commerce (simple)
📦 Weather app z external API

// Umiejętności:
- Pisać czytelny kod
- Debugować problemy
- Pracować z Git
- Zrozumieć MVC pattern
- Pisać podstawowe testy

Mid Developer (2-4 lata)

// Technologie:
✅ Advanced C# (tego co w kursie!)
✅ Design patterns (SOLID, DDD)
✅ Authentication/Authorization (JWT, OAuth)
✅ Caching (Redis)
✅ Message queues (RabbitMQ)
✅ Docker basics
✅ CI/CD pipelines
✅ Performance optimization

// Projekty:
📦 Microservices architecture
📦 Real-time chat (SignalR)
📦 Payment integration
📦 Multi-tenant SaaS

// Umiejętności:
- Projektować architekturę
- Code reviews
- Mentorować juniorów
- Optymalizować performance
- Pisać maintainable code

Senior Developer (4+ lat)

// Technologie:
✅ System design
✅ Kubernetes
✅ Cloud platforms (Azure/AWS)
✅ Event-driven architecture
✅ Domain-Driven Design
✅ CQRS, Event Sourcing
✅ Performance tuning
✅ Security best practices

// Projekty:
📦 Distributed systems
📦 High-traffic applications
📦 Legacy modernization
📦 Technical leadership

// Umiejętności:
- Architecture decisions
- Technical leadership
- Cross-team collaboration
- Business understanding
- Mentoring team
- Tech stack choices

Specjalizacje

Co osiągnąłeś?

• ✅ Fundamenty C# - zmienne, typy, OOP, kontrola flow
• ✅ Modern syntax - records, pattern matching, init-only, nullable
• ✅ Generics & Collections - List, Dictionary, custom generics
• ✅ LINQ - query data elegancko i wydajnie
• ✅ Async/Await - asynchroniczne programowanie
• ✅ Advanced OOP - abstrakcja, polimorfizm, interfaces
• ✅ Delegates & Events - funkcyjne programowanie
• ✅ Error handling - exceptions, Result pattern
• ✅ Testing - xUnit, mocking, TDD
• ✅ Performance - Span<T>, benchmarking, optimization
• ✅ Ecosystem - JSON, DI, File I/O

Następne kroki

// 🎯 Twój action plan:

// Krok 1: Wybierz ścieżkę (1 dzień)
// Zdecyduj: Backend? Full-stack? Mobile? Cloud?

// Krok 2: Pierwszy projekt (2 tygodnie)
// Zbuduj coś małego z wybranej ścieżki
// Backend: REST API dla TODO list
// Full-stack: Blazor app
// Mobile: MAUI counter app

// Krok 3: Portfolio (1 miesiąc)
// 3-5 projektów na GitHub
// README z opisami
// Live demo jeśli możliwe

// Krok 4: Aplikuj (ongoing)
// Junior positions
// Internships
// Junior/Trainee programs

// Krok 5: Ucz się cały czas
// Czytaj blogi
// Oglądaj conference talks
// Eksperymentuj z new features
// Build, ship, repeat! 🚀

Jeżeli seria wpisów dotycząca C# w 2026 była dla Ciebie pomocna, pozwoliła Ci rozwinąć obecne umiejętności lub dzięki niej nauczyłeś się czegoś nowego... będę wdzięczny za wsparcie w każdej postaci wraz z wiadomością, którą będę miał przyjemność przeczytać.

Z góry dziekuje za każde wsparcie - i pamiętajcie, wpisy były, są i będą za darmo!