VB.NET Autostart für Dein eigenes Programm erstellen – 2024 Version

Dein VB.NET Programm automatisch bei Systemstart starten

Hast Du Deine nächste tolle Anwendung entwickelt, Welche Du nun via VB.NET in den Autostart packen möchtest? Im heutigen Beitrag schauen wir uns genau das und mehr, wie z. B. das Erstellen von Verknüpfungen via der „WshShell“ an. Bleib also dran, es wird ziemlich interessant 😉!

💡 Hinweis: Wenn Du es eilig hast, kannst Du auch direkt zum Code weiter unten scrollen, bzw. das Inhaltsverzeichnis für das Springen zu verschiedenen Eckpunkten verwenden. Auch wenn der Beitrag seinen Fokus auf VB.NET hat, sind alle Code-Beispiele natürlich auch für C# verfügbar! Springe für den kompletten Code, oder für dessen Verwendungsbeispiele nach unten.

Wie Du vielleicht weißt hatte ich auch schonmal ein Video zum Thema gemacht – vor unfassbaren 11 Jahren, oh man, ich werde alt.. Ein Abonnent hatte mich darauf aufmerksam gemacht, dass es in die Jahre gekommen ist und er sich ein Update wünscht. Dies war mir Befehl und nun sind wir hier 🤓!

Wenn Du moderne Anwendungen entwickeln möchtest – Welche dann passenderweise in den Autostart können –, solltest Du Dir unbedingt diese beiden Beiträge anschauen:

• Der ultimative INotifyPropertyChanged Guide – für C# & VB.NET
• Der ultimative WPF DataGrid MVVM Guide – C# & VB.NET

Als Video ansehen – „VB.NET Autostart von Programmen“

Wenn Du es eiliger, bzw. eventuell keine Lust auf Text hast, kannst Du natürlich auch gerne zum Videoformat greifen und Dich berieseln lassen. Nutze auch im Video gerne die Kapitel, um zu den Stellen von besonderem Interesse zu springen.

Wie startet man Software überhaupt via Autostart?

Bevor wir uns an die VB.NET-spezifische Thematik wagen, ist es ggf. vorerst ganz sinnvoll, sich mit dieser Frage auseinanderzusetzen: Wie starte ich ein Programm überhaupt bei Systemstart? Grundsätzlich ist die Antwort darauf ziemlich einfach, denn Windows bietet eigentlich alle Bordmittel, Die man als Administrator oder auch Entwickler, braucht.

Dazu gibt es den sogenannten Autostart-Ordner, Welcher ungefähr so wie gleich folgend aussieht. Bei mir ist – zugegebenermaßen – nicht viel dort zu sehen, denn ich versuche den immer „clean“ zu halten.

Vorgehensweise

Um ein Programm beim Start des Windows-Systems automatisch mit-starten zu lassen, muss man Dieses, bzw. eine Verknüpfung dazu in den Autostart-Ordner ablegen. Das Schöne ist hier wirklich die Möglichkeit der Verknüpfung, denn wer hat Lust, jedes Mal x Megabyte zu kopieren und eventuell dann doppelt zu haben. Ich persönlich hatte bei dieser Vorgehensweise auch nie Probleme, im Gegensatz zu einigen recherchierten Suchergebnissen auf Google. Kommentiere gerne, wenn auch Du auf derartige Probleme stößt, würde mich interessieren!

Vorsicht geboten

Wie erwähnt wird jedes Programm, bzw. jede Verknüpfung im genannten Ordner automatisch bei Systemstart gestartet. Das stattet uns Entwickler & Administratoren natürlich auch mit einer großen Bürde aus. Erstens – so finde ich – sollte man dem Nutzer bei Systemstart nicht direkt 20 GUIs an den Kopf schmeißen und zweitens sollte man ja auch noch an die Startzeit denken. Wer hat schon Lust, 5 Minuten länger zu warten, nur weil ein Programm bei Start schon viel Auslastung zieht!?

Welche Möglichkeiten habe ich beim Autostart?

