Wie wird in .NET MAUI eine Navigation mit mehreren Seiten und Flyout-Menü implementiert?

Die Struktur einer .NET MAUI-Anwendung beginnt häufig mit der Definition der Hauptseite in der App.xaml.cs, wo die Eigenschaft MainPage auf eine Instanz von AppShell gesetzt wird. AppShell dient als zentrales Navigationsgerüst und kann durch das Hinzufügen mehrerer Inhaltsseiten die Benutzerführung der App organisieren. Wird im Shell jedoch nur eine einzige Inhaltsseite definiert, bleibt die Navigation unsichtbar, da mindestens zwei Shell-Content-Elemente erforderlich sind, um Navigationsoptionen im Flyout anzuzeigen.

Um ein intuitives und visuell ansprechendes Flyout-Menü zu realisieren, müssen zunächst geeignete Icons in das Projekt eingebunden werden. Dies erfolgt durch das Einfügen von Bilddateien in den Ressourcenordner unter Resources/Images. Diese Icons können anschließend im AppShell.xaml als Symbole für die Flyout-Elemente verwendet werden. Das Flyout selbst wird durch Setzen entsprechender Eigenschaften wie FlyoutBehavior auf Flyout aktiviert, während Designaspekte wie Hintergrundfarben das visuelle Erlebnis verbessern.

Die Erweiterung der App mit weiteren ContentPages erfolgt durch das Hinzufügen neuer XAML-Seiten im Projekt, beispielsweise CategoriesPage.xaml, EmployeesPage.xaml oder CustomersPage.xaml. Jede dieser Seiten erhält einen eigenen Titel und individuelle Inhalte, die über XAML definiert werden. Die Bearbeitung erfolgt im Quelltext, da Visual Studio 2022 noch keine grafische Designansicht für MAUI XAML anbietet. Die Integration von Steuerelementen, wie Buttons, geschieht über Drag & Drop aus der Toolbox oder direkt im XAML-Code.

Bei der Entwicklung sollte beachtet werden, dass beim Einsatz von Emulatoren oder Simulatoren ältere App-Versionen noch im Hintergrund laufen können. Es ist daher ratsam, die vollständige Bereitstellung der neuen Version abzuwarten, was durch Statusanzeigen in Visual Studio angezeigt wird.

Wichtig ist das Verständnis, dass AppShell als zentrales Navigationselement nicht nur die visuelle Navigation steuert, sondern auch die Interaktion zwischen den einzelnen Seiten orchestriert. Die richtige Konfiguration der Shell-Elemente ist essenziell, um ein konsistentes und benutzerfreundliches Navigationssystem zu gewährleisten. Darüber hinaus sorgt die Verwendung von XAML und MVVM-Architekturen für eine klare Trennung von Design und Logik, was die Wartbarkeit und Erweiterbarkeit der Anwendung verbessert.

Das Zusammenspiel von Ressourcenmanagement, Navigation und Event-Handling bildet die Grundlage für die Erstellung moderner, responsiver Anwendungen mit .NET MAUI. Für den Leser ist es entscheidend, diese Zusammenhänge nicht isoliert, sondern im Kontext des gesamten App-Designs zu sehen, um robuste und intuitive Benutzeroberflächen zu entwickeln.

Wie man eine Azure SQL-Datenbank mit Visual Studio und Docker verwaltet

Um mit einer Azure SQL-Datenbank zu arbeiten, gibt es mehrere mögliche Ansätze, je nach den verfügbaren Ressourcen und Präferenzen des Entwicklers. Einer der einfachsten Wege, eine Verbindung zu einer Azure SQL-Datenbank herzustellen, besteht darin, Visual Studio zu verwenden. In diesem Abschnitt wird beschrieben, wie man eine Azure SQL-Datenbank in Visual Studio verbindet und wie man Daten mit Transact-SQL (T-SQL) verwaltet.

Zunächst benötigen Sie eine gültige Verbindung zu einer Azure SQL-Datenbank. Dazu müssen Sie im Verbindungshinweis den Servernamen und die erforderlichen Zugangsdaten korrekt eingeben. Beispielhafte Verbindungszeichenfolgen sind wie folgt:

