Magdagdag ng mga parameter sa isang executable mula sa .lnk shortcut nito sa Windows

Kapag nagtatrabaho ka gamit ang mga shortcut sa Windows, hindi lang lahat ng pag-double click: madalas mong kailangan ang .lnk para maglunsad ng executable na may mga partikular na argumento, gaya ng notepad.exe file.txt o mga switch ng uri /EDevIto ay susi sa pag-automate, pag-debug, o pagtiyak na magbubukas ang isang app sa tamang konteksto.

Bilang karagdagan sa manu-manong paglikha sa pamamagitan ng interface, ngayon ay may mga makabagong pamamaraan para bumuo at pamahalaan ang mga shortcut na may mga parameter mula sa PowerShell o gamit ang Windows COM engine Iskrip Host (WSH). At kung nanggaling ka sa mga naka-package na kapaligiran (MSIX/AppX) o nakatagpo ka ng mga program na "nagsisimula lamang sa kanilang shortcut", may mga diskarte upang I-redirect ang mga argumento, isaayos ang mga manifest, at package sa PSF nang hindi sinisira ang karanasan.

Ano ang ibig sabihin ng magdagdag ng mga parameter sa isang executable mula sa isang .lnk?

Ang shortcut (.lnk) ay isang file lamang na tumuturo sa isang destinasyon (TargetPath) at, opsyonal, ilakip ang mga argumento (Mga Argumento), isang gumaganang direktoryo (WorkingDirectory), isang icon, mga shortcut sa keyboard at iba pang metadata. Ang mga argumentong ito ay kung ano ang nakikita mo kapag, halimbawa, tumakbo ka notepad.exe C:\Notes\task.txt o mag-apply ka ng modifier tulad ng / ligtas.

Sa mga sitwasyon ng enterprise, maraming Start menu app ang umaasa sa isang launcher na nagpapasa ng isang partikular na parameter sa pangunahing executable. Kung nawawala ang parameter na iyon, maaaring mag-crash o magsimula ang app maling pag-uugali. Iyon ang dahilan kung bakit mahalagang tukuyin kung aling shortcut ang pinapatakbo at kung anong mga argumento.

Kung kailangan mong i-clone ang shortcut na iyon o i-deploy ito nang malaki, magagawa mo ito gamit ang isang script na bubuo ng .lnk sa mabilisang paraan. Iniiwasan nito ang pamamahagi ng mga static na file tulad ng Internet Explorer.lnk at sa halip ay nagbibigay sa iyo ng kakayahang umangkop sa bumuo ng mga ito sa mabilisang sa bawat pangkat.

Karaniwan din na gustong i-convert ang karanasan ng isang .lnk sa isang bagay na maaaring gamitin ng mga tool na tumatanggap lamang ng mga .exe na file. Sa kasong iyon, ang susi ay upang kopyahin ang TargetPath + Mga Pangangatwiran + WorkingDirectory mula sa shortcut, o paggamit ng "launcher" na nagpapatakbo ng .lnk para sa iyo.

Gumawa ng shortcut na may mga parameter mula sa PowerShell (modernong paraan)

Maaaring gamitin ng PowerShell ang COM object ng WScript.Shell upang bumuo ng mga .lnk na file nang hindi umaasa sa mga dati nang file. Isa itong modernong paraan, perpekto para sa mga deployment at automation.

Ang halimbawang ito ay lumilikha ng isang shortcut sa pampublikong desktop na nagpapatakbo ng isang programa na may mga argumento at nagtatakda ng icon, gumaganang direktoryo, at istilo ng window. Pansinin kung paano itinalaga ang mga ito. TargetPath y Mga argumento:

$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()

