C# UpdateManager.CreateShortcutsForExecutable方法代码示例

        /// <summary>
        /// Execute when app is updating
        /// </summary>
        /// <param name="version"><see cref="Version"/> version</param>
        private static void OnAppUpdate(Version version)
        {
            using (var manager = new UpdateManager(Constants.UpdateServerUrl))
            {
                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.Desktop, true);
                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.StartMenu, true);
                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.AppRoot, true);

                manager.RemoveUninstallerRegistryEntry();
                manager.CreateUninstallerRegistryEntry();
            }
        }

        public static void OnInitialInstall(Version version)
        {
            var exePath = Assembly.GetEntryAssembly().Location;
            string appName = Path.GetFileName(exePath);

            var updatePath = ConfigurationManager.AppSettings["UpdatePathFolder"];
            var packageId = ConfigurationManager.AppSettings["PackageID"];

            using (var mgr = new UpdateManager(updatePath, packageId, FrameworkVersion.Net45))
            {

                // Create Desktop and Start Menu shortcuts
                mgr.CreateShortcutsForExecutable(appName, DefaultLocations, false);
            }
        }

        public AppBootstrapper()
        {
            using (var mgr = new UpdateManager(AppInfo.UpdatePath, "Espera", FrameworkVersion.Net45))
            {
                // We have to re-implement the things Squirrel does for normal applications, because
                // we're marked as Squirrel-aware
                SquirrelAwareApp.HandleEvents(
                    onInitialInstall: v => mgr.CreateShortcutForThisExe(),
                    onAppUpdate: v =>
                    {
                        mgr.CreateShortcutForThisExe();
                        // Update the shortcut for the portable version
                        mgr.CreateShortcutsForExecutable("Espera.exe", ShortcutLocation.AppRoot, false);
                    },
                    onAppUninstall: v => mgr.RemoveShortcutForThisExe());
            }

            this.Initialize();
        }

        protected override void OnStartup(object sender, StartupEventArgs e)
        {
            base.OnStartup(sender, e);

            if (!Directory.Exists(AppConfig.DownloadPath))
                Directory.CreateDirectory(AppConfig.DownloadPath);

            var logConfig = new LoggingConfiguration();

            var target = new FileTarget
            {
                FileName = Path.Combine(AppConfig.LogPath, "Log.txt"),
                Layout = @"${longdate}|${level}|${message} ${exception:format=ToString,StackTrace}",
                ArchiveAboveSize = 1024 * 1024 * 2,
                ArchiveNumbering = ArchiveNumberingMode.Sequence
            };

            logConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, target));
            LogManager.Configuration = logConfig;

            Locator.CurrentMutable.RegisterConstant(new NLogLogger(LogManager.GetCurrentClassLogger()), typeof(ILogger));
            this.Log().Info("Flashbang is starting...");

            #if !DEBUG

                using (var mgr = new UpdateManager(AppConfig.UpdatePath, "Flashbang", FrameworkVersion.Net45))
                {
                    SquirrelAwareApp.HandleEvents(v => mgr.CreateShortcutForThisExe(), v =>
                        {
                            mgr.CreateShortcutForThisExe();
                            mgr.CreateShortcutsForExecutable("Flashbang.exe", ShortcutLocation.AppRoot, false);
                        },
                        onAppUninstall: v => mgr.RemoveShortcutForThisExe());
                }

            #endif
        }

        public void Shortcut(string exeName, string shortcutArgs, string processStartArgs, string icon)
        {
            if (String.IsNullOrWhiteSpace(exeName)) {
                ShowHelp();
                return;
            }

            var appName = getAppNameFromDirectory();
            var defaultLocations = ShortcutLocation.StartMenu | ShortcutLocation.Desktop;
            var locations = parseShortcutLocations(shortcutArgs);

            using (var mgr = new UpdateManager("", appName)) {
                mgr.CreateShortcutsForExecutable(exeName, locations ?? defaultLocations, false, processStartArgs, icon);
            }
        }

        public void Shortcut(string exeName)
        {
            if (String.IsNullOrWhiteSpace(exeName)) {
                ShowHelp();
                return;
            }

            var appName = getAppNameFromDirectory();
            using (var mgr = new UpdateManager("", appName, FrameworkVersion.Net45)) {
                mgr.CreateShortcutsForExecutable(exeName, ShortcutLocation.Desktop | ShortcutLocation.StartMenu, false);
            }
        }

        public void Shortcut(string exeName, string shortcutArgs)
        {
            if (String.IsNullOrWhiteSpace(exeName)) {
                ShowHelp();
                return;
            }

            var appName = getAppNameFromDirectory();
            var defaultLocations = ShortcutLocation.StartMenu | ShortcutLocation.Desktop;
            var locations = parseShortcutLocations(shortcutArgs);

            // NB: Always basing the rootAppDirectory relative to ours allows us to create Portable
            // Applications
            var ourDir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "..");

            using (var mgr = new UpdateManager("", appName, FrameworkVersion.Net45, ourDir)) {
                mgr.CreateShortcutsForExecutable(exeName, locations ?? defaultLocations, false);
            }
        }

        /// <summary>
        /// Execute when app is installing
        /// </summary>
        /// <param name="version"><see cref="Version"/> version</param>
        private static void OnInitialInstall(Version version)
        {
            using (var manager = new UpdateManager(Constants.UpdateServerUrl))
            {
                manager.CreateShortcutForThisExe();

                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.Desktop, false);
                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.StartMenu, false);
                manager.CreateShortcutsForExecutable("Popcorn.exe", ShortcutLocation.AppRoot, false);

                manager.CreateUninstallerRegistryEntry();
            }
        }

 public void ApplyAutorun()
 {
     using (var mgr = new UpdateManager(""))
     {
         try
         {
             if (Autorun)
                 mgr.CreateShortcutsForExecutable("Artemis.exe", ShortcutLocation.Startup, false);
             else
                 mgr.RemoveShortcutsForExecutable("Artemis.exe", ShortcutLocation.Startup);
         }
         catch (FileNotFoundException)
         {
             // Ignored, only happens when running from VS
         }
         catch (DirectoryNotFoundException)
         {
             // Ignored, only happens when running from VS
         }
         
     }
 }

        internal static void HandleSquirrelInstallEvent(string[] args)
        {
            #if __MonoCS__
            Debug.Fail("HandleSquirrelInstallEvent should not run on Linux!");	// and the code below doesn't compile on Linux
            return;
            #else
            bool firstTime = false;
            var updateUrlResult = LookupUrlOfSquirrelUpdate();
            // Should only be null if we're not online. Not sure how squirrel will handle that,
            // but at least one of these operations is responsible for setting up shortcuts to the program,
            // which we'd LIKE to work offline. Passing it a plausible url, even though it will presumably fail,
            // seems less likely to cause problems than passing null.
            if(string.IsNullOrEmpty(updateUrlResult.URL))
                updateUrlResult.URL = @"https://s3.amazonaws.com/bloomlibrary.org/squirrel";
            if (args[0] == "--squirrel-uninstall")
            {
                RemoveBloomRegistryEntries();
            }
            if (args[0] == "--squirrel-updated")
            {
                var props = new Dictionary<string, string>();
                if (args.Length > 1)
                    props["newVersion"] = args[1];
                props["channel"] = ApplicationUpdateSupport.ChannelName;
                Analytics.Track("Update Version", props);
            }
            string iconPath = null;
            if (args[0] == "--squirrel-install")
            {
                //Using an icon in the root folder fixes the problem of losing the shortcut icon when we
                //upgrade, lose the original, and eventually the windows explorer cache loses it.
                //There was another attempt at fixing this by finding all the shortcuts and updating them, but that didn't work in our testing and this seems simpler and more robust.
                //There may be some other reason for the old approach of pointing at the icon of the app itself (e.g. could be a different icon)?
                var exePath = Application.ExecutablePath;
                var rootAppDirectory = Path.GetDirectoryName(Path.GetDirectoryName(exePath));
                // directory that holds e.g. /3.6/Bloom.exe
                var versionIconPath = Path.ChangeExtension(exePath, "ico"); // where this installation has icon
                iconPath = Path.ChangeExtension(Path.Combine(rootAppDirectory, Path.GetFileName(exePath)), "ico");
                // where we will put a version-independent icon
                try
                {
                    if (RobustFile.Exists(versionIconPath))
                        RobustFile.Copy(versionIconPath, iconPath, true);
                }
                catch (Exception)
                {
                    // ignore...most likely some earlier version of the icon is locked somehow, fairly harmless.
                }
                // Normally this is done on every run of the program, but if we're doing a silent allUsers install,
                // this is our only time running with admin privileges so we can actually make the entries for all users.
                MakeBloomRegistryEntries(args);
            }
            switch (args[0])
            {
                // args[1] is version number
                case "--squirrel-install": // (first?) installed
                case "--squirrel-updated": // updated to specified version
                case "--squirrel-obsolete": // this version is no longer newest
                case "--squirrel-uninstall": // being uninstalled
                    using (var mgr = new UpdateManager(updateUrlResult.URL, Application.ProductName))
                    {
                        // WARNING, in most of these scenarios, the app exits at the end of HandleEvents;
                        // thus, the method call does not return and nothing can be done after it!
                        // We replace two of the usual calls in order to take control of where shortcuts are installed.
                        SquirrelAwareApp.HandleEvents(

                            onInitialInstall: v =>
                            {
                                mgr.CreateShortcutsForExecutable(Path.GetFileName(Assembly.GetEntryAssembly().Location),
                                    StartMenuLocations,
                                    false, // not just an update, since this is case initial install
                                    null, // can provide arguments to pass to Update.exe in shortcut, defaults are OK
                                    iconPath,
                                    SharedByAllUsers());
                                // Normally we can't do this in our quick silent run as part of install, because of the need to escalate
                                // privilege. But if we're being installed for all users we must already be running as admin.
                                // We don't need to do an extra restart of Bloom because this install-setup run of Bloom will finish
                                // right away anyway. We do this last because we've had some trouble (BL-3342) with timeouts
                                // if this install somehow ties up the CPU until Squirrel thinks Bloom is taking too long to do its
                                // install-only run.
                                if (SharedByAllUsers())
                                    FontInstaller.InstallFont("AndikaNewBasic", needsRestart: false);
                            },
                            onAppUpdate: v => mgr.CreateShortcutForThisExe(),
                            onAppUninstall: v => mgr.RemoveShortcutsForExecutable(Path.GetFileName(Assembly.GetEntryAssembly().Location), StartMenuLocations, SharedByAllUsers()),
                            onFirstRun: () => firstTime = true,
                            arguments: args);
                    }
                    break;
            }
            #endif
        }

 private static void OnInitialInstall(Version version)
 {
     try
     {
         Log.InfoFormat("OnInitialInstall for version {0}", version);
         using (var updateManager = new UpdateManager(Program.PackageUrl, Program.PackageId))
         {
             updateManager.CreateShortcutsForExecutable("Nuts.exe", ShortcutLocation.Desktop, false);
         }
     }
     catch (Exception exception)
     {
         Log.Error("OnInitialInstall encountered and exception", exception);
         throw;
     }
 }

        public static void InstallEvent()
        {
            var exePath = Assembly.GetEntryAssembly().Location;
            var appName = Path.GetFileName(exePath);

            using (var mgr = new UpdateManager(@"https://releases.noelpush.com/", "NoelPush"))
            {
                mgr.CreateShortcutsForExecutable(appName, ShortcutLocation.StartMenu | ShortcutLocation.Startup, false);
                mgr.CreateUninstallerRegistryEntry();
                mgr.Dispose();
            }
        }

 public static void UpdateEvent()
 {
     using (var mgr = new UpdateManager(@"https://releases.noelpush.com/", "NoelPush"))
     {
         mgr.CreateShortcutsForExecutable("NoelPush.exe", ShortcutLocation.StartMenu | ShortcutLocation.Startup, false);
         mgr.Dispose();
     }
 }