pgsql
Copy code
Server=tcp:apps-services-net7.database.windows.net,1433;

Initial Catalog=Northwind;
Persist Security Info=False;
User ID=markjprice;
Password={your_password};
MultipleActiveResultSets=False;
Encrypt=True;
TrustServerCertificate=False;
Connection Timeout=30;

Der Servername wird in diesem Fall durch "apps-services-net7" dargestellt, der öffentlich und global eindeutig sein muss. Das bedeutet, dass jeder Entwickler seine eigene, individuelle Serverbezeichnung in der Verbindungszeichenfolge angeben muss.

Nachdem die Verbindungsdetails eingegeben wurden, öffnen Sie Ihr bevorzugtes Datenbanktool. Für Visual Studio 2022 finden Sie dies im Bereich "Server Explorer", während Sie für Windows-Systeme auch das SQL Server Management Studio verwenden können. Falls Sie Visual Studio Code nutzen, benötigen Sie das SQL Server Tool, das durch die mssql-Erweiterung ergänzt werden kann. Dies ist auch für plattformübergreifende Nutzung wichtig, weshalb sich Azure Data Studio als nützlich erweist.

In Visual Studio müssen Sie die Verbindung zur Azure SQL-Datenbank herstellen, indem Sie in der Server Explorer-Ansicht auf „Datenquelle auswählen“ klicken und Microsoft SQL Server als Quelle wählen. Nach dem Verbinden können Sie mit der Erstellung von SQL-Abfragen fortfahren, indem Sie mit der rechten Maustaste auf die Datenquelle klicken und „Neue Abfrage“ wählen.

Azure SQL Edge in Docker

Nicht jeder Entwickler hat Zugang zu einer Windows-Umgebung oder möchte die kostenpflichtigen Azure-Ressourcen nutzen. In diesem Fall kann Azure SQL Edge eine Lösung sein, die lokal auf Docker ausgeführt wird. Azure SQL Edge ist eine minimale Version von SQL Server, die auf Docker betrieben wird und nur den Datenbank-Engine enthält. Es handelt sich dabei um eine plattformübergreifende Lösung, die sowohl auf Linux- als auch Mac- und Windows-Systemen funktioniert.

Um Azure SQL Edge in Docker zu installieren, müssen Sie zunächst Docker auf Ihrem System einrichten. Nachdem Docker installiert ist, können Sie das neueste Container-Image für Azure SQL Edge mit dem folgenden Befehl herunterladen:

bash
Copy code
docker pull mcr.microsoft.com/azure-sql-edge:latest

Nachdem das Image erfolgreich heruntergeladen wurde, starten Sie den Container mit dem Befehl:

bash
Copy code
docker run --cap-add SYS_PTRACE -e 'ACCEPT_EULA=1' -e 'MSSQL_SA_PASSWORD=s3cret-Ninja' -p 1433:1433 --name azuresqledge -d mcr.microsoft.com/azure-sql-edge

Achten Sie darauf, dass das Passwort mindestens 8 Zeichen lang sein muss und Zeichen aus mindestens drei der vier folgenden Gruppen enthalten muss: Großbuchstaben, Kleinbuchstaben, Ziffern und Symbole. Andernfalls kann der Container die SQL Edge Engine nicht einrichten.

Sobald der Container läuft, können Sie über Visual Studio, SQL Server Management Studio oder Azure Data Studio eine Verbindung herstellen und Abfragen ausführen. Um sicherzustellen, dass der Docker-Container läuft, können Sie den Befehl docker ps -a verwenden, um den Status der Container zu prüfen. Wenn der Container ordnungsgemäß läuft, sehen Sie eine entsprechende Ausgabe mit dem Status "Up" und dem externen Port 1433, der mit dem internen Port des Containers verbunden ist.

Transact-SQL und seine Anwendung

Transact-SQL (T-SQL) ist die Erweiterung des SQL-Standards, die speziell von Microsoft für SQL Server entwickelt wurde. T-SQL bietet zusätzliche Funktionen wie Fehlerbehandlung, Variablen und Programmierschleifen, die über den reinen SQL-Standard hinausgehen. In T-SQL sind die Datentypen nicht case-sensitive, was bedeutet, dass int und INT dasselbe sind. Diese Flexibilität gilt auch für SQL-Schlüsselwörter wie SELECT und select.

