wails/website/i18n/de/docusaurus-plugin-content-docs/current/guides/troubleshooting.mdx

# Problembehandlung

Eine Auswahl an Tipps zur Fehlerbehebung.

## Der `wails` Befehl fehlt?

Wenn das System meldet, dass der `wails` Befehl fehlt, stelle sicher, dass die Go-Installationsanleitung korrekt befolgt wurde. Normalerweise bedeutet dies, dass sich das `go/bin` Verzeichnis im Home-Verzeichnis deines Benutzers nicht in der `PATH` Umgebungsvariable befindet. Normalerweise müssen alle Eingabeaufforderungen geschlossen und neu geöffnet werden, so dass Änderungen an der Umgebung des Installers in der Eingabeaufforderung übernommen werden.

## Meine Anwendung zeigt einen weißen/leeren Bildschirm an

Überprüfe, ob deine Anwendung die Assets aus dem richtigen Verzeichnis enthält. In deiner `main.go` Datei hast du etwas Ähnliches wie den folgenden Code:

```go
//go:embed all:frontend/dist
var assets embed.FS
```

Stelle sicher, dass `frontend/dist` deine Applikations-Assets enthält.

### Mac

Wenn dies auf dem Mac geschieht, versuche folgendes zu deiner `Info.plist` hinzuzufügen:

```xml
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsLocalNetworking</key>
    <true/>
</dict>
```

Referenz: https://github.com/wailsapp/wails/issues/1504#issuecomment-1174317433

## Mac-Anwendung ungültig

Wenn deine erstellte Anwendung im Finder so aussieht:

```mdx-code-block
<p className="text--center">
  <img
    src={
      require("@site/static/img/troubleshooting/invalid_mac_app.png").default
    }
  />
</p>
```

ist es wahrscheinlich, dass die Anwendungs `info.plist` ungültig ist. Aktualisiere die Datei in `build/<yourapp>.app/Contents/info.plist` und prüfe, ob die Daten gültig sind, z.B. prüfe, ob der Binärname korrekt ist. Um die Änderungen fortzusetzen, kopiere die Datei zurück in das Verzeichnis `build/darwin`.

## Meine Anwendung zeigt nicht das richtige Symbol im Windows Explorer an

Wenn deine Anwendung nicht das richtige Symbol anzeigt, lösche die versteckte `IconCache.db` Datei im `C:\Users\&#060;dein Benutzername&#062;\AppData\Local` Verzeichnis. Dies zwingt Windows, den Symbol-Cache neu zu erstellen.

Quelle: https://github.com/wailsapp/wails/issues/2360#issuecomment-1556070036

## Backend-Methode kann nicht im Frontend mit variadischen Argumenten aufgerufen werden

Wenn du eine Backend-Methode mit variadischen Parametern definiert hast, z. B:

```go
func (a *App) TestFunc(msg string, args ...interface{}) error {
    // Code
}
```

wenn diese Methode aus dem Frontned aus so aufgerufen wird, wird dies fehlschlagen:

```js
var msg = "Hello: ";
var args = ["Go", "JS"];
window.go.main.App.TestFunc(msg, ...args)
  .then((result) => {
    //do things here
  })
  .catch((error) => {
    //handle error
  });
```

Übergangslösung:

```js
var msg = "Hello ";
var args = ["Go", "JS"];
window.go.main.App.TestFunc(msg, args)
  .then((result) => {
    //without the 3 dots
    //do things here
  })
  .catch((error) => {
    //handle error
  });
```

Credit: https://github.com/wailsapp/wails/issues/1186

## Ich habe Proxy-Fehler beim Installieren von Wails

Wenn du solche Fehler bekommst:

```
"https://proxy.golang.org/github.com/wailsapp/wails/cmd/wails/@v/list": dial tcp 172.217.163.49:443: connectex: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.
```

ist es wahrscheinlich daran, dass der offizielle Go-Proxy blockiert wird (Benutzer in China haben dies gemeldet). Die Lösung besteht darin, den Proxy manuell einzurichten, z. B:

```
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct
```

Quelle: https://github.com/wailsapp/wails/issues/1233

## Der generierte TypeScript-Code hat nicht die richtigen Typen

