Aangepaste opdrachten definiëren voor Python-projecten in Visual Studio

Wanneer u uw Python-projecten ontwikkelt, kunt u overschakelen naar een opdrachtvenster om specifieke scripts of modules uit te voeren, pip-opdrachten uit te voeren of andere hulpprogramma's met uw code te gebruiken. Als u uw werkstroom wilt verbeteren, kunt u aangepaste opdrachten toevoegen aan het Python-projectmenu in Visual Studio. De aangepaste Python-opdrachten kunnen worden uitgevoerd in een consolevenster of in het venster Uitvoer van Visual Studio. U kunt ook reguliere expressies gebruiken om Visual Studio te laten instrueren hoe u fouten en waarschuwingen van de uitvoer van de opdracht kunt parseren.

Vereiste voorwaarden

• Visual Studio in Windows geïnstalleerd met ondersteuning voor Python-workloads. Zie Python-ondersteuning installeren in Visual Studiovoor meer informatie.

Visual Studio voor Mac wordt niet ondersteund. Visual Studio Code in Windows, Mac en Linux werkt goed met Python via beschikbare extensies.

Aangepaste opdrachten verkennen

Standaard bevat het Python-projectmenu twee opdrachten: PyLint uitvoeren en Mypy uitvoeren:

Aangepaste Python-opdrachten die u definieert, worden weergegeven in hetzelfde menu. Een aangepaste opdracht kan verwijzen naar een Python-bestand, een Python-module, inline Python-code, een willekeurig uitvoerbaar bestand of een pip-opdracht. U kunt ook opgeven hoe en waar de opdracht wordt uitgevoerd.

U kunt aangepaste opdrachten op verschillende manieren toevoegen:

• Definieer aangepaste opdrachten rechtstreeks in een Python-projectbestand (.pyproj). Deze opdrachten zijn van toepassing op dat specifieke project.

• Aangepaste opdrachten definiëren in een doelenbestand (.targets). U kunt de opdrachten in dit bestand eenvoudig importeren om ze met meerdere projecten te gebruiken.

• Maak een Python-project op basis van een projectsjabloon in Visual Studio waarmee aangepaste Python-opdrachten worden gedefinieerd.

  Bepaalde Python-projectsjablonen in Visual Studio voegen aangepaste opdrachten toe met behulp van een doelbestand. Met de Bottle Web Project- en Flask Web Project-sjablonen worden twee opdrachten toegevoegd, de server start en de foutopsporingsserver starten. De Sjabloon Django Web Project voegt deze opdrachten toe en nog enkele andere:

  

Project opnieuw laden voor toegang tot aangepaste opdrachten

Wanneer een project is geopend in Visual Studio en u wijzigingen aanbrengt in het bijbehorende projectbestand in een editor, moet u het project opnieuw laden om de wijzigingen toe te passen. Nadat u aangepaste Python-opdrachten in een Python-projectbestand hebt gedefinieerd, moet u het Python-project opnieuw laden om de opdrachten weer te geven in het Python-projectmenu . Wanneer u aangepaste opdrachten wijzigt die zijn gedefinieerd in een doelbestand, moet u de volledige Visual Studio-oplossing opnieuw bouwen voor elk project dat het doelbestand importeert.

Een veelvoorkomende benadering is om de wijzigingen aan te brengen in het Python-projectbestand rechtstreeks in Visual Studio:

1. Open uw Python-project in Visual Studio. (Wanneer u een project opent in Visual Studio, wordt het project standaard geladen .)

2. Klik in Solution Explorer met de rechtermuisknop op het Python-project en selecteer Project verwijderen.

   Visual Studio verwijdert het project en opent het bijbehorende Python-projectbestand (.pyproj) in de editor.

   Als het projectbestand niet wordt geopend, klikt u opnieuw met de rechtermuisknop op het Python-project en selecteert u Projectbestand bewerken:

   

3. Breng uw wijzigingen aan in het projectbestand in de Visual Studio-editor en sla uw werk op.

4. Klik in Solution Explorer met de rechtermuisknop op het niet-geladen project en selecteer Project opnieuw laden. Als u het project opnieuw probeert te laden zonder de wijzigingen in het projectbestand op te slaan, wordt u door Visual Studio gevraagd om de actie te voltooien.