Egal ob mit VB.NET (oder C#..), oder ohne, wir haben verschiedene Möglichkeiten, den Autostart zu verwenden. Einerseits können wir benutzerspezifische Startmöglichkeiten verwenden, oder auch global, also für alle Nutzer einen automatischen Programmstart anlegen. In diesem Beitrag gehe ich jedoch in erster Linie auf den benutzerspezifischen Autostart ein.

Wo, bzw. wie finde ich die Autostart-Ordner?

In erster Linie kommt das natürlich darauf an, für wen Du einen Autostart erstellen möchtest. Möchtest Du Dein Programm z. B. für den aktuellen Nutzer in den Autostart legen, dann kommt folgendes Verzeichnis in Frage. Beachte hierbei, dass Du den Platzhalter natürlich durch den jeweiligen Nutzernamen ersetzen müsstest:

C:\Users\<DeinNutzername>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

Du kannst den Ordner auch vereinfacht finden, indem Du die Windows-Taste+R drückst, was den „Ausführen“-Dialog startet. Und im nächsten Schritt dann:

shell:startup

eingeben, was Dich dann in dem für Dich passenden Autostart-Ordner auskommen lässt. Cool, oder?

Globaler Autostart-Ordner

Möchtest Du hingegen den „globalen“ Ordner finden, kannst Du stattdessen in folgendem Verzeichnis

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

und mit diesem Befehl hier fündig werden (denke an Windows-Taste+R):

shell:common startup

Hier findest Du dann die Programme, Welche für alle Nutzer automatisch bei Systemstart gestartet werden sollen.

Wie sieht der VB.NET Autostart nun aus?

Um nun die oben erklärte Logik, bzw. Vorgehensweise mit VB.NET nachzubilden, müssen wir ja praktisch nichts Anderes tun. Wir müssen (via Code) eine Verknüpfung unserer Anwendung erschaffen und Diese nach Möglichkeit im Autostart-Ordner unserer Wahl unterbringen. Besonders die Erstellung einer Verknüpfung kann aber tricky sein, wenn man nicht weiß, wie.

Zusätzlich könnte man weitere Hilfsmittel schreiben, um z. B. überprüfen zu können, ob sich unsere Anwendung aktuell schon im Autostart befindet. Dies alles werden wir selbstverständlich nach Regeln der OOP (Objektorientierten Programmierung) in eine Klasse auslagern. So bleibt alles schön wiederverwendbar und portierbar.

Lege also im nächsten Schritt einen Ordner namens „Utils“ in Deinem Projekt an und erstelle dort drin eine „Autostart“-Klasse.

Mit VB.NET den Autostart-Ordner ermitteln

Bevor wir uns jedoch Gedanken über Dinge wie „Wie kann ich die Verknüpfung erstellen“, usw. machen, starten wir easy. Zuerst einmal müssen wir wissen, wie wir an den Autostart-Ordner kommen, ist ja schließlich Betriebssystem-Sache. Zufälligerweise benutzen wir eine optimale Sprache für dieses Betriebssystem vom selben Hersteller – kann ja dann nicht so schwer sein, richtig? Richtig!

Um an den Pfad zum Autostart-Ordner (auch Startup-Folder genannt) zu kommen, können wir vorgefertigte Funktionen nutzen. Die Methode unseres Vertrauens befindet sich in der „Environment“-Klasse und heißt „GetFolderPath“. Diese erwartet einen Wert der „SpecialFolder“-Enumeration aus selbiger Klasse.

Implementieren wir nun eine Art „Singleton“-, bzw. eine „Lazy“-Property (Eigenschaft), Welche uns den Autostart-Ordner serviert. So müssen wir der Environment nicht öfter als nötig auf die Nerven gehen – ergo, die Funktion nur einmalig aufrufen und den Rückgabewert zwischenspeichern:

        Private Shared _startupDirectory As String

        Public Shared ReadOnly Property StartupDirectory As String
            Get
                If String.IsNullOrWhiteSpace(_startupDirectory) Then
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup)
                End If
                Return _startupDirectory
            End Get
        End Property

    private static string _startupDirectory;

    public static string StartupDirectory
    {
        get
        {
            if (string.IsNullOrWhiteSpace(_startupDirectory))
                _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
            return _startupDirectory;
        }
    }

Einen Eintrag in den Autostart mit VB.NET hinzufügen