Die grundlegenden T-SQL-Datentypen umfassen numerische Typen wie int, decimal und money, Zeittypen wie datetime und date, sowie Texttypen wie varchar, nvarchar und text. Darüber hinaus unterstützt T-SQL auch spezielle Typen wie uniqueidentifier und xml, die in speziellen Anwendungsfällen verwendet werden.

Kommentare in T-SQL können auf zwei Arten gemacht werden: Einzeilige Kommentare beginnen mit --, während Blockkommentare mit /* beginnen und mit */ enden. Dies entspricht der Syntax, die auch in anderen Programmiersprachen wie C# verwendet wird.

Variablen werden in T-SQL mit dem Präfix @ deklariert und können mit den Befehlen SET, SELECT oder DECLARE initialisiert werden. Hier ein einfaches Beispiel:

sql
Copy code
DECLARE @WholeNumber INT;  -- Eine Variable deklarieren

SET @WholeNumber = 10;  -- Einen Wert zuweisen

Diese Variablen können dann in SQL-Abfragen verwendet werden, um flexible und dynamische Abfragen zu ermöglichen.

Wie man gRPC in einer .NET-Anwendung mit EF Core und MVC implementiert

Die Entwicklung von effizienten Microservices ist heutzutage ein zentrales Thema in der Softwareentwicklung. Besonders in Umgebungen, die auf schnelle und skalierbare Interaktionen angewiesen sind, bietet gRPC eine hervorragende Möglichkeit, die Kommunikation zwischen Microservices zu optimieren. In diesem Abschnitt werden wir untersuchen, wie man gRPC in einer .NET-Anwendung mit EF Core integriert und einen Microservice aufbaut, der auf eine relationale Datenbank zugreift.

Ein entscheidender Schritt in der Entwicklung eines gRPC-Services besteht darin, zunächst ein .proto-File zu definieren, das als Vertrag zwischen dem Client und dem Server fungiert. Dieses File beschreibt die Datenstrukturen und die Methoden, die der Service bereitstellt. In unserem Beispiel bauen wir einen Service, der Informationen über „Shipper“ aus der Northwind-Datenbank liefert.

Der erste Schritt ist, die .proto-Datei zu erstellen. Dies kann im Visual Studio unter Verwendung des Templates „Protocol Buffer File“ erfolgen. In dieser Datei definieren wir die benötigten Nachrichten und den Service, wie im folgenden Beispiel gezeigt:

proto
Copy code
syntax = "proto3";

option csharp_namespace = "Northwind.Grpc.Service";
package shipper;
service Shipper {
   rpc GetShipper (ShipperRequest) returns (ShipperReply);
}
message ShipperRequest {
   int32 shipperId = 1;
}
message ShipperReply {
   int32 shipperId = 1;
   string companyName = 2;
   string phone = 3;
}

Im nächsten Schritt fügen wir das gRPC-Projekt in das Hauptprojekt ein, das auf die Northwind-Datenbank zugreift. Dazu referenzieren wir das EF Core-Modell, das in einem früheren Kapitel erstellt wurde, und stellen sicher, dass die gRPC-Service-Methoden mit den entsprechenden Datenbankoperationen verbunden sind.

Der Service selbst wird durch die Implementierung einer Klasse ShipperService definiert, die das Interface von gRPC implementiert. Diese Klasse verwendet das Entity Framework (EF) Core, um mit der Datenbank zu interagieren und die erforderlichen Informationen über die „Shipper“ zurückzugeben. Das folgende Beispiel zeigt die Implementierung einer einfachen Methode GetShipper, die einen einzelnen „Shipper“ anhand seiner ID abruft:

csharp
Copy code
public class ShipperService : Shipper.ShipperBase {

