Visual Studio

Einführung in die Entwicklungsumgebung

Visual Studio ist eine von Microsoft entwickelte integrierte Entwicklungsumgebung (IDE), die mehrere Programmiersprachen wie C++, C#, VB.NET, Python, JavaScript usw. unterstützt. Geeignet für die Entwicklung von Desktop-Anwendungen, Websites, Cloud-Diensten und mobilen Anwendungen.

Hauptfunktionen

• Code-Editor mit Syntaxhervorhebung, automatischer Vervollständigung und Echtzeit-Fehlermeldungen
• Leistungsstarke Debugging-Tools, die Programme Zeile für Zeile ausführen und den Variablenstatus überprüfen können
• Integrierte Git-Integration für einfache Versionskontrolle
• Unterstützen Sie Unit-Tests und Testmanagement
• Bietet eine Vielzahl von Modulen und Erweiterungen zur Unterstützung unterschiedlicher Entwicklungsanforderungen

Versionsunterschied

• Community：Kostenlose Version, geeignet für einzelne Entwickler, Studenten und kleine Teams
• Professional：Bezahlte Version, geeignet für kleine und mittlere Unternehmen
• Enterprise：Die umfassendsten Funktionen für große Entwicklungsteams und Unternehmen

Plattformunterstützung

Visual Studio unterstützt Windows-Betriebssysteme und Visual Studio für Mac ist für macOS konzipiert.

Häufige Verwendungen

• Entwickeln Sie Windows-Desktopanwendungen (z. B. WinForms, WPF)
• Entwickeln Sie ASP.NET-Websites und APIs
• Entwickeln Sie mobile Apps mit Xamarin oder .NET MAUI
• Schreiben von Spielen (in Verbindung mit der Unity-Engine)
• Entwickeln Sie Azure-Cloud-Dienste und -Anwendungen

Formatierung der Visual Studio-Syntax

1. Code automatisch formatieren

2. Aktivieren Sie die automatische Formatierung

3. Ändern Sie die Formatierungseinstellungen

4. Verwenden Sie Codierungsstilprofile

   [*.cs]
   indent_style = space
   indent_size = 4
   

5. Installieren Sie Erweiterungstools

6. Formatprobleme schnell beheben

7. Zusammenfassung

.NET SDK-Version

Überprüfen Sie das installierte .NET SDK

Sie können die auf Ihrem Computer installierte .NET SDK-Version über das Befehlszeilentool überprüfen:

dotnet --list-sdks

Wenn ein Ergebnis ähnlich dem folgenden angezeigt wird, weist dies auf die installierte SDK-Version hin:

8.0.100 [C:\Program Files\dotnet\sdk]
9.0.100-preview.3.24172.9 [C:\Program Files\dotnet\sdk]

Wenn die Version, die Sie verwenden möchten, nicht angezeigt wird, bedeutet dies, dass sie noch nicht installiert ist.

Laden Sie das .NET SDK herunter und installieren Sie es

1. Gehe zuOffizielle .NET-Downloadseite
2. Wählen Sie die entsprechende Version (z. B. .NET 9) und die Betriebssystemplattform (Windows, macOS, Linux) aus.
3. Laden Sie das Installationsprogramm herunter und führen Sie es aus

Aktivieren Sie Eingabeaufforderungszeichen in Visual Studio

1. Öffnen Sie Visual Studio
2. Klicken Sie auf die Menüspalte:Werkzeuge > Befehlszeile > Zeichen für die Entwickler-Eingabeaufforderung
3. Es öffnet sich ein Eingabeaufforderungsfenster mit dem eingestellten Entwicklungsumgebungspfad, der direkt verwendet werden kann.dotnetBefehl

Wenn diese Option nicht angezeigt wird, können Sie auch im Windows-Startmenü nach „Entwickler-Eingabeaufforderung für VS“ suchen, um sie zu öffnen.

Verwenden Sie das integrierte Terminal von Visual Studio (unterstützt ab 2022).