Kung gusto mong kopyahin ang pag-uugali ng isang umiiral na shortcut (halimbawa, iyon Internet Explorer.lnk na kinopya mo sa iyong mga deployment), maaari mong basahin ang mga katangian nito, at bumuo ng isa pang .lnk na may parehong tadhana at argumentoBagaman hindi ito mahigpit na kinakailangan para sa karamihan ng mga kaso, ang pagiging malinaw tungkol sa kung aling mga halaga ang isang shortcut na kopya ay maiiwasan ang mga sorpresa.

Gumawa ng shortcut gamit ang WSH/VBScript (classic na modelo)

Binibigyang-daan ka ng Windows Script Host (WSH) na patakbuhin ang VBScript at JScript sa katutubong paraan at inilalantad ang isang object model kung saan maaari mong gamitin. gumawa ng mga shortcut. Bagama't isa itong "classic" na paraan, gumagana pa rin ito sa modernong Windows dahil isinama ang WSH mula pa noong Windows 98/2000 at available sa NT 4.0 sa pamamagitan ng Options Package.

Ang lohika ay simple: i-instantiate mo ang WScript.Shell, ituro ito sa folder ng Desktop at gamitin Lumikha ngShortcut upang itayo ang .lnk. Mula doon, iko-customize mo ang mga property tulad ng TargetPath, Mga Argumento, IconLocation, WindowStyle, o Hotkey, at i-save.