Im nächsten Schritt schauen wir uns an, wie wir unsere VB.NET-Anwendung, bzw. eine Verknüpfung davon in den Autostart-Ordner gelegt bekommen. Dazu bauen wir uns eine kleine „AddEntry“ Methode, Welcher es egal ist, ob ein Pfad zu unserer Anwendung mitkommt, denn Diesen, kann Sie auch selbst ermitteln. So bleibt uns die Möglichkeit übrig, fremde Anwendungen, sowie die Eigene gemütlich hinzuzufügen:

        ''' <summary>
        ''' Adds an entry to the autostart folder for the given Application
        ''' </summary>
        ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        Public Shared Sub AddEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            CreateShortcut(applicationFilePath)
        End Sub

/// <summary>
/// Adds an entry to the autostart folder for the given Application
/// </summary>
/// <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the currently executing .exe</param>
public static void AddEntry(string applicationFilePath = "")
{
    var noAppPathProvided = applicationFilePath == "";
    if (noAppPathProvided)
        DefaultToExecutingExe(applicationFilePath);
    CreateShortcut(applicationFilePath);
}

Wie Du hier schon sehen kannst, schauen wir (wie erwähnt), ob ein passender „applicationFilePath“ mitgeliefert wurde. Wenn nicht „Defaulten“ wir zur ausführenden Exe-Datei, also dem aktuellen Programm. So oder so erstellen wir am Ende der Methode eine Verknüpfung, was wir im nächsten Schritt besprechen werden.

Die ausgeführte .Exe-Datei erkennen

Nachdem wir die eigentliche Methode schon einmal im letzten Schritt vorbereitet haben, fehlen nun noch die 2 Sub-Routinen. In erster Linie schauen wir hier uns hier schnell die „DefaultToExecutingExe“-Methode an. Diese bekommt einen „ByRef“-Parameter übergeben – empfand ich hier irgendwie leichter lesbar – aber ist nur meine Meinung. Diese setzt dann den „applicationFilePath“ via „Process“-Klasse, bzw. mittels einer verschachtelten Sub-Eigenschaft des Prozesses. Diesen ermitteln wir mit der statischen „GetCurrentProcess“-Funktion der „Process“-Klasse. Hier gibt es ab .NET 6 auch eine neue Variante, allerdings habe ich hier Die genommen, Welche vermutlich am geläufigsten ist.

Unsere VB.NET Anwendung als Verknüpfung in den Autostart legen

Nun fehlt nur noch ein letztes Werkzeug, die Funktionalität, für unsere (und auch andere Anwendungen) eine Verknüpfung erzeugen zu können. Dies kann – wie oben bereits erwähnt – ein wenig tricky werden, wenn man nicht weiß, wie. Wir verwenden dazu das „WshShell“-Interface, Welches komischerweise instanziiert werden kann, Du glaubst mir nicht? Guck in den Code!

COM-Verweis hinzufügen

Bevor wir damit jedoch starten können, müssen wir zuerst noch den benötigten COM-Verweis auf das „Windows Script Host Object Model“ hinzufügen. Das kannst Du ganz einfach machen, indem Du einen Rechtsklick auf Dein Projekt durchführst und anschließend „Hinzufügen->COM-Verweis“ auswählst.

Danach erscheint dieses folgende Fenster, wo Du dann oben rechts dementsprechend z. B. nach „host“ suchen kannst, dann dürftest Du – siehe Bild – schnell fündig werden:

Ein instanziierbares Interface – what the f**?

Um ehrlich zu sein – wie ich nunmal bin.. – habe ich mich selbst damit auch nicht auseinandergesetzt, warum man diese Schnittstelle instanziieren kann (auch in C#). Und da ich COM-Dinge eigentlich nie benötige, ist mir das hier auch relativ egal, solange es funktioniert. Ich gehe mal ohne Recherche davon aus, dass das an der Deklaration des Interfaces liegt, dort sehen wir ein „CoClass“-Attribut.

Vermutlich wird „der Code“ dann sehen: „Ah, da ist ein CoClass Ding, also muss ich das wohl instaziieren“ – oder so ähnlich. EDIT: Habe kurz nachgeguckt, liegt wie vermutet an dem „CoClass“-Attribut – Erfahrung „strikes again“ 😉!

Eine Verknüpfung erstellen

Nachdem wir das Interface nun instanziieren können – ew, klingt immer noch ekelig, na egal – tun wir gleich genau das. Vorher erstellen wir noch ein „FileInfo“-Objekt, Welches uns bei der Arbeit mit Datei-Infos wie den Namen der Datei, usw. unterstützen wird. Und dann gehen wir schonmal hin und erstellen den letztendlichen Pfad der Verknüpfung mit String-Interpolation.

Hier verwenden wir ein weiteres kleines Helferlein, was – wie der Name schon sagt – den Dateinamen ohne Dateiendung für uns herausfiltert. Dazu übergeben wir der statischen „Path“-Klassen-Funktion „GetFileNameWithoutExtension“, den Namen des „FileInfo“-Objektes.

Im letzten Schritt erzeugen wir die Verknüpfung auf Objekt-Ebene und casten Sie in ein für unsere Zwecke passendes Interface – „IWshShortcut“. Anschließend kannst Du weitere Eigenschaften wie z. B. die Beschreibung und den Icon-Pfad angeben, dies lasse ich hier aber aus. Zuletzt kommen die beiden wichtigsten Schritte: Den Ziel-Pfad, also den Pfad zur eigentlichen Anwendung festzulegen und dann final auch „Save“ aufzurufen, damit die Verknüpfung tatsächlich erstellt wird.

Prüfen ob ein Autostart-Eintrag existiert

Nun haben wir die Funktionalität von oben vorliegen und würden direkt mit der Nächsten starten. Es wäre schließlich ganz nützlich, wenn man auch prüfen könnte, ob bereits eine Verknüpfung im Autostart ist. Dazu erstellen wir im nächsten Schritt eine „EntryExists“-Funktion, Welche dies über einen Boolean kommuniziert.

In den ersten Zeilen verfahren wir hier wir in der „AddEntry“-Methode, also bezogen auf die Pfad-Sache. Wenn kein Pfad angegeben wurde, nehmen wir den Pfad der aktuellen Exe-Datei, usw. Danach bauen wir uns den Pfad zur Verknüpfung (im Autostart-Ordner!) zusammen. Wenn eine derartige Datei (dort) existiert, dann haben wir das Programm bereits im Autostart – yay!

        Public Shared Function EntryExists(Optional applicationFilePath As String = "") As Boolean
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Return IO.File.Exists(shortcutPath)
        End Function

public static bool EntryExists(string applicationFilePath = "")
{
    var noAppPathProvided = applicationFilePath == "";
    if (noAppPathProvided)
        DefaultToExecutingExe(applicationFilePath);
    var applicationFile = new FileInfo(applicationFilePath);
    var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
    return System.IO.File.Exists(shortcutPath);
}

Mit VB.NET den Autostart wieder entfernen

Im letzten Abschnitt dieses Beitrages werden wir uns ansehen, wie wir erzeugte Einträge auch wieder entfernen können. Dies kennt man natürlich bereits aus größeren Tools. Wir schreiben also eine „RemoveEntry“-Methode, Welche sehr ähnlich zu den Vorherigen funktioniert. Zuerst prüfen wir wieder die Pfad-Übergabe, danach erstellen wir der Einfachheit halber eine „FileInfo“ und danach generieren wir den Verknüpfungs-Pfad.

Wenn Dieser Pfad existent ist, wird er gelöscht, somit wird auch unser VB.NET Autostart entfernt. Beachte hierbei, dass ich bewusst kein Try-Catch drum gemacht habe. Ich möchte aktiv auf Fehler reagieren und diese separat und sauber verarbeiten können.

Kompletter Code

Hier findest Du den wichtigsten Code für diesen Beitrag. In diesem Beispiel handelt es sich um die kleine von mir gebaute Hilfs-Klasse. Diese vereinfacht Dir die Erstellung der Programm-Verknüpfung innerhalb des Autostart-Ordners via VB.NET (und C#!):

Imports System.IO
Imports IWshRuntimeLibrary

Namespace Utils

    Public Class Autostart

        Private Shared _startupDirectory As String

        Public Shared ReadOnly Property StartupDirectory As String
            Get
                If String.IsNullOrWhiteSpace(_startupDirectory) Then
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup)
                End If
                Return _startupDirectory
            End Get
        End Property

        ''' <summary>
        ''' Adds an entry to the autostart folder for the given Application
        ''' </summary>
        ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        Public Shared Sub AddEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            CreateShortcut(applicationFilePath)
        End Sub

        Private Shared Sub DefaultToExecutingExe(ByRef applicationFilePath As String)
            applicationFilePath = Process.GetCurrentProcess().MainModule.FileName
        End Sub

        Private Shared Sub CreateShortcut(applicationFilePath As String)
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Dim shell = New WshShell()
            Dim shortcut = CType(shell.CreateShortcut(shortcutPath), IWshShortcut)
            With shortcut
                ' .Description = ""
                ' .IconLocation = ""
                .TargetPath = applicationFile.FullName
                .Save()
            End With
        End Sub

        Public Shared Function EntryExists(Optional applicationFilePath As String = "") As Boolean
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Return IO.File.Exists(shortcutPath)
        End Function

        Public Shared Sub RemoveEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            IO.File.Delete(shortcutPath)
        End Sub

    End Class

