标签: cancellation

有谁知道如何使用Android设备的内置声学回声消除？它位于硅片的某个地方,用于GSM/CDMA免提电话.我们真的很想进入VoIP应用程序,而不是自己动手.

本

在我看来我有图像视图,图像视图的数据来自Url,图像大约1-3 MB.如果用户Swipes然后我想加载下一个图像,如果我慢慢滑动,每件事情都可以正常工作但是当我快速滑动时我想取消之前的操作并从新网址开始.

对于Ex.如果第二和第三张图像的操作位于中间,如果用户滑动4次,我想取消这些并开始下载第4张图像

但是现在在第4张图像的地方我得到第一张第2张图像跟随第3张然后第4张图像出现.

这是我的示例代码

- (void)handleSwipeLeft:(UISwipeGestureRecognizer *)aSwipeGestureRecognizer {


    [BackgroundOperation cancelAllOperations];  // To cancel previous one 


    [self performSelector:@selector(LoadImage) withObject:nil afterDelay:0.1];


}

-(void)LoadImage
{
    BackgroundOperation=[[NSOperationQueue alloc]init];  


    imgvww.image=[UIImage imageNamed:@"loader.png"]; // Place holder    till download finishes 


   [BackgroundOperation addOperationWithBlock:^
     {
         UIImage *img=[UIImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:[[self.ItemDetails objectAtIndex:0] objectForKey:@"ImageUrl"]]]];  // Getting data from URL 

         [[NSOperationQueue mainQueue] addOperationWithBlock:^{


             imgvww.image=img;  //Adding to image view after completion 


         }];

     }];
 }

谢谢.

我正在构建表单验证并学习promises我决定使用promise模式实现异步验证函数:

var validateAjax = function(value) {
    return new Promise(function(resolve, reject) {
        $.ajax('data.json', {data: {value: value}}).success(function(data, status, xhr) {
            if (data.valid) {
                resolve(xhr)
            }
            else {
                reject(data.message)
            }
        }).error(function(xhr, textStatus) {
            reject(textStatus)
        })
    })
}

//...
var validators = [validateAjax];
$('body').delegate('.validate', 'keyup', function() {
    var value = $('#the-input').val();
    var results = validators.map(function(validator) {
        return validator(input)
    });

    var allResolved = Promise.all(results).then(function() {
        //...
    }).catch(function() {
        //...
    })
});

这似乎工作正常,输入被验证为用户类型(代码简化不会太长,例如缺少keyup后的超时等等).

现在我想知道如果前一个keyup事件的验证仍在进行中,如何终止ajax请求.是否可能以某种方式检测承诺在哪种状态并且可能拒绝来自外部的承诺？

我遇到了.NET HttpClient类(.NET 4.5.1,System.Net.Http v4.0.0.0)的问题.我正在调用HttpClient.GetAsync,传入一个CancellationToken(作为Nuget包的一部分,用于抽象webservices之间的调用).如果在进行调用之前已取消令牌,则请求将在不抛出异常的情况下通过.这种行为似乎不正确.

我的测试(不完整,未完全编写 - 无异常检查):

[TestMethod]
public async Task Should_Cancel_If_Cancellation_Token_Called()
{
    var endpoint = "nonexistent";
    var cancellationTokenSource = new CancellationTokenSource();

    var _mockHttpMessageHandler = new MockHttpMessageHandler();
    _mockHttpMessageHandler
        .When("*")
        .Respond(HttpStatusCode.OK);

    var _apiClient = new ApiClientService(new HttpClient(_mockHttpMessageHandler));
    cancellationTokenSource.Cancel();

    var result = await _apiClient.Get<string>(endpoint, null, cancellationTokenSource.Token);
}

我正在测试的方法:

public async Task<T> Get<T>(string endpoint, IEnumerable<KeyValuePair<string, string>> parameters = null, CancellationToken cancellationToken = default(CancellationToken))
{
    var builder = new UriBuilder(Properties.Settings.Default.MyEndpointHost + endpoint);
    builder.Query = buildQueryStringFromParameters(parameters);

    _httpClient.DefaultRequestHeaders.Accept.Clear();
    _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

    try …

我试图把它减少到尽可能小的重复,但它仍然有点长,我道歉.

我有一个F#项目引用一个C#项目,代码如下所示.

public static class CSharpClass {
    public static async Task AsyncMethod(CancellationToken cancellationToken) {
        await Task.Delay(3000);
        cancellationToken.ThrowIfCancellationRequested();
    }
}

这是F#代码.

type Message = 
    | Work of CancellationToken
    | Quit of AsyncReplyChannel<unit>

let mkAgent() = MailboxProcessor.Start <| fun inbox -> 
    let rec loop() = async {
        let! msg = inbox.TryReceive(250)
        match msg with
        | Some (Work cancellationToken) ->
            let! result = 
                CSharpClass.AsyncMethod(cancellationToken)
                |> Async.AwaitTask
                |> Async.Catch
            // THIS POINT IS NEVER REACHED AFTER CANCELLATION
            match result with
            | Choice1Of2 _ -> …

我有一个与外部资源交互的 ASP.NET MVC 应用程序，并且有一个操作需要很多时间。所以在控制器中我有这样的方法

[HttpPost]
public async Task<JsonResult> SomeMethod(..., CancellationToken token)
{
    await _someService.ExecuteSlowOperationAsync(..., token);
    ...
}

这个缓慢的操作看起来像

public async Task ExecuteSlowOperationAsync(..., CancellationToken token)
{
    return await Task.Run(() => 
    {
       //interacting with external resource
    }, token);
} 

此方法与模态视图相关联，如果请求将花费太多时间，用户可能会决定关闭它。据此，我必须在不等待结果的情况下取消请求，因此在客户端我有类似的代码

...
var request = $.ajax(...);

...

$('#modal').on('hidden.bs.modal', function () {
  request.abort();
});

如果我正确理解这篇文章，取消令牌通过框架模型绑定器与请求绑定，无需对其进行任何操作。当用户关闭模态表单时，在浏览器控制台中，我可以看到请求状态“已取消”，但在服务器端缓慢的操作仍在执行。Aslo我试过

CancellationToken disconnectedToken = Response.ClientDisconnectedToken;            
var source = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, disconnectedToken);

然后从这个来源拿了令牌，但还是一无所获。

我觉得我错过了一些重要的事情并且对这种情况有误解。任何想法如何使它工作？

编辑：这个问题的要求已经改变。请参阅下面的更新部分。

我有一个异步迭代器方法，它产生一个IAsyncEnumerable<int>（数字流），每 200 毫秒一个数字。此方法的调用者使用流，但希望在 1000 毫秒后停止枚举。因此使用了 a CancellationTokenSource，并且将令牌作为参数传递给WithCancellation扩展方法。但令牌不受尊重。枚举一直持续到所有数字都被消耗完：

static async IAsyncEnumerable<int> GetSequence()
{
    for (int i = 1; i <= 10; i++)
    {
        await Task.Delay(200);
        yield return i;
    }
}

var cts = new CancellationTokenSource(1000);
await foreach (var i in GetSequence().WithCancellation(cts.Token))
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} > {i}");
}

