So übermitteln Sie Q#-Programme mit Visual Studio Code

Übermitteln von Q#-Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code zum Ausführen, Debuggen und Übermitteln eines Q#-Programms an Azure Quantum verwenden.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

• Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
• Die neueste Version von Visual Studio Code oder öffnen Sie VS Code im Web.
• Die neueste Version der Azure Quantum Development Kit-Erweiterung.

Laden eines Q#-Beispielprogramms

1. Wählen Sie in VS Code "Datei > Neue Textdatei" aus, und speichern Sie die Datei als RandomNum.qs.

2. Öffnen Sie RandomNum.qs , und geben sampleSie es ein, und wählen Sie dann "Random Bit"-Beispiel aus der Liste der Optionen aus, und speichern Sie die Datei.

   

Ausführen eines Q#-Programms

1. Wenn Sie das Programm lokal auf dem integrierten Simulator testen möchten, klicken Sie in der Liste der Befehle neben dem Einstiegspunktvorgang auf "Ausführen ", oder drücken Sie STRG+F5. Die Ausgabe wird in der Debugkonsole angezeigt.

2. Wenn Sie Ihr Programm debuggen möchten, bevor Sie es an Azure Quantum übermitteln, klicken Sie in der Liste der Befehle neben dem Einstiegspunktvorgang auf "Debuggen ", oder drücken Sie F5. Mit den Debugsteuerelementen am oberen Rand können Sie den Code schrittweise durchlaufen, zur entsprechenden Stelle im Code gelangen und den Code wieder verlassen. Weitere Informationen zum Debuggen von Q#-Programmen finden Sie unter "Testen und Debuggen".

   

Visualisieren des Häufigkeits histogramms

Das Häufigkeits histogramm stellt die Verteilung von Ergebnissen dar, die aus dem Ausführen eines Quantenprogramms mehrmals oder "Shots" gewonnen wurden. Jeder Balken im Histogramm entspricht einem möglichen Ergebnis, und seine Höhe stellt die Anzahl der Beobachteten dar. Das Häufigkeits histogramm hilft dabei, die Wahrscheinlichkeitsverteilung dieser Ergebnisse zu visualisieren.

1. Wählen Sie "Ansicht"> aus, und geben Sie "Histogramm" ein, das die Datei "Q#" anzeigen und die Histogrammoption anzeigen soll. Sie können auch in der Liste der Befehle neben dem Einstiegspunktvorgang auf Histogramm klicken. Wählen Sie diese Option aus, um das Q#-Histogrammfenster zu öffnen.

   

2. Geben Sie eine Reihe von Aufnahmen ein, um das Programm auszuführen, z. B. 100 Aufnahmen, und drücken Sie die EINGABETASTE. Das Histogramm wird im Q#-Histogrammfenster angezeigt.

3. Klicken Sie auf das Symbol für die oberen linken Einstellungen, um Optionen anzuzeigen.

   

4. Klicken Sie auf eine Leiste, um den Prozentsatz dieses Ergebnisses anzuzeigen. In diesem Fall gibt es zwei mögliche Ergebnisse, 0 und 1, und der Prozentsatz der einzelnen Ergebnisse liegt bei 50 %.

   

Visualisieren des Quantenkreises

Quantenschaltungsdiagramme sind eine visuelle Darstellung von Quantenvorgängen. Sie zeigen den Fluss von Qubits durch das Quantenprogramm, einschließlich der Tore und Messungen, die auf sie angewendet werden. Weitere Informationen finden Sie unter Quantenschaltungsdiagramme in Visual Studio Code.

1. Wählen Sie "Ansicht"> aus, und geben Sie "Schaltkreis" ein, der die Option "Q#: Schaltkreis anzeigen" anzeigen soll. Sie können auch in der Liste der Befehle neben dem Einstiegspunktvorgang auf " Circuit " klicken.

   