End Namespace

using System.IO;
using IWshRuntimeLibrary;

namespace Utils
{
    public class Autostart
    {
        private static string _startupDirectory;

        public static string StartupDirectory
        {
            get
            {
                if (string.IsNullOrWhiteSpace(_startupDirectory))
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
                return _startupDirectory;
            }
        }

        /// <summary>
        ///         ''' Adds an entry to the autostart folder for the given Application
        ///         ''' </summary>
        ///         ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        public static void AddEntry(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            CreateShortcut(applicationFilePath);
        }

        private static void DefaultToExecutingExe(ref string applicationFilePath)
        {
            applicationFilePath = Process.GetCurrentProcess().MainModule.FileName;
        }

        private static void CreateShortcut(string applicationFilePath)
        {
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            var shell = new WshShell();
            var shortcut = (IWshShortcut)shell.CreateShortcut(shortcutPath);
            {
                var withBlock = shortcut;
                // .Description = ""
                // .IconLocation = ""
                withBlock.TargetPath = applicationFile.FullName;
                withBlock.Save();
            }
        }

        public static bool EntryExists(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            return System.IO.File.Exists(shortcutPath);
        }

        public static void RemoveEntry(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            System.IO.File.Delete(shortcutPath);
        }
    }
}

Verwendung des Codes