输出：

12:55:17.506 > 1
12:55:17.739 > 2
12:55:17.941 > 3
12:55:18.155 > 4
12:55:18.367 > 5
12:55:18.520
: > 572 18 >
18 :55:18.973 > 8 …

我需要拒绝来自其身体外的承诺,以处理想要取消操作的用户的情况.

在这里,我需要通过在每个排队的上传中调用#start来同时启动多个上传.管理上传队列的类然后存储所有承诺和用于Ember.RSVP.all处理所有承诺已解决或拒绝的承诺.这很好用.

现在,我想取消上传

App.Upload = Ember.Object.extend({
  start: function() {
    var self = this;

    return new Ember.RSVP.Promise(function(resolve, reject) {
      self.startUpload() // Async upload with jQuery
        .then(
          function(resp) { resolve(resp) },
          function(error) { reject(error) }
        );
    });
  },

  cancel: function() {
    this.get('currentUpload').cancel() // Works, and cancels the upload
    // Would like to reject the promise here
  },

  startUpload: function() {
    return this.set('currentUpload', /* some jqXHR that i build to upload */)
  }
});

我已经想到了很多方法来处理它,但我没有找到任何方法myPromise.reject(reason).

所以我做的是将reject函数存储在Upload …

一段时间以来，我一直在尝试了解 C# 用于异步代码的整个异步/等待模型。添加异步流（IAsyncEnumerable<T>类型）看起来真的很酷，特别是对于我正在编写的一些代码。

创建异步方法时的最佳实践是包含一个CancellationToken参数并使用它来取消异步进程。（理想情况下，将其传递给方法中使用的底层异步方法调用。）

创建返回异步流 (an ) 的方法时，IAsyncEnumerable<T>文档指出您的CancellationToken参数应使用属性进行修饰，然后使用该方法本身[EnumeratorCancellation]传递令牌。.WithCancellation()IAsyncEnumerable<T>

但是，我一定做错了什么，因为这仍然会触发警告：

CA2016：将 CancellationToken 参数转发到采用 1 的方法

无论我是否以更标准的方式执行此操作，都会出现此警告：

async IAsyncEnumerable<aThingo> GetFlibbityStream([EnumeratorCancellation] CancellationToken cancellationToken = default) {
    aThingo slowValue = null;
    do {
        aThingo slowValue = await GetThatThingo(cancellationToken);
        yield return slowValue;
    while (slowValue != null);
}


async Task DoingStuff(CancellationToken cancellationToken) {
    await foreach(var thng in ThingStreamCreator.GetFlibbityStream().WithCancellation(cancellationToken)) {
        CrushThatThing(thng);
    }
}

或者在我需要获取AsyncEnumerator自身的地方（因为我需要一起迭代两个异步流，但不一定以相同的速率。）

async Task ValidatingThingsAsync(CancellationToken cancellationToken) {
    await using IAsyncEnumerator<aThingo> srcEnumerator …

我需要支持取消一个函数，该函数返回一个可以在启动后取消的对象。就我而言，该类requester位于我无法修改的第三方库中。

actor MyActor {

    ...

    func doSomething() async throws -> ResultData {

        var requestHandle: Handle?
    
        return try await withTaskCancellationHandler {
            requestHandle?.cancel() // COMPILE ERROR: "Reference to captured var 'requestHandle' in concurrently-executing code"
        } operation: {

            return try await withCheckedThrowingContinuation{ continuation in
            
                requestHandle = requester.start() { result, error in
            
                    if let error = error
                        continuation.resume(throwing: error)
                    } else {
                        let myResultData = ResultData(result)
                        continuation.resume(returning: myResultData)
                    }
                }
            }
        }
    }

    ...
}

我已经审查了其他问题和此线程：https://forums.swift.org/t/how-to-use-withtaskcancellationhandler-properly/54341/4

有些案例非常相似，但又不完全相同。由于以下错误，此代码将无法编译：

“在并发执行的代码中引用捕获的 var 'requestHandle'”

我假设编译器试图在 …