Parameters toevoegen aan een uitvoerbaar bestand via de .lnk-snelkoppeling in Windows

Bij het werken met snelkoppelingen in Windows, het is niet alleen maar dubbelklikken: je hebt vaak de .lnk nodig om een ​​uitvoerbaar bestand met specifieke argumenten te starten, zoals notepad.exe bestand.txt of schakelaars van het type /EDevDit is essentieel voor het automatiseren, debuggen en ervoor zorgen dat een app met de juiste context wordt geopend.

Naast de handmatige creatie via de interface zijn er tegenwoordig moderne methoden om snelkoppelingen te genereren en te beheren met parameters van PowerShell of met de Windows COM-engine Script Host (WSH). En als je uit een gebundelde omgeving komt (MSIX/AppX) of programma's tegenkomt die "alleen via hun snelkoppeling starten", zijn er technieken om Argumenten omleiden, manifesten aanpassen en verpakken met PSF zonder de ervaring te verstoren.

Wat betekent het om parameters toe te voegen aan een uitvoerbaar bestand vanuit een .lnk?

Een snelkoppeling (.lnk) is eenvoudigweg een bestand dat naar een bestemming (TargetPath) verwijst en, optioneel, argumenten toevoegen (Argumenten), een werkmap (WorkingDirectory), een pictogram, sneltoetsen en andere metadata. Deze argumenten ziet u bijvoorbeeld wanneer u notepad.exe C:\Notes\task.txt of je past een modifier toe zoals /veilig.

In zakelijke scenario's vertrouwen veel apps in het Startmenu op een launcher die een specifieke parameter doorgeeft aan het uitvoerbare bestand. Als die parameter ontbreekt, kan de app crashen of plotseling starten. onjuist gedragDaarom is het belangrijk om precies te identificeren welke snelkoppeling wordt uitgevoerd en met welke argumenten.

Als je die snelkoppeling wilt klonen of op grote schaal wilt implementeren, kun je dat doen met een script dat de .lnk direct genereert. Dit voorkomt de distributie van statische bestanden zoals Internet Explorer.lnk en geeft u in plaats daarvan de flexibiliteit om genereer ze on the fly in elk team.

Het komt ook vaak voor dat men de ervaring van een .lnk wil omzetten naar iets dat kan worden aangeroepen door tools die alleen .exe-bestanden accepteren. In dat geval is het belangrijk om de TargetPath + Argumenten + Werkmap via de snelkoppeling, of door een "launcher" te gebruiken die het .lnk-bestand voor u uitvoert.

Een snelkoppeling maken met parameters vanuit PowerShell (moderne methode)

PowerShell kan het COM-object van WScript.Shell Om .lnk-bestanden te bouwen zonder afhankelijk te zijn van reeds bestaande bestanden. Het is een moderne methode, ideaal voor implementaties en automatisering.

In dit voorbeeld wordt een snelkoppeling op het openbare bureaublad gemaakt die een programma met argumenten uitvoert en het pictogram, de werkmap en de vensterstijl instelt. Let op hoe deze worden toegewezen. Doelpad y argumenten:

$WshShell = New-Object -ComObject WScript.Shell
$Desktop   = [Environment]::GetFolderPath('CommonDesktopDirectory')
$LnkPath   = Join-Path $Desktop 'MiAplicacion.lnk'
$Shortcut  = $WshShell.CreateShortcut($LnkPath)

$Shortcut.TargetPath       = 'C:\\Rutas\\MiApp\\MiApp.exe'
$Shortcut.Arguments        = '/modo=admin /perfil=Default'
$Shortcut.WorkingDirectory = 'C:\\Rutas\\MiApp'
$Shortcut.IconLocation     = 'C:\\Rutas\\MiApp\\MiApp.exe,0'
$Shortcut.WindowStyle      = 1 # 1=Normal, 3=Maximizada, 7=Minimizada
$Shortcut.Hotkey           = 'CTRL+ALT+M'
$Shortcut.Save()

Als u het gedrag van een bestaande snelkoppeling wilt repliceren (bijvoorbeeld die Internet Explorer.lnk die u in uw implementaties hebt gekopieerd), kunt u de eigenschappen ervan lezen en een andere .lnk genereren met dezelfde lot en argumentenHoewel het in de meeste gevallen niet strikt noodzakelijk is, voorkomt u verrassingen als u duidelijk weet welke waarden een snelkoppeling kopieert.

Een snelkoppeling maken met WSH/VBScript (klassiek model)