Um den obigen Code verwenden zu können, kannst Du z. B. 2 Knöpfe und eine CheckBox in Deine Form setzen. Beim Start des Formulares wird die Checkbox je nachdem ob das VB.NET Programm im Autostart liegt gefüllt. Wenn Du dann auf die jeweiligen Buttons drückst, kannst Du das Programm wieder aus dem Autostart entfernen, bzw. natürlich auch hinzufügen. Die Namen sind denke ich selbsterklärend..

Imports AutoStartExampleVb.Utils

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        chbAutostartActivated.Checked = Autostart.EntryExists()
    End Sub

    Private Sub btnActivateAutostart_Click(sender As Object, e As EventArgs) Handles btnActivateAutostart.Click
        Autostart.AddEntry()
        chbAutostartActivated.Checked = True
    End Sub

    Private Sub btnDeactivateAutostart_Click(sender As Object, e As EventArgs) Handles btnDeactivateAutostart.Click
        Autostart.RemoveEntry()
        chbAutostartActivated.Checked = False
    End Sub

End Class

using System;
using AutoStartExampleVb.Utils;

public class Form1
{
    private void Form1_Load(object sender, EventArgs e)
    {
        chbAutostartActivated.Checked = Autostart.EntryExists();
    }

    private void btnActivateAutostart_Click(object sender, EventArgs e)
    {
        Autostart.AddEntry();
        chbAutostartActivated.Checked = true;
    }

    private void btnDeactivateAutostart_Click(object sender, EventArgs e)
    {
        Autostart.RemoveEntry();
        chbAutostartActivated.Checked = false;
    }
}

Downloads

Keine Lust alles zu kopieren und es manuell zusammen zu frickeln? Dann lade Dir hier einfach den Beispielcode herunter, Dieser beinhaltet die komplette und fertig testbare Projektmappe.