App.xaml.cs

using System.Collections.Generic;
using System.IO;
using Application = System.Windows.Application;
using MessageBox = System.Windows.MessageBox;
using MessageBoxButton = System.Windows.MessageBoxButton;
using MessageBoxImage = System.Windows.MessageBoxImage;
using StartupEventArgs = System.Windows.StartupEventArgs;
using DispatcherUnhandledExceptionEventArgs = System.Windows.Threading.DispatcherUnhandledExceptionEventArgs;
using ReadFolder.Services;

namespace ReadFolder;

public partial class App : Application
{
    private static int _uiExceptionShown;

    protected override void OnStartup(StartupEventArgs e)
    {
        DispatcherUnhandledException += OnDispatcherUnhandledException;
        AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
        TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;

        base.OnStartup(e);

        var startupPath = ResolveStartupPath(e.Args);
        LocalizationService.Instance.SetLanguage(null);

        var window = new MainWindow(startupPath);
        MainWindow = window;
        window.Show();
    }

    private static string? ResolveStartupPath(IReadOnlyList<string> args)
    {
        if (args.Count == 0)
        {
            return null;
        }

        var rawPath = args[0];
        if (string.IsNullOrWhiteSpace(rawPath))
        {
            return null;
        }

        if (Directory.Exists(rawPath))
        {
            return rawPath;
        }

        if (File.Exists(rawPath))
        {
            return Path.GetDirectoryName(rawPath);
        }

        return null;
    }

    private static void OnDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
    {
        if (Interlocked.Exchange(ref _uiExceptionShown, 1) != 0)
        {
            e.Handled = true;
            return;
        }

        MessageBox.Show(
            BuildExceptionMessage("Unhandled UI exception", e.Exception),
            "ReadFolder",
            MessageBoxButton.OK,
            MessageBoxImage.Error);
        e.Handled = true;
    }

    private static void OnUnhandledException(object? sender, UnhandledExceptionEventArgs e)
    {
        if (Interlocked.Exchange(ref _uiExceptionShown, 1) != 0)
        {
            return;
        }

        if (e.ExceptionObject is Exception ex)
        {
            MessageBox.Show(
                BuildExceptionMessage("Unhandled exception", ex),
                "ReadFolder",
                MessageBoxButton.OK,
                MessageBoxImage.Error);
        }
    }

    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
    {
        if (Interlocked.Exchange(ref _uiExceptionShown, 1) != 0)
        {
            e.SetObserved();
            return;
        }

        MessageBox.Show(
            BuildExceptionMessage("Background task exception", e.Exception),
            "ReadFolder",
            MessageBoxButton.OK,
            MessageBoxImage.Warning);
        e.SetObserved();
    }

    private static string BuildExceptionMessage(string title, Exception exception)
    {
        var lines = new List<string>
        {
            title + ":",
            string.Empty,
            exception.Message
        };

        var inner = exception.InnerException;
        var depth = 1;
        while (inner != null && depth <= 4)
        {
            lines.Add(string.Empty);
            lines.Add($"InnerException {depth}:");
            lines.Add(inner.Message);
            inner = inner.InnerException;
            depth++;
        }

        if (!string.IsNullOrWhiteSpace(exception.StackTrace))
        {
            lines.Add(string.Empty);
            lines.Add("StackTrace:");
            lines.Add(exception.StackTrace);
        }

        return string.Join(Environment.NewLine, lines);
    }
}