Fatal编程技术网
  • csharp/
  • C# HttpClient未在最小化的UWP应用程序中执行GetAsync

C# HttpClient未在最小化的UWP应用程序中执行GetAsync

c# uwp

C# HttpClient未在最小化的UWP应用程序中执行GetAsync,c#,uwp,C#,Uwp,我正在做一个项目，在那里我播放了几段视频。为了能够播放这些视频，我需要在应用程序通过HttpClient从System.Net.Http请求时获取它们的数据。一切正常，UWP应用程序在前台时从互联网下载所需信息 一旦应用程序离开前台并被用户最小化，HttpClient，无论它是来自System.Net.Httpnamesoace还是Windows.Web.Http命名空间，都不会工作。我甚至尝试在那里设置一个断点，当我向前移动时，HttpClient不会响应wait client.GetAsyn

我正在做一个项目，在那里我播放了几段视频。为了能够播放这些视频，我需要在应用程序通过
HttpClient
从
System.Net.Http
请求时获取它们的数据。一切正常，UWP应用程序在前台时从互联网下载所需信息

一旦应用程序离开前台并被用户最小化，
HttpClient
，无论它是来自
System.Net.Http
namesoace还是
Windows.Web.Http
命名空间，都不会工作。我甚至尝试在那里设置一个断点，当我向前移动时，
HttpClient
不会响应
wait client.GetAsync（）
方法，并且不会返回任何结果，除非再次激活应用程序，然后它返回任何值。我不能使用
背景任务
，因为它们需要
触发器
，但我需要按需访问数据

我也读过一篇描述请求
ExtendedExecutionState
的文章，但结果仍然是一样的。当应用程序收到播放项目列表的请求时，我请求此状态。即使在得到允许的
结果后，
HttpClient
仍具有与上述相同的行为

是否有任何方法可以在请求时执行与internet相关的查询并获取一些信息

我从internet访问数据时执行的代码是：


public static async Task<string> GetResponseDataFromAPI(string apiRequestUrl, CancellationTokenSource cts = default)
{
    cts = cts ?? new CancellationTokenSource(TimeSpan.FromSeconds(20));
    try
    {
        var responseData = await AuthRequestHelper.globalHttpClient.GetAsync(apiRequestUrl, cts.Token);
        var result = await responseData.Content.ReadAsStringAsync();
        return result;
    }
    catch (Exception ex)
    {
        INotifyHelper.iNotifyObject.IsVideoLoading = false;
        INotifyHelper.iNotifyObject.IsDataLoading = false;
        // show error
        return "{ \"error\": {\"code\": " + $"\"{ex.HResult}\", \"message\": \"{ex.Message}\"" + "} }";
    }
}


在最小化状态下，是否可以执行所请求的操作？如果您能帮我指出正确的方向，我们将不胜感激。谢谢
即使应用程序被挂起或关闭，也可以在后台下载数据

HttpClient更适合于快速完成的非常短的下载。对于长时间下载，如视频，请使用。如果您需要在下载完成时处理该文件，则可以使用该完成作为后台任务的触发器


请参阅提供的文档链接以了解概述和操作方法。在
上有一个完整的样本，所以我决定在这里写下我自己的答案，因为我不确定是否有其他人会提到这个问题。我怀疑的一件事是，我最近将C语言更新为v7.3，因为VS2017在编写一些代码时这么说。也许问题与此相关，但到目前为止，我的解决方案在最小化状态下工作

我还想在这里声明，我首先实现了
BackgroundTask
，以克服这个问题，使用
ApplicationTrigger
在需要时触发该过程，但这确实是一种黑客行为。请看一下代码：