2. Der Schaltkreis wird im Q#-Schaltkreisfenster angezeigt. Das Schaltkreisdiagramm zeigt ein Qubit-Register, das in den Zustand |0⟩ initialisiert wird. Anschließend wird ein Hadamard-Tor , H, auf das Qubit angewendet, gefolgt von einem Messvorgang, der durch ein Metersymbol dargestellt wird. Weitere Informationen finden Sie unter Quantum Circuits Conventions.

   

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Sie können Aufträge direkt über VS Code verbinden und übermitteln. In diesem Beispiel übermitteln Sie einen Auftrag an den Rigetti-Simulator.

1. Wählen Sie "Ansicht" aus– Befehlspalette und geben Sie "Q#" ein: Verbinden mit einem Azure Quantum-Arbeitsbereich>. Drücken Sie die EINGABETASTE.

2. Wählen Sie Azure-Konto aus, und folgen Sie den Anweisungen, um eine Verbindung mit Ihrem bevorzugten Verzeichnis, Abonnement und Arbeitsbereich herzustellen.

   Hinweis

   Wenn Sie über eine Verbindungszeichenfolge verfügen, können Sie die Verbindungszeichenfolge auswählen und die Verbindungszeichenfolge einfügen, die Ihrem Azure Quantum-Arbeitsbereich entspricht. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit einem Quantum-Arbeitsbereich mithilfe eines Verbindungszeichenfolge.

3. Sobald Sie verbunden sind, erweitern Sie im Explorer-Bereich Quantum Workspaces.

4. Erweitern Sie Ihren Arbeitsbereich, und erweitern Sie den Rigetti-Anbieter .

   Hinweis

   Wenn beim Herstellen einer Verbindung mit Azure Quantum ein Problem vorliegt, wird neben dem Arbeitsbereichsnamen ein Warnsymbol angezeigt. Zeigen Sie auf den Arbeitsbereichsnamen, um Fehlerinformationen anzuzeigen.

5. Wählen Sie rigetti.sim.qvm als Ihr target.

   

6. Wählen Sie das Wiedergabesymbol rechts neben dem target Namen aus, um mit der Übermittlung des aktuellen Q#-Programms zu beginnen. Wenn Sie ein Popup erhalten, wählen Sie das QIR-Profil target ändern und fortfahren.

   

7. Fügen Sie einen Namen hinzu, um den Auftrag zu identifizieren.

8. Add the number of shots, or number of times that the program is run.

9. Drücken Sie die EINGABETASTE, um den Auftrag zu senden. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.

10. Erweitern Sie Aufträge, und zeigen Sie mit der Maus auf Ihren Auftrag. Dadurch werden die Anzahl und der Status Ihres Auftrags angezeigt.

11. Wählen Sie zum Anzeigen der Ergebnisse das Cloudsymbol neben dem Auftragsnamen aus, um die Ergebnisse aus dem Arbeitsbereichsspeicher herunterzuladen und in VS Code anzuzeigen.

    

Übermitteln von Aufträgen für Jupyter-Notizbücher an Azure Quantum

Erfahren Sie, wie Sie VS Code zum Ausführen, Debuggen und Übermitteln eines Q#-Jupyter-Notizbuchs an Azure Quantum verwenden. Die Schritte in diesem Artikel gelten auch für Jupyter-Notizbücher auf Ihrem lokalen Jupyter-Server oder -Notizbücher im Azure Quantum-Portal.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

• Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.

• Eine Python-Umgebung mit installiertem Python und Pip.

• VS Code mit installierten Azure Quantum Development Kit-, Python- und Jupyter-Erweiterungen .

• Azure Quantum qsharp, qsharp-widgetsund azure-quantum Pakete, und das ipykernel Paket.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

Ausführen und Testen Des Programms im lokalen Simulator

1. Wählen Sie in VS Code die Optionen Ansicht > Befehlspalette und dann Erstellen aus: Verwenden von Jupyter Notebook.

2. In der oberen rechten Ecke erkennt und zeigt VS Code die Version von Python und die virtuelle Python-Umgebung an, die für das Notizbuch ausgewählt wurde. Wenn Sie über mehrere Python-Umgebungen verfügen, müssen Sie möglicherweise einen Kernel mit der Kernelauswahl oben rechts auswählen. Wenn keine Umgebung erkannt wurde, finden Sie Informationen zum Einrichten unter Jupyter-Notizbücher in VS Code .