Het loskoppelen-bewerken-opslaan-herladen proces kan vervelend worden wanneer u aangepaste opdrachten ontwikkelt. Een efficiëntere werkstroom omvat het gelijktijdig laden van het project in Visual Studio en het openen van het Python-projectbestand in een afzonderlijke editor. U kunt een willekeurige editor gebruiken, zoals een andere instantie van Visual Studio, Visual Studio Code, Kladblok, enzovoort. Nadat u de wijzigingen in de editor hebt opgeslagen en weer bent overgeschakeld naar Visual Studio, detecteert Visual Studio de wijzigingen in het projectbestand voor het geopende project en wordt u gevraagd actie te ondernemen:

Selecteer Alles opnieuw laden of opnieuw laden en Visual Studio past direct wijzigingen in het geopende project toe.

Aangepaste opdrachten toevoegen met projectbestand

In de volgende procedure ziet u hoe u een aangepaste opdracht maakt door de definitie toe te voegen in het Python-projectbestand (.pyproj) en uw project opnieuw te laden in Visual Studio. Met de aangepaste opdracht wordt het opstartbestand van een project rechtstreeks uitgevoerd met behulp van de python.exe opdracht, die in principe hetzelfde is als het gebruik van de optie Foutopsporing>starten zonder foutopsporing op de hoofdwerkbalk van Visual Studio.

1. Maak in Visual Studio een nieuw Python-project met de naam Python-CustomCommands met behulp van de Python-toepassingssjabloon . Zie Quickstart: Een Python-project maken op basis van een sjabloon voor instructies.

   Visual Studio maakt het Python-project en laadt het in uw sessie. U kunt het project configureren via het projectbestand (.pyproj). Dit bestand is alleen zichtbaar in Visual Studio wanneer het project is geopend, maar is uitgeladen. Het project heeft ook een Python-bestand (.py) voor de toepassingscode.

2. Open het Python_CustomCommands.py toepassingsbestand in de editor en voeg de volgende code toe:

   print("Hello custom commands")
   

3. Klik in Solution Explorer met de rechtermuisknop op het Python-project, selecteer Python en let op de opdrachten in het contextmenu. Momenteel zijn de enige opdrachten in het contextmenu PyLint en Mypy uitvoeren. Wanneer u aangepaste opdrachten definieert, worden deze ook weergegeven in dit menu.

4. Start een afzonderlijke editor buiten uw Visual Studio-sessie en open het Python-projectbestand (Python-CustomCommands.pyproj) in de editor. (Open het projectbestand (.pyproj) en niet het Python-toepassingsbestand (.py).)

5. Zoek in het projectbestand het afsluitende </Project> element aan het einde van het bestand en voeg de volgende XML toe direct vóór het afsluitende element:

   <PropertyGroup>
     <PythonCommands>
       $(PythonCommands);
     </PythonCommands>
   </PropertyGroup>
   

6. Sla de wijzigingen in het projectbestand op en ga terug naar Visual Studio. Visual Studio detecteert wijzigingen in het projectbestand en vraagt u actie te ondernemen. Selecteer bij de prompt Opnieuw laden om uw geopende project bij te werken met de wijzigingen in het projectbestand.

7. Klik in Solution Explorer met de rechtermuisknop op het Python-project, selecteer Python en controleer de opdrachten in het contextmenu.

   In het contextmenu worden nog steeds alleen de opdrachten PyLint uitvoeren en Mypy uitvoeren weergegeven. De code die u zojuist hebt toegevoegd aan het projectbestand, repliceert gewoon de standaardeigenschapsgroep <PythonCommands> die de Opdracht PyLint bevat. In de volgende stap voegt u meer code toe voor de aangepaste opdracht.

8. Schakel over naar de editor waar u het projectbestand bijwerkt. Voeg de volgende <Target> elementdefinitie toe binnen het <Project> element. U kunt de <Target> definitie vóór of na de <PropertyGroup> eerder beschreven definitie positioneren.

   Dit <Target> element definieert een aangepaste opdracht voor het uitvoeren van het opstartbestand voor het project (geïdentificeerd door de eigenschap StartupFile ) met behulp van de python.exe opdracht in een consolevenster. De kenmerkdefinitie ExecuteIn="consolepause" maakt gebruik van een console die wacht totdat u een sleutel selecteert om het consolevenster te sluiten.

   <Target Name="Example_RunStartupFile" Label="Run startup file" Returns="@(Commands)">
     <CreatePythonCommandItem
       TargetType="script"
       Target="$(StartupFile)"
       Arguments=""
       WorkingDirectory="$(MSBuildProjectDirectory)"
       ExecuteIn="consolepause">
       <Output TaskParameter="Command" ItemName="Commands" />
     </CreatePythonCommandItem>
   </Target>
   