Met Windows Script Host (WSH) kunt u VBScript en JScript native uitvoeren en wordt een objectmodel beschikbaar gesteld waarmee u snelkoppelingen makenHoewel het een ‘klassieke’ manier is, werkt het nog steeds op moderne Windows omdat WSH geïntegreerd is sinds Windows 98/2000 en beschikbaar is in NT 4.0 via de Optiepakket.

De logica is eenvoudig: u maakt een instantie van WScript.Shell, wijst het naar de map Bureaublad en gebruikt Snelkoppeling maken om het .lnk-bestand te bouwen. Van daaruit kunt u eigenschappen zoals TargetPath, Arguments, IconLocation, WindowStyle of Hotkey aanpassen en opslaan.

Basisvoorbeeld met visuele parameters en opties Geïnspireerd door Microsoft-ondersteuningsvoorbeelden (opnieuw weergegeven in VBScript/WSH):

Set WshShell = CreateObject("WScript.Shell")
Desktop = WshShell.SpecialFolders("Desktop")
Set Lnk = WshShell.CreateShortcut(Desktop & "\\EjemploWSH.lnk")

Lnk.TargetPath = "%windir%\\notepad.exe"
Lnk.Arguments = "C:\\Temp\\demo.txt"
Lnk.WorkingDirectory = "C:\\Temp"
Lnk.IconLocation = "C:\\miicono.ico"
Lnk.WindowStyle = 3 ' 3=Maximizada, 7=Minimizada, 4=Normal
Lnk.Hotkey = "ALT+CTRL+F"
Lnk.Save

Met WSH kunt u ook URL-snelkoppelingen maken. In dit geval heeft de snelkoppeling de extensie .URL en verwijst het TargetPath naar de webadres:

Set WshShell = CreateObject("WScript.Shell")
Desktop = WshShell.SpecialFolders("Desktop")
Set UrlLink = WshShell.CreateShortcut(Desktop & "\\SitioMicrosoft.URL")
UrlLink.TargetPath = "http://www.microsoft.com"
UrlLink.Save

Als u van Visual FoxPro komt, is het idee hetzelfde: WSH COM Automation stelt methoden beschikbaar zoals Snelkoppeling maken en equivalente eigenschappen, zodat u het patroon eenvoudig kunt vertalen naar uw voorkeurstaal.

“Mijn macro start alleen .exe, maar de app moet geopend worden via zijn .lnk”

Een echt geval: sommige games of tools ‘valideren’ hun Boot vanaf de snelkoppeling zelf. Als uw macroprogramma alleen draait .exe, nee .lnk, je hebt verschillende praktische opties.

Optie 1: Reproduceer de opstart van de snelkoppeling. Open de .lnk-eigenschappen en kopieer deze exact. Doel, argumenten y OpstartmapConfigureer vervolgens je macro om die exe met die argumenten aan te roepen, indien mogelijk beginnend in de corresponderende werkmap. In de meeste gevallen voldoet de interne verificatie van de app. met dezelfde parameters.

Optie 2: Gebruik een minimale launcherU kunt een klein uitvoerbaar bestand of script maken dat de snelkoppeling aanroept, bijvoorbeeld met PowerShell:

Start-Process -FilePath "C:\\Ruta\\a\\MiAcceso.lnk"

Of met de START-volgorde van cmd.exe, dat snelkoppelingen kan openen als u het juiste pad en een lege titel tussen aanhalingstekens:

cmd.exe /c start "" "C:\\Ruta\\a\\MiAcceso.lnk"