3. Führen Sie in der ersten Zelle des Notizbuchs den folgenden Python-Code aus, um die erforderlichen Module zu importieren:

   import qsharp
   import azure.quantum
   

   • Das qsharp Modul aktiviert den %%qsharp magischen Befehl, mit dem Sie Q#-Code direkt in eine Zelle eingeben können.
   • Das azure-quantum Modul bietet Konnektivität zu Ihrem Azure Quantum-Arbeitsbereich.

   Hinweis

   Wenn der Jupyter Python-Kernel ipykernel nicht erkannt wird, werden Sie von VS Code aufgefordert, ihn zu installieren.

4. Fügen Sie eine weitere Zelle hinzu, und geben Sie diesen Q#-Code ein, der eine vom Benutzer angegebene Anzahl zufälliger Bits zurückgibt:

   Hinweis

   Beachten Sie, dass die Notizbuchzelle, sobald Sie den Zauberbefehl %%qsharpeingeben, den Typ von Python in Q# ändert.

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

5. Zum Testen des Vorgangs können Sie die Methode verwenden, mit der eval alle zuvor im Notizbuch definierten Q#-Vorgänge aufgerufen werden können:

   qsharp.eval("RandomNBits(4)")
   

   [Zero, One, One, Zero]
   

6. Verwenden Sie die run Methode, um Ihr Programm auf den lokalen Simulator auszuführen. Geben Sie das shotsProgramm oder die Häufigkeit an, mit der das Programm ausgeführt werden soll, und der Simulator gibt die Ergebnisse als Python-Liste zurück.

   qsharp.run("RandomNBits(4)", shots=10)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Visualisieren des Quantenkreises

Sie können Quantenschaltungen mithilfe des qsharp-widgets Pakets visualisieren. Dieses Paket stellt ein Widget bereit, das ein Quantenschaltungsdiagramm als SVG-Bild rendert. Weitere Informationen finden Sie unter Quantenschaltungsdiagramme mit Jupyter-Notizbüchern.

Fügen Sie einer neuen Zelle den folgenden Code hinzu, um den Schaltkreis zu visualisieren:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Weitere Informationen finden Sie unter Quantum Circuits Conventions.

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie einen beliebigen Q#-Programmtyp übermitteln. Azure Quantum-Hardware targets unterstützt jedoch noch nicht die vollständigen Funktionen, die zum Ausführen aller Q#-Programme erforderlich sind. Um Q#-Programme zu kompilieren und an Azure Quantum zu übermitteln, müssen Sie Ihr target Profil festlegen, um Q# mitzuteilen, welche Funktionen Ihre target Hardware unterstützt. Derzeit ist dies das Basisprofil. Weitere Informationen finden Sie unter Profiltypen in Azure Quantum.

So initialisieren Sie den Q#-Dolmetscher erneut, und kompilieren Sie Ihr Programm mit dem Basisprofil:

1. Verwenden Sie die init Methode, um das Profil festzulegen:

   qsharp.init(target_profile=qsharp.TargetProfile.Base)
   

2. Da Sie den Dolmetscher neu initialisiert haben, müssen Sie Den Code erneut mit dem neuen Profil ausführen:

   %%qsharp
   
   operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

3. Verwenden Sie als Nächstes die compile Methode, um den Vorgang oder die Funktion anzugeben, der der Einstiegspunkt zu Ihrem Programm ist. Dadurch wird Ihr Code in das QIR-Format kompiliert, das dann an jede Quantenhardware übermittelt werden kann:

   MyProgram = qsharp.compile("RandomNBits(4)")
   

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Nachdem Ihr Programm nun in das richtige Format kompiliert wurde, erstellen Sie ein azure.quantum.Workspace Objekt, um eine Verbindung mit Azure Quantum herzustellen. Sie verwenden die Ressourcen-ID Ihres Azure Quantum-Arbeitsbereichs, um eine Verbindung herzustellen. Die Ressourcen-ID und der Speicherort können auf der Übersichtsseite des Arbeitsbereichs im Azure-Portal kopiert werden.