Pangunahing halimbawa na may visual na mga parameter at mga pagpipilian May inspirasyon ng mga halimbawa ng suporta ng Microsoft (muling ipinahayag sa 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

Pinapayagan ka rin ng WSH na lumikha ng mga shortcut ng URL. Sa kasong ito, ang shortcut ay may .URL extension at ang TargetPath ay tumuturo sa web address:

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

Kung nagmumula ka sa Visual FoxPro, pareho ang ideya: Ang WSH COM Automation ay naglalantad ng mga pamamaraan tulad ng Lumikha ngShortcut at mga katumbas na katangian, upang madali mong maisalin ang pattern sa iyong gustong wika.

"Ang aking macro ay naglulunsad lamang ng .exe, ngunit ang app ay nangangailangan ng pagbubukas mula sa .lnk nito"

Isang tunay na kaso: ang ilang mga laro o tool ay "nagpapatunay" sa kanila boot mula sa shortcut mismo. Kung ang iyong macro program ay tumatakbo lamang Exe, hindi .lnk, mayroon kang ilang praktikal na opsyon.

Opsyon 1: I-reproduce ang startup ng shortcut. Buksan ang mga katangian ng .lnk at eksaktong kopyahin ito. Target, Mga argumento y Folder ng Startup. Pagkatapos, i-configure ang iyong macro para tawagan ang exe na iyon gamit ang mga argumentong iyon, simula sa kaukulang direktoryo ng gumagana kung maaari. Sa karamihan ng mga kaso, nasiyahan ang panloob na pag-verify ng app. na may parehong mga parameter.

Opsyon 2: Gumamit ng a minimal na launcherMaaari kang lumikha ng isang maliit na executable o script na humihiling ng shortcut. Halimbawa, gamit ang PowerShell:

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

O sa START order ng cmd.exe, na maaaring magbukas ng mga shortcut kung ipapasa mo ito sa tamang landas at a walang laman na pamagat sa mga panipi:

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

Kung talagang kailangan mo ng .exe, mag-compile ng stub (hal., sa C#) na nagpapatakbo ng .lnk o tumatawag sa exe na may mga argumentong nakaimbak sa shortcut. "Ginagawa" ng taktikang ito ang shortcut sa isang callable. macro compatible nang hindi binabago ang boot logic.

Paano matukoy kung ang isang Start menu launcher ay nangangailangan ng mga parameter

Bago isama ang isang app sa iyong mga deployment, magandang ideya na tingnan kung nasa Start menu ang mga launcher nito depende sa mga argumentoAng isang gumaganang paraan upang makita ito ay ang mga sumusunod:

1. I-install ang Windows application sa isang pansubok na computer.
2. Buksan ang Start Menu at hanapin ang application launcher.
3. Patakbuhin ang bawat nauugnay na launcher. Kung magsisimula ito nang walang problema, malamang na hindi ito nangangailangan ng anumang partikular na parameter.
4. I-uninstall ang application mula sa pansubok na computer.
5. I-install ito ngayon gamit ang tradisyonal na Win32 installer nito.
6. Bumalik ka sa Start Menu, hanapin ang app at i-right click.
7. Piliin ang Higit pa > Buksan ang lokasyon ng file.
8. Para sa bawat shortcut na natagpuan, buksan ang Properties.
9. Sa bukid Target, sinusuri kung lumilitaw ang mga argumento pagkatapos ng executable path.
10. Isulat ang mga parameter na ito upang magamit muli sa iyong pagsasama o packaging.

Gamit ang impormasyong ito, magagawa mong eksaktong kopyahin ang pattern ng pagpapatupad (executable + arguments + startup folder) kapag gumagawa ng sarili mong mga shortcut o kapag gumagawa ng mga startup script.

Windows Apps (MSIX/AppX): Pag-redirect, PSF, at Bakit Minsan "Huwag Magsimula nang Tama"

ang app naka-package na redirect resources sa C:\\Program Files\\WindowsAppsKung sinubukan ng isang application na magsulat sa loob ng nakahiwalay na lalagyan na iyon, magkakaroon ito ng mga error sa pahintulot at maaaring mabigo sa mga gawain tulad ng I-save ang mga setting o lumikha pansamantalang mga file.

Upang matugunan ito, ang Package Support Framework (PSF) ay nagbibigay-daan para sa pagpapakilala ng isang intermediate launcher at mga panuntunan sa pag-redirect na nagsasaayos ng gawi nang hindi hinahawakan ang orihinal na binary. Sa antas ng pagpapatakbo, ang karaniwang daloy ng trabaho ay dumadaan sa apat na yugto:

1. Isinasagawa ang app sa isang lokal na direktoryo.
2. Lumikha ng config.json mula sa PSF at ipasok ang nauugnay na mga binary ng PSF.
3. Update AppxManifest para ang launcher ay maging PSFLauncher.
4. I-repackage at lagdaan ang MSIX package.

Binibigyang-daan ka ng diskarteng ito na muling i-configure ang launcher, magdagdag ng mga argumento sa pamamagitan ng PSF, at i-redirect ang mga gumaganang landas, lahat nang hindi binabago ang orihinal na maipapatupad ng application.

Mga tool na kailangan para sa daloy sa PSF

Sa ipatupad ang PSF at i-repackage ang app na kakailanganin mo:

• Kliyente ng NuGet (nuget.exe).
• Package Support Framework (Microsoft.PackageSupportFramework).
• Windows 10 SDK (kamakailang bersyon) na may mga utility tulad ng makeappx y signtool.
• Sysinternals Process Monitor (opsyonal, lubhang kapaki-pakinabang para sa pag-diagnose pag-access ng file at pagpaparehistro).

I-download ang nuget.exe at ilagay ito, halimbawa, sa C:\\PSF\\nuget. Pagkatapos, mula sa PowerShell na may mataas na mga pribilehiyo, i-install ang PSF sa pamamagitan ng NuGet sa isang gumaganang folder:

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

Para sa Windows 10 SDK, sa panahon ng pag-install, suriin ang hindi bababa sa: Signing Tools para sa Desktop Apps, SDK para sa C++ UWP Apps, at ang mga bahagi ng lokasyon ng SDK. Ang mga piraso ay nagbibigay ng lahat ng kailangan para sa packaging at pagpirma.

App Staging: Pag-unpack ng MSIX

Unang tukuyin ang mga variable para sa path ng package, folder ng pagtatanghal ng dula, arkitektura, at bersyon ng SDK. Ang isang halimbawa ng pagsasaayos ay:

$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

Kapag naka-install ang SDK, gumamit ng makeappx to alisin MSIX sa pagtatanghal:

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

Pagkatapos ng hakbang na ito, ang mga nilalaman ng package ay iniimbak sa isang nae-edit na folder. Ito ay nagpapahintulot sa iyo na magdagdag PSFLauncher, ang runtime at ang configuration file ng JSON na may mga kinakailangang argumento.

Lumikha ng PSF config.json at maglagay ng mga binary

Sa direktoryo ng pagtatanghal ng dula, lumikha ng isang file config.json na naglalarawan sa bawat aplikasyon sa loob ng package na nangangailangan ng mga pagsasaayos. Kasama sa minimum na base id, pinatutupad y argumento:

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

Buksan ang AppxManifest.xml ng package at hanapin ang node . Kinukuha ang halaga ng katangian nito Maipapatupad at gamitin ito sa executable field ng config.json; ihanay din ang id kasama ang application identifier sa manifest. Kung naaangkop, idagdag workingdirectory na tumuturo sa naaangkop na kamag-anak na folder.

Isang kinatawan na halimbawa ng config.json na may mga partikular na argumento:

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

Mula sa PSF package na na-download mula sa NuGet, kopyahin ang mga binary para sa iyong arkitektura (x64/x86) hanggang sa ugat ng staging: PSFLauncher32/64.exe, PSFRuntime32/64.dll y PSFRunDll32/64.exe. Nilalaman nito ang pakete ng launcher at runtime mula sa PSF.

I-update ang AppxManifest para magamit ang PSFLauncher

I-edit ang AppxManifest.xml at palitan ang Executable attribute ng node upang ituro sa PSFLauncher32.exe o PSFLauncher64.exe, kung naaangkop. Ang EntryPoint ay karaniwang pinananatili bilang Windows.FullTrustApplication:

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

Sa pamamagitan nito, ang aktwal na pagsisimula ng app ay dumadaan sa PSFLauncher, na magbabasa ng iyong config.json, ay mag-iniksyon ng mga argumento at maglalapat ng mga pag-redirect ng file/folder kung kinakailangan.

I-repackage at lagdaan ang na-update na MSIX

Tukuyin ang mga variable upang i-package at lagdaan ang panghuling MSIX: path ng output, certificate sa pag-sign ng code, at password. Tiyaking mayroon kang a wastong sertipiko para sa lagda.

$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"

mag-impake mula sa pagtatanghal hanggang sa isang bagong MSIX:

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

At lagdaan ang pakete gamit signtool.exe mula sa SDK:

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

Mayroon ka na ngayong PSF-packaged MSIX na nagpapatakbo ng tamang binary sa mga kinakailangang argumento, at may mga pag-redirect kung sakaling kailanganin ito ng application.

Manu-manong paraan: gumawa ng shortcut na may parameter mula sa Explorer

Kung mas gusto mong gawin ito sa pamamagitan ng kamay, ang proseso ng grapiko ay simple: i-right click sa Desktop > Bago> Shortcut at sa lokasyon, ipasok ang executable na sinusundan ng parameter, halimbawa:

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

Matapos itong pangalanan, buksan ang Properties nito at ayusin, kung kailangan mo, ang Folder ng Startup, ang icon (Shortcut tab > Change Icon) at ang keyboard shortcut. Ang pamamaraang ito ay mabilis para sa pagpapatunay ng mga argumento tulad ng /EDev nang walang pagsulat ng mga script.

Pagbuo ng .lnk "on the fly" sa mga deployment: mula sa pagkopya hanggang sa paggawa

Kung dati nang kinopya ng iyong package ang isang "Internet Explorer.lnk" at gusto mo na ngayong maging "walang nilalaman" ang proseso (i.e. ang .lnk ay wala sa package at ito ay dynamic na lumikha), Ang PowerShell ay ang gustong ruta sa mga modernong kapaligiran.

Un script .ps1 halimbawa na maaari mong isama sa iyong tool sa pag-deploy:

$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()

Ang diskarte na ito ay umiiwas sa pamamahagi ng mga static na file at nagbibigay-daan sa iyo na umangkop mga argumento, icon at ruta depende sa team o sa patakaran ng organisasyon, lahat sa runtime.

Mga magagandang kasanayan at mabilis na tip

• Palaging suriin ang gumaganang direktoryo. Maraming mga app ang nagpapalagay ng mga kaugnay na landas, kaya kung hindi ka magtatakda WorkingDirectory sa executable, maaari kang makakuha ng mga error o abnormal na pag-uugali kapag naglo-load ng mga configuration file.
• Takasan ang mga landas at argumento na may mga puwang gamit ang double quotes. Sa Mga Shortcut, ang TargetPath ay karaniwang nakapaloob sa mga panipi; maaaring kailanganin din ng mga argumento ang mga ito kung isasama nila puwang o mga espesyal na karakter.
• Kung gumagamit ang shortcut ng mga variable ng kapaligiran (%windir%, %ProgramFiles%), igalang ang mga ito kapag gumagawa ng .lnk. Sa ganitong paraan, mananatiling pareho ang shortcut. portable sa pagitan ng mga makina na may iba't ibang landas (hal. x86 vs x64).
• Para sa mga diagnostic sa MSIX, umasa sa Process Monitor. Makikita mo kung ano ang sinusubukang buksan ng app, kung saan ito nabigo dahil sa mga pahintulot, at ano mga panuntunan sa pag-redirect kailangan mo sa PSF.
• Bersyon ng iyong .ps1 script at idokumento ang mga argumento. Ang isang maliit na README kasama ang script ay nakakatipid ng oras kapag binabago ang mga parameter tulad ng /profile, mga debug switch o mga espesyal na boot mode.

Mas praktikal na mga halimbawa ng WSH (inspirasyon ng klasikong dokumentasyon)

Variation na nakatuon sa argumento: bukas Visual FoxPro/Visual Studio na may configuration file, setting ng window style, icon at startup folder:

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

Shortcut sa isang corporate URL na may extension na .URL. Kapaki-pakinabang para sa pamamahagi ng access sa mga panloob na portal o mga manwal:

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

Kailan pipiliin ang bawat paraan

PowerShell: Tamang-tama para sa mga modernong deployment, GPO, Intune, SCCM, at mga gawain sa deployment. automation. Ito ang inirerekomendang paraan kung ayaw mong ipamahagi ang mga pre-made na .lnk file.

WSH/VBScript: Perpekto kapag nagmana ka ng mga lumang script o kung kailangan mong mapanatili ang pagiging tugma sa mga legacy na kapaligiran. Ang COM API ng WScript.Shell ay matatag at napakasimple.

PSF na may MSIX/AppX: Mahalaga kapag ang Start menu launcher ay nangangailangan ng mga parameter o kapag kailangan ng naka-package na app mga pag-redirect upang gumana ng maayos. Binibigyang-daan kang ayusin ang pag-uugali nang hindi hinahawakan ang orihinal na binary.

Manu-manong paraan: kapaki-pakinabang para sa mabilis na pagsubok, gumawa ng ad-hoc shortcut na may parameter (gaya ng /EDev) o ipakita ang pagiging posible bago ito i-automate gamit ang mga script.

Naghahanap ka mang magdagdag ng mga parameter sa isang executable mula sa shortcut nito, kailangang buuin ang .lnk "on the fly" gamit ang PowerShell, o kahit na kailangang harapin ang mga MSIX package na nangangailangan ng PSF, narito ang kumpletong repertoire: tukuyin ang mga argumento sa Start menu, gumawa ng mga shortcut gamit ang WSH/PowerShell, lutasin ang mga limitasyon ng mga tool na naglulunsad lang ng mga .exe file, at i-repackage ang mga app gamit ang PSF para magsimula ang lahat gaya ng inaasahan ng user.