小编Bre*_*use的帖子

我有一个我想用反射调用的私有静态泛型方法,但实际上我想在另一个方法中"捆绑"它.C#7.0支持本地功能,所以这绝对是可能的.

你会说"你为什么不直接叫它？" 但我正在用它来获得以强类型方式使用对象和System.Type的能力,所以我需要动态调用它.如果我将它作为自己的私有静态泛型方法,则此代码已经有效.

private static void HandleResponse(object data, Type asType)
{
    var application = typeof(Program);

    application
        .GetMethod(nameof(UseAs), BindingFlags.Static | BindingFlags.NonPublic)
        .MakeGenericMethod(asType)
        .Invoke(null, new object[] { data });
}

public static void UseAs<T>(T obj)
{
    Console.WriteLine($"Object is now a: {typeof(T)}:");
};

上面的代码有效.如果我通过:

data: new TestObject(),
type: typeof(TestObject)

我实际上在UseAs中有一个TestObject.

所以,我想把这一切都放在一个方法中,如下所示:

private static void HandleResponse(object data, Type asType)
{
    void useAs<T>(T obj)
    {
        Console.WriteLine($"Object is now a: {typeof(T)}:");
    };

    var application = typeof(Program);

    application
        .GetMethod(nameof(UseAs), BindingFlags.Static | BindingFlags.NonPublic)
        .MakeGenericMethod(asType)
        .Invoke(null, new object[] { …

我有一个Task我正在开始并希望等待在WPF应用程序中完成.在这个任务中,我调用了一个Action调度员.

如果我使用Task.Wait()它似乎挂起,好像方法永远不会完成.此外,Dispatcher.Invoke中的断点永远不会被命中.

如果我使用Task.RunSyncronously()它似乎工作正常并且Dispatcher内的断点被击中.

为什么会有区别？

代码示例如下:

public void ExampleMethod()
{
    // When doing the following:
    var task = new Task(LoadStuff);

    // This never returns:
    task.Start();
    task.Wait();

    // This version, however, does:
    task.RunSyncronously();
}

private void LoadStuff()
{
    ObservableCollection<StuffObj> stuff = Stuff.Load(arg1, true);

    DispatchHelper.RunOnDispatcher(() =>
    {
        ...
    });
}

public static class DispatchHelper
{
    public static void RunOnDispatcher(Action action)
    {
        Application.Current.Dispatcher.Invoke(action);
    }
}