1. Füllen Sie in einer neuen Zelle Ihre Ressourcen-ID und Ihren Standort aus Ihrem Azure Quantum-Arbeitsbereich aus:

   MyWorkspace = azure.quantum.Workspace(
       resource_id = "MyResourceID",
       location = "MyLocation"
   )
   

2. Verwenden Sie die get_targets Methode, um die verfügbare Hardware targets in Ihrem Arbeitsbereich anzuzeigen:

   MyTargets = MyWorkspace.get_targets()
   print("This workspace's targets:")
   MyTargets
   

3. Wählen Sie folgendes aus rigetti.sim.qvmtarget:

   MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
   

4. Verwenden Sie schließlich die submit Methode, um Ihr Programm mit seinen Parametern zu übermitteln und die Ergebnisse anzuzeigen:

   job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
   job.get_results()
   

   {'[0, 1, 1, 1]': 0.08,
    '[1, 1, 0, 0]': 0.1,
    '[0, 0, 1, 0]': 0.04,
    '[0, 1, 0, 0]': 0.05,
    '[1, 0, 1, 0]': 0.05,
    '[1, 0, 0, 0]': 0.07,
    '[0, 1, 0, 1]': 0.07,
    '[1, 0, 1, 1]': 0.07,
    '[0, 0, 0, 0]': 0.08,
    '[1, 1, 1, 0]': 0.05,
    '[0, 0, 0, 1]': 0.1,
    '[0, 0, 1, 1]': 0.04,
    '[0, 1, 1, 0]': 0.09,
    '[1, 0, 0, 1]': 0.04,
    '[1, 1, 1, 1]': 0.05,
    '[1, 1, 0, 1]': 0.02}
   

5. Auf alle Eigenschaften des Auftrags kann zugegriffen job.detailswerden, z. B.:

   print(job.details)
   print("\nJob name:", job.details.name)
   print("Job status:", job.details.status)
   print("Job ID:", job.details.id)
   

   {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
   Job name: MyQuantumJob
   Job status: Succeeded
   Job ID: 0150202e-9638-11ee-be2f-b16153380354
   

Weitere Auftragsdetails

Das azure.quantum Python-Paket enthält zusätzliche Methoden zum Anzeigen detaillierterer Auftragsdaten.

• job.get_results_histogram(): Diese Methode gibt ein Wörterbuch der Ergebnisse und die Anzahl der Aufnahmen für jede eindeutige Messung zurück. Die Ergebnisse für den vorherigen Auftrag würden z. B.

  print(job.get_results_histogram()) 
  

  {   
      '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
      '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
      '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
      '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
      '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
      '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
      '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
      '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
      '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
      '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
      '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
      '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
      '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
      '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
      '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
      '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
  }
  

• job.get_results_shots() : Diese Methode gibt eine Liste der einzelnen Aufnahmeergebnisse zurück. Die Ergebnisse für den vorherigen Auftrag würden z. B.

  print(job.get_results_shots()) 
  

  [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]
  

Übermitteln von Python mit Q#-Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code verwenden, um ein Python-Programm zu schreiben, das Q#-Vorgänge aufruft, eine Verbindung mit Azure mithilfe der Python-Befehle oder der Azure CLI herzustellen und Ihren Auftrag zu übermitteln.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

• Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
• Eine Python-Umgebung mit installiertem Python und Pip.
• VS Code mit installierter Azure Quantum Development Kit - und Python-Erweiterung .
• Azure Quantum qsharp und azure-quantum Pakete.
• Azure CLI mit der neuesten installierten Azure Quantum-Erweiterung.

Erstellen und Importieren ihrer Q#-Vorgänge

Mit dem qsharp Paket können Sie Ihre Funktionen und Vorgänge in Q#-Dateien speichern und Q#-Projekte erstellen, mit denen Sie sie aus Ihrem Python-Code aufrufen können. Dies ist besonders hilfreich, wenn Sie ein Programm starten müssen, das Eingabeparameter verwendet.

1. Führen Sie die Schritte zum Erstellen eines Q#-Projekts aus.

2. Öffnen Sie eine neue Textdatei, fügen Sie den folgenden Q#-Code hinzu, der eine vom Benutzer angegebene Anzahl zufälliger Bits zurückgibt, und speichern Sie die Datei im Verzeichnis "/src " in Ihrem Projekt als Source.qs.

   
       operation Random() : Result {
       use q = Qubit();
       H(q);
       let result = M(q);
       Reset(q);
       return result
   }
   
   operation RandomNBits(N: Int): Result[] {
       mutable results = [];
       for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
       }
       return results
   }
   