9. Vervang de <PythonCommands> eigenschapsgroep (toegevoegd in stap 5) door de volgende XML. Deze syntaxis definieert het Name kenmerk voor het <Target> element, waarmee de aangepaste opdracht wordt toegevoegd aan het contextmenu van Python . De opdracht heeft het menulabel Opstartbestand uitvoeren.

     <PythonCommands>
       $(PythonCommands);
       Example_RunStartupFile
     </PythonCommands>
   

   Aanbeveling

   Als u de aangepaste opdracht wilt weergeven in het contextmenu voordat de standaardopdrachten die in het $(PythonCommands) token zijn gedefinieerd, plaatst u de <Target> syntaxis voor uw opdracht vóór dat token.

10. Sla de wijzigingen in het projectbestand op en ga terug naar Visual Studio. Laad uw project opnieuw op de prompt.

11. Klik in Solution Explorer met de rechtermuisknop op het Python-project, selecteer Python en controleer de opdrachten opnieuw in het contextmenu.

    De aangepaste opdracht Opstartbestand uitvoeren bevindt zich nu in het menu. Als u de aangepaste opdracht niet ziet, controleert u of u de Name kenmerkwaarde voor het <Target> element hebt toegevoegd aan het <PythonCommands> element, zoals beschreven in stap 9. Bekijk ook de overwegingen die worden vermeld in de sectie Probleemoplossing verderop in dit artikel.

    

12. Selecteer de opdracht Opstartbestand uitvoeren . Er wordt een consolevenster geopend en de tekst Hallo aangepaste opdrachten weergegeven, gevolgd door Druk op een willekeurige toets om door te gaan. Bevestig de uitvoer en sluit het consolevenster.

    

    Opmerking

    Het aangepaste opdrachtscript wordt uitgevoerd in de geactiveerde omgeving voor uw Python-project.

13. Schakel over naar de editor met het projectbestand. Wijzig in de <Target> elementdefinitie (toegevoegd in stap 8) de waarde van het ExecuteIn kenmerk in output.

      <CreatePythonCommandItem
        ...
        ExecuteIn="output">
        ...
      </CreatePythonCommandItem>
    

14. Sla uw wijzigingen op, ga terug naar Visual Studio en laad uw project opnieuw.

15. Selecteer opnieuw de aangepaste opdracht Opstartbestand uitvoeren in het contextmenu van Python . De programma-uitvoer wordt nu weergegeven in het visual studio-uitvoervenster in plaats van een consolevenster:

    

16. Als u meer aangepaste opdrachten wilt toevoegen, volgt u hetzelfde proces:

    1. Definieer een geschikt element voor de aangepaste <Target> opdracht in het projectbestand.

    2. Voeg de Name kenmerkwaarde voor het <Target> element toe aan de <PythonCommands> eigenschapsgroep.

    3. Sla uw wijzigingen op in het projectbestand.

    4. Laad uw project opnieuw in Visual Studio.

Projecteigenschappen gebruiken

Als u wilt verwijzen naar projecteigenschappen of omgevingsvariabelen in <Target> elementkenmerkwaarden, gebruikt u de eigenschapsnaam binnen een $() token, zoals $(StartupFile) en $(MSBuildProjectDirectory). Zie MSBuild-eigenschappenvoor meer informatie.

Als u een opdracht zoals ($StartupFile) die gebruikmaakt van projecteigenschappen zoals de eigenschap StartupFile aanroept en de opdracht mislukt omdat het token niet is gedefinieerd, wordt de opdracht door Visual Studio uitgeschakeld totdat u het project opnieuw laadt. Als u wijzigingen aanbrengt in het project waarmee de eigenschapsdefinitie wordt gewijzigd, wordt de status van de gerelateerde opdracht niet vernieuwd. In dit geval moet u het project nog steeds opnieuw laden.

Inzicht in <de structuur van het doelelement>

U definieert de details voor een aangepaste opdracht met behulp van het <Target> element. De algemene vorm van het <Target> element wordt weergegeven in de volgende pseudocode:

<Target Name="Name1" Label="Display Name" Returns="@(Commands)">
    <CreatePythonCommandItem Target="filename, module name, or code"
        TargetType="executable/script/module/code/pip"
        Arguments="..."
        ExecuteIn="console/consolepause/output/repl[:Display name]/none"
        WorkingDirectory="..."
        ErrorRegex="..."
        WarningRegex="..."
        RequiredPackages="...;..."
        Environment="...">

      <!-- Output always appears in this form, with these exact attributes -->
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Doelkenmerken

De volgende tabel bevat de <Target> elementkenmerken.

Kenmerken van CreatePythonCommandItem

Het <Target> element bevat <CreatePythonCommandItem> en <Output> elementen, waarmee het gedetailleerde gedrag voor de aangepaste opdracht wordt gedefinieerd. De volgende tabel bevat de beschikbare <CreatePythonCommandItem> elementkenmerken. Alle kenmerkwaarden zijn hoofdletterongevoelig.

Benoemde capture-groepen voor reguliere expressies

Wanneer Visual Studio fouten en waarschuwingen van de uitvoer van aangepaste opdrachten parseert, worden reguliere expressies in de ErrorRegex en WarningRegex kenmerkwaarden verwacht voor gebruik van de volgende benoemde groepen:

• (?<message>...): Tekst van de fout.
• (?<code>...): foutcodewaarde.
• (?<filename>...): Naam van het bestand waarvoor de fout wordt gerapporteerd.
• (?<line>...): Regelnummer van de locatie in het bestand waarvoor de fout wordt gerapporteerd.
• (?<column>...): Kolomnummer van de locatie in het bestand waarvoor de fout wordt gerapporteerd.

PyLint produceert bijvoorbeeld waarschuwingen van het volgende formulier:

************* Module hello
C:  1, 0: Missing module docstring (missing-docstring)

Om Visual Studio de juiste informatie uit deze waarschuwingen te laten extraheren en weer te geven in het venster Foutenlijst , is de WarningRegex kenmerkwaarde voor de opdracht Pylint uitvoeren als volgt:

^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]

Aangepaste opdrachten importeren met doelenbestand

Als u aangepaste opdrachten definieert in een Python-projectbestand, zijn de opdrachten alleen beschikbaar voor dat specifieke project. Wanneer u aangepaste opdrachten wilt maken en deze in meerdere projecten wilt gebruiken, kunt u de <PythonCommands> eigenschapsgroep definiëren met al uw <Target> elementen in een doelenbestand (.targets) en dat bestand vervolgens importeren in uw Python-projecten.

• Het doelbestand gebruikt dezelfde indeling en syntaxis om aangepaste opdrachten te definiëren zoals beschreven voor het Python-projectbestand (.pyproj). De algemene elementen die moeten worden geconfigureerd, zijn onder andere<PythonCommands>, <Target><CreatePythonCommandItem>en<Output>:

  <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     <PropertyGroup>
       <PythonCommands>
         $(PythonCommands);
         <!-- Additional command names -->
       </PythonCommands>
     </PropertyGroup>
  
     <Target Name="..." Label="..." Returns="@(Commands)">
       <!-- CreatePythonCommandItem and Output elements... -->
     </Target>
  
     <!-- Any number of additional Target elements-->
  </Project>
  

• Als u een doelbestand in uw project wilt importeren, voegt u een <Import Project="(path)"> element toe ergens binnen het <Project> element in uw projectbestand.

  Als u bijvoorbeeld een projectbestand hebt met de naam CustomCommands.targets in een doelmap in uw Python-project, voegt u de volgende code toe aan uw projectbestand:

  <Import Project="targets/CustomCommands.targets"/>
  

• Als uw projectbestand een doelbestand importeert en u wijzigingen aanbrengt in het doelbestand terwijl uw project is geopend in Visual Studio, moet u de Visual Studio-oplossingopnieuw bouwen die uw project bevat, en niet alleen uw project.

  

Voorbeeldopdrachten

De volgende secties bevatten voorbeeldcode die u kunt gebruiken om aangepaste opdrachten voor uw Python-projecten te definiëren.

PyLint uitvoeren (moduledoel)