Manchmal hat der generierte TypeScript-Code nicht die richtigen Typen. Um dies zu migrieren, ist es möglich, mit dem `ts_type` struct-Tag anzugeben, welche Typen erzeugt werden sollen. Für weitere Details ließ bitte [diese](https://github.com/tkrajina/typescriptify-golang-structs#custom-types) Seite.

## Wenn ich von `index.html` weg navigiere, kann ich keine Methoden mehr im Frontend aufrufen

Wenn du von `index.html` zu einer neuen Html-Datei wechselst, geht der Kontext verloren. Dies kann durch das Hinzufügen von folgenden Importen in die `<head>` Sektion einer neuen Seite korrigiert werden:

```html
<head>
  <script src="/wails/ipc.js"></script>
  <script src="/wails/runtime.js"></script>
</head>
```

Quelle: https://github.com/wailsapp/wails/discussions/1512

## Ich bekomme den `too many open files` Fehler auf meinem Mac, wenn ich `wails dev` ausführe

Standardmäßig erlaubt macOS nur das Öffnen von maximal 256 Dateien. Dies kann den Befehl `wails dev` beeinflussen. Dieses Limit kann durch den Befehl `ulimit -n 1024` im Terminal erhöht werden.

FSNotify will [auf Apples fsevents](https://github.com/fsnotify/fsnotify/issues/11) für Mac umsteigen. Wenn dies nicht bald abgeschlossen ist, erstellen wir unsere eigene Implementierung, siehe [hier](https://github.com/wailsapp/wails/issues/1733).

## Meine Mac-App gibt mir seltsame Kompilierungsfehler

Einige Benutzer haben gemeldet, dass sie Fehler bei der Kompilierung sehen, wie zum Beispiel:

```shell
# github.com/wailsapp/wails/v2/internal/frontend/desktop/darwin
In file included from ../../pkg/mod/github.com/wailsapp/wails/v2@v2.0.0-beta.44.2/internal/frontend/desktop/darwin/callbacks.go:9:
In file included from /Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h:12:
/Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/NSBundle.h:91:143: error: function does not return NSString
- (NSAttributedString *)localizedAttributedStringForKey:(NSString *)key value:(nullable NSString *)value table:(nullable NSString *)tableName NS_FORMAT_ARGUMENT(1) NS_REFINED_FOR_SWIFT API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0));
                                                         ~~~~~~~~~~~~~~                                                                       ^                  ~
/Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/NSObjCRuntime.h:103:48: note: expanded from macro 'NS_FORMAT_ARGUMENT'
        #define NS_FORMAT_ARGUMENT(A) __attribute__ ((format_arg(A)))
```

Dies liegt _normalerweise_ an einer Unstimmigkeit zwischen der von dir verwendeten Betriebssystemversion und der Version der installierten XCode Command Line Tools. Wenn du einen solchen Fehler siehst, aktualisiere deine XCode Command Line Tools auf die neueste Version.

Wenn die Neuinstallation von Xcode Command Tools noch fehlschlägt, kannst du den Pfad des Toolkits überprüfen:

`xcode-select -p`

Wenn `/Applications/Xcode.app/Contents/Developer` angezeigt wird, führe `sudo xcode-select --switch /Library/Developer/CommandLineTools` aus

Quellen: https://github.com/wailsapp/wails/issues/1806 und https://github.com/wailsapp/wails/issues/1140#issuecomment-1290446496

## Meine Anwendung wird nicht auf Mac kompiliert

Wenn du solche Fehler bekommst:

```shell
l1@m2 GoEasyDesigner % go build -tags dev -gcflags "all=-N -l"
/Users/l1/sdk/go1.20.5/pkg/tool/darwin_arm64/link: running clang failed: exit status 1
Undefined symbols for architecture arm64:
  "_OBJC_CLASS_$_UTType", referenced from:
      objc-class-ref in 000016.o
ld: symbol(s) not found for architecture arm64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
```
Vergewissere dich, dass du das neueste SDK installiert hast. Solltest du trotzdem denselben Fehler erhalten, versuche folgendes:

```shell
export CGO_LDFLAGS="-Framework UniformTypeIdentifiers" && go build -tags dev -gcflags "all=-N -l"
```

Quelle: https://github.com/wailsapp/wails/pull/2925#issuecomment-1726828562


--

## Dienst kann nicht gestartet werden: Host-Version "x.x.x stimmt nicht mit der Binärversion "x.x.x" überein

Es ist besser, `frontend/node_modules` und `frontend/package-lock.json` zu deiner `.gitignore` hinzuzufügen. Andernfalls kann es vorkommen, dass du deine Anwendung nicht ausführen kannst, wenn du das Repository auf einem anderen Computer öffnest, auf dem möglicherweise andere Versionen von Node installiert sind.

Falls das der Fall ist, lösche `frontend/node_modules` und `frontend/package-lock.json` und führe den `wails build` oder `wails dev` Befehl erneut aus.

## Der Build Prozess hat sich bei "Generating bindings" aufgehängt

Das Erzeugen von Verknüpfungen führt deine Anwendung in einem speziellen Modus aus. Wenn die Anwendung, absichtlich oder unabsichtlich, eine Endlosschleife enthält (d.h. nicht beendet wird, nachdem `wails.Run()` beendet wurde), kann dies dazu führen, dass der Erstellungsprozess in der Phase der Verknüpfungserzeugung stecken bleibt. Bitte vergewissere dich, dass dein Code korrekt endet.

## Beim Start blinkt die Mac-Anwendung weiß

Dies liegt daran, dass der Standard-Hintergrund der Webview weiß ist. Wenn du stattdessen die Hintergrundfarbe des Fensters verwenden möchtest, kannst du den Hintergrund des Webviews mit der folgenden Konfiguration transparent machen:

```go
    err := wails.Run(&options.App{
        Title:  "macflash",
        Width:  1024,
        Height: 768,
        // Other settings
        Mac: &mac.Options{
            WebviewIsTransparent: true,
        },
    })
```

## Ich bekomme einen "Microsoft Edge can't read or write to its data directory" Fehler wenn ich mein Programm als Administrator unter Windows laufen lasse

Du hast dein Programm so eingestellt, dass es Administratorrechte benötigt, und es hat super funktioniert! Leider sehen einige Benutzer den Fehler "Microsoft Edge can't read or write to its data directory" beim ausführen der Anwendung.

Wenn ein Windows-Rechner zwei lokale Konten hat:

- Alice, ein Admin
- Bob, ein normaler Benutzer

Bob sieht einen UAC-Prompt beim Ausführen deines Programms. Bob gibt Alices Administrator-Anmeldedaten in diese Eingabeaufforderung ein. Die App startet mit Administratorberechtigungen unter Alices Konto.

Wails weist das WebView2 an, Benutzerdaten im angegebenen `WebviewUserDataPath` zu speichern. Standardmäßig `%APPDATA%\[BinaryName.exe]`.

Da die Anwendung unter Alices Konto läuft, wird `%APPDATA%\[BinaryName.exe]` zu `C:\Users\Alice\AppData\Roaming\[BinaryName.exe]` aufgelöst.

WebView2 [erstellt einige untergeordnete Prozesse unter Bobs eingeloggtem Account anstelle von Alices Admin-Konto](https://github.com/MicrosoftEdge/WebView2Feedback/issues/932#issue-807464179). Da Bob nicht auf `C:\Users\Alice\AppData\Roaming\[BinaryName.exe]`zugreifen kann, wird der Fehler "Microsoft Edge can't read or write to its data directory" angezeigt.

Mögliche Lösung #1:

Refactor your application to work without constant admin permissions. Wenn du nur eine kleine Anzahl von Verwaltungsaufgaben ausführen musst (z. B. einen Updater), kannst du deine Anwendung mit den minimalen Berechtigungen ausführen und dann den Befehl `runas` verwenden, um diese Aufgaben bei Bedarf mit Verwaltungsberechtigungen auszuführen:

```go
//go:build windows

package sample

import (
    "golang.org/x/sys/windows"
    "syscall"
)

// Calling RunAs("C:\path\to\my\updater.exe") shows Bob a UAC prompt. Bob enters Alice's admin credentials. Der Updater startet mit Admin-Berechtigungen unter Alices Konto.
func RunAs(path string) error {
    verbPtr, _ := syscall.UTF16PtrFromString("runas")
    exePtr, _ := syscall.UTF16PtrFromString(path)
    cwdPtr, _ := syscall.UTF16PtrFromString("")
    argPtr, _ := syscall.UTF16PtrFromString("")

    var showCmd int32 = 1 //SW_NORMAL

    err := windows.ShellExecute(0, verbPtr, exePtr, argPtr, cwdPtr, showCmd)
    if err != nil {
        return err
    }
    return nil
}
```

Mögliche Lösung #2:

Führe deine Anwendung mit erweiterten Berechtigungen aus. Wenn du unbedingt mit konstanten Administratorrechten arbeiten willst, funktioniert WebView2 korrekt, auch wenn du ein Datenverzeichnis verwendest, auf dem beide Benutzer zugreifen können, vorrausgestzt du startest deine Anwendung mit folgenden Rechten: `SeBackupPrivilege`, `SeDebugPrivilege` und `SeRestorePrivilege`. Hier ist ein Beispiel:

```go
package main

import (
    "embed"
    "os"
    "runtime"

    "github.com/fourcorelabs/wintoken"
    "github.com/hectane/go-acl"
    "github.com/wailsapp/wails/v2"
    "github.com/wailsapp/wails/v2/pkg/options"
    "github.com/wailsapp/wails/v2/pkg/options/assetserver"
    "github.com/wailsapp/wails/v2/pkg/options/windows"
)

//go:embed all:frontend/dist
var assets embed.FS

const (
    fixedTokenKey = "SAMPLE_RANDOM_KEY"
    fixedTokenVal = "with-fixed-token"
    webviewDir    = "C:\\ProgramData\\Sample"
)

func runWithFixedToken() {
    println("Re-launching self")
    token, err := wintoken.OpenProcessToken(0, wintoken.TokenPrimary) //pass 0 for own process
    if err != nil {
        panic(err)
    }
    defer token.Close()

    token.EnableTokenPrivileges([]string{
        "SeBackupPrivilege",
        "SeDebugPrivilege",
        "SeRestorePrivilege",
    })

    cmd := exec.Command(os.Args[0])
    cmd.Args = os.Args
    cmd.Env = os.Environ()
    cmd.Env = append(cmd.Env, fmt.Sprintf("%v=%v", fixedTokenKey, fixedTokenVal))
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    cmd.SysProcAttr = &syscall.SysProcAttr{Token: syscall.Token(token.Token())}
    if err := cmd.Run(); err != nil {
        println("Error after launching self:", err)
        os.Exit(1)
    }
    println("Clean self launch :)")
    os.Exit(0)
}

func main() {
    if runtime.GOOS == "windows" && os.Getenv(fixedTokenKey) != fixedTokenVal {
        runWithFixedToken()
    }

    println("Setting data dir to", webviewDir)
    if err := os.MkdirAll(webviewDir, os.ModePerm); err != nil {
        println("Failed creating dir:", err)
    }
    if err := acl.Chmod(webviewDir, 0777); err != nil {
        println("Failed setting ACL on dir:", err)
    }

    app := NewApp()

    err := wails.Run(&options.App{
        Title:  "sample-data-dir",
        Width:  1024,
        Height: 768,
        AssetServer: &assetserver.Options{
            Assets: assets,
        },
        Bind: []interface{}{
            app,
        },
        Windows: &windows.Options{
            WebviewUserDataPath: webviewDir,
        },
    })

    if err != nil {
        println("Error:", err.Error())
    }
}
```

Wenn du ein Datenverzeichnis verwendest, auf das beide Benutzer Zugriff haben, aber nicht die erweiterten Rechte, erhälst du den WebView2 Fehler `80010108 The object invoked has disconnected from its clients`.

Mögliche zukünftige Lösung #3: [führe das WebView2 über einen in-memory Modus aus, wenn dieser implementiert ist](https://github.com/MicrosoftEdge/WebView2Feedback/issues/3637#issuecomment-1728300982).

## WebView2 wurde erfolgreich installiert, obwohl der Befehl Wails Doctor anzeigt, dass WebView2 nicht installiert ist

Wenn du das WebView2 installierst hast, aber der Befehl `wails doctor` anzeigt, dass es nicht installiert ist, ist es wahrscheinlich, dass die installierte WebView2-Laufzeit für eine andere Architektur war. Du kannst die korrekte Laufzeit [hier](https://developer.microsoft.com/en-us/microsoft-edge/webview2/) herunterladen.

Quelle: https://github.com/wailsapp/wails/issues/2917

## WebVie2wProcess failed with kind

Wenn deine Windows-App diese Art von Fehler erzeugt, kannst du  [hier](https://docs.microsoft.com/en-us/microsoft-edge/webview2/reference/winrt/microsoft_web_webview2_core/corewebview2processfailedkind?view=webview2-winrt-1.0.2045.28)  überprüfen, was der Fehler bedeutet.