3. Öffnen Sie im Projektstammordner (mit der qsharp.json Datei) eine andere Datei, und speichern Sie sie unter randomNum.py.

4. Fügen Sie den folgenden Code hinzu, um die qsharp Module zu azure.quantum importieren.

   import qsharp
   import azure.quantum
   

5. Fügen Sie als Nächstes Code zum Definieren des Q#-Projektstammordners hinzu, und testen Sie den target Vorgang im lokalen Simulator. Der Vorgang wird vom <Namespace> aufgerufen.<operation_name( )>, und in diesem Fall übergeben Sie die Anzahl der zufälligen Bits, die zurückgegeben werden sollen.

   Hinweis

   Da kein Namespace angegeben Source.qswurde, verwendet der Compiler den Dateinamen als Standardnamespace - Source.RandomNBits(). Weitere Informationen finden Sie unter Projekte und implizite Namespaces.

   qsharp.init(project_root = '../MyProjectRootFolder')
   print(qsharp.eval("Source.RandomNBits(4)"))
   

   [Zero, One, One, Zero]
   

6. Sie können den Vorgang auch mit der run Methode testen, die einen zusätzlichen shots Parameter übergibt, und die Ergebnisse in einer Python-Liste zurückgibt. Ersetzen randomNum.pySie in , die vorherige Druckausweisung durch Folgendes:

   result = qsharp.run("Source.RandomNBits(4)", shots=10)
   for x in result:
       print(x)
   

   [[One, One, One, One],
   [Zero, Zero, One, Zero],
   [One, Zero, Zero, One],
   [Zero, One, Zero, Zero],
   [One, Zero, One, One],
   [One, Zero, One, Zero],
   [One, One, One, Zero],
   [One, One, One, One],
   [Zero, Zero, Zero, One],
   [One, Zero, Zero, One]]
   

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie einen beliebigen Q#-Programmtyp übermitteln. Azure Quantum-Hardware targets unterstützt jedoch noch nicht die vollständigen Funktionen, die zum Ausführen aller Q#-Programme erforderlich sind. Um Q#-Programme zu kompilieren und an Azure Quantum zu übermitteln, müssen Sie Ihr target Profil festlegen, um Q# mitzuteilen, welche Funktionen Ihre target Hardware unterstützt. Derzeit ist das entweder das Profil oder Adpative_RI das Base Profil. Weitere Informationen finden Sie unter Profiltypen in Azure Quantum.

1. Verwenden Sie die init Methode, um das Profil festzulegen:

   qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
   

   Hinweis

   Da Sie den qsharp-Zustand erneut initialisieren, müssen Sie den project_root Parameter erneut festlegen, damit der Compiler weiß, wo der RandomNBits Vorgang gefunden werden soll. Dies könnte auch in Schritt 5 des vorherigen Verfahrens geschehen sein.

2. Verwenden Sie dann die compile Methode, um den Vorgang oder die Funktion anzugeben, der der Einstiegspunkt für Ihr Programm ist. Das kompilierte Programm kann dann an jede Quantenhardware übermittelt werden:

   MyProgram = qsharp.compile("Source.RandomNBits(4)")
   

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Sie können eine Verbindung mit Azure Quantum herstellen und Ihren Auftrag mithilfe eines python-erstellten Workspace Objekts übermitteln oder Ihren Auftrag mithilfe der Azure CLI verbinden und übermitteln. Wenn Sie Azure CLI verwenden, müssen Sie das kompilierte Programm als Textdatei speichern und diese Datei mit einem CLI-Befehl übermitteln.