Moderne .NET-Entwicklung: Skalierbare Lösungen bauen

Bei vensas bauen wir verlässliche, skalierbare Software. Als Implementierungspartner und Softwareentwicklungsteam für unsere Kunden bringen wir jahrzehntelange praktische Erfahrung in jedes Projekt ein, stets mit Fokus auf Qualität und zukunftsfähige Architektur.

Mit .NET arbeiten wir seit Version 1.0. Wir haben die Plattform durch all ihre Entwicklungsstufen begleitet, aus jedem Paradigmenwechsel gelernt und unsere Architekturansätze entsprechend angepasst.

Erfahrung aus allen .NET-Generationen

Unsere Expertise basiert auf der Entwicklung kommerzieller Software im gesamten .NET-Ökosystem. Auch wenn wir heute keine neuen Systeme mehr mit Legacy-Technologien wie dem .NET Compact Framework (Windows Mobile) oder WCF (.NET Framework) entwickeln, hilft uns diese Erfahrung bis heute, verteilte Architekturen zu verstehen und Altsysteme wirksam zu modernisieren. Dank unserer langjährigen Arbeit mit Xamarin migrieren wir außerdem ältere plattformübergreifende mobile Anwendungen auf das moderne .NET MAUI-Framework.

Heute konzipieren und liefern wir moderne Systeme auf Basis von:

• ASP.NET Core & .NET Core: Entwicklung hochperformanter, plattformübergreifender Webservices und Webanwendungen.
• Entity Framework & ASP.NET Identity: Verwaltung des Datenzugriffs und Absicherung von Anwendungen.
• Semantic Kernel: Integration moderner KI-Funktionen in Unternehmenssoftware.
• .NET MAUI: Bereitstellung nativer Multi-Plattform-App-UIs für iOS, Android, Windows und macOS aus einer einzigen Codebasis.

Unser Architektur-Standard: Clean Architecture und CQRS

Wenn wir den Technologie-Stack für ein neues Projekt selbst entwerfen dürfen, basiert unsere Standardarchitektur auf ASP.NET Core APIs unter Verwendung von Clean Architecture und dem CQRS-Pattern (Command Query Responsibility Segregation).

Clean Architecture stellt sicher, dass unsere zentrale Domänenlogik unabhängig von der Benutzeroberfläche, Datenbanken oder externen Frameworks bleibt. Durch die Kombination mit CQRS trennen wir Leseoperationen (Queries) strikt von Schreiboperationen (Commands).

Diese Trennung ermöglicht es uns, Geschäftsprozesse präziser abzubilden. Unsere Minimal API Endpoints bleiben außergewöhnlich schlank und delegieren die eigentliche Arbeit an dedizierte Handler.

// 1. Das Command definieren
public record CreateOrderCommand(Guid CustomerId, List<OrderItem> Items) : IRequest<Guid>;

// 2. Den Handler implementieren
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
{
    private readonly ApplicationDbContext _dbContext;

    public CreateOrderCommandHandler(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        var order = new Order(request.CustomerId, request.Items);
        _dbContext.Orders.Add(order);
        await _dbContext.SaveChangesAsync(cancellationToken);
        
        return order.Id;
    }
}

// 3. Schlanker API-Endpoint
app.MapPost("/api/orders", async (CreateOrderCommand command, IMediator mediator) => 
{
    var orderId = await mediator.Send(command);
    return Results.Created($"/api/orders/{orderId}", orderId);
});

Typische Enterprise-Probleme und wie wir sie lösen

Für Probleme, die im Enterprise-Umfeld immer wieder auftauchen, haben wir in unseren Projekten erprobte Ansätze entwickelt:

• Resiliente Integrationen mit Polly: Die Integration externer Systeme kann fehlschlagen. Wir setzen auf die IHttpClientFactory in Kombination mit Polly-Policies. Anstelle von einfachen Retries implementieren wir Exponential Backoff mit Jitter und Circuit Breakern. Dies verhindert, dass unsere Systeme sich erholende externe APIs überlasten, und stellt sicher, dass unsere Anwendung auch bei Teilausfällen reaktionsfähig bleibt.
• KI-Integration via Semantic Kernel: Wir nutzen den Semantic Kernel von Microsoft, um LLM-Interaktionen direkt in unseren .NET-Backends zu orchestrieren. In jüngsten Umsetzungen haben wir Chat-Agenten implementiert, die unstrukturierte Geschäftsdokumente verarbeiten und autonom native C#-Plugins aufrufen, um Backend-Workflows auszulösen. So verbinden wir natürliche Sprache sicher mit strukturierten Geschäftsprozessen.
• Asynchrone Daten-Pipelines: Für Projekte, die eine Synchronisation von großen Datenmengen zwischen Systemen erfordern, nutzen wir Hintergrundprozesse mit Hangfire gekoppelt mit den Dokumentendatenbank-Fähigkeiten von MartenDB (auf Basis von PostgreSQL). Dadurch können wir verlässliche, ereignisgesteuerte Datentransfer-Pipelines aufbauen, die asynchron ausgeführt werden, ohne die Workflows der Benutzer zu blockieren.
• Komplexe Dokumentengenerierung: Im Kundenservice und Reklamationsmanagement ist die Generierung dynamischer, markenkonformer PDFs oft zwingend erforderlich. Wir nutzen QuestPDF, um komplexe PDF-Dokumente programmgesteuert direkt aus unserem Backend über eine fließende, deklarative C#-API zu entwerfen und zu generieren. Wartungsanfällige HTML-zu-PDF-Konverter und ihren Mehraufwand sparen wir uns damit.
• Performance- und Speicheroptimierung: Neue Runtime-Funktionen übernehmen wir zeitnah. Durch das Upgrade unserer Services auf .NET 9 und die Vorbereitung auf .NET 10 reduzieren wir aktiv den Speicherbedarf und die Startzeiten unserer Anwendungen. Das verbessert das Nutzererlebnis und senkt spürbar die Cloud-Hosting-Kosten.