public static async Task<string> GetBackgroundTaskReturnValue(string apiRequestUrl)
{
        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = true;
        if (StaticItemsHelper.IsBackgroundPlaylistTaskRunning)
        {
            for (int seconds = 0; seconds < 20;)
            {
                if (!StaticItemsHelper.IsBackgroundPlaylistTaskRunning)
                {
                    break;
                }
                else
                {
                    Task.Delay(1000).Wait();
                }
            }
        }
        var request = BackgroundTaskHelper.BackgroundPlaylistTrigger.RequestAsync().GetResults();
        if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed)
        {
            SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlaylistPlaybackURLKey] = apiRequestUrl;
            SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlaylistPlaybackTokenKey] = StaticItemsHelper.CurrentUserAccessToken;
            if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile file)
            {
                await file.DeleteAsync();
            }
            for (int seconds = 0; seconds < 30;)
            {
                if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile _rfile)
                {
                    var _returnVal = FileIO.ReadTextAsync(_rfile).GetResults();
                    if (!string.IsNullOrEmpty(_returnVal.ToString()))
                    {
                        await _rfile.DeleteAsync();
                        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackTokenKey);
                        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackURLKey);
                        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = false;
                        return _returnVal;
                    }
                }
                Task.Delay(2000).Wait();
                seconds += 2;
            }
        }
        else if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.CurrentlyRunning)
        {
            for (int seconds = 0; seconds < 30;)
            {
                Task.Delay(2000).Wait();
                seconds += 2;
                request = BackgroundTaskHelper.BackgroundPlaylistTrigger.RequestAsync().GetResults();
                if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed)
                {
                    return GetBackgroundTaskReturnValue(apiRequestUrl).Result;
                }
            }
        }
        if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile _file)
        {
            await _file.DeleteAsync();
        }
        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackTokenKey);
        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackURLKey);
        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = false;
        return "{ \"error\": {\"code\": \"NetworkError\", \"message\": \"Server returned nothing.\"} }";
}