1. Klicken Sie in Visual Studio auf:Anzeigen > TerminalOder verwenden Sie TastenkombinationenCtrl + `
2. Terminaltyp auswählen (z. B. PowerShell oder CMD)
3. Kann direkt eingegeben werdendotnetBefehl zum Überprüfen oder Betreiben des SDK

C#-Sprache

Sprachmerkmale

• Es wurde von Microsoft entwickelt und ist eine primäre Sprache der .NET-Plattform.
• Unterstützt objektorientierte (OOP), generische (Generics), LINQ und asynchrone Programme (async/await).
• Plattformübergreifend: Kann unter Windows, Linux, macOS bis .NET 6/7/8 ausgeführt werden.

grundlegendes Beispiel

Verwenden des Systems;

Klassenprogramm {
    static void Main() {
        string name = "world";
        Console.WriteLine($"Hallo, {name}!");
    }
}

Häufige Anwendungsbereiche

• Desktop-Anwendung：Windows Forms, WPF
• Webentwicklung：ASP.NET Core (MVC, Blazor, Web API)
• mobile Anwendung：.NET MAUI, Xamarin
• Spieleentwicklung: Unity verwendet C# als Hauptskriptsprache
• Unternehmensanwendungen: ERP, CRM und andere Systeme

Erweiterte Funktionen

• Lambda-Ausdruck:(x, y) => x + y
• LINQ-Abfrage:var q = list.Where(x => x > 10);
• Asynchron:await Task.Delay(1000);
• Nullable-Referenztyp: verbesserte Nullsicherheit.
• Datensatztyp: Wird für unveränderliche Datenmodelle verwendet.

CS8618 Non-Nullable ist nicht initialisiert

Warninhalt

CS8618 bedeutet: am Ende des Konstruktors,Nicht nullbarDie Eigenschaften von sind nicht initialisiert, daher warnt der C#-Compiler, dass dies der Fall sein könntenull。

Beispielfragen

öffentliche Klasse Produkt {
    öffentlicher String Name { get; Satz; } // Warnung CS8618
}

Lösung

Methode 1: Wert im Konstruktor zuweisen (empfohlen)

public class Product {
    public string Name { get; set; }

    public Product(string name) {
        Name = name;
    }
}

Methode 2: Geben Sie den Attributen Standardwerte

public class Product {
    public string Name { get; set; } = string.Empty;
}

Methode 3: Null zulassen

public class Product {
    public string? Name { get; set; }
}

→ Gilt fürNamevernünftigerweise erlaubt seinnullSituation.

Methode 4: VerwendenrequiredModifikatoren (unterstützt von C# 11+)

öffentliche Klasse Produkt {
    öffentliche erforderliche Zeichenfolge Name { get; Satz; }
}

// Der Aufrufer muss initialisiert werden
var p = neues Produkt { Name = „Mobiltelefon“ }; // OK

Anregung

• Wenn das Attribut logischerweise nicht sein darfnull:verwendenKonstrukteuroderrequired。
• Wenn erlaubtnull:Ändern zustring?。
• Wenn Sie nur Warnungen vermeiden möchten, aber kein geschäftliches Bedürfnis haben: geben SieStandardwert(wiestring.Empty）。

.NET-Programme

Konvertieren Sie Float in String, um wissenschaftliche Notation zu vermeiden

Problemstellung

System::String^ tmpStr = "Value: " + someFloat;

Lösung

Beispielprogramm

Verwenden des Namespace-Systems;

Float-Wert = 123456,789f;

// Methode 1: String::Format
String^ tmpStr1 = String::Format("Value: {0:F2}", value); // F2 stellt 2 Nachkommastellen dar
Console::WriteLine(tmpStr1);

// Methode 2: ToString passendes Format
String^ tmpStr2 = "Wert: " + value.ToString("F2");
Console::WriteLine(tmpStr2);

//Methode 3: Mehr Ziffern
String^ tmpStr3 = "Wert: " + value.ToString("F6");
Console::WriteLine(tmpStr3);

Codeanweisungen formatieren

• F2: Festes Dezimalpunktformat, 2 Nachkommastellen
• F6: Festes Dezimalpunktformat, 6 Nachkommastellen
• Wenn Sie Dezimalstellen je nach Bedarf dynamisch festlegen müssen, können Sie Folgendes verwendenF{Ziffern}

.NET und std str transkodieren verstümmelte Zeichen

Grund

In C++/CLI,gcnew System::String(stdStr.c_str())Willestd::string(normalerweiseANSI / UTF-8Kodierung) direkt in .NETSystem::String,UndSystem::StringDie Erwartung istUTF-16。
WennstdStrWenn es Nicht-ASCII-Zeichen enthält (z. B. Chinesisch), werden verstümmelte Zeichen angezeigt.

Lösung 1: Verwendenmarshal_as(Anregung)

Namespace muss in Anführungszeichen gesetzt werden:

#include <msclr/marshal_cppstd.h>
Verwenden des Namensraums msclr::interop;

std::string stdStr = "Chinesischer Test";
System::String^ netStr = Marshal_as<System::String^>(stdStr);

✅ Diese Methode kann UTF-8 / ANSI automatisch korrekt in .NET Unicode konvertieren.

Lösung 2: Wenn Sie sicher sind, dass std::string UTF-8 ist, können Sie es manuell konvertieren

#include <codecvt>
#include <locale>

std::string utf8Str = u8"Chinesischer Test";
std::wstring wideStr = std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>{}.from_bytes(utf8Str);
System::String^ netStr = gcnew System::String(wideStr.c_str());

Lösung 3: Wenn die Quelle iststd::wstring

Wenn die C++-Seite ursprünglich breite Zeichenfolgen verwendet, verwenden Sie diese einfach direkt:

std::wstring wstr = L"Chinesischer Test";
System::String^ netStr = gcnew System::String(wstr.c_str());

Anregung

• wiestd::stringDie Quelle ist UTF-8 (in modernen Systemen üblich) → Verwendungmarshal_asodercodecvt。
• Wenn es sich um eine alte ANSI-Zeichenkodierung handelt (z. B. die lokale Kodierung Big5, Shift-JIS) → wird empfohlen, sie zuerst in C++ in UTF-8 zu konvertieren.
• Verwenden Sie es nicht direktgcnew String(stdStr.c_str()), es sei denn, die Zeichenfolge ist rein englisch.

.NET List

Grundlegende Einführung

In .NET (Sprachen wie C++/CLI, C#, VB.NET usw.)List<T>ist eine generische Sammlungskategorie, Kann jede Art von Daten (T) speichern und eine dynamische Größenänderungsfunktion bereitstellen. es gehört dazuSystem::Collections::GenericNamensraum.

Deklaration und Initialisierung

//Namespace importieren
Verwenden des Namespace-Systems;
unter Verwendung des Namensraums System::Collections::Generic;

int main()
{
    // Eine Liste zum Speichern von int deklarieren
    List<int>^ zahlen = gcnew List<int>();

    // Elemente direkt während der Initialisierung hinzufügen
    List<String^>^ name = gcnew List<String^>({ "Alice", "Bob", "Charlie" });
}

Elemente hinzufügen, entfernen und darauf zugreifen

List<int>^ nums = gcnew List<int>();

//Neues Element hinzufügen
nums->Add(10);
nums->Add(20);
nums->Add(30);

//An angegebener Position einfügen
nums->Insert(1, 15); // 15 an Index 1 einfügen

//Angegebenen Wert entfernen
nums->Remove(20);

//Entferne den angegebenen Index
nums->RemoveAt(0);

// Elemente abrufen
int value = nums[1]; // Holen Sie sich das Element bei Index 1

// Überprüfen Sie, ob es enthält
if (nums->Contains(30))
    Console::WriteLine("Gefunden 30");

// Alle Elemente löschen
nums->Clear();

Traverse-Liste

// for-Schleife
for (int i = 0; i < nums->Count; i++)
{
    Console::WriteLine("{0}th element: {1}", i, nums[i]);
}

// für jede Schleife
für jeden (int n in nums)
{
    Console::WriteLine(n);
}

Gemeinsame Eigenschaften und Methoden

Beispielausgabe

10
15
30

.NET Dictionary

Grundlegende Einführung

In .NET (Sprachen wie C++/CLI, C#, VB.NET usw.)Dictionary<TKey, TValue>ist eine generische Sammlung, Wird zum Speichern von „Schlüssel-Wert-Paaren“ verwendet. Jeder Schlüssel muss eindeutig sein und der Wert muss wiederholbar sein. es gehört dazuSystem::Collections::GenericNamensraum.

Deklaration und Initialisierung

//Namespace importieren
Verwenden des Namespace-Systems;
unter Verwendung des Namensraums System::Collections::Generic;

int main()
{
    //Erstelle ein Wörterbuch mit dem Schlüssel als int und dem Wert als String
    Dictionary<int, String^>^ users = gcnew Dictionary<int, String^>();

    // Direkte Initialisierung
    Benutzer->Add(1, „Alice“);
    Benutzer->Add(2, "Bob");
    Benutzer->Add(3, „Charlie“);

    0 zurückgeben;
}

Elemente hinzufügen, ändern, löschen und darauf zugreifen

Dictionary<String^, int>^ ages = gcnew Dictionary<String^, int>();

//Neues Element hinzufügen
ages->Add("Tom", 25);
ages->Add("Jerry", 30);

//Wert ändern (über Indexer)
alter["Tom"] = 26;

// Hinzufügen oder ändern (wenn der Schlüssel nicht vorhanden ist, wird er automatisch hinzugefügt)
alter["Spike"] = 40;

// Element löschen
ages->Remove("Jerry");

//Auf Elemente zugreifen
if (ages->ContainsKey("Tom"))
{
    Console::WriteLine("Toms Alter ist {0}", ages["Tom"]);
}

// Versuchen Sie, den Wert zu erhalten (Ausnahmen vermeiden)
int Alter;
if (ages->TryGetValue("Spike", Alter))
{
    Console::WriteLine("Spikes Alter ist {0}", age);
}

Traverse-Wörterbuch

Dictionary<int, String^>^ users = gcnew Dictionary<int, String^>();
Benutzer->Add(1, „Alice“);
Benutzer->Add(2, "Bob");
Benutzer->Add(3, „Charlie“);

// KeyValuePair-Schleife verwenden
für jeden (KeyValuePair<int, String^> Eintrag in Benutzer)
{
    Console::WriteLine("Key = {0}, Value = {1}", Entry.Key, Entry.Value);
}

//Nur Schlüssel erhalten
für jeden (int-Schlüssel in Benutzern->Schlüssel)
{
    Console::WriteLine("Key: {0}", key);
}

//Nur Werte abrufen
für jeden (String^ Name in Benutzern->Werte)
{
    Console::WriteLine("Name: {0}", name);
}

Gemeinsame Eigenschaften und Methoden

Beispielausgabe

Schlüssel = 1, Wert = Alice
Schlüssel = 2, Wert = Bob
Schlüssel = 3, Wert = Charlie
Tom ist 26 Jahre alt
Spike ist 40 Jahre alt

Rufen Sie mit .NET C++ die neueste Datei in einem Verzeichnis ab

Einführung

In .NET C++ können Sie verwendenSystem::IONamespaces bieten Funktionen zum Bearbeiten von Dateien und Verzeichnissen. Das Abrufen der neuesten Dateien im Verzeichnis kann durch Lesen aller Dateiinformationen und Vergleichen des letzten Änderungsdatums erreicht werden.

Beispielcode

Hier ist ein vollständiges Beispiel, das zeigt, wie Sie die neueste Datei in einem angegebenen Verzeichnis abrufen:

#include „stdafx.h“
#include <iostream>
#include <cliext/vector>
#include <System.IO>

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::IO;
Verwenden des Namensraums cliext;

int main()
{
    Versuchen Sie es
    {
        //Verzeichnispfad angeben
        String^directoryPath = "C:\\Ihr\\Verzeichnis\\Pfad";

        // Überprüfen Sie, ob das Verzeichnis existiert
        if (!Directory::Exists(directoryPath))
        {
            Console::WriteLine("Verzeichnis existiert nicht: {0}", Verzeichnispfad);
            return -1;
        }

        // Alle Dateien im Verzeichnis abrufen
        Array^ files = Directory::GetFiles(directoryPath);

        // Wenn sich keine Dateien im Verzeichnis befinden
        if (Dateien->Länge == 0)
        {
            Console::WriteLine("Es gibt keine Datei im Verzeichnis.");
            0 zurückgeben;
        }

        // Finde die neueste Datei
        String^ neuesteFile = nullptr;
        DateTime neuesteTime = DateTime::MinValue;

        für jede (String^ Datei in Dateien)
        {
            // Die letzte Änderungszeit der Datei abrufen
            DateTime lastWriteTime = File::GetLastWriteTime(file);

            // Zeit vergleichen und neueste Dateiinformationen aktualisieren
            if (lastWriteTime > neuesteTime)
            {
                neuesteTime = lastWriteTime;
                neuesteDatei = Datei;
            }
        }

        // Die neuesten Dateiinformationen ausgeben
        Console::WriteLine("Neueste Datei: {0}", neuesteDatei);
        Console::WriteLine("Letzte Änderungszeit: {0}", neuesteZeit);
    }
    Catch (Ausnahme^ ex)
    {
        Console::WriteLine("Ein Fehler ist aufgetreten: {0}", ex->Message);
    }

    0 zurückgeben;
}

Code-Erklärung

• Dateiliste abrufen:verwendenDirectory::GetFilesMethode zum Abrufen aller Archivpfade im angegebenen Verzeichnis.
• Holen Sie sich die letzte Änderungszeit:verwendenFile::GetLastWriteTimeMethode zum Abrufen der letzten Änderungszeit jeder Datei.
• Zeit vergleichen:Vergleichen Sie die Änderungszeit jeder Datei mit der aktuell letzten Zeit und aktualisieren Sie die neuesten Dateiinformationen.
• Fehlerbehandlung:verwendentry-catchDer Block fängt potenzielle Ausnahmen ab, z. B. ein Verzeichnis, das nicht existiert oder auf das nicht zugegriffen werden kann.

Anwendungsszenarien

• Dateiverwaltungssystem: Finden Sie schnell die zuletzt hochgeladenen oder geänderten Dateien.
• Protokollanalyse: Wählen Sie automatisch die neuesten Protokolldateien zur Verarbeitung aus.
• Backup-Prüfung: Stellen Sie sicher, dass kürzlich gesicherte Archive den Erwartungen entsprechen.

Dinge zu beachten

• Stellen Sie sicher, dass das Verzeichnis vorhanden ist. Andernfalls muss es im Voraus verarbeitet werden oder der Benutzer muss dazu aufgefordert werden.
• Wenn das Verzeichnis eine große Anzahl von Dateien enthält, kann die Leistung beeinträchtigt sein und es kann eine zusätzliche Optimierung in Betracht gezogen werden.
• Berechtigungsprobleme: Der Benutzer, der das Programm ausführt, muss über die Berechtigung zum Zugriff auf Verzeichnisse und Dateien verfügen.

.NET: System.Reflection

//Definieren Sie eine einfache Beispielklasse
öffentliche Klasse SampleClass {
    öffentlicher String SayHello(Stringname) {
        return $"Hallo, {name}!";
    }
}

// Verwenden Sie Reflection, um Methoden dynamisch aufzurufen
Verwenden des Systems;
Verwenden von System.Reflection;

Klassenprogramm {
    static void Main() {
        //Eine Instanz der SampleClass-Klasse erstellen
        Typ sampleType = typeof(SampleClass);
        object sampleInstance = Activator.CreateInstance(sampleType);

        // Informationen zur SayHello-Methode abrufen
        MethodInfo methodInfo = sampleType.GetMethod("SayHello");

        // Rufen Sie die SayHello-Methode dynamisch auf
        object result = methodInfo.Invoke(sampleInstance, new object[] { "World" });
        Console.WriteLine(result); // Ausgabe: Hallo Welt!
    }
}

System::Management::ManagementClass

verwenden

System::Management::ManagementClassIst eine der Klassen im .NET Framework, die die Arbeit mit Windows Management Instrumentation (WMI) ermöglicht. Es ermöglicht Entwicklern, Systeminformationen wie Hardware, Betriebssystem, Netzwerkeinstellungen usw. zu lesen, zu bearbeiten und zu verwalten.

Namensraum

System::ManagementbefindetSystem.Management.dllIm Namespace müssen Sie eine Referenz hinzufügen, bevor Sie diese Funktion verwenden können.

Häufige Verwendungen

• Alle Netzwerkkarteneinstellungen auflisten (Win32_NetworkAdapterConfiguration)
• Rufen Sie CPU- oder Speicherinformationen ab
• Fragen Sie Informationen zu Diensten, Prozessen, Festplatten, BIOS usw. ab.

Einfaches Beispiel

// C++/CLI-Schreibmethode
Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Management;

int main() {
    versuche es mit {
        ManagementClass^ mc = gcnew ManagementClass("Win32_OperatingSystem");
        für jedes (ManagementObject^ mo in mc->GetInstances()) {
            Console::WriteLine("Betriebssystemname: {0}", mo["Caption"]);
        }
    }
    Catch (Ausnahme^ ex) {
        Console::WriteLine("Error: {0}", ex->Message);
    }
    0 zurückgeben;
}

Häufige Fehler und Fehlerbehebung

• Muss zum Projekt hinzugefügt werdenSystem.Management.dllReferenz.
• Der Benutzer muss über ausreichende Rechte verfügen, um das Programm auszuführen (einige WMI-Abfragen erfordern Administratorrechte).
• Falsche Schreibweisen von WMI-Abfragezeichenfolgen können dazu führenManagementException。

Verwandte Kategorien

• ManagementObject
• ManagementObjectSearcher
• ManagementBaseObject

Beheben Sie den Fehler „Ungültige Klasse“ in Win32_NetworkAdapterConfiguration

Beschreibung des Fehlercodes

• WMI-Klasse nicht registriert
• Das WMI-Repository ist beschädigt
• Das System ist rationalisiert oder einige Komponenten fehlen

Lösungsschritte

net stop winmgmt
winmgmt /resetrepository
net start winmgmt

veranschaulichen

• net stop winmgmt：Stoppen Sie den WMI-Verwaltungsdienst
• winmgmt /resetrepository：Erstellen Sie das WMI-Repository neu, um beschädigte Kategorieinformationen zu reparieren
• net start winmgmt：Starten Sie den WMI-Verwaltungsdienst neu

Nach der Reparatur überprüfen

Get-WmiObject Win32_NetworkAdapterConfiguration

1. Drücken Sie Win + R und geben Sie einwbemtest
2. Klicken Sie auf „Verbinden“ und geben Sie einroot\cimv2und verbinden
3. Klicken Sie auf „Abfrage“ und geben Sie einSELECT * FROM Win32_NetworkAdapterConfiguration

Zusätzliche Vorschläge

• Bitte führen Sie die Eingabeaufforderung als Systemadministrator aus
• Wenn Sie häufig WMI-Probleme haben, können Sie es verwendenDISM /Online /Cleanup-Image /RestoreHealthSystemabbild reparieren
• Bevor Sie das Repository zurücksetzen, schließen Sie bitte die zugehörigen abhängigen Dienste und vermeiden Sie Programme, die WMI verwenden.

.NET C++ liest eine HTML-Tabelle

Überblick

In .NET C++-Projekten (oder häufiger C++/CLI-Projekten) erfordert das Lesen und Parsen von HTML-Tabellen in Dateien normalerweise die Verwendung einer externen HTML-Parsing-Bibliothek, da das Standard-.NET-Framework und C++ selbst nicht über integrierte leistungsstarke HTML-DOM-Parsing-Funktionen verfügen. Eine gängige und effiziente Option besteht darin, eine Bibliothek in C# oder einer anderen .NET-Sprache zu verwenden und dann in C++/CLI darauf zu verweisen.

Für C++/CLI-Projekte ist die Verwendung der praktischste und empfehlenswerteste AnsatzHtml Agility Pack(HAP), ein sehr beliebter .NET-HTML-Parser. Obwohl HAP in C# geschrieben ist, kann es nahtlos als Referenz in jeder .NET-Sprache, einschließlich C++/CLI, verwendet werden.

Schritte zur Verwendung des Html Agility Pack

1. Erstellen Sie ein C++/CLI-Projekt:Stellen Sie sicher, dass es sich bei Ihrem Projekt um ein C++/CLI-Projekt handelt (z. B. CLR-Konsolenanwendung oder Windows Forms-App).
2. Holen Sie sich das HTML Agility Pack:
   • Suchen und installieren Sie über den NuGet-Paketmanager von Visual StudioHtmlAgilityPack。
3. Programmcode-Implementierung (C++/CLI):

Codebeispiel

Das Folgende ist ein C++/CLI-Codeausschnitt, der zeigt, wie man eine lokale HTML-Datei liest und die erste Tabelle darin analysiert (<table>) Inhalt:

#using <System.dll>
#using <System.Xml.dll>
#using <HtmlAgilityPack.dll> // Stellen Sie sicher, dass die Referenz enthalten ist

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::IO;
Verwenden des Namensraums HtmlAgilityPack;

void ParseHtmlTable(String^ filePath)
{
    // Überprüfen Sie, ob die Datei existiert
    if (!File::Exists(filePath))
    {
        Console::WriteLine("Fehler: Datei existiert nicht.");
        zurückkehren;
    }

    // 1. HTML-Datei laden
    HtmlDocument^ doc = gcnew HtmlDocument();
    Versuchen Sie es
    {
        //HTML aus Datei laden
        doc->Load(filePath);
    }
    Catch (Ausnahme^ ex)
    {
        Console::WriteLine("Beim Laden der Datei ist ein Fehler aufgetreten: " + ex->Message);
        zurückkehren;
    }

    // 2. Wählen Sie die erste <Tabelle> Knoten
    HtmlNode^ table = doc->DocumentNode->SelectSingleNode("//table");

    if (Tabelle != nullptr)
    {
        Console::WriteLine("Suchen Sie die HTML-Tabelle und beginnen Sie mit dem Parsen...");

        // 3. Alles auswählen <tr> (Tabellenspalte) Knoten
        HtmlNodeCollection^ rows = table->SelectNodes(".//tr");

        if (Zeilen != nullptr)
        {
            für jede (HtmlNode^ Zeile in Zeilen)
            {
                // 4. Wählen Sie <td> oder <th> (Zellen-)Knoten
                // Verwenden Sie | Operator zur Auswahl von <td> oder <th>
                HtmlNodeCollection^ celles = row->SelectNodes("td | th");

                if (Zellen != nullptr)
                {
                    String^ rowData = "";
                    für jede (HtmlNode^ Zelle in Zellen)
                    {
                        // Den internen Text der Zelle abrufen und die führenden und nachfolgenden Leerzeichen entfernen
                        rowData += cell->InnerText->Trim() + "\t";
                    }
                    Console::WriteLine(rowData);
                }
            }
        }
        sonst
        {
            Console::WriteLine("<tr> Tag nicht in Tabelle gefunden.");
        }
    }
    sonst
    {
        Console::WriteLine("<table>-Tag nicht in der Datei gefunden.");
    }
}

int main(array<String^>^ args)
{
    // Bitte ersetzen Sie „your_html_file.html“ durch Ihren tatsächlichen Dateipfad
    String^ htmlFilePath = "C:\\path\\to\\your_html_file.html";
    ParseHtmlTable(htmlFilePath);
    0 zurückgeben;
}

Erläuterung der wichtigsten technischen Punkte

• C++/CLI：Ermöglicht die Zusammenarbeit von C++-Code mit dem .NET Framework (CLR), das die Grundlage für die Verwendung von C#-Bibliotheken wie HAP bildet.
• Html Agility Pack：Sorgen Sie für KraftXPathUnterstützung.
  • doc->Load(filePath): Lokale HTML-Dateien in die DOM-Struktur von HAP einlesen.
  • SelectSingleNode("//table"): Verwenden Sie den XPath-Ausdruck, um den ersten in der Datei auszuwählen<table>Element.
  • SelectNodes(".//tr"): Wählen Sie den aktuellen Knoten aus (<table>) alles unten<tr>Element.
  • SelectNodes("td | th"):Wählen<tr>Alles unter dem Knoten<td>oder<th>Element.
  • cell->InnerText: Rufen Sie den Klartext des Zelleninhalts ab und HTML-Tags werden automatisch entfernt.
• gcnewUnd^：Dies ist die Syntax, die von C++/CLI zum Erstellen und Verwalten von .NET-Objekten verwendet wird (verwaltet durch den CLR-Garbage-Collection-Mechanismus).

.NET C++ HTTP API-Server

Verwendung der HttpListener-Klasse

HttpListenerMit der Klasse können Sie einen einfachen, selbstgehosteten HTTP-Server in einer C++/CLI-Anwendung erstellen.

Projektanforderungen und -einstellungen

Erstellen Sie ein C++/CLI-Projekt in Visual Studio (z. B. CLR-Konsolenanwendung) und stellen Sie sicher, dass darauf verwiesen wirdSystem.dll。

Codebeispiel

Folgendes wird verwendetHttpListenerC++/CLI-Code zum Erstellen eines einfachen API-Servers und zur Verarbeitung von GET-Anfragen.

#using <System.dll>

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Net;
Verwenden des Namensraums System::Threading::Tasks;
Verwenden des Namensraums System::Text;

// Funktion zur Verarbeitung eingehender HTTP-Anfragen
void HandleRequest(HttpListenerContext^ Kontext)
{
    HttpListenerRequest^ request = context->Request;
    HttpListenerResponse^ Response = context->Response;

    //Standardantworteinstellungen
    Response->ContentType = "application/json; charset=utf-8";
    String^ ResponseString = "";
    Antwort->StatusCode = 200; // Standard ist OK

    // Überprüfen Sie den angeforderten Pfad und die angeforderte Methode
    String^ url = request->RawUrl->ToLower();
    
    if (url == "/api/status" && request->HttpMethod == "GET")
    {
        // GET /api/status-Anfrage verarbeiten
        ResponseString = "{\"Status\": \"Server läuft\", \"Sprache\": \"C++/CLI\"}";
    }
    sonst
    {
        // Andere undefinierte Anfragen bearbeiten
        Antwort->StatusCode = 404; // Nicht gefunden
        ResponseString = "{\"error\": \"404 Not Found\", \"path\": \"" + url + "\"}";
    }

    // String-Antwort in Bytes konvertieren und in den Ausgabestream schreiben
    array<Byte>^ buffer = Encoding::UTF8->GetBytes(responseString);
    Antwort->ContentLength64 = buffer->Length;
    
    Versuchen Sie es
    {
        Antwort->OutputStream->Write(buffer, 0, buffer->Length);
        Antwort->OutputStream->Close();
    }
    Catch (Ausnahme^)
    {
        // Schreibfehler ignorieren, normalerweise trennt der Client die Verbindung
    }
}

// Funktion zum Starten von HttpListener
void StartListener(String^ Präfix)
{
    HttpListener^ listener = gcnew HttpListener();
    
    Versuchen Sie es
    {
        listener->Präfixe->Add(prefix);
        listener->Start();
        Console::WriteLine("C++/CLI API Server gestartet, überwacht: {0}", Präfix);
    }
    Catch (Ausnahme^ ex)
    {
        Console::WriteLine("Beim Starten von HttpListener ist ein Fehler aufgetreten. Bitte bestätigen Sie, ob die Berechtigung oder Adresse belegt ist.");
        Console::WriteLine("Fehlermeldung: {0}", ex->Message);
        zurückkehren;
    }

    // Asynchrone Schleife, weiterhin Anfragen empfangen
    while (listener->IsListening)
    {
        Versuchen Sie es
        {
            // Synchron auf die nächste Anfrage warten
            HttpListenerContext^ context = listener->GetContext();
            
            // Verwenden Sie Task, um Anforderungen asynchron zu verarbeiten, um das Blockieren von Abhörschleifen zu vermeiden
            Task::Factory->StartNew(gcnew Action<HttpListenerContext^>(&HandleRequest), context);
        }
        Catch (Ausnahme^)
        {
            // Eine Ausnahme wird ausgelöst, wenn der Listener gestoppt wird
            Pause;
        }
    }
    
    if (listener->IsListening)
    {
        listener->Close();
    }
}

int main(array<String^>^ args)
{
    //Legen Sie das URL-Präfix für die Überwachung fest
    // Hinweis: Unter Windows sind möglicherweise Administratorrechte oder die Verwendung von netsh zum Registrieren des URL-Namespace erforderlich.
    String^ listenPrefix = "http://localhost:8080/";
    StartListener(listeningPrefix);
    
    Console::WriteLine("Drücken Sie eine beliebige Taste, um den Server zu beenden...");
    Console::ReadKey(true);
    
    0 zurückgeben;
}

Hinweis zu Ausführungsberechtigungen

Wenn der Code auf Windows-Systemen nicht mit Administratorrechten ausgeführt wird,HttpListenerBeim Abhören eines bestimmten Ports kann eine Ausnahme „Zugriff verweigert“ ausgelöst werden. Mit dem folgenden Befehl können Sie einen URL-Namespace registrieren, um Nicht-Administratorkonten die Ausführung des Servers zu ermöglichen:

netsh http add urlacl url=http://+:8080/ user=Everyone

Inhttp://+:8080/sollte durch das tatsächlich in Ihrem Code verwendete Präfix ersetzt werden.

ASP.NET Core C# HTTP-API-Server

Überblick

In ASP.NET Core ist der Standardprojekttyp zum Erstellen eines HTTP-API-Servers die Web-API. Neueste .NET-Version (.NET 6 und höher) empfohlenMinimal APIsum schnell und einfach API-Endpunkte zu erstellen.

Minimale APIs kombinieren Startlogik (Startup) und Routing-Definitionen (Routing) in einer einzigen Datei mit minimalen Dateien und CodezeilenProgram.csMitte.

Projekteinrichtung (mit CLI)

Um ein neues Minimal-API-Projekt zu erstellen, können Sie die .NET CLI (Command Line Interface) verwenden:

dotnet new web -n MinimalApiServer
cd MinimalApiServer

Programmcode-Beispiel: Program.cs

Das Folgende ist die Kerndatei des Minimal API-ServersProgram.csVollständiger Inhalt. Es definiert den Serverstart, die Middleware und zwei API-Endpunkte (einen GET, einen POST).

// 1. Erstellen Sie eine WebApplication-Instanz (ersetzt die traditionelle Startup-Kategorie)
var builder = WebApplication.CreateBuilder(args);

// 2. Dienst registrieren (Dienstkonfiguration)
//Hier können Sie Datenbankverbindungen, Verifizierungsdienste usw. hinzufügen.
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); // Swagger/OpenAPI-Unterstützung aktivieren

var app = builder.Build();

// 3. Konfigurieren Sie die HTTP-Anforderungspipeline (Middleware-Konfiguration)

// Aktivieren Sie in der Entwicklungsumgebung die Swagger-Benutzeroberfläche zum Testen
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// HTTPS-Umleitung aktivieren (empfohlen für Produktionsumgebungen)
// app.UseHttpsRedirection();

// 4. API-Endpunkt definieren (Endpunktdefinition)
// Entitätsklasse, die für POST-Anfragen verwendet wird
Public Record Product(int Id, string Name, decimal Price);

// GET-Anforderungsendpunkt: /api/hello
app.MapGet("/api/hello", () =>
{
    return Results.Ok(new { message = "Hallo von der ASP.NET Core Minimal API!", timestamp = DateTime.Now });
});

// GET-Anfrageendpunkt: /api/products/{id}
app.MapGet("/api/products/{id}", (int id) =>
{
    // Angenommen, Produkte aus der Datenbank abzufragen
    if (id == 1)
    {
        return Results.Ok(new Product(1, "laptop", 1200.00m));
    }
    return Results.NotFound(new { error = $"Produkt-ID {id} nicht gefunden" });
});

// POST-Anfrageendpunkt: /api/products
app.MapPost("/api/products", (Produktprodukt) =>
{
    // ASP.NET Core deserialisiert den JSON-Anfragetext automatisch in eine Produktentität
    Console.WriteLine($"Neues Produkt erhalten: {product.Name} (ID: {product.Id})");
    
    //In der tatsächlichen Anwendung wird hier der Datenbank-Hinzufügungsvorgang ausgeführt.
    //Return 201 Statuscode erstellt
    return Results.Created($"/api/products/{product.Id}", product);
});

// 5. Starten Sie die Anwendung und beginnen Sie mit der Überwachung auf HTTP-Anfragen
app.Run();

Ausführung und Prüfung

1. Führen Sie den Server aus:Im Projektverzeichnis ausführendotnet run。
2. Testendpunkt:Server werden normalerweise standardmäßig verwendethttp://localhost:5000oderhttps://localhost:7000laufen.
   • Zugriff über einen Browser oder ein Tool wie Postman/api/hello (GET)。
   • Zugang/swaggerPfad zur Anzeige der Swagger-Benutzeroberfläche zum Testen aller definierten API-Endpunkte.

Wichtige technische Punkte

• WebApplication.CreateBuilder(args)：Dies ist der Ausgangspunkt für den Start von ASP.NET Core. Es erstellt Hosts und Builder zum Konfigurieren der Dienste und Middleware der Anwendung.
• app.Services.AddSwaggerGen()：Registrieren Sie sich für unterstützende DiensteSwagger/OpenAPIDateien, was API-Tests und Dateigenerierung erheblich vereinfacht.
• Middleware: app.UseSwagger()、app.UseHttpsRedirection()usw. Diese Komponenten bilden nacheinander die Anforderungsverarbeitungspipeline. Jede Anfrage fließt durch diese Middlewares.
• app.MapGet / app.MapPost：Dies ist die Kernmethode, die in Minimal-APIs zum Definieren der Routing- und Verarbeitungslogik verwendet wird. Sie binden HTTP-Verben an bestimmte URL-Pfade und Lambda-Handlerfunktionen.
• Automatische Modellbindung:existierenapp.MapPostWenn der Client im Beispiel JSON-Daten sendet, konvertiert (deserialisiert) ASP.NET Core diese automatisch in C#.ProductAufzeichnen.

So führen Sie .NET-Programme auf Chromebook aus

1. Führen Sie .NET mit der Linux-Unterstützung des Chromebooks aus

Die meisten modernen Chromebooks unterstützen die Ausführung von Linux-Anwendungen über das Crostini-Projekt.

1. Aktivieren Sie Linux-Funktionen:
   • EingebenEinstellungen > Erweitert > Entwickler > Linux aktivieren (Beta)。
2. Installieren Sie das .NET SDK:
   • Öffnen Sie ein Linux-Terminal und folgen Sie den AnweisungenOffizielle Microsoft-WebsiteInstallationsanleitung.
   • Zum Beispiel:

     sudo apt update
     sudo apt install -y dotnet-sdk-7.0

3. Kompilieren Sie die .NET-Anwendung und führen Sie sie im Terminal aus.

2. Verwenden Sie eine Cloud-Entwicklungsumgebung

Mit der Cloud-Plattform können Sie .NET-Programme auf Ihrem Chromebook ausführen, ohne lokal Software installieren zu müssen.

• Empfohlene Optionen:
  • GitHub Codespaces
  • Visual Studio Code for Web
  • Replit

3. Verwenden Sie Docker-Container, um .NET auszuführen

Chromebooks unterstützen die Verwendung von Containern zum Ausführen von Anwendungen, und Sie können eine .NET-Umgebung über Docker starten.

1. Installieren Sie Docker in einer Linux-Umgebung.
2. Laden Sie das .NET-Container-Image herunter:

   docker pull mcr.microsoft.com/dotnet/runtime:7.0

3. Führen Sie Ihr .NET-Programm in einem Container aus.

4. Nutzen Sie plattformübergreifende Unterstützung

Ab .NET 6 können Anwendungen auf mehreren Plattformen, einschließlich Linux, ausgeführt werden. Kompilieren Sie Ihre App in einem plattformübergreifenden Format und stellen Sie sie auf Chromebooks bereit.

1. Kompilieren Sie Ihre Anwendung auf einem beliebigen Computer:

   dotnet publish -c Release -r linux-x64 --self-contained

2. Übertragen Sie das kompilierte Archiv auf Ihr Chromebook und führen Sie es mit der mitgelieferten Laufzeit aus.

Dinge zu beachten

• Wirksamkeit:.NET-Anwendungen sind auf Chromebooks der unteren Preisklasse möglicherweise langsamer.
• Abhängigkeiten:Anwendungen, die auf Windows-spezifische APIs angewiesen sind, funktionieren möglicherweise nicht ordnungsgemäß.
• Modellunterstützung:Bitte stellen Sie sicher, dass Ihr Chromebook Linux- oder Virtualisierungsfunktionen unterstützt.

.NET-UI-Programmierung

Haupttechnologie

• Windows Forms (WinForms): Ein früheres UI-Framework, einfach und leicht zu erlernen, geeignet für kleine und mittlere Desktop-Anwendungen.
• WPF (Windows Presentation Foundation): Unterstützt Datenbindung, Stile, Animation und XAML-Syntax, geeignet für große Desktop-Anwendungen.
• UWP (Universal Windows Platform): Entwickelt für die Windows 10/11-Plattform und kann auf PC, Tablet, Xbox und anderen Geräten ausgeführt werden.
• MAUI (.NET Multi-platform App UI): Unterstützt die plattformübergreifende (Windows, Android, iOS, macOS) UI-Entwicklung und ist eine weiterentwickelte Version von Xamarin.Forms.
• Blazor (Web UI): Verwenden Sie C#, um die Front-End-Web-Benutzeroberfläche zu schreiben, die auf der Browser- (WebAssembly) oder Serverseite ausgeführt werden kann.

Einfaches WinForms-Beispiel

Verwenden des Systems;
Verwenden von System.Windows.Forms;

öffentliche Klasse MyForm : Form {
    public MyForm() {
        Button btn = new Button();
        btn.Text = "Klick mich";
        btn.Click += (s, e) => MessageBox.Show("Sie haben auf die Schaltfläche geklickt!");
        Controls.Add(btn);
    }

    [STAThread]
    static void Main() {
        Application.EnableVisualStyles();
        Application.Run(new MyForm());
    }
}

Einfaches WPF-Beispiel (XAML + C#)

// MainWindow.xaml
<Window x:Class="WpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        Titel="WPF-Beispiel" Höhe="200" Breite="300">
    <StackPanel>
        <Button Content="Klick mich" Click="Button_Click"/>
    </StackPanel>
</Fenster>

// MainWindow.xaml.cs
private void Button_Click(object sender, RoutedEventArgs e) {
    MessageBox.Show("Sie haben auf die Schaltfläche geklickt!");
}

Einfaches MAUI-Beispiel

// MainPage.xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             x:Class="MyApp.MainPage">
    <VerticalStackLayout Spacing="25" Padding="30">
        <Button Text="Click me" Clicked="OnButtonClicked"/>
    </VerticalStackLayout>
</ContentPage>

// MainPage.xaml.cs
private void OnButtonClicked(object sender, EventArgs e) {
    wait DisplayAlert("Notification", "Sie haben auf die Schaltfläche geklickt!", "OK");
}

Beratung zur Auswahl der UI-Technologie

.NET durchläuft untergeordnete Steuerelemente, um Eigenschaften stapelweise zu ändern

Die folgenden Beispiele zeigen die VerwendungControls->GetEnumerator()Methode zum schrittweisen Durchlaufen aller untergeordneten Steuerelemente in einem .NET-Formular und zum stapelweisen Ändern ihrer Eigenschaften.

Beispielcode:

Verwenden des Systems;
Verwenden von System.Drawing;
Verwenden von System.Windows.Forms;

public class FormExample : Form
{
    öffentliches FormExample()
    {
        //Initialize some controls
        Button button1 = new Button { Text = "Button 1", Location = new Point(10, 10) };
        TextBox textBox1 = new TextBox { Location = new Point(10, 50) };
        
        Controls.Add(button1);
        Controls.Add(textBox1);

        // Verwenden Sie GetEnumerator(), um die Steuerelementeigenschaften zu durchlaufen und zu ändern
        ModifyControls();
    }

    private void ModifyControls()
    {
        var enumerator = Controls.GetEnumerator();
        
        while (enumerator.MoveNext())
        {
            Control control = (Control)enumerator.Current;

            // Einstellungsbeispiel: Hintergrundfarbe aller Controls auf Hellblau setzen
            control.BackColor = Color.LightBlue;
            
            // Wenn das Steuerelement eine TextBox ist, machen Sie es nicht bearbeitbar
            if (Steuerelement ist TextBox)
            {
                control.Enabled = false;
            }
        }
    }
    
    //Starten Sie die Anwendung
    public static void Main()
    {
        Application.Run(new FormExample());
    }
}

veranschaulichen

**GetEnumerator()**: Verwenden Sie die Methode „Controls.GetEnumerator()“, um den Enumerator des Steuerelements abzurufen, sodass alle untergeordneten Steuerelemente durchlaufen werden können.

**Bedingte Änderung**: Ändern Sie in der „while“-Schleife die Eigenschaften jedes „Control“-Objekts, z. B. indem Sie die Hintergrundfarbe auf Hellblau setzen, und nehmen Sie spezifische Änderungen basierend auf dem Steuerelementtyp vor, z. B. indem Sie die „TextBox“ auf nicht bearbeitbar setzen.

**Verwendung**: Diese Methode ist sehr effektiv, wenn Sie Eigenschaften stapelweise ändern müssen, z. B. das Anpassen des UI-Stils oder das Deaktivieren mehrerer Steuerelemente unter bestimmten Umständen.

Ausführungseffekt

Nach der Ausführung ändert sich die Hintergrundfarbe aller Steuerelemente in Hellblau und alle „TextBox“-Steuerelemente werden auf nicht bearbeitbar gesetzt.

.NET MessageBox

1. Grundlegende Syntax und allgemeine Überladung

In C++/CLI,MessageBox::ShowEs handelt sich um eine statische Methode zum Öffnen eines Dialogfelds. Die umfassendste Aufrufmethode umfasst: Nachrichteninhalt, Titel, Schaltflächentyp, Symbol und Standardschaltfläche.

Verwenden des Namensraums System::Windows::Forms;

//Die einfachste Anzeige
MessageBox::Show("Vorgang abgeschlossen");

//Vollständige Parameterversion
DialogResult result = MessageBox::Show(
    „Möchten Sie diese Datei wirklich löschen?“, // Nachrichteninhalt (Text)
    „Löschen bestätigen“, // Fenstertitel (Beschriftung)
    MessageBoxButtons::YesNo, // Tastenkombination
    MessageBoxIcon::Warning, // Eingabeaufforderungssymbol
    MessageBoxDefaultButton::Button2 // Standardmäßig liegt der Fokus auf der zweiten Schaltfläche (Nein)
);

2. Verarbeiten Sie den Rückgabewert (DialogResult)

Muss aktiviert werden, wenn eine Schaltfläche mehrere Optionen enthält, z. B. Ja/Nein oder OK/AbbrechenDialogResultum die nachfolgende Logik zu bestimmen.

if (result == DialogResult::Yes) {
    //Löschlogik ausführen
} sonst {
    //Vorgang abbrechen
}

3. Gemeinsame Aufzählungswertreferenz

4. Fortgeschrittene Technik: Kombinieren Sie std::string oder float

WeilMessageBox::ShowEmpfangen wird .NETSystem::String^Wenn Sie über native C++-Daten verfügen, müssen Sie diese konvertieren.

#include <string>
#include <msclr/marshal_cppstd.h>

// std::string in MessageBox anzeigen
std::string cpp_str = „Kernfehler“;
MessageBox::Show(msclr::interop::marshal_as<System::String^>(cpp_str));

//Float formatieren und anzeigen
float dist = 1,23456f;
MessageBox::Show("Der Abstand ist: " + dist.ToString("F2")); // Anzeige „Der Abstand beträgt: 1,23“

Häufige Fehler und Lösungen

• Mehrdeutiger Anruf: Manchmal verwirrt der Compiler die überladene Version, wenn nur zwei Zeichenfolgen übergeben werden. Es wird empfohlen, sie explizit hinzuzufügenMessageBoxButtons::OK。
• Thread-Problem: MessageBox muss standardmäßig antworten (modal) und blockiert den aktuellen UI-Thread. Stellen Sie sicher, dass Sie Thread-Aufrufe in der Hauptbenutzeroberfläche ausführen, um ein Einfrieren des Bildschirms zu vermeiden.
• Namespace-Konflikt: Bei gleichzeitiger Verwendungusing namespace System;Undusing namespace System::Windows::Forms;, möglicherweise mit anderenMessageBoxDefinitionskonflikt, es wird empfohlen, den vollständigen Namen zu verwendenSystem::Windows::Forms::MessageBox::Show(...)。

Benutzerdefiniertes .NET-Eingabedialogfeld

1. Warum unterstützt MessageBox Edit Box nicht?

System::Windows::Forms::MessageBoxist darauf ausgelegt, „Benachrichtigungen“ oder „Warnungen“ anzuzeigen und Benutzerentscheidungen über Standardschaltflächen einzuholen. Es verfügt nicht über die Funktion, Steuerelemente dynamisch einzufügen. Wenn Sie Text eingeben müssen, ist die Standardmethode die VererbungSystem::Windows::Forms::FormErstellen Sie ein benutzerdefiniertes Dialogfeld.

2. Implementieren Sie eine benutzerdefinierte InputBox

Dies ist eine einfache, wiederverwendbare Kategorie, die Beschriftungen, Textfelder und OK-Schaltflächen enthält.

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Windows::Forms;
Verwenden des Namensraums System::Drawing;

öffentliche Referenzklasse CustomInputBox: öffentliche Form {
öffentlich:
    TextBox^ txtInput;
    Schaltfläche^ btnOK;
    Label^ lblPrompt;

    CustomInputBox(String^ title, String^ prompt) {
        //Grundlegende Eigenschaften des Formulars festlegen
        this->Text = Titel;
        this->Size = System::Drawing::Size(300, 150);
        this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog;
        this->StartPosition = FormStartPosition::CenterParent;
        this->MaximizeBox = false;
        this->MinimizeBox = false;

        // Eingabeaufforderungstext
        lblPrompt = gcnew Label();
        lblPrompt->Text = prompt;
        lblPrompt->Location = Point(15, 15);
        lblPrompt->Size = System::Drawing::Size(250, 20);

        // Eingabefeld
        txtInput = gcnew TextBox();
        txtInput->Location = Point(15, 40);
        txtInput->Size = System::Drawing::Size(250, 20);

        // OK-Taste
        btnOK = gcnew Button();
        btnOK->Text = "OK";
        btnOK->DialogResult = System::Windows::Forms::DialogResult::OK;
        btnOK->Location = Point(190, 75);
        
        // Steuerelemente hinzufügen
        this->Controls->Add(lblPrompt);
        this->Controls->Add(txtInput);
        this->Controls->Add(btnOK);
        
        //Legen Sie die Standardschaltfläche fest (das Drücken der Eingabetaste entspricht dem Klicken auf OK)
        this->AcceptButton = btnOK;
    }
};

3. So rufen Sie das Hauptprogramm auf

verwendenShowDialog()Die Methode öffnet das Fenster im Forced-Response-Modus und prüft, ob der Rückgabewert vorhanden istOK。

void OnButtonClick() {
    CustomInputBox^ ibox = gcnew CustomInputBox("Systemeingabe", "Bitte geben Sie den Dateinamen ein:");
    
    if (ibox->ShowDialog() == System::Windows::Forms::DialogResult::OK) {
        String^ userInput = ibox->txtInput->Text;
        
        if (!String::IsNullOrWhiteSpace(userInput)) {
            // Verarbeite die vom Benutzer eingegebene Zeichenfolge
            MessageBox::Show("Sie haben Folgendes eingegeben: " + userInput);
        }
    }
}

4. Planvergleich

Häufige Fallstricke

• Ressourcenfreigabe: In C++/CLI gibt es zwar GC, für die Form-Klasse wird jedoch die Verwendung empfohlendelete ibox;Oder stellen Sie sicher, dass Ressourcen nach Ablauf des Bereichs ordnungsgemäß freigegeben werden.
• Thread-Sicherheit: Alle UI-Steuervorgänge (einschließlich der Anzeige benutzerdefinierter Dialogfelder) müssen vorhanden seinSTA (Single Thread Apartment)Im Ausführungsthread ausführen, normalerweise im Hauptausführungsthread der Benutzeroberfläche.
• Zwangsreaktion (modal):verwendenShowDialog()stattShow()Dadurch wird sichergestellt, dass der Benutzer das Eingabefenster schließen muss, bevor er das Hauptfenster bedient, und direkt abrufen kannDialogResult。

PictureBox-Rotkreuzfehler

Phänomenbeschreibung

PictureBox zeigt ein rotes Kreuz an, was darauf hinweist, dass dieOnPaintWährend der Ausführung ist eine Ausnahme aufgetreten. Allerdings verschluckt .NET diese Ausnahme standardmäßig und zeigt sie nicht im allgemeinen Protokoll oder an den Unterbrechungspunkten an, was das Debuggen erschwert.

Häufige Ursachen

Vergleich der Fehlermeldungen

Debug-Schritte

Da das Problem des Roten Kreuzes möglicherweise nicht oft auftritt, wird empfohlen, in der folgenden Reihenfolge vorzugehen:

1. Abfangen von OnPaint-Ausnahmen: PictureBox erben, überschreibenOnPaint, Verwenden Sie try/catch, um Ausnahmen abzufangen und auszugebenDebug.WriteLine, nach der Erfassung ausführenthis.Image = nullVermeiden Sie anhaltende rote Kreuze.
2. Ausnahmemeldung bestätigen: Beachten Sie die Meldung im Visual Studio-Ausgabefenster. Sehen Sie sich die Tabelle der Fehlermeldungen oben an, um die Grundursache zu finden.
3. Verfolgen des Bitmap-Lebenszyklus: Jedes Mal, wenn Bitmap entsorgen zugewiesen wird, aufzeichnenEnvironment.StackTraceFinden Sie heraus, wer die Ressource zu welchem ​​Zeitpunkt freigegeben hat.
4. Verhindern Sie die Entsorgung einer Bitmap, die noch verwendet wird: Vor der Entsorgung prüfen Ob die PictureBox noch die Bitmap enthält, wenn ja, zuerstImageAuf null setzen und dann entsorgen.

Sicherer Bildwechselmodus

Alle Bildwechselvorgänge werden in diesem Modus ausgeführt, um die Thread-Sicherheit und die korrekte Entsorgungsreihenfolge zu gewährleisten:

// C++/CLI
void SafeUpdateImage(Bitmap^ newBmp) {
    if (pictureBox1->InvokeRequired) {
        pictureBox1->Invoke(gcnew Action<Bitmap^>(
            this, &YourClass::SafeUpdateImage), newBmp);
        zurückkehren;
    }
    Bitmap^ old = safe_cast<Bitmap^>(pictureBox1->Image);
    pictureBox1->Image = newBmp; // Zuerst zum neuen Bild wechseln
    if (old != nullptr) old->Dispose(); // Altes Bild wieder entsorgen
}

Der richtige Weg, eine Bitmap aus Stream zu erstellen

// Fehler: Bitmap ungültig, nachdem der Stream geschlossen wurde
using (var stream = new FileStream(path, FileMode.Open)) {
    pictureBox1.Image = new Bitmap(stream);
}

// Richtig: Deep Copy, verlässt sich nicht auf Stream
Bitmap geladen;
using (var stream = new FileStream(path, FileMode.Open))
using (var tmp = new Bitmap(stream)) {
    geladen = neue Bitmap(tmp);
}
pictureBox1.Image = geladen;

Checkliste zur Fehlerbehebung

Rufen Sie den Inhalt der Nachricht m in .NET StackTrace ab

Problemhintergrund

Wenn die folgende Fehlermeldung im Stack-Trace angezeigt wird, müssen Entwickler möglicherweise eine Überprüfung durchführenMessageDer Inhalt des Objekts:

   at ....MainForm.Dispose(Boolean A_0)
   at System.Windows.Forms.Form.WmClose(Message& m)
   at System.Windows.Forms.NativeWindow.Callback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)
   ...
    

Zu diesem Zeitpunkt ist ein Überschreiben oder Erkennen erforderlichWndProcin der MethodeMessage mum die Details zu überprüfen.

Lösung

Es gibt verschiedene Möglichkeiten zur Überprüfung oder AufzeichnungMessageDer Inhalt des Objekts.

1. Überschreiben Sie die WndProc-Methode

Wenn Sie Zugriff auf den Quellcode des Formulars oder Steuerelements haben, wird das Überschreiben empfohlenWndProcMethode, direkt aufzeichnen oder prüfenMessage mInhalt.

protected override void WndProc(ref Message m)
{
    Versuchen Sie es
    {
        //Den Inhalt der Nachricht aufzeichnen
        Console.WriteLine($"Nachrichtendetails: hWnd={m.HWnd}, Msg={m.Msg}, WParam={m.WParam}, LParam={m.LParam}");
        base.WndProc(ref m);
    }
    Catch (Ausnahme ex)
    {
        Console.WriteLine($"Exception: {ex}");
        werfen; // Das ursprüngliche Ausnahmeverhalten beibehalten
    }
}
    

Dieser Code protokolliert bei jedem Empfang einer Nachricht relevante Informationen und ermöglicht dem Entwickler eine weitere Analyse.

2. Fügen Sie der Dispose-Methode eine Ausnahmebehandlung hinzu

Wenn der Fehler auftritt inDisposeIn der Methode können Sie eine Ausnahmebehandlung innerhalb der Methode hinzufügen, um relevante Informationen zu überprüfen.

protected override void Dispose(bool disposing)
{
    Versuchen Sie es
    {
        wenn (entsorgen)
        {
            // Ressourcen freigeben
        }
        base.Dispose(entsorgen);
    }
    Catch (Ausnahme ex)
    {
        Console.WriteLine($"Ausnahme in Dispose: {ex}");
        werfen;
    }
}
    

Dadurch wird sichergestellt, dass wichtige Fehlerinformationen beim Freigeben von Ressourcen nicht ignoriert werden.

3. Verwenden Sie die globale Ausnahmebehandlung

Wenn Sie nicht feststellen können, wo der Fehler aufgetreten ist, können Sie die globale Ausnahmebehandlung verwenden, um Stack-Traces und zugehörige Informationen aufzuzeichnen.

AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
    Exception ex = (Exception)args.ExceptionObject;
    Console.WriteLine($"Unhandled Exception: {ex}");
    Environment.Exit(1);
};

    

4. Verwenden Sie das Debug-Tool, um die Nachricht zu überprüfen

Sie können Visual Studio verwenden, um Haltepunkte festzulegenWndProcoderDisposeMethode und ÜberprüfungMessageDer Inhalt des Objekts.

Schlüsseleigenschaften des Message-Objekts

• HWnd: Das Handle des Fensters, das die Nachricht empfängt.
• Msg: ID der Nachricht.
• WParam: Zusätzliche Nachrichteninformationen (Wortparameter).
• LParam: Zusätzliche Nachrichteninformationen (langer Parameter).

Dinge zu beachten

• überschreibenWndProcOder seien Sie vorsichtig, wenn Sie den Code ändern, um eine Beeinträchtigung des vorhandenen Verhaltens zu vermeiden.
• WennMessageDie Koordinaten oder die ID sind nicht festgelegt. Sie können eine bedingte Beurteilung hinzufügen, um die erforderlichen Informationen zu filtern.
• Schauen Sie sich [Windows-Nachrichten an Dokumentation](https://learn.microsoft.com/en-us/windows/win32/winmsg/about-messages-and-message-queues), um den Zweck von Nachrichten-IDs zu verstehen.

Überschreiben von Form.WmClose(Message& m) in .NET C++

Problemhintergrund

In .NET C++/CLI,WmClose(Message& m)JaSystem.Windows.Forms.FormDie interne Schutzmethode kann nicht direkt überschrieben werden. Eine Überschreibung ist jedoch möglichWndProcMethode zum Abfangen und VerarbeitenWM_CLOSENachricht, um eine ähnliche Überschreibung zu erreichenWmCloseWirkung.

Vollständiges Beispiel

#include <Windows.h>
#include <System.Windows.Forms.h>

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Windows::Forms;

öffentliche Referenzklasse CustomForm: öffentliches Formular
{
geschützt:
    // Überschreibung des WmClose-Verhaltens simulieren
    void WmClose(Message% m)
    {
        //Fügen Sie hier ein benutzerdefiniertes WM_CLOSE-Verhalten hinzu
        if (MessageBox::Show("Sind Sie sicher, dass Sie das Fenster schließen möchten?", "Bestätigen", MessageBoxButtons::YesNo) == DialogResult::Yes)
        {
            // Rufen Sie weiterhin das Basisverhalten für ein ordnungsgemäßes Herunterfahren auf
            this->Form::WndProc(m);
        }
        sonst
        {
            // Verhindern, dass das Fenster geschlossen wird
            Rückkehr;
        }
    }

    // WndProc überschreiben, WM_CLOSE-Nachricht abfangen und WmClose aufrufen
    virtuelle Leere WndProc(Message% m) überschreiben
    {
        const int WM_CLOSE = 0x0010;

        if (m.Msg == WM_CLOSE)
        {
            WmClose(m); // Rufen Sie die benutzerdefinierte WmClose-Methode auf
        }
        sonst
        {
            // Andere Nachrichten verarbeiten
            Form::WndProc(m);
        }
    }
};

[STAThread]
int main(array<String^>^ args)
{
    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);

    CustomForm^ form = gcnew CustomForm();
    form->Text = „Beispiel zum Überschreiben des WmClose-Verhaltens“;
    Application::Run(form);

    0 zurückgeben;
}
    

Code-Erklärung

1. WmClose-Methode

Überschreiben simulierenWmCloseMethode zum Anpassen des Fensterschließverhaltens hier. Verwenden Sie ein Bestätigungsdialogfeld, um den Benutzer zu fragen, ob er das Fenster schließen möchte.

2. Überschreiben Sie WndProc

überschreibenWndProcMethode zum AbfangenWM_CLOSENachricht senden und an einen Benutzer delegierenWmCloseVerfahren.

3. Fahren Sie mit der Verarbeitung anderer Nachrichten fort

ohne AbfangenWM_CLOSEIm Falle des Aufrufs der BasisklasseWndProcMethode zur Verarbeitung anderer Nachrichten.

Dinge zu beachten

• WmCloseDie Methode simuliert lediglich ein Überschreiben, verarbeitet die Nachricht jedoch tatsächlich, indem sie sie abfängt.
• AnrufForm::WndProcum sicherzustellen, dass das Basisverhalten ordnungsgemäß funktioniert.
• Bitte achten Sie darauf, Nachrichten korrekt zu behandeln, um andere Funktionen nicht zu beeinträchtigen.

System::Windows::Forms::Control::InvokeRequired

Gebrauchsanweisung

Vollständiges Beispiel: PictureBox-Bilder festlegen

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Windows::Forms;
Verwenden des Namensraums System::Drawing;

Referenzklasse ImageHelper {
öffentlich:
    static void SetImageSafe(PictureBox^ pPictureBox, Bitmap^ b) {
        if (pPictureBox == nullptr)
            Rückkehr;

        if (pPictureBox->InvokeRequired) {
            // Verwenden Sie MethodInvoker, um dieselbe Funktion aufzurufen, aber im UI-Thread auszuführen
            pPictureBox->Invoke(
                gcnew MethodInvoker(gcnew Action(ImageHelper::InvokeCallback), 
                gcnew Tuple(pPictureBox, b))
            );
        } sonst {
            ApplyImage(pPictureBox, b);
        }
    }

privat:
    // Marshalled-Funktions-Proxy
    static void InvokeCallback(Object^ state) {
        Tupel^ args = static_cast^>(Staat);
        ApplyImage(args->Item1, args->Item2);
    }

    // Tatsächliche Ausführung der Einstellungsbildlogik
    static void ApplyImage(PictureBox^ pPictureBox, Bitmap^ b) {
        versuche es mit {
            if (b != nullptr) {
                if (pPictureBox->Image != nullptr)
                    pPictureBox->Image löschen;
                pPictureBox->Image = b;
            }
        }
        Catch (System::Exception^ ex) {
            Console::WriteLine("Bild konnte nicht festgelegt werden: " + ex->Message);
        }
    }
};

Konzentrieren Sie sich auf die Organisation

• InvokeRequiredKann nur zur Vererbung verwendet werdenControlObjekt (z. B. PictureBox).
• WenntrueDies bedeutet, dass der aktuelle Ausführungsthread nicht der UI-Ausführungsthread ist und verwendet werden mussInvoke。
• verwendenTupleKapseln Sie mehrere Parameter und übergeben Sie sie zur Verarbeitung an die statische Proxy-Funktion.
• verwendentry-catchDurch das Abfangen von Ausnahmen werden Programmabstürze vermieden.

Schützen Sie pPictureBox->Image = b, um Programmabstürze zu vermeiden

Mögliche Absturzursachen

• Versuchen Sie, über einen Nicht-UI-Thread auf die UI-Steuerung zuzugreifen
• Bildobjekt b ist nullptr oder wurde freigegeben
• Das vorherige Bild wurde nicht veröffentlicht, was zur Erschöpfung der GDI-Ressourcen führte

Empfohlene Vorgehensweisen zum sicheren Einrichten von Bildern

using namespace System;
using namespace System::Windows::Forms;
using namespace System::Drawing;

void SetImageSafe(PictureBox^ pPictureBox, Bitmap^ b) {
    if (pPictureBox->InvokeRequired) {
        pPictureBox->Invoke(gcnew MethodInvoker(
            gcnew EventHandler(nullptr, &SetImageInvoker)
        ), gcnew array{ pPictureBox, b });
    } sonst {
        SetImageInternal(pPictureBox, b);
    }
}

void SetImageInvoker(Object^ sender, EventArgs^ e) {
    // Wenn diese Version nicht verwendet wird, kann sie ignoriert und als vollständige Referenz beibehalten werden.
}

void SetImageInternal(PictureBox^ pPictureBox, Bitmap^ b) {
    versuche es mit {
        if (b != nullptr) {
            if (pPictureBox->Image != nullptr)
                pPictureBox->Image löschen;

            pPictureBox->Image = b;
        }
    }
    Catch (System::Exception^ ex) {
        Console::WriteLine("Bild konnte nicht festgelegt werden: " + ex->Message);
    }
}

Vereinfachte Version (anonyme Delegation wird empfohlen)

Verwenden des Namespace-Systems;
Verwenden des Namensraums System::Windows::Forms;
Verwenden des Namensraums System::Drawing;

void SafeAssignImage(PictureBox^ pPictureBox, Bitmap^ b) {
    if (pPictureBox->InvokeRequired) {
        pPictureBox->Invoke(gcnew MethodInvoker(gcnew Delegat {
            versuche es mit {
                if (b != nullptr) {
                    if (pPictureBox->Image != nullptr)
                        pPictureBox->Image löschen;
                    pPictureBox->Image = b;
                }
            } Catch (System::Exception^ ex) {
                Console::WriteLine("Bild konnte nicht festgelegt werden: " + ex->Message);
            }
        }));
    } sonst {
        versuche es mit {
            if (b != nullptr) {
                if (pPictureBox->Image != nullptr)
                    pPictureBox->Image löschen;
                pPictureBox->Image = b;
            }
        } Catch (System::Exception^ ex) {
            Console::WriteLine("Bild konnte nicht festgelegt werden: " + ex->Message);
        }
    }
}

Weitere Informationen

• gcnew MethodInvoker(...)Muss eine legale Delegation sein, die C++11-Lambda-Syntax (z. B. [=]()) wird nicht unterstützt.
• Um Parameter zu übergeben, können Sie verwendenBeginInvokeübereinstimmenObject^Array und analysieren.
• Das Freigeben des vorherigen Images ist ein entscheidender Schritt, um zu verhindern, dass Ihnen die GDI-Ressourcen ausgehen.

Richten Sie mit Blazor eine einheitliche Sprach-Frontend-Entwicklungsumgebung ein

Was ist Blazor?

Blazor ist ein von Microsoft eingeführtes Front-End-Framework, das es Entwicklern ermöglicht, mithilfe der C#- und Razor-Syntax interaktive Webanwendungen zu erstellen. C#-Code kann im Browser ohne Verwendung von JavaScript ausgeführt werden.

Vorteile für Entwickler

• Nutzen Sie den bekannten C#- und .NET-Technologie-Stack für die Full-End-Entwicklung
• Gemeinsame Back-End- und Front-End-Bibliotheken und Geschäftslogik
• Reduzieren Sie die Lernkurve und verbessern Sie die Entwicklungseffizienz

Blazor-Modus

• Blazor Server：Verwenden Sie SignalR, um die Verbindung zum Server aufrechtzuerhalten, und der Server übernimmt die UI-Logik
• Blazor WebAssembly：Kompilieren Sie C#-Programmcode in WebAssembly und führen Sie ihn browserseitig aus

Integration mit .NET

Blazor integriert ASP.NET Core nahtlos, kann mit vorhandenen .NET-Anwendungen kombiniert werden und unterstützt Abhängigkeitsinjektion, Routing, Komponentenarchitektur und andere Funktionen.

Bereitstellungsmethode

• Kann als eigenständige statische Website bereitgestellt werden
• Oder integrieren und veröffentlichen Sie es im ASP.NET Core-Projekt
• Unterstützt Azure, GitHub Pages, Docker und andere Umgebungen

Zusammenfassung

Für Entwickler, deren Haupttechnologie .NET ist, bietet Blazor eine Lösung, die der einheitlichen JavaScript-Sprache von Node.js entspricht und es sowohl dem Front-End als auch dem Back-End ermöglicht, C# zu verwenden, wodurch ein konsistenteres Entwicklungserlebnis entsteht.

Erstellen Sie plattformübergreifende Anwendungen mit .NET MAUI

Was ist .NET MAUI?

.NET MAUI (Multi-Plattform App UI) ist ein von Microsoft eingeführtes plattformübergreifendes Anwendungsframework. Sie können C# und XAML verwenden, um einmalig Code zu schreiben und ihn unter Windows, Android, iOS und sogar macOS bereitzustellen.

Vorteile für Entwickler

• Einheitliche Verwendung von C# zur Entwicklung von Frontend und Benutzeroberfläche
• Teilen Sie Geschäftslogik, Datenmodelle und Dienste
• Vereinfachen Sie Wartungs- und Entwicklungsprozesse für mehrere Plattformen

Unterstützte Plattformen

• Desktop:Windows（WinUI）、macOS（MacCatalyst）
• Aktion:Android、iOS
• Web (mit Blazor):Kann mit Blazor kombiniert werden, um hybride Web-Apps zu erstellen

Blazor-Hybridmodus

Der Blazor-Hybridmodus von .NET MAUI kann zum Einbetten der Web-Benutzeroberfläche in native Anwendungen verwendet werden, sodass Entwickler Razor-Komponenten verwenden können, um plattformübergreifende Benutzeroberflächen zu entwickeln und gleichzeitig auf native APIs zuzugreifen.

Integration und Bereitstellung

• Vollständig in .NET 7 / .NET 8 integriert, mit Visual Studio zur Bereitstellung leistungsstarker Design- und Debugging-Tools
• Stellen Sie es im Microsoft Store oder bei Google Play bereit oder veröffentlichen Sie Installationsdateien direkt
• Unterstützen Sie die Integration von DevOps und CI/CD-Prozessen

Zusammenfassung

.NET MAUI ist derzeit die umfassendste plattformübergreifende .NET-Lösung. Es kann mit Blazor kombiniert werden, um eine einheitliche Anwendungsentwicklung für Web-, Desktop- und mobile Plattformen zu erreichen und .NET-Entwicklern ein umfassendes Erlebnis zu bieten, das in Sprache und Technologie konsistent ist.

Vergleich zwischen ASP.NET Core und .NET MAUI

Position

• ASP.NET Core: Für die Entwicklung plattformübergreifender serverseitiger Webanwendungen und APIs.
• .NET MAUI: Wird zur Entwicklung plattformübergreifender Clientanwendungen (Desktop- und Mobilgeräte) verwendet.

Support-Plattform

• ASP.NET Core: Serverumgebung unter Windows, Linux, macOS, Ausgabe als Webseite oder API.
• .NET MAUI: Android, iOS, Windows, macOS, zum Erstellen nativer GUI-Anwendungen.

Entwicklungssprache

• Benutzen Sie beidesC#mit der .NET-Plattform.

Benutzeroberfläche und Interaktion

• ASP.NET Core: Geben Sie HTML/CSS/JS über Razor Pages, MVC, Blazor usw. aus und verlassen Sie sich auf das Browser-Rendering.
• .NET MAUI: Verwenden Sie XAML oder C#, um eine plattformübergreifende native Benutzeroberfläche zu erstellen und diese direkt auf Mobilgeräten oder Desktops zu rendern.

Anwendbare Szenarien

• ASP.NET Core: Websysteme auf Unternehmensebene, Back-End-APIs und Cloud-Anwendungen.
• .NET MAUI: Plattformübergreifende App, mobile Anwendung, Desktop-Anwendung.

Integration

.NET MAUI kann über API-Aufrufe in die von ASP.NET Core erstellten Back-End-Dienste integriert werden, um eine vollständige „Front-End-App + Back-End-API“-Architektur zu bilden.

Zusammenfassen

ASP.NET Core löst die Probleme von „Back-End-Diensten“ und „Webanwendungen“, während .NET MAUI sich auf „clientseitige plattformübergreifende Apps“ konzentriert. Die beiden schließen sich nicht gegenseitig aus, werden aber oft zusammen verwendet, um eine Komplettlösung zu bilden.

Einfaches .NET MAUI-Anwendungsbeispiel

Erstellen Sie eine einfache .NET MAUI-Anwendung

Unten sehen Sie ein Beispiel einer plattformübergreifenden Anwendung, die mit .NET MAUI erstellt wurde und eine Schaltfläche auf dem Bildschirm anzeigt, die beim Klicken die Textanzahl aktualisiert.

Hauptdatei: MainPage.xaml

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MauiApp.MainPage">

    <VerticalStackLayout Spacing="25" Padding="30">
        <Label x:Name="counterLabel"
               Text="Sie haben noch nicht auf die Schaltfläche geklickt"
               Schriftgröße="24"
               HorizontalOptions="Center" />

        <Button Text="Klick mich"
                Clicked="OnCounterClicked"
                HorizontalOptions="Center" />
    </VerticalStackLayout>
</ContentPage>

Backend-Code: MainPage.xaml.cs

namespaceMauiApp;

öffentliche Teilklasse MainPage: ContentPage
{
    int count = 0;

    öffentliche Hauptseite()
    {
        InitializeComponent();
    }

    private void OnCounterClicked(object sender, EventArgs e)
    {
        count++;
        counterLabel.Text = $"Sie haben {count} Mal geklickt";
    }
}

Ausführungsmethode

• Wählen Sie in Visual Studio die Zielplattform (Windows/Android/iOS) aus
• Klicken Sie auf „Ausführen“, um die plattformübergreifende Benutzeroberfläche anzuzeigen

Zusammenfassung

Dieses einfache Beispiel demonstriert die plattformübergreifenden Funktionen von .NET MAUI. Entwickler müssen XAML- und C#-Code nur einmal schreiben, um ihn auf mehreren Plattformen gleichzeitig auszuführen.

Erstellen Sie ein .NET MAUI-Projekt in Visual Studio

Schritt 1: Installieren Sie die erforderlichen Tools

• Herunterladen und installierenVisual Studio 2022 17.3 oder höheroderVisual Studio 2022 for Mac
• Wählen Sie bei der Installation „.NET MAUI (UI-Entwicklung für plattformübergreifende Anwendungen)Arbeitsbelastung

Schritt 2: Erstellen Sie ein neues MAUI-Projekt

1. Öffnen Sie Visual Studio
2. Klicken Sie auf „Neues Projekt erstellen“
3. Suchen und wählen Sie „.NET MAUI App"Vorlage
4. Klicken Sie auf „Weiter“ und geben Sie den Projektnamen und den Speicherort ein
5. Klicken Sie auf „Erstellen“, um die Projektinitialisierung abzuschließen

Schritt 3: Verstehen Sie die Projektstruktur

• MainPage.xaml: UI-Schnittstelle definieren (mit XAML)
• MainPage.xaml.cs: Backend-Code (C#) verarbeitet Ereignisse
• MauiProgram.cs: Anwendungsstart- und Dienstregistrierungspunkt
• PlatformsOrdner: Native Einstellungen für jede Plattform (Android, iOS, Windows, MacCatalyst)

Schritt 4: Führen Sie die Anwendung aus

• Wählen Sie in der Visual Studio-Symbolleiste das Plattformziel (z. B. Windows, Android-Emulator) aus
• Klicken Sie auf die Schaltfläche „Ausführen“ und die Anwendung wird auf der entsprechenden Plattform gestartet

Weitere Informationen

• Für die Entwicklung von Android-Anwendungen ist die Installation des Android SDK und des Emulators erforderlich
• iOS erfordert einen Mac und eine Verbindung zu Xcode

Zusammenfassung

Es sind nur wenige Schritte erforderlich, um mit Visual Studio ein .NET MAUI-Projekt zu erstellen, und ein Codesatz kann gleichzeitig auf mehreren Plattformen bereitgestellt werden, was es zur idealen Wahl für moderne C#-Full-End-Entwickler macht.

MainPage.xaml Beispiele und Erklärungen

Beispiel: MainPage.xaml

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.MainPage">

    <VerticalStackLayout Spacing="25" Padding="30"
                         VerticalOptions="Center">

        <Label
            Text="Willkommen bei .NET MAUI!"
            SemanticProperties.HeadingLevel="Level1"
            Schriftgröße="32"
            HorizontalOptions="Center" />

        <Schaltfläche
            x:Name="counterBtn"
            Text="Klick mich!"
            Clicked="OnCounterClicked"
            HorizontalOptions="Center" />

    </VerticalStackLayout>

</ContentPage>

Entsprechende MainPage.xaml.cs

Verwenden des Systems;
Namespace MyMauiApp;

öffentliche Teilklasse MainPage: ContentPage
{
    int count = 0;

    öffentliche Hauptseite()
    {
        InitializeComponent();
    }

    private void OnCounterClicked(object sender, EventArgs e)
    {
        count++;
        counterBtn.Text = $"Sie haben {count} Mal geklickt";
    }
}

Komponentenbeschreibung

• <ContentPage>：MAUI stellt den Grundtyp einer Seite dar, ähnlich einem Bildschirm oder Fenster.
• <VerticalStackLayout>：Stapeln Sie Behälter vertikal, sodass die darin enthaltenen Elemente in der Reihenfolge von oben nach unten angeordnet sind. konfigurierbarSpacing(Abstand) undPadding(innerer Abstand).
• <Label>：Ein Steuerelement, das statischen Text anzeigt. Hier werden große Schriftgröße und zentrierte Ausrichtung eingestellt.
• <Button>：Tastensteuerung, Einstellungenx:Namefür den Zugriff durch das C#-Backend,ClickedDas Attribut gibt die Methode zur Verarbeitung von Klickereignissen an.

C#-Codebeschreibung

• InitializeComponent(): Initialisieren Sie die in XAML definierte UI-Struktur.
• OnCounterClicked: Klicken Sie auf die Ereignisverarbeitungsmethode und aktualisieren Sie den Schaltflächentext jedes Mal, wenn auf die Schaltfläche geklickt wird.
• counterBtn.Text: Steuern Sie die Eigenschaften der Schaltfläche über den in XAML angegebenen Namen.

Ergebniseffekt

Nach der Ausführung werden in der Mitte des Bildschirms eine Willkommensnachricht und eine Schaltfläche angezeigt. Jedes Mal, wenn Sie auf die Schaltfläche klicken, wird der Text auf der Schaltfläche zu „Sie haben X-mal geklickt“ aktualisiert.

Beispiele und Erklärungen für MauiProgram.cs

Beispiel: MauiProgram.cs

using Microsoft.Extensions.Logging;

namespace MyMauiApp;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        
        builder
            .UseMauiApp() // Geben Sie den Einstiegspunkt der Anwendung an
            .ConfigureFonts(fonts =>
            {
                Schriftarten.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                Schriftarten.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
            });

#if DEBUG
        builder.Logging.AddDebug();
#endif

        return builder.Build();
    }
}

Funktionsbeschreibung

• public static MauiApp CreateMauiApp(): Dies ist eine der Eingabemethoden der gesamten Anwendung, die für das Zusammenstellen und Zurückgeben einer ausführbaren Datei verantwortlich istMauiAppBeispiel.
• MauiApp.CreateBuilder(): Richten Sie einen Builder (Builder) für die Anwendung ein, mit dem das grundlegende Verhalten und die Dienste der Anwendung festgelegt werden.
• UseMauiApp<App>(): Gibt die Hauptkategorie der Anwendung an (normalerweiseApp.xaml.csApp-Kategorie) ist dies die Stammkomponente der Anwendung.
• ConfigureFonts(): Registrieren Sie die Schriftartdatei, um sie in der Anwendung verfügbar zu machen. Die linke Seite ist der Name der Entitätsdatei und die rechte Seite ist der Proxy-Name. XAML oder C# können Schriftarten über den Proxynamen verwenden.
• #if DEBUG ... #endif: Im Debugging-Modus wurde ein neuer Debugging-Ausgaberekorder (Logger) hinzugefügt, um das Debuggen zu erleichtern.
• builder.Build(): Generieren Sie die endgültige Anwendungsinstanz basierend auf den oben genannten Einstellungen.

Gemeinsame Erweiterungen

• Registrierungsdienste (DI)：

  builder.Services.AddSingleton<MainPage>();

  Dadurch kann MainPage mithilfe der Abhängigkeitsinjektion geladen werden, beispielsweise in der App-KlasseserviceProvider.GetService<MainPage>()。
• Registrieren Sie ViewModel oder eine andere Klasse：

  builder.Services.AddTransient<MyViewModel>();
  builder.Services.AddSingleton<IMyService, MyService>();
      

Zusammenfassen

MauiProgram.csGenau wie bei ASP.NET CoreStartup.csoderProgram.cs, ist das Haupteinstellungszentrum für den Anwendungsstart und die Dienstregistrierung. Bei der Entwicklung großer MAUI-Anwendungen kommt es häufig vor, diese Datei zu erweitern, um DI, Protokollierung, Komponenteneinstellungen usw. hinzuzufügen.

Bereitstellen von .NET C++-Programmen auf Ubuntu

Vorwort

Die Bereitstellung von .NET C++ (C++/CLI oder .NET-basierte C++-Anwendungen) auf Ubuntu-Systemen muss je nach Projekttyp separat behandelt werden. Wenn Sie reines C++/CLI verwenden (basierend auf .NET Framework), können Sie es nicht direkt unter Linux ausführen und müssen es verwendenPlattformübergreifende Technologie für .NET 6/7/8(Zum Beispiel C++/CLR → C# oder die Verwendung von C++/Native mit .NET-Interoperabilität).

Bereitstellungsübersicht

Abhängig von der Art der Anwendung kann die Bereitstellung in drei Szenarien unterteilt werden:

1. Reine C++-Anwendung:Mit g++ kompiliert und direkt auf Ubuntu ausgeführt.
2. .NET Managed C++ (C++/CLI)：Muss für C# oder C++/CLI für Core, unterstützt von .NET 6 und höher (unterstützt nur von Windows), neu gestaltet werden.
3. Hybridanwendung:C++ stellt hauptsächlich C# und Leistungsmodule in Form dynamischer Funktionsbibliotheken (.so) bereit.

Umgebungsinstallation

Installieren Sie das .NET SDK und die erforderlichen Tools in Ubuntu:

sudo apt update
sudo apt install -y dotnet-sdk-8.0
sudo apt install -y build-essential

(Kann je nach Ausführung ausgetauscht werdendotnet-sdk-8.0fürdotnet-sdk-7.0oder andere Versionen)

Projekt erstellen

Wenn Sie .NET C# als Hauptprogramm verwenden und die C++-Bibliothek aufrufen:

# Erstellen Sie die Hauptanwendung
dotnet neue Konsole -n MyApp
cdMyApp

# Erstellen Sie eine native Funktionsbibliothek
mkdir nativ
CD nativ
nano add.cpp

add.cpp-Beispiel:

extern "C" int add(int a, int b) {
    return a + b;
}

Als gemeinsam genutzte Funktionsbibliothek kompilieren:

g++ -fPIC -shared -o libadd.so add.cpp

Aufrufen von C++-Bibliotheken in C# (.NET)

BeiProgram.csdazu kommen:

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("libadd.so", EntryPoint="add")]
    public static extern int Add(int a, int b);

    static void Main()
    {
        Console.WriteLine("3 + 5 = " + Add(3, 5));
    }
}

Ausführung und Prüfung

Kehren Sie zum Projektstammverzeichnis zurück und führen Sie Folgendes aus:

dotnet run

Wenn das Ausgabeergebnis ist3 + 5 = 8, was auf eine erfolgreiche Bereitstellung hinweist.

Release-Bereitstellungsversion

Programme können in unabhängig ausführbare Bereitstellungsdateien gepackt werden:

dotnet publish -c Release -r linux-x64 --self-contained true

Die generierte ausführbare Datei befindet sich inbin/Release/net8.0/linux-x64/publish/。

Docker-Container-Bereitstellung (optional)

Anwendungen können mit Docker in Containern verpackt werden, um auf jedem Ubuntu-System ausgeführt zu werden:

# Dockerfile-Beispiel
VON mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR/app
KOPIEREN ./veröffentlichen .
KOPIEREN ./native/libadd.so /usr/lib/
ENTRYPOINT ["./MyApp"]

Container erstellen und ausführen:

docker build -t myapp .
docker run --rm myapp

Dinge zu beachten

• C++/CLI unterstützt nur Windows und kann nicht direkt auf Ubuntu ausgeführt werden.
• Wenn plattformübergreifende Interoperabilität erforderlich ist, wird die Verwendung von P/Invoke empfohlen (C# ruft C++ auf).
• Linux-Nutzung.soFunktionsbibliothek, die von Windows verwendet wird.dll。
• Stellen Sie sicher, dass der Bibliothekspfad darin enthalten istLD_LIBRARY_PATH。

Zusammenfassen

Eine praktikable Möglichkeit, .NET C++-Programme auf Ubuntu bereitzustellen, ist normalerweiseNative C# + C++-Bibliothek”-Struktur. Wenn das ursprüngliche Programm auf C++/CLI basiert, muss es neu gestaltet werden, um plattformübergreifendes .NET zu unterstützen. Die am meisten empfohlene Methode ist die Verwendung von .NET 8 + nativen C++-Modulen mit Docker, um einen stabilen, portablen und konsistenten Bereitstellungsprozess zu erreichen.

email: [email protected]

T:0000

資訊與搜尋 | 回dev首頁
email: Yan Sa [email protected] Line: 阿央
電話: 02-27566655 ,03-5924828

阿央
泱泱科技
捷昱科技泱泱企業