Flow.Launcher/Flow.Launcher.Core/Resource/DispatcherHelper.cs at 66e9e6f0b490762722725d04eadb72a00960cc39 · Flow-Launcher/Flow.Launcher · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
using System;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;

namespace Flow.Launcher.Core.Resource;

#pragma warning disable VSTHRD001 // Avoid legacy thread switching APIs

public static class DispatcherHelper
{
    public static void Invoke(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        Invoke(Application.Current?.Dispatcher, action, priority);
    }

    public static T Invoke<T>(Func<T> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        return Invoke(Application.Current?.Dispatcher, func, priority);
    }

    public static void Invoke(Dispatcher dispatcher, Action action, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        if (dispatcher == null) return;
        if (dispatcher.CheckAccess())
        {
            action();
        }
        else
        {
            dispatcher.Invoke(action, priority);
        }
    }

    public static T Invoke<T>(Dispatcher dispatcher, Func<T> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        if (dispatcher == null) return default;
        if (dispatcher.CheckAccess())
        {
            return func();
        }
        else
        {
            return dispatcher.Invoke(func, priority);
        }
    }

    public static async Task InvokeAsync(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        await InvokeAsync(Application.Current?.Dispatcher, action, priority);
    }

    public static async Task<T> InvokeAsync<T>(Func<T> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        return await InvokeAsync(Application.Current?.Dispatcher, func, priority);
    }

    public static async Task InvokeAsync(Func<Task> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        await InvokeAsync(Application.Current?.Dispatcher, func, priority);
    }

    public static async Task InvokeAsync(Dispatcher dispatcher, Action action, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        if (dispatcher == null) return;
        if (dispatcher.CheckAccess())
        {
            action();
        }
        else
        {
            await dispatcher.InvokeAsync(action, priority);
        }
    }

    public static async Task<T> InvokeAsync<T>(Dispatcher dispatcher, Func<T> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        if (dispatcher == null) return default;
        if (dispatcher.CheckAccess())
        {
            return func();
        }
        else
        {
            return await dispatcher.InvokeAsync(func, priority);
        }
    }

    public static async Task InvokeAsync(Dispatcher dispatcher, Func<Task> func, DispatcherPriority priority = DispatcherPriority.Normal)
    {
        if (dispatcher == null) return;
        if (dispatcher.CheckAccess())
        {
            await func();
        }
        else
        {
            var task = await dispatcher.InvokeAsync(func, priority);
            await task;
        }
    }
}