公共静态异步任务GetBackgroundTaskReturnValue（字符串APIRestUrl）
{
StaticItemsHelper.isBackgroundPlaylayTaskRunning=true；
if（StaticItemsHelper.isBackgroundPlaylayTaskRunning）
{
用于（整数秒=0；秒<20；）
{
如果（！StaticItemsHelper.isBackgroundPlaylTaskRunning）
{
打破
}
其他的
{
Task.Delay（1000.Wait（）；
}
}
}
var request=BackgroundTaskHelper.BackgroundPlayTrigger.RequestAsync（）.GetResults（）；
if（请求==Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed）
{
SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlayPlaybackUrlKey]=APIRestUrl；
SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlayPlaybackTokenKey]=StaticItemsHelper.CurrentUserAccessToken；
if（SettingsHelper.tempFolder.TryGetItemAsync（SettingsHelper.backgroundPlayPlaybackReturnKey）.GetResults（）是存储文件）
{
wait file.deleteSync（）；
}
用于（整数秒=0；秒<30；）
{
if（SettingsHelper.tempFolder.TryGetItemAsync（SettingsHelper.backgroundPlayPlaybackReturnKey）.GetResults（）是存储文件_rfile）
{
var _returnVal=FileIO.ReadTextAsync（_rfile）.GetResults（）；
如果（！string.IsNullOrEmpty（_returnVal.ToString（）））
{
等待_rfile.DeleteAsync（）；
SettingsHelper.localSettings.Values.Remove（SettingsHelper.BackgroundPlayPlaybackTokenKey）；
SettingsHelper.localSettings.Values.Remove（SettingsHelper.BackgroundPlayPlayPlaybackUrlKey）；
StaticItemsHelper.isBackgroundPlaylayTaskRunning=false；
返回_returnVal；
}
}
Task.Delay（2000.Wait（）；
秒+=2；
}
}
else if（请求==Windows.ApplicationModel.Background.ApplicationRiggerResult.CurrentlyRunning）
{
用于（整数秒=0；秒<30；）
{
Task.Delay（2000.Wait（）；
秒+=2；
request=BackgroundTaskHelper.BackgroundPlayTrigger.RequestAsync（）.GetResults（）；
if（请求==Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed）
{
返回GetBackgroundTaskReturnValue（APIRestUrl）；
}
}
}
if（SettingsHelper.tempFolder.TryGetItemAsync（SettingsHelper.backgroundPlayPlaybackReturnKey）.GetResults（）是存储文件_文件）
{
等待_file.deleteAncy（）；
}
SettingsHelper.localSettings.Values.Remove（SettingsHelper.BackgroundPlayPlaybackTokenKey）；
SettingsHelper.localSettings.Values.Remove（SettingsHelper.BackgroundPlayPlayPlaybackUrlKey）；
StaticItemsHelper.isBackgroundPlaylayTaskRunning=false；
返回“{\”错误\“：{\”代码\“：\”网络错误\“，\”混乱

public static async Task<string> GetBackgroundTaskReturnValue(string apiRequestUrl)
{
        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = true;
        if (StaticItemsHelper.IsBackgroundPlaylistTaskRunning)
        {
            for (int seconds = 0; seconds < 20;)
            {
                if (!StaticItemsHelper.IsBackgroundPlaylistTaskRunning)
                {
                    break;
                }
                else
                {
                    Task.Delay(1000).Wait();
                }
            }
        }
        var request = BackgroundTaskHelper.BackgroundPlaylistTrigger.RequestAsync().GetResults();
        if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed)
        {
            SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlaylistPlaybackURLKey] = apiRequestUrl;
            SettingsHelper.localSettings.Values[SettingsHelper.BackgroundPlaylistPlaybackTokenKey] = StaticItemsHelper.CurrentUserAccessToken;
            if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile file)
            {
                await file.DeleteAsync();
            }
            for (int seconds = 0; seconds < 30;)
            {
                if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile _rfile)
                {
                    var _returnVal = FileIO.ReadTextAsync(_rfile).GetResults();
                    if (!string.IsNullOrEmpty(_returnVal.ToString()))
                    {
                        await _rfile.DeleteAsync();
                        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackTokenKey);
                        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackURLKey);
                        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = false;
                        return _returnVal;
                    }
                }
                Task.Delay(2000).Wait();
                seconds += 2;
            }
        }
        else if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.CurrentlyRunning)
        {
            for (int seconds = 0; seconds < 30;)
            {
                Task.Delay(2000).Wait();
                seconds += 2;
                request = BackgroundTaskHelper.BackgroundPlaylistTrigger.RequestAsync().GetResults();
                if (request == Windows.ApplicationModel.Background.ApplicationTriggerResult.Allowed)
                {
                    return GetBackgroundTaskReturnValue(apiRequestUrl).Result;
                }
            }
        }
        if (SettingsHelper.tempFolder.TryGetItemAsync(SettingsHelper.BackgroundPlaylistPlaybackReturnKey).GetResults() is StorageFile _file)
        {
            await _file.DeleteAsync();
        }
        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackTokenKey);
        SettingsHelper.localSettings.Values.Remove(SettingsHelper.BackgroundPlaylistPlaybackURLKey);
        StaticItemsHelper.IsBackgroundPlaylistTaskRunning = false;
        return "{ \"error\": {\"code\": \"NetworkError\", \"message\": \"Server returned nothing.\"} }";
}



public static async Task<string> GetResponseDataFromAPI(string apiRequestUrl, CancellationTokenSource cts = default)
{
        cts = cts ?? new CancellationTokenSource(TimeSpan.FromSeconds(20));
        try
        {
            if (StaticItemsHelper.IsAppInBackground)
            {
                //return await ViewHelper.GetBackgroundTaskReturnValue(apiRequestUrl);
                var responseData = AuthRequestHelper.globalHttpClient.GetAsync(apiRequestUrl, cts.Token).Result;
                var result = responseData.Content.ReadAsStringAsync().Result;
                return result;
            }
            else
            {
                var responseData = await AuthRequestHelper.globalHttpClient.GetAsync(apiRequestUrl, cts.Token);
                var result = await responseData.Content.ReadAsStringAsync();
                return result;
            }
        }
        catch (Exception ex)
        {
            INotifyHelper.iNotifyObject.IsDataLoading = false;
            // show error
            return "{ \"error\": {\"code\": " + $"\"{ex.HResult}\", \"message\": \"{ex.Message}\"" + "} }";
        }
}