   protected readonly ILogger _logger;
   protected readonly NorthwindContext db;
   public ShipperService(ILogger logger, NorthwindContext db) {
       _logger = logger;
       this.db = db;
   }
   public override async Task<ShipperReply> GetShipper(ShipperRequest request, ServerCallContext context) {
       ShipperEntity? shipper = await db.Shippers.FindAsync(request.ShipperId);
       if (shipper == null) {
           return null;
       } else {
           return ToShipperReply(shipper);
       }
   }
   private ShipperReply ToShipperReply(ShipperEntity shipper) {
       return new ShipperReply {
           ShipperId = shipper.ShipperId,
           CompanyName = shipper.CompanyName,
           Phone = shipper.Phone
       };
   }
}

Das Proto-File erzeugt Klassen, die die Nachrichten darstellen, die zwischen dem gRPC-Service und dem Client gesendet werden. Da wir jedoch die Entity-Klassen aus dem EF Core-Modell nicht direkt verwenden können, benötigen wir eine Hilfsmethode wie ToShipperReply, um die Entitäten in die gRPC-Nachrichten umzuwandeln.

Sobald der gRPC-Service definiert ist, wird dieser im Program.cs registriert. In der Konfiguration des HTTP-Pipelines wird ein zusätzlicher Schritt eingefügt, um den ShipperService zu registrieren:

csharp
Copy code
app.MapGrpcService<ShipperService>();

Im nächsten Schritt geht es darum, den gRPC-Client im MVC-Projekt zu integrieren. Der Client stellt eine Verbindung zum gRPC-Service her und kann die Methode GetShipper aufrufen, um die Daten über einen Shipper zu erhalten. Dazu wird die .proto-Datei ebenfalls in das MVC-Projekt eingefügt, und die gRPC-Client-Services werden so konfiguriert, dass sie mit dem Server kommunizieren.

Die Konfiguration des Clients erfolgt wie folgt, wobei der gRPC-Client mit dem entsprechenden Endpunkt auf dem Server verbunden wird:

csharp
Copy code
builder.Services.AddGrpcClient("Shipper", options => {

   options.Address = new Uri("https://localhost:5121");
});

Im HomeController.cs des MVC-Projekts fügen wir dann eine Methode hinzu, um die gRPC-Client-Methoden aufzurufen und die Daten an die View zu übergeben:

csharp
Copy code
public async Task<IActionResult> Index(string name = "Henrietta", int id = 1) {
   try {
       ShipperReply shipperReply = await shipperClient.GetShipperAsync(new ShipperRequest { ShipperId = id });

       ViewData["shipper"] = $"Shipper from gRPC service: ID: {shipperReply.ShipperId}, Name: {shipperReply.CompanyName}, Phone: {shipperReply.Phone}";

   } catch (Exception ex) {
       _logger.LogWarning($"Northwind.Grpc.Service is not responding.");
       ViewData["exception"] = ex.Message;
   }
   return View();
}

Hierbei handelt es sich um eine einfache Implementierung eines gRPC-Clients, der die Daten von einem Microservice abruft und diese im Frontend anzeigt.

Es ist von wesentlicher Bedeutung, dass beim Design von Microservices, insbesondere bei der Integration von gRPC, der Fokus auf Skalierbarkeit und Leistung gelegt wird. Die Verwendung von gRPC statt RESTful-APIs kann die Kommunikation erheblich beschleunigen, insbesondere in hochgradig verteilten Systemen, wo geringe Latenzzeiten und hohe Durchsatzraten entscheidend sind. Darüber hinaus sollte die Architektur von gRPC-Services gut durchdacht sein, um eine effiziente Fehlerbehandlung und Protokollierung zu gewährleisten, wie es im obigen Beispiel durch den Einsatz von ILogger und Fehlerbehandlungsroutinen demonstriert wird.

Es ist ebenfalls wichtig, dass man sich der Unterschiede zwischen den gRPC-Nachrichtentypen und den Entity-Klassen von EF Core bewusst ist. Während Entity-Klassen direkt mit der Datenbank interagieren, sind gRPC-Nachrichtentypen strikt an den Kommunikationsprozess zwischen Client und Server gebunden. Eine ordnungsgemäße Abstraktion und Mapping-Strategie ist notwendig, um fehlerfreie und effiziente Interaktionen zu gewährleisten.