Desidero creare un collegamento che punta a un file EXE, sul desktop, utilizzando .NET Framework 3.5 e facendo affidamento su un'API Windows ufficiale. Come lo posso fare?Crea collegamento sul desktop C#
risposta
collegamento URL
private void urlShortcutToDesktop(string linkName, string linkUrl)
{
string deskDir = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
using (StreamWriter writer = new StreamWriter(deskDir + "\\" + linkName + ".url"))
{
writer.WriteLine("[InternetShortcut]");
writer.WriteLine("URL=" + linkUrl);
writer.Flush();
}
}
scorciatoia applicazione
private void appShortcutToDesktop(string linkName)
{
string deskDir = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
using (StreamWriter writer = new StreamWriter(deskDir + "\\" + linkName + ".url"))
{
string app = System.Reflection.Assembly.GetExecutingAssembly().Location;
writer.WriteLine("[InternetShortcut]");
writer.WriteLine("URL=file:///" + app);
writer.WriteLine("IconIndex=0");
string icon = app.Replace('\\', '/');
writer.WriteLine("IconFile=" + icon);
writer.Flush();
}
}
anche controllare questi
se si desidera utilizzare alcune funzioni specifiche dell'API, si vorrà utilizzare lo IShellLink interface
come come IPersistFile interface
(tramite l'interoperabilità COM).
Here is an article that goes into detail what you need to do it, as well as sample code:
Questi funzionano correttamente. Ma voglio creare scorciatoie attraverso alcune funzioni API come DllImport ("coredll.dll")] public static extern int SHCreateShortcut (StringBuilder szShortcut, StringBuilder szTarget); –
@Vipin perché? C'è qualche ragione per cui una delle soluzioni di cui sopra non è abbastanza buona? – alex
un utente stupido può cambiarlo –
È possibile utilizzare questa classe ShellLink.cs per creare il collegamento.
Per ottenere la directory desktop, utilizzare:
var dir = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
o utilizzare Environment.SpecialFolder.CommonDesktopDirectory
di creare per tutti gli utenti.
Con le opzioni aggiuntive come tasto di scelta rapida, descrizione ecc
In un primo momento, Progetto > Aggiungi riferimento > COM > Windows Script Host Object Model.
using IWshRuntimeLibrary;
private void CreateShortcut()
{
object shDesktop = (object)"Desktop";
WshShell shell = new WshShell();
string shortcutAddress = (string)shell.SpecialFolders.Item(ref shDesktop) + @"\Notepad.lnk";
IWshShortcut shortcut = (IWshShortcut)shell.CreateShortcut(shortcutAddress);
shortcut.Description = "New shortcut for a Notepad";
shortcut.Hotkey = "Ctrl+Shift+N";
shortcut.TargetPath = Environment.GetFolderPath(Environment.SpecialFolders.System) + @"\notepad.exe";
shortcut.Save();
}
Questo ha funzionato bene per me. – tofutim
Questo è stato davvero vicino per me. Avevo bisogno di aggiungere la directory .exe alla proprietà "WorkingDirectory" sul collegamento. (shortcut.WorkingDirectory) +1 – samuelesque
Per specificare un indice di icona (in IconLocation), utilizzare un valore come "path_to_icon_file, #", dove # è l'indice dell'icona. Vedere https://msdn.microsoft.com/en-us/library/xsy6k3ys(v=vs.84).aspx – Chris
Usa ShellLink.cs a vbAccelerator per creare il collegamento con facilità!
private static void AddShortCut()
{
using (ShellLink shortcut = new ShellLink())
{
shortcut.Target = Application.ExecutablePath;
shortcut.WorkingDirectory = Path.GetDirectoryName(Application.ExecutablePath);
shortcut.Description = "My Shorcut";
shortcut.DisplayMode = ShellLink.LinkDisplayMode.edmNormal;
shortcut.Save(SHORTCUT_FILEPATH);
}
}
Questo link è ora morto, ma è possibile trovare una versione archiviata di esso [qui] (https://web.archive.org/web/20150414052035/http://www.vbaccelerator.com/home/NET/Code/ biblioteche/Shell_Projects/Creating_and_Modifying_Shortcuts/article.asp). –
Senza ulteriore riferimento:
using System;
using System.Runtime.InteropServices;
public class Shortcut
{
private static Type m_type = Type.GetTypeFromProgID("WScript.Shell");
private static object m_shell = Activator.CreateInstance(m_type);
[ComImport, TypeLibType((short)0x1040), Guid("F935DC23-1CF0-11D0-ADB9-00C04FD58A0B")]
private interface IWshShortcut
{
[DispId(0)]
string FullName { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0)] get; }
[DispId(0x3e8)]
string Arguments { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3e8)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3e8)] set; }
[DispId(0x3e9)]
string Description { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3e9)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3e9)] set; }
[DispId(0x3ea)]
string Hotkey { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3ea)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3ea)] set; }
[DispId(0x3eb)]
string IconLocation { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3eb)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3eb)] set; }
[DispId(0x3ec)]
string RelativePath { [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3ec)] set; }
[DispId(0x3ed)]
string TargetPath { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3ed)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3ed)] set; }
[DispId(0x3ee)]
int WindowStyle { [DispId(0x3ee)] get; [param: In] [DispId(0x3ee)] set; }
[DispId(0x3ef)]
string WorkingDirectory { [return: MarshalAs(UnmanagedType.BStr)] [DispId(0x3ef)] get; [param: In, MarshalAs(UnmanagedType.BStr)] [DispId(0x3ef)] set; }
[TypeLibFunc((short)0x40), DispId(0x7d0)]
void Load([In, MarshalAs(UnmanagedType.BStr)] string PathLink);
[DispId(0x7d1)]
void Save();
}
public static void Create(string fileName, string targetPath, string arguments, string workingDirectory, string description, string hotkey, string iconPath)
{
IWshShortcut shortcut = (IWshShortcut)m_type.InvokeMember("CreateShortcut", System.Reflection.BindingFlags.InvokeMethod, null, m_shell, new object[] { fileName });
shortcut.Description = description;
shortcut.Hotkey = hotkey;
shortcut.TargetPath = targetPath;
shortcut.WorkingDirectory = workingDirectory;
shortcut.Arguments = arguments;
if (!string.IsNullOrEmpty(iconPath))
shortcut.IconLocation = iconPath;
shortcut.Save();
}
}
per creare un collegamento sul desktop:
string lnkFileName = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "Notepad.lnk");
Shortcut.Create(lnkFileName,
System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "notepad.exe"),
null, null, "Open Notepad", "Ctrl+Shift+N", null);
Ecco un pezzo di codice che non ha dipendenza da un oggetto COM esterno (WSH), e supporta i programmi a 32 e 64 bit:
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
namespace TestShortcut
{
class Program
{
static void Main(string[] args)
{
IShellLink link = (IShellLink)new ShellLink();
// setup shortcut information
link.SetDescription("My Description");
link.SetPath(@"c:\MyPath\MyProgram.exe");
// save it
IPersistFile file = (IPersistFile)link;
string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
file.Save(Path.Combine(desktopPath, "MyLink.lnk"), false);
}
}
[ComImport]
[Guid("00021401-0000-0000-C000-000000000046")]
internal class ShellLink
{
}
[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("000214F9-0000-0000-C000-000000000046")]
internal interface IShellLink
{
void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, out IntPtr pfd, int fFlags);
void GetIDList(out IntPtr ppidl);
void SetIDList(IntPtr pidl);
void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName);
void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName);
void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath);
void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir);
void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath);
void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs);
void GetHotkey(out short pwHotkey);
void SetHotkey(short wHotkey);
void GetShowCmd(out int piShowCmd);
void SetShowCmd(int iShowCmd);
void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, int cchIconPath, out int piIcon);
void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon);
void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved);
void Resolve(IntPtr hwnd, int fFlags);
void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile);
}
}
Questa tecnica non funziona in Windows 8. – BrutalDev
@BrutalDev - Che cosa non funziona? L'ho provato su Windows 8 x64 e funziona. –
Anche eseguendo Win8 x64, copiato l'esempio di codice sopra esattamente come è, crea un'icona sul mio desktop senza percorso. L'esecuzione del collegamento apre semplicemente explorer sul desktop. Questo è un problema simile che ho avuto con ShellLink.cs ma in Windows XP/2003. L'unico esempio che funziona in modo definitivo su tutte le versioni di Windows è Rustam Irzaev che utilizza WSHOM come ho menzionato nel mio commento alla domanda principale: "Questo è stato molto promettente, ma crea scorciatoie non valide in Windows 8" – BrutalDev
EDIT: Non consiglio più questa soluzione. Se non esiste ancora un metodo migliore rispetto all'utilizzo del motore di scripting di Windows, almeno utilizza la soluzione di @ Mehmet che chiama direttamente il motore piuttosto che creare uno script di testo in chiaro.
Abbiamo utilizzato VBScript per generare un collegamento. Non ha bisogno di p/Invoke, COM Interop e DLL aggiuntive.Funziona in questo modo:
- Generare un VBScript in fase di esecuzione con i parametri specificati del # metodo di CreateShortcut C
- Salva questo VBScript in un file temporaneo
- Attendere che lo script per finire
- Eliminare la temporanea File
Qui si va:
static string _scriptTempFilename;
/// <summary>
/// Creates a shortcut at the specified path with the given target and
/// arguments.
/// </summary>
/// <param name="path">The path where the shortcut will be created. This should
/// be a file with the LNK extension.</param>
/// <param name="target">The target of the shortcut, e.g. the program or file
/// or folder which will be opened.</param>
/// <param name="arguments">The additional command line arguments passed to the
/// target.</param>
public static void CreateShortcut(string path, string target, string arguments)
{
// Check if link path ends with LNK or URL
string extension = Path.GetExtension(path).ToUpper();
if (extension != ".LNK" && extension != ".URL")
{
throw new ArgumentException("The path of the shortcut must have the extension .lnk or .url.");
}
// Get temporary file name with correct extension
_scriptTempFilename = Path.GetTempFileName();
File.Move(_scriptTempFilename, _scriptTempFilename += ".vbs");
// Generate script and write it in the temporary file
File.WriteAllText(_scriptTempFilename, String.Format(@"Dim WSHShell
Set WSHShell = WScript.CreateObject({0}WScript.Shell{0})
Dim Shortcut
Set Shortcut = WSHShell.CreateShortcut({0}{1}{0})
Shortcut.TargetPath = {0}{2}{0}
Shortcut.WorkingDirectory = {0}{3}{0}
Shortcut.Arguments = {0}{4}{0}
Shortcut.Save",
"\"", path, target, Path.GetDirectoryName(target), arguments),
Encoding.Unicode);
// Run the script and delete it after it has finished
Process process = new Process();
process.StartInfo.FileName = _scriptTempFilename;
process.Start();
process.WaitForExit();
File.Delete(_scriptTempFilename);
}
Uso il riferimento "Modello oggetto host Windows Script" per creare un collegamento.
e di creare collegamento sul specifica posizione:
void CreateShortcut(string linkPath, string filename)
{
// Create shortcut dir if not exists
if (!Directory.Exists(linkPath))
Directory.CreateDirectory(linkPath);
// shortcut file name
string linkName = Path.ChangeExtension(Path.GetFileName(filename), ".lnk");
// COM object instance/props
IWshRuntimeLibrary.WshShell shell = new IWshRuntimeLibrary.WshShell();
IWshRuntimeLibrary.IWshShortcut sc = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(linkName);
sc.Description = "some desc";
//shortcut.IconLocation = @"C:\...";
sc.TargetPath = linkPath;
// save shortcut to target
sc.Save();
}
Ecco il mio codice:
public static class ShortcutHelper
{
#region Constants
/// <summary>
/// Default shortcut extension
/// </summary>
public const string DEFAULT_SHORTCUT_EXTENSION = ".lnk";
private const string WSCRIPT_SHELL_NAME = "WScript.Shell";
#endregion
/// <summary>
/// Create shortcut in current path.
/// </summary>
/// <param name="linkFileName">shortcut name(include .lnk extension.)</param>
/// <param name="targetPath">target path</param>
/// <param name="workingDirectory">working path</param>
/// <param name="arguments">arguments</param>
/// <param name="hotkey">hot key(ex: Ctrl+Shift+Alt+A)</param>
/// <param name="shortcutWindowStyle">window style</param>
/// <param name="description">shortcut description</param>
/// <param name="iconNumber">icon index(start of 0)</param>
/// <returns>shortcut file path.</returns>
/// <exception cref="System.IO.FileNotFoundException"></exception>
public static string CreateShortcut(
string linkFileName,
string targetPath,
string workingDirectory = "",
string arguments = "",
string hotkey = "",
ShortcutWindowStyles shortcutWindowStyle = ShortcutWindowStyles.WshNormalFocus,
string description = "",
int iconNumber = 0)
{
if (linkFileName.Contains(DEFAULT_SHORTCUT_EXTENSION) == false)
{
linkFileName = string.Format("{0}{1}", linkFileName, DEFAULT_SHORTCUT_EXTENSION);
}
if (File.Exists(targetPath) == false)
{
throw new FileNotFoundException(targetPath);
}
if (workingDirectory == string.Empty)
{
workingDirectory = Path.GetDirectoryName(targetPath);
}
string iconLocation = string.Format("{0},{1}", targetPath, iconNumber);
if (Environment.Version.Major >= 4)
{
Type shellType = Type.GetTypeFromProgID(WSCRIPT_SHELL_NAME);
dynamic shell = Activator.CreateInstance(shellType);
dynamic shortcut = shell.CreateShortcut(linkFileName);
shortcut.TargetPath = targetPath;
shortcut.WorkingDirectory = workingDirectory;
shortcut.Arguments = arguments;
shortcut.Hotkey = hotkey;
shortcut.WindowStyle = shortcutWindowStyle;
shortcut.Description = description;
shortcut.IconLocation = iconLocation;
shortcut.Save();
}
else
{
Type shellType = Type.GetTypeFromProgID(WSCRIPT_SHELL_NAME);
object shell = Activator.CreateInstance(shellType);
object shortcut = shellType.InvokeMethod("CreateShortcut", shell, linkFileName);
Type shortcutType = shortcut.GetType();
shortcutType.InvokeSetMember("TargetPath", shortcut, targetPath);
shortcutType.InvokeSetMember("WorkingDirectory", shortcut, workingDirectory);
shortcutType.InvokeSetMember("Arguments", shortcut, arguments);
shortcutType.InvokeSetMember("Hotkey", shortcut, hotkey);
shortcutType.InvokeSetMember("WindowStyle", shortcut, shortcutWindowStyle);
shortcutType.InvokeSetMember("Description", shortcut, description);
shortcutType.InvokeSetMember("IconLocation", shortcut, iconLocation);
shortcutType.InvokeMethod("Save", shortcut);
}
return Path.Combine(System.Windows.Forms.Application.StartupPath, linkFileName);
}
private static object InvokeSetMember(this Type type, string methodName, object targetInstance, params object[] arguments)
{
return type.InvokeMember(
methodName,
BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty,
null,
targetInstance,
arguments);
}
private static object InvokeMethod(this Type type, string methodName, object targetInstance, params object[] arguments)
{
return type.InvokeMember(
methodName,
BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod,
null,
targetInstance,
arguments);
}
/// <summary>
/// windows styles
/// </summary>
public enum ShortcutWindowStyles
{
/// <summary>
/// Hide
/// </summary>
WshHide = 0,
/// <summary>
/// NormalFocus
/// </summary>
WshNormalFocus = 1,
/// <summary>
/// MinimizedFocus
/// </summary>
WshMinimizedFocus = 2,
/// <summary>
/// MaximizedFocus
/// </summary>
WshMaximizedFocus = 3,
/// <summary>
/// NormalNoFocus
/// </summary>
WshNormalNoFocus = 4,
/// <summary>
/// MinimizedNoFocus
/// </summary>
WshMinimizedNoFocus = 6,
}
}
io uso solo per la mia app:
using IWshRuntimeLibrary; // > Ref > COM > Windows Script Host Object
...
private static void CreateShortcut()
{
string link = Environment.GetFolderPath(Environment.SpecialFolder.Desktop)
+ Path.DirectorySeparatorChar + Application.ProductName + ".lnk";
var shell = new WshShell();
var shortcut = shell.CreateShortcut(link) as IWshShortcut;
shortcut.TargetPath = Application.ExecutablePath;
shortcut.WorkingDirectory = Application.StartupPath;
//shortcut...
shortcut.Save();
}
Works out of the box, basta copiare -regalo – rluks
suo È un metodo di estensione (testato), con commenti per aiutarti.
using IWshRuntimeLibrary;
using System;
namespace Extensions
{
public static class XShortCut
{
/// <summary>
/// Creates a shortcut in the startup folder from a exe as found in the current directory.
/// </summary>
/// <param name="exeName">The exe name e.g. test.exe as found in the current directory</param>
/// <param name="startIn">The shortcut's "Start In" folder</param>
/// <param name="description">The shortcut's description</param>
/// <returns>The folder path where created</returns>
public static string CreateShortCutInStartUpFolder(string exeName, string startIn, string description)
{
var startupFolderPath = Environment.SpecialFolder.Startup.GetFolderPath();
var linkPath = startupFolderPath + @"\" + exeName + "-Shortcut.lnk";
var targetPath = Environment.CurrentDirectory + @"\" + exeName;
XFile.Delete(linkPath);
Create(linkPath, targetPath, startIn, description);
return startupFolderPath;
}
/// <summary>
/// Create a shortcut
/// </summary>
/// <param name="fullPathToLink">the full path to the shortcut to be created</param>
/// <param name="fullPathToTargetExe">the full path to the exe to 'really execute'</param>
/// <param name="startIn">Start in this folder</param>
/// <param name="description">Description for the link</param>
public static void Create(string fullPathToLink, string fullPathToTargetExe, string startIn, string description)
{
var shell = new WshShell();
var link = (IWshShortcut)shell.CreateShortcut(fullPathToLink);
link.IconLocation = fullPathToTargetExe;
link.TargetPath = fullPathToTargetExe;
link.Description = description;
link.WorkingDirectory = startIn;
link.Save();
}
}
}
E un esempio di utilizzo:
XShortCut.CreateShortCutInStartUpFolder(THEEXENAME,
Environment.CurrentDirectory,
"Starts some executable in the current directory of application");
prima parm imposta il nome exe (che si trova nella directory corrente) 2 ° parm è la "Start In" cartella e 3 ° parm è la descrizione di scelta rapida.
La convenzione di denominazione del collegamento lascia alcuna ambiguità su ciò che farà. Per testare il collegamento basta fare doppio clic su di esso.
Nota finale: l'applicazione stessa (destinazione) deve avere associata un'immagine ICON. Il collegamento è facilmente in grado di individuare l'icona all'interno dell'exe. Se l'applicazione di destinazione ha più di un'icona, è possibile aprire le proprietà del collegamento e modificare l'icona in qualsiasi altra trovata nell'exe.
Sto ricevendo un messaggio di errore che .GetFolderPath() non esiste. Lo stesso per XFile.Delete. Cosa mi manca? – RalphF
L'errore si verifica qui? Environment.SpecialFolder.Startup.GetFolderPath(); –
- 1. C# PowerShell crea un file di testo vuoto sul desktop
- 2. Collegamento icona desktop
- 3. Collegamento sul desktop per riavviare un servizio Windows
- 4. Desktop che crea una finestra del desktop?
- 5. sostituisci lo stesso collegamento da desktop innosetup
- 6. disegno sotto icone sul desktop
- 7. L'applicazione Web Start creata su NetBeans Platform non crea un collegamento sul desktop e avvia la voce del menu
- 8. Crea un'applicazione per Web e desktop
- 9. Collegamento desktop Linux e icona dall'installazione
- 10. Crea dinamicamente collegamento Javascript
- 11. Android: File adb pull sul desktop
- 12. IzPack - Collegamento desktop su Windows - Non funzionante
- 13. Wpf - centratura sul desktop primario
- 14. Come disegnare direttamente sul desktop di Windows, C#?
- 15. Riferimento C# al desktop
- 16. izpack: crea un collegamento su Windows
- 17. Come creare un collegamento al file (file * .lnk) sul desktop in Windows?
- 18. Trascinare un modulo WPF sul desktop
- 19. Come distribuire un'applicazione Metro sul desktop?
- 20. WiX 3 mi fa impazzire - prova a creare un collegamento sul desktop
- 21. Come aggiungere un'opzione di collegamento sul desktop nella pagina Fine nel programma di installazione di NSIS?
- 22. CREF non crea collegamento nel Visualizzatore oggetti
- 23. Applicazione Swing -> Trascina sul desktop/cartella
- 24. Windows Phone 7 stili sul desktop app
- 25. Sviluppo per OpenGL ES sul desktop
- 26. Symfony2: Crea un collegamento alla disconnessione
- 27. Creazione di un'icona sul desktop per Shiny App
- 28. C#: ottieni dimensioni desktop complete?
- 29. Come si crea un collegamento software in modo programmatico in c/C++?
- 30. Piuttosto stampa matematica nell'applicazione desktop C#
L'utilizzo del modello di oggetti host di script di Windows da Rustam Irzaev è l'unico affidabile per un collegamento appropriato. ayush: questa tecnica manca di alcune funzionalità come tasti di scelta rapida e descrizioni. Thorarin: ShellLink funziona bene nella maggior parte dei casi, ma in particolare non funziona in Windows XP e crea scorciatoie non valide. Simon Mourier: questo è stato molto promettente, ma crea scorciatoie non valide in Windows 8. – BrutalDev