相关疑难解决方法(0)

我从存储库调用Web API(C#)中的方法.该方法是存储库没有返回任何东西.这是虚空.我应该在API方法中返回,因为async方法不能有Void返回类型.

这是我在API中的Async方法:

    [HttpPost]
    [Route("AddApp")]
    public async Task<?> AddApp([FromBody]Application app)
    {        
        loansRepository.InsertApplication(app);
    }

这是EntityFrame工作在存储库中插入(我可以通过这种方式改变这个)

     public void InsertApplication(Application app)
    {

        this.loansContext.Application.Add(app);
    }

对不起,我对这个问题做了修改,我不知道该怎么办？在任务中

我目前遇到IIS崩溃的问题,在事件日志中留下以下消息.他们在指导错误的实际来源方面没有太大帮助,但是一些研究表明,这只是产生任务的情况,而不是等待结果,如果父进程完成它们最终完成它不能与导致空引用异常的父线程相关联.那是对的吗？

在大多数情况下,我已经删除或添加了等待这种情况,但在某些方面它很方便.一个这样的例子是会话开始是内存缓存会话特有的一些细节,但是它们并不重要,所以我启动任务来完成这项工作,但不等待它.

我已经添加了ConfigureAwait(false),这是否足以防止将来出现错误？听起来这将删除线程切换,我认为这将防止错误.

Task.Run(() =>
{
    // Do caching here

}).ConfigureAwait(false);

ASP.NET 4.0.30319.0

Exception: System.NullReferenceException

Message: Object reference not set to an instance of an object.

StackTrace:    at System.Web.ThreadContext.AssociateWithCurrentThread(Boolean setImpersonationContext)
   at System.Web.HttpApplication.OnThreadEnterPrivate(Boolean setImpersonationContext)
   at System.Web.LegacyAspNetSynchronizationContext.CallCallbackPossiblyUnderLock(SendOrPostCallback callback, Object state)
   at System.Web.LegacyAspNetSynchronizationContext.CallCallback(SendOrPostCallback callback, Object state)
   at System.Threading.Tasks.AwaitTaskContinuation.RunCallback(ContextCallback callback, Object state, Task& currentTask)
--- End of stack trace from previous location where exception was thrown ---
   at System.Threading.Tasks.AwaitTaskContinuation.<ThrowAsyncIfNecessary>b__1(Object s)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback …

我有一个旧版本的ASP.NET MVC应用程序没有Startup.cs.我想实现一种干净的方式,HttpClient以便我可以使用我的API调用第三方.

这是我到目前为止基于我收到的关于这个问题的一些想法/建议所做的.问题是,当我进行API调用时,它无处可去.我把它放在一个try catch但我甚至没有得到例外.API提供商告诉我他们没有看到搜索参数.

首先,我HttpClientAccessor为延迟加载创建了这个.

public static class HttpClientAccessor
{
   public static Func<HttpClient> ValueFactory = () =>
   {
      var client = new HttpClient();

      client.BaseAddress = new Uri("https://apiUrl.com");
      client.DefaultRequestHeaders.Accept.Clear();
      client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
      client.DefaultRequestHeaders.TryAddWithoutValidation("APIAccessToken", "token1");
      client.DefaultRequestHeaders.TryAddWithoutValidation("UserToken", "token2");

       return client;
   };

   private static Lazy<HttpClient> client = new Lazy<HttpClient>(ValueFactory);

   public static HttpClient HttpClient
   {
      get { return client.Value; }
   }
}

然后我创建了一个自己的API客户端,以便我可以在一个地方使用API​​调用函数,如下所示:

public class MyApiClient
{

   public async Task GetSomeData()
   {
       var client = HttpClientAccessor.HttpClient;
       try
       { …

谁能告诉我GetAwaiter()和之间的区别ConfigureAwait(false)。

它们都用在 Async 方法中来解决死锁情况并ConfigureAwait在不使用 Synchrnoization 上下文的情况下完成任务。我正在寻找我们可以使用的场景GetAwaiter()以及我们使用的场景ConfigureAwait(false)。

我听说如果它是我正在构建的库，那么我需要使用ConfigureAwait(false)它生成 Await 任务的 Configurable Awaitable 对象。我可以ConfigureAwait在 Unittest 案例项目中使用还是应该使用GetAwaiter()get wait 任务。

我有大量的[WebMethod]整个应用程序，我希望我所有的[WebMethod]都是异步的。我[WebMethod]用 async 和 await 关键字装饰了我所有的签名，然后运行我的应用程序。它没有按预期进行。假设我有以下代码

背后的代码

[WebMethod]
public static async Task<List<XXX>> GetXXX()
{
    return await new BusinessLogic().GetXXX().ConfigureAwait(false);
}

业务层

    internal async Task<List<XXX>> GetXXX()
    {
        var obj = await objDAL.GetXXX().ConfigureAwait(false);
        List<XXX> listDO = new List<XXX>();
        foreach (var item in obj)
        {
            listDO.Add(new Countries
            {
                XXXName = item.name,
                XXXID = item.id
            });
        }
        return listDO;

objDAL.GetXXX

    internal async Task<List<tblXXX>> GetXXX()
    {
        using (ABCEntities ctx = new ABCEntities())
        {
            return await ctx.tblXXX.ToListAsync().ConfigureAwait(false);
        }
    }

我已经将调试器放在上面代码到达的整个路径中return await …

我试图理解ConfigureAwait(false)ASP.NET中的行为.特别是如果我没有await结果.我的意思的一个例子:

var result = DoSomethingAsync().ConfigureAwait(false);

// do some things other things here. Is our task executing simultaneously?

await result;

从我所读到的,在ASP.NET(不是核心)的上下文中,我理解:

• ConfigureAwait(false)将阻止在返回应用程序流时重新创建上下文.如果未指定,则仍可以在与原始文件不同的线程上恢复上下文.
• ConfigureAwait(false)将使用默认的线程池调度程序,并且AspNetSynchronizationContext将不再涉及.
• 在ASP.NET(非核心)中,AspNetSynchronizationContext确保所有任务按顺序运行(不是并行运行),但每个任务可以在不同的线程上运行.
• 在单个请求的上下文中进行并行执行是不可取的,因为它会影响ASP.NET线程池启发式,而并行化则以处理并行请求的形式出现.使用任务可防止在IO操作期间阻止线程.

假设我所说的一切都是正确的,上面的代码示例会发生什么？从我所读到的,这段代码将导致并行化.如果这是真的,那么这会被认为是非常危险的ASP.NET,每个请求窃取多个线程？

如果不是这样,为什么不呢？什么是同步任务AspNetSynchronizationContext之后不再涉及给定ConfigureAwait(false)？

更新:

在我的第三点使用"顺序"这个词是不正确的.我应该说的是"任务将一次运行一个".对我而言,这意味着不是平行的.这取自本文中的信息.下表三分之二描述了每个同步上下文的功能.ASP.NET同步上下文一次执行一个任务.https://msdn.microsoft.com/en-us/magazine/gg598924.aspx

鉴于ConfigureAwait(false)将继续执行远离ASP.NET同步上下文并执行默认上下文(一次不执行一个),这是否可能(但不一定)导致请求使用超过一个线程同时？

或者我在这里完全误解了什么？

更新2:

我在下面问了一个更简洁的问题:

在ASP.NET Classic中,ConfigureAwait(false)会导致continuation在多个线程上并行执行吗？

我遇到了以下有关何时何地使用的文章ConfigureAwait(false)，但无法得到答案。

您不需要 ConfigureAwait(false)，但仍可在库和 UI 应用程序中使用它。（例如 Xamarin、WinForms 等）

https://blog.stephencleary.com/2017/03/aspnetcore-synchronization-context.html

此链接说相反的答案

为所有服务器端代码调用 ConfigureAwait 的最佳实践

正确使用 Task.Run 和 async-await 时

我的问题：

场景 1：下面的代码作为后台服务运行。

我的问题：ConfigureAwait(false)无论何时await都需要像下面的 A 和 B 一样使用：

    [Service(Name = "com.MainApplicationService", Label = "Main Application Service", Exported = false)]
    public class MainApplicationService : Android.App.Service
    {

        public override IBinder OnBind(Intent intent)
        {
            return null;
        }

        [return: GeneratedEnum]
        public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
        {
            await InitAsync().ConfigureAwait(false);   //line A

            Task.Run(async () => await …

比较以下两种方法:

static async Task<int> DownloadAsync(string url)
{
    var client = new WebClient();
    var awaitable = client.DownloadDataTaskAsync(url);
    byte[] data = await awaitable;
    return data.Length;
}

用法: Task<int> task = DownloadAsync("http://stackoverflow.com");

static Task<int> Download(string url)
{
    var client = new WebClient();
    var task = client.DownloadDataTaskAsync(url);
    byte[] data = task.Result;
    return Task.FromResult(data.Length);
}

用法:

Task task = new Task(() => Download("http://stackoverflow.com"));
task.Start();

据我所知,两种方法都是异步运行的.我的问题是:
两种方法之间的行为有什么不同吗？
为什么我们更喜欢异步 - 等待其他它是一个很好的模式？

我正在调用我的DocumentDB数据库来查询一个人.如果该人不在数据库中,那么我正在尝试将该人插入我的收藏中.

当我检查集合时,我看到正在创建新人,但我的代码似乎挂起了我进行第二次调用以将人插入集合的地方.知道我的代码挂起的原因吗？我没有包括节省空间的所有代码,例如GetDatabaseAsync(),GetCollectionAsync()等都在工作.

using (client = new DocumentClient(new Uri(endPointUrl), authorizationKey))
{
   //Get the database
   var database = await GetDatabaseAsync();

   //Get the Document Collection
   var collection = await GetCollectionAsync(database.SelfLink, "People");

   string sqlQuery = "SELECT * FROM People f WHERE f.id = \"" + user.PersonId + "\"";

   dynamic doc = client.CreateDocumentQuery(collection.SelfLink, sqlQuery).AsEnumerable().FirstOrDefault();

   if (doc == null)
   {
      // User is not in the database. Add user to the database
      try
      {
         **// This is where the code is hanging. It creates the user …

我有以下代码，作为 POST 请求按预期工作（给定正确的 URL 等）。似乎我在读取状态代码时遇到了问题（我收到了成功的 201，根据该数字，我需要继续处理）。知道如何获取状态代码吗？

static async Task CreateConsentAsync(Uri HTTPaddress, ConsentHeaders cconsentHeaders, ConsentBody cconsent)
{
    HttpClient client = new HttpClient();

    try
    {
        client.BaseAddress = HTTPaddress;
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
        client.DefaultRequestHeaders.Add("Connection", "keep-alive");
        client.DefaultRequestHeaders.Add("Cache-Control", "no-cache");

        client.DefaultRequestHeaders.Add("otherHeader", myValue);
        //etc. more headers added, as needed...

        HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, client.BaseAddress);

        request.Content = new StringContent(JsonConvert.SerializeObject(cconsent, Formatting.Indented), System.Text.Encoding.UTF8, "application/json");

        Console.WriteLine("\r\n" + "POST Request:\r\n" + client.DefaultRequestHeaders + "\r\nBody:\r\n" + JsonConvert.SerializeObject(cconsent, Formatting.Indented) + "\r\n");

        await client.SendAsync(request).ContinueWith
        (
            responseTask => 
            {
                Console.WriteLine("Response: {0}", responseTask.Result + "\r\nBody:\r\n" + responseTask.Result.Content.ReadAsStringAsync().Result); …