Als je absoluut een .exe nodig hebt, compileer dan een stub (bijvoorbeeld in C#) die de .lnk uitvoert of de exe aanroept met de argumenten die in de snelkoppeling zijn opgeslagen. Deze tactiek "verandert" de snelkoppeling in een aanroepbare snelkoppeling. macro-compatibel zonder de opstartlogica te wijzigen.

Hoe u kunt vaststellen of een Start-menustarter parameters nodig heeft

Voordat u een app in uw implementaties integreert, is het een goed idee om te controleren of de bijbehorende launchers in het Startmenu afhankelijk zijn van argumentenEen werkende methode om dit te detecteren is de volgende:

1. Installeer de Windows-applicatie op een testcomputer.
2. Open de Start Menu en zoek de applicatiestarter.
3. Start elke bijbehorende launcher. Als deze zonder problemen start, zijn er waarschijnlijk geen specifieke parameters nodig.
4. Verwijder de applicatie van de testcomputer.
5. Installeer het nu met behulp van het traditionele Win32-installatieprogramma.
6. Ga terug naar Start Menu, zoek de app en klik met de rechtermuisknop.
7. Selecteer Meer > Open de bestandslocatie.
8. Open Eigenschappen voor elke gevonden snelkoppeling.
9. In het veld Doel, onderzoekt of argumenten na het uitvoerbare pad verschijnen.
10. Noteer deze parameters zodat u ze opnieuw kunt gebruiken in uw integratie of verpakking.

Met deze informatie kunt u het uitvoeringspatroon (uitvoerbaar bestand + argumenten + opstartmap) exact repliceren bij het maken van uw eigen snelkoppelingen of bij het bouwen van opstartscripts.

Windows-apps (MSIX/AppX): omleiding, PSF en waarom ze soms ‘niet goed starten’

De apps verpakte omleidingsbronnen naar C:\\Program Files\\WindowsAppsAls een applicatie probeert te schrijven in die geïsoleerde container, loopt deze tegen toestemmingsfouten aan en kan deze taken zoals: Instellingen opslaan of creëer tijdelijke bestanden.

Om dit aan te pakken, maakt het Package Support Framework (PSF) de introductie mogelijk van een tussenliggende launcher en omleidingsregels die het gedrag aanpassen zonder de oorspronkelijke binaire code aan te passen. Op operationeel niveau doorloopt de typische workflow vier fasen:

1. De app in een lokale directory plaatsen.
2. Maak het config.json van PSF en voeg de relevante PSF-binaries in.
3. Update AppxManifest dat de launcher PSFLauncher zou zijn.
4. Herpak en onderteken het MSIX-pakket.

Met deze aanpak kunt u de launcher opnieuw configureren, argumenten toevoegen via PSF en werkpaden omleiden, allemaal zonder de origineel uitvoerbaar bestand van de applicatie.

Benodigde hulpmiddelen voor stroming met PSF

naar PSF implementeren en de app opnieuw verpakken, heb je het volgende nodig:

• Klant van NuGet (nuget.exe).
• Pakketondersteuningsframework (Microsoft.PackageSupportFramework).
• Windows 10 SDK (recente versie) met hulpprogramma's zoals maakappx y tekengereedschap.
• Sysinternals Process Monitor (optioneel, zeer nuttig voor het diagnosticeren bestandstoegang en registratie).

Download nuget.exe en plaats het bijvoorbeeld in C:\\PSF\\nugetInstalleer vervolgens PSF via NuGet in een werkmap vanuit PowerShell met verhoogde rechten:

Set-Location "C:\\PSF"
.\nuget\nuget.exe install Microsoft.PackageSupportFramework

Controleer voor Windows 10 SDK tijdens de installatie ten minste: Signing Tools voor desktop-apps, SDK voor C++ UWP-apps en de componenten van plaats van de SDK. Deze onderdelen bevatten alles wat nodig is voor verpakking en ondertekening.

App Staging: MSIX uitpakken

Definieer eerst variabelen voor het pakketpad, staging-map, architectuur en SDK-versie. Een voorbeeldconfiguratie zou zijn:

$AppPath = "C:\\PSF\\SourceApp\\PSFSampleApp.msix"        # Instalador MSIX
$StagingFolder = "C:\\PSF\\Staging\\PSFSampleApp"         # Carpeta de staging
$OSArchitecture = "x$((gcim Win32_Processor).AddressWidth)"     # x64 o x86
$Win10SDKVersion = "10.0.19041.0"                              # Versión del SDK

Nadat de SDK is geïnstalleerd, gebruikt u makeappx om uitpakken MSIX in staging:

Set-Location "${env:ProgramFiles(x86)}\\Windows Kits\\10\\Bin\\$Win10SDKVersion\\$OSArchitecture"
.\makeappx.exe unpack /p "$AppPath" /d "$StagingFolder"

Na deze stap wordt de inhoud van het pakket opgeslagen in een bewerkbare map. Dit stelt u in staat om PSFLauncher, de runtime en het JSON-configuratiebestand met de benodigde argumenten.

Maak PSF config.json en voeg binaire bestanden in

Maak een bestand in de staging directory config.json die elke applicatie binnen het pakket beschrijft die aanpassingen vereist. De minimale basis omvat id, uitvoerbaar y argumenten:

{
  "applications": [
    {
      "id": "",
      "executable": "",
      "arguments": ""
    }
  ]
}

Open de AppxManifest.xml van het pakket en zoek het knooppunt . Neemt de waarde van zijn attribuut Uitvoerbaar en gebruik het in het uitvoerbare veld van config.json; lijn ook de id met de applicatie-ID in het manifest. Voeg indien van toepassing toe werkmap die naar de juiste relatieve map verwijst.

Een representatief voorbeeld van config.json met specifieke argumenten:

{
  "applications": [
    {
      "id": "PSFSample",
      "executable": "VFS/ProgramFilesX64/PS Sample App/PSFSample.exe",
      "arguments": "/bootfromsettingshortcut"
    }
  ]
}

Kopieer vanuit het PSF-pakket dat u van NuGet hebt gedownload de binaire bestanden voor uw architectuur (x64/x86) naar de root van de staging-omgeving: PSFLauncher32/64.exe, PSFRuntime32/64.dll y PSFRunDll32/64.exe. Hiermee wordt het pakket uitgerust met de launcher en runtime van PSF.

AppxManifest bijwerken om PSFLauncher te gebruiken

Bewerk AppxManifest.xml en vervang het Uitvoerbare kenmerk van het knooppunt wijzen naar PSFLauncher32.exe o PSFLauncher64.exe, indien van toepassing. Het EntryPoint wordt doorgaans bewaard als Windows.FullTrustApplication:

<Applications>
  <Application Executable="PSFLauncher32.exe" EntryPoint="Windows.FullTrustApplication">
    ...
  </Application>
</Applications>

Hiermee verloopt de daadwerkelijke opstart van de app via PSFLauncher, die uw config.json, injecteert argumenten en past indien nodig bestands-/mapomleidingen toe.

Herverpakken en ondertekenen van de bijgewerkte MSIX

Definieer variabelen om de uiteindelijke MSIX te verpakken en te ondertekenen: uitvoerpad, codeondertekeningscertificaat en wachtwoord. Zorg ervoor dat u een geldig certificaat voor ondertekening.

$AppPath = "C:\\PSF\\SourceApp\\PSFSampleApp_Updated.msix"
$CodeSigningCert = "C:\\PSF\\Cert\\CodeSigningCertificate.pfx"
$CodeSigningPass = "<Password>"
$StagingFolder = "C:\\PSF\\Staging\\PSFSampleApp"
$OSArchitecture = "x$((gcim Win32_Processor).AddressWidth)"
$Win10SDKVersion = "10.0.19041.0"

Pakket van staging naar een nieuwe MSIX:

Set-Location "${env:ProgramFiles(x86)}\\Windows Kits\\10\\Bin\\$Win10SDKVersion\\$OSArchitecture"
.\makeappx.exe pack /p "$AppPath" /d "$StagingFolder"

En onderteken het pakket met SignTool.exe van de SDK:

Set-Location "${env:ProgramFiles(x86)}\\Windows Kits\\10\\Bin\\$Win10SDKVersion\\$OSArchitecture"
.\signtool.exe sign /v /fd sha256 /f $CodeSigningCert /p $CodeSigningPass $AppPath

Je hebt nu een PSF-verpakte MSIX die het juiste binaire bestand uitvoert met de vereiste argumentenen met omleidingen voor het geval de toepassing dat nodig heeft.

Handmatige methode: maak een snelkoppeling met een parameter vanuit de Verkenner

Als u het liever handmatig doet, is het grafische proces eenvoudig: klik met de rechtermuisknop op het bureaublad > Nieuw> Snelkoppeling en voer in de locatie het uitvoerbare bestand in, gevolgd door de parameter, bijvoorbeeld:

"C:\\Rutas\\MiApp\\MiApp.exe" /EDev

Nadat u het een naam hebt gegeven, opent u de Eigenschappen en past u indien nodig de Opstartmap, het pictogram (tabblad Snelkoppeling > Pictogram wijzigen) en de sneltoets. Deze methode is snel voor het valideren van argumenten zoals /EDev zonder scripts te schrijven.

Het genereren van .lnk “on the fly” in implementaties: van kopiëren naar maken

Als uw pakket eerder een "Internet Explorer.lnk" heeft gekopieerd en u wilt nu dat het proces "inhoudsloos" is (d.w.z. de .lnk bestaat niet in het pakket en is dynamisch creëren), PowerShell is de voorkeursroute in moderne omgevingen.

Un script .ps1 voorbeeld dat u in uw implementatietool kunt integreren:

$Shell = New-Object -ComObject WScript.Shell
$Shortcut = $Shell.CreateShortcut("$env:Public\\Desktop\\IE.lnk")
$Shortcut.TargetPath = "$env:ProgramFiles\\Internet Explorer\\iexplore.exe"
$Shortcut.Arguments = "https://intranet.empresa.local"
$Shortcut.WorkingDirectory = "$env:ProgramFiles\\Internet Explorer"
$Shortcut.IconLocation = "$env:ProgramFiles\\Internet Explorer\\iexplore.exe,0"
$Shortcut.Save()

Met deze aanpak vermijdt u de distributie van statische bestanden en kunt u zich aanpassen argumenten, iconen en routes afhankelijk van het team of het beleid van de organisatie, allemaal tijdens runtime.

Goede praktijken en snelle tips

• Controleer altijd de werkdirectory. Veel apps gebruiken relatieve paden, dus als u deze niet instelt Werkmap naar het uitvoerbare bestand, kunnen er fouten of afwijkend gedrag optreden bij het laden van configuratiebestanden.
• Escape-paden en argumenten met spaties met behulp van dubbele aanhalingstekens. In Shortcuts wordt het TargetPath meestal tussen aanhalingstekens geplaatst; argumenten kunnen dit ook vereisen als ze spaties bevatten. ruimten of speciale tekens.
• Als de snelkoppeling omgevingsvariabelen gebruikt (%windir%, %ProgramFiles%), respecteer deze dan bij het aanmaken van de .lnk. Op deze manier blijft de snelkoppeling ongewijzigd. portable tussen machines met verschillende paden (bijv. x86 vs. x64).
• Voor diagnostiek op MSIX kunt u vertrouwen op Process Monitor. U ziet wat de app probeert te openen, waar dit mislukt vanwege machtigingen en wat er gebeurt. omleidingsregels die je nodig hebt in PSF.
• Versieer uw .ps1-scripts en documenteer de argumenten. Een korte README bij het script bespaart tijd bij het wijzigen van parameters zoals /profiel, debug-schakelaars of speciale opstartmodi.

Meer praktische WSH-voorbeelden (geïnspireerd op klassieke documentatie)

Argumentgerichte variatie: open Visual FoxPro/Visual Studio met een configuratiebestand, instelling van vensterstijl, pictogram en opstartmap:

Set WshShell = CreateObject("WScript.Shell")
Desktop = WshShell.SpecialFolders("Desktop")
Set S = WshShell.CreateShortcut(Desktop & "\\DevConfig.lnk")
S.WindowStyle = 7 ' Minimizada (0=Maximizada, 4=Normal)
S.IconLocation = "C:\\ruta\\builder.ico"
S.TargetPath = "C:\\Program Files\\Microsoft Visual Studio\\VFP98\\vfp6.exe"
S.Arguments = "-c \"C:\\Rutas\\config.fpw\""
S.WorkingDirectory = "C:\\"
S.Save

Snelkoppeling naar een bedrijfs-URL met de extensie .URL. Handig voor het distribueren van toegang tot interne portalen of handleidingen:

Set WshShell = CreateObject("WScript.Shell")
Desktop = WshShell.SpecialFolders("Desktop")
Set U = WshShell.CreateShortcut(Desktop & "\\PortalEmpresa.URL")
U.TargetPath = "https://intranet.empresa.local"
U.Save

Wanneer moet u welke methode kiezen?

PowerShell: ideaal voor moderne implementaties, GPO's, Intune, SCCM en implementatietaken. automatiseringDit is de aanbevolen methode als u geen kant-en-klare .lnk-bestanden wilt verspreiden.

WSH/VBScript: Perfect als u oude scripts erft of als u de compatibiliteit met legacy-omgevingenDe COM API van WScript.Shell is stabiel en zeer eenvoudig.

PSF met MSIX/AppX: essentieel wanneer de Start-menustarter parameters nodig heeft of wanneer een verpakte app omleidingen om goed te functioneren. Hiermee kunt u het gedrag aanpassen zonder de originele binaire code aan te passen.

Handmatige methode: handig voor snelle tests, maak een ad-hoc-snelkoppeling met een parameter (zoals /EDev) of de haalbaarheid aantonen voordat u het met scripts automatiseert.

Of u nu parameters aan een uitvoerbaar bestand wilt toevoegen via een snelkoppeling, het .lnk-bestand "on the fly" met PowerShell wilt genereren of zelfs te maken hebt met MSIX-pakketten die PSF vereisen, hier is het complete repertoire: argumenten identificeren in het menu Start, snelkoppelingen maken met WSH/PowerShell, beperkingen omzeilen van hulpprogramma's die alleen .exe-bestanden starten en apps opnieuw verpakken met PSF, zodat alles start zoals de gebruiker verwacht.