De volgende code wordt weergegeven in het bestand Microsoft.PythonTools.targets :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);PythonRunPyLintCommand</PythonCommands>
  <PyLintWarningRegex>
    <![CDATA[^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]>
  </PyLintWarningRegex>
</PropertyGroup>

<Target Name="PythonRunPyLintCommand"
        Label="resource:Microsoft.PythonTools.Common;Microsoft.PythonTools.Common.Strings;RunPyLintLabel"
        Returns="@(Commands)">
  <CreatePythonCommandItem Target="pylint.lint"
                           TargetType="module"
                           Arguments="&quot;--msg-template={abspath}({line},{column}): warning {msg_id}: {msg} [{C}:{symbol}]&quot; -r n @(Compile, ' ')"
                           WorkingDirectory="$(MSBuildProjectDirectory)"
                           ExecuteIn="output"
                           RequiredPackages="pylint&gt;=1.0.0"
                           WarningRegex="$(PyLintWarningRegex)">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Voer pip install uit voor een specifiek pakket (pip target)

Met de volgende opdracht wordt de pip install my-package opdracht uitgevoerd in het venster Uitvoer van Visual Studio. U kunt een dergelijke opdracht gebruiken wanneer u een pakket ontwikkelt en de installatie test. Het <Target> element bevat de pakketnaam in plaats van de install opdracht, die wordt aangenomen wanneer u de ExecuteIn="output" kenmerkdefinitie gebruikt.

<PropertyGroup>
  <PythonCommands>$(PythonCommands);InstallMyPackage</PythonCommands>
</PropertyGroup>

<Target Name="InstallMyPackage" Label="pip install my-package" Returns="@(Commands)">
  <CreatePythonCommandItem Target="my-package" TargetType="pip" Arguments=""
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Verouderde pip-pakketten weergeven (pip target)

Met de volgende opdracht wordt pip uitgevoerd met de list functie om verouderde PIP-pakketten te identificeren:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowOutdatedPackages</PythonCommands>
</PropertyGroup>

<Target Name="ShowOutdatedPackages" Label="Show outdated pip packages" Returns="@(Commands)">
  <CreatePythonCommandItem Target="list" TargetType="pip" Arguments="-o --format columns"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="consolepause">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Uitvoerbaar bestand uitvoeren met consolepause

Met de volgende opdracht wordt de where functie uitgevoerd om de locatie van Python-bestanden weer te geven die beginnen vanuit de projectmap:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowAllPythonFilesInProject</PythonCommands>
</PropertyGroup>

<Target Name="ShowAllPythonFilesInProject" Label="Show Python files in project" Returns="@(Commands)">
  <CreatePythonCommandItem Target="where" TargetType="executable" Arguments="/r . *.py"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Server uitvoeren en foutopsporingsserveropdrachten uitvoeren

Bekijk de opslagplaats Microsoft.PythonTools.Web.target op GitHub om te ontdekken hoe de opdrachten voor de server starten en foutopsporingsserver starten voor webprojecten worden gedefinieerd.

Pakket installeren voor ontwikkeling

Met de volgende code wordt PIP uitgevoerd om pakketten te installeren:

<PropertyGroup>
  <PythonCommands>PipInstallDevCommand;$(PythonCommands);</PythonCommands>
</PropertyGroup>

<Target Name="PipInstallDevCommand" Label="Install package for development" Returns="@(Commands)">
    <CreatePythonCommandItem Target="pip" TargetType="module" Arguments="install --editable $(ProjectDir)"
        WorkingDirectory="$(WorkingDirectory)" ExecuteIn="Repl:Install package for development">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Van fxthomas/Example.pyproj.xml (GitHub), gebruikt met machtiging.

Windows Installer genereren

Met het volgende script wordt een Windows Installer gegenereerd:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWinInstCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWinInstCommand" Label="Generate Windows Installer" Returns="@(Commands)">
    <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
        Arguments="bdist_wininst --user-access-control=force --title &quot;$(InstallerTitle)&quot; --dist-dir=&quot;$(DistributionOutputDir)&quot;"
        WorkingDirectory="$(WorkingDirectory)" RequiredPackages="setuptools"
        ExecuteIn="Repl:Generate Windows Installer">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Van fxthomas/Example.pyproj.xml (GitHub), gebruikt met machtiging.

Python-wielpakket genereren

Met het volgende script wordt een Python-wielpakket gegenereerd:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWheelCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWheelCommand" Label="Generate Wheel Package" Returns="@(Commands)">

  <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
      Arguments="bdist_wheel --dist-dir=&quot;$(DistributionOutputDir)&quot;"
      WorkingDirectory="$(WorkingDirectory)" RequiredPackages="wheel;setuptools"
      ExecuteIn="Repl:Generate Wheel Package">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Van fxthomas/Example.pyproj.xml (GitHub), gebruikt met machtiging.

Problemen met aangepaste opdrachten oplossen

Bekijk de volgende secties voor mogelijke problemen met betrekking tot het werken met aangepaste opdrachten.

Projectbestand is niet geladen

Dit foutbericht geeft aan dat u syntaxisfouten in het projectbestand hebt. Het bericht bevat de specifieke fout met een regelnummer en een tekenpositie.

Het consolevenster wordt gesloten nadat de opdracht is uitgevoerd

Als het consolevenster direct wordt gesloten nadat de opdracht is uitgevoerd, gebruikt u de ExecuteIn="consolepause" kenmerkdefinitie in plaats van ExecuteIn="console".

Opdracht ontbreekt in het menu

Als u de aangepaste opdracht niet ziet in het contextmenu van Python , controleert u de volgende items:

• Controleer of de opdracht is opgenomen in de <PythonCommands> eigenschapsgroep.
• Controleer of de opdrachtnaam zoals gedefinieerd in de opdrachtlijst overeenkomt met de naam die is opgegeven in het <Target> element.

Dit is een voorbeeld. In het volgende XML-fragment komt de Example naam in de <PythonCommands> eigenschapsgroep niet overeen met de ExampleCommand naam in de <Target> elementdefinitie. Visual Studio vindt geen opdracht met de naam Example, dus er wordt geen opdracht weergegeven. ExampleCommand Gebruik deze in de opdrachtlijst of wijzig de naam van het doel in alleenExample.

  <PropertyGroup>
    <PythonCommands>$(PythonCommands);Example</PythonCommands>
  </PropertyGroup>
  <Target Name="ExampleCommand" Label="Example Command" Returns="@(Commands)">
    <!-- ... -->
  </Target>

Fout bij het uitvoeren van de opdracht, kan opdrachtdoel niet ophalen

Dit foutbericht geeft aan dat de inhoud van de <Target> of <CreatePythonCommandItem> elementen onjuist is.

Hier volgen enkele mogelijke redenen voor deze fout:

• Het vereiste <Target> elementkenmerk is leeg.
• Het vereiste TargetType kenmerk is leeg of bevat een niet-herkende waarde.
• Het vereiste ExecuteIn kenmerk is leeg of bevat een niet-herkende waarde.
• Het ErrorRegex kenmerk of WarningRegex kenmerk wordt opgegeven zonder de ExecuteIn="output" kenmerkdefinitie in te stellen.
• Niet-herkende kenmerken bestaan in het element. De kenmerkreferentie kan bijvoorbeeld verkeerd worden gespeld als Argumnets in plaats van Arguments.

Kenmerkwaarden kunnen leeg zijn als u verwijst naar een eigenschap die niet is gedefinieerd. Als u het token $(StartupFile) gebruikt, maar er geen opstartbestand is gedefinieerd in het project, wordt het token omgezet in een lege tekenreeks. In dergelijke gevallen wilt u mogelijk een standaardwaarde definiëren. De opdrachten voor de run-server en de foutopsporingsserver uitvoeren die zijn gedefinieerd in de projectsjablonen Bottle, Flask en Django gebruiken standaard het manage.py-bestand (als er geen opstartbestand van de server is opgegeven in de projecteigenschappen).

Visual Studio reageert niet meer, loopt vast

Als Visual Studio niet meer reageert en vastloopt wanneer u de aangepaste opdracht uitvoert, probeert u waarschijnlijk een consoleopdracht uit te voeren met de ExecuteIn="output" kenmerkdefinitie. In dergelijke gevallen kan Visual Studio vastlopen wanneer het de uitvoer probeert te parsen. Als u deze voorwaarde wilt voorkomen, gebruikt u in plaats daarvan de ExecuteIn="console" kenmerkdefinitie. Zie Probleem 3681 voor meer informatie.

Opdracht wordt niet herkend als uitvoerbaar programma of batchbestand

Wanneer u de TargetType="executable" kenmerkdefinitie instelt, moet de waarde in het Target kenmerk alleen de programmanaam zijn zonder argumenten, zoals python of python.exe alleen. In dit geval verplaatst u argumenten naar het Arguments kenmerk.