如何写一个异步方法与参数?

我想写一个带out参数的async方法，像这样:

public async void Method1()
{
    int op;
    int result = await GetDataTaskAsync(out op);
}

我如何做到这一点在GetDataTaskAsync?

当前回答

这与Michael Gehling提供的答案非常相似，但我有自己的解决方案，直到我找到了他的解决方案，并注意到我不是第一个想到使用隐式转换的人。

无论如何，当nullable设置为启用时，我也想共享

public readonly struct TryResult<TOut>
{
    #region constructors

    public TryResult(bool success, TOut? value) => (Success, Value) = (success, value);

    #endregion

    #region properties

    public                                            bool  Success { get; init; }
    [MemberNotNullWhen(true, nameof(Success))] public TOut? Value   { get; init; }

    #endregion

    #region methods

    public static implicit operator bool(TryResult<TOut> result) => result.Success;
    public static implicit operator TryResult<TOut>(TOut value) => new (true, value);

    public void Deconstruct(out bool success, out TOut? value) => (success, value) = (Success, Value);

    public TryResult<TOut> Out([NotNullWhen(true)] out TOut? value)
    {
        value = Value;

        return this;
    }

    #endregion
}

然后你可以像这样写一个Try方法:

public static async Task<TryResult<byte[]>> TryGetBytesAsync(string file) =>
    File.Exists(file)
        ? await File.ReadAllBytesAsync(file)
        : default(TryResult<byte[]>);

像这样叫它:

if ((await TryGetBytesAsync(file)).Out(out var bytes))
    Console.WriteLine($"File has {bytes.Length} bytes.");

2022-10-18 17:44:22

其他回答

下面是@dcastro回答的代码，为c# 7.0修改了命名元组和元组解构，简化了符号:

public async void Method1()
{
    // Version 1, named tuples:
    // just to show how it works
    /*
    var tuple = await GetDataTaskAsync();
    int op = tuple.paramOp;
    int result = tuple.paramResult;
    */

    // Version 2, tuple deconstruction:
    // much shorter, most elegant
    (int op, int result) = await GetDataTaskAsync();
}

public async Task<(int paramOp, int paramResult)> GetDataTaskAsync()
{
    //...
    return (1, 2);
}

有关新的命名元组、元组字面量和元组解构的详细信息，请参见: https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/

2018-06-13 13:26:16

Alex在可读性上有很好的观点。同样，函数也具有足够的接口来定义返回的类型，并且还可以获得有意义的变量名。

delegate void OpDelegate(int op);
Task<bool> GetDataTaskAsync(OpDelegate callback)
{
    bool canGetData = true;
    if (canGetData) callback(5);
    return Task.FromResult(canGetData);
}

调用者提供一个lambda(或一个命名函数)，智能感知通过从委托复制变量名来提供帮助。

int myOp;
bool result = await GetDataTaskAsync(op => myOp = op);

这种特殊的方法类似于“Try”方法，如果方法结果为真，则设置myOp。否则，你不会关心myOp。

2015-09-11 04:35:32

我有同样的问题，因为我喜欢使用Try-method-pattern，基本上似乎与async- wait-paradigm不兼容…

对我来说重要的是，我可以在一个if-子句中调用try -方法，而不必预先定义out-变量，但可以像下面的例子那样内联执行:

if (TryReceive(out string msg))
{
    // use msg
}

所以我提出了以下解决方案:

注意:新的解决方案更优越，因为它可以与在这里的许多其他答案中描述的仅返回元组的方法一起使用，这可能经常在现有代码中找到!

新的解决方案:

Create extension methods for ValueTuples: public static class TupleExtensions { public static bool TryOut<P2>(this ValueTuple<bool, P2> tuple, out P2 p2) { bool p1; (p1, p2) = tuple; return p1; } public static bool TryOut<P2, P3>(this ValueTuple<bool, P2, P3> tuple, out P2 p2, out P3 p3) { bool p1; (p1, p2, p3) = tuple; return p1; } // continue to support larger tuples... } Define async Try-method like this: public async Task<(bool, string)> TryReceiveAsync() { string message; bool success; // ... return (success, message); } Call the async Try-method like this: if ((await TryReceiveAsync()).TryOut(out string msg)) { // use msg }

旧的解决方案:

Define a helper struct: public struct AsyncOut<T, OUT> { private readonly T returnValue; private readonly OUT result; public AsyncOut(T returnValue, OUT result) { this.returnValue = returnValue; this.result = result; } public T Out(out OUT result) { result = this.result; return returnValue; } public T ReturnValue => returnValue; public static implicit operator AsyncOut<T, OUT>((T returnValue ,OUT result) tuple) => new AsyncOut<T, OUT>(tuple.returnValue, tuple.result); } Define async Try-method like this: public async Task<AsyncOut<bool, string>> TryReceiveAsync() { string message; bool success; // ... return (success, message); } Call the async Try-method like this: if ((await TryReceiveAsync()).Out(out string msg)) { // use msg }

对于多个out参数，您可以定义额外的结构(例如AsyncOut<T,OUT1, OUT2>)，或者您可以返回一个元组。

2019-08-29 09:59:36

在异步方法中不能有ref或out参数(如前所述)。

这需要在数据移动中进行一些建模:

public class Data
{
    public int Op {get; set;}
    public int Result {get; set;}
}

public async void Method1()
{
    Data data = await GetDataTaskAsync();
    // use data.Op and data.Result from here on
}

public async Task<Data> GetDataTaskAsync()
{
    var returnValue = new Data();
    // Fill up returnValue
    return returnValue;
}

您获得了更容易重用代码的能力，而且它比变量或元组更具可读性。

2013-09-10 11:47:32