相关疑难解决方法(0)

我正在使用.NET HttpClient向我的服务器发送请求.我已将HttpClient.Timeout属性设置为10秒,因此A task was cancelled每当服务器无法在不到10秒的时间内处理我的请求时,我就会收到异常.好到这里.

但是,如果关闭服务器,则需要HttpClient大约20秒才能返回正确的异常,例如图片中的异常.

我想看到这个异常超过1​​0秒才能区分Server Down和Operation花了太长时间的情况.我在msdn文档中找不到任何相关内容.是否有可以设置的超时HttpClient？

这是我如何构建的 HttpClient

 var webRequestHandler = new WebRequestHandler
        {
            UseProxy = false,
            Proxy = null,
            AllowPipelining = false,
            ContinueTimeout = TimeSpan.Zero,
            UseCookies = false,
            AllowAutoRedirect = false,
        };
 var httpClient = new HttpClient(webRequestHandler);
 httpClient.Timeout = timeout;

  httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Accept", "application/json");
  httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", userAgent);
  httpClient.DefaultRequestHeaders.ExpectContinue = false;

我有以下代码连接到SignalR Hub

    private static async Task StartListening()
    {
        try
        {


            var hubConnection = new HubConnection("http://localhost:8080/");                
            IHubProxy hubProxy = hubConnection.CreateHubProxy("Broadcaster");
            hubProxy.On<EventData>("notifyCardAccessEvent", eventData =>
            {
                Log.Info(string.Format("Incoming data: {0} {1}", eventData.Id, eventData.DateTime));
            });
            ServicePointManager.DefaultConnectionLimit = 10;
            await hubConnection.Start();
            Log.Info("Connected");
        }
        catch (Exception ex)
        {
            Log.Error(ex);
        }
    }

在我的Form_Load方法中,我有这个

StartListening();

但是,Resharper提示我"考虑将'await'运算符应用于调用的结果"

所以我这样做了:

Log.Info("Connecting to SignalR hub...");
StartListening().Wait();
Log.Info("Connected!");

但是,这会导致我的UI线程挂起并且Connected!永远不会打印到日志文件中.

所以我的问题是,我Wait()什么时候应该使用？我应该使用Wait()的实例和场景是什么,什么时候不应该使用Wait()？

我正在研究ASP.NET MVC项目.
我需要一些时间来解释我的疯狂情况.
我正在尝试从MVC项目向Android和Apple设备发送推送通知.
两者的发送逻辑都是正确的,请不要浪费你的时间考虑这个

我面临的灾难是:不调用负责发送通知的静态类中的静态方法.(我不是新鲜的程序员,我在C#编程方面有超过5年的时间)但我无法调用方法.

为了让您进入问题的上下文,当我在本地计算机(开发计算机)上执行代码时,将调用并执行此方法并将通知到达设备.
当我发布MVC项目并将其部署到我们的服务器时,不会调用静态方法.

我如何知道该方法未被调用？
因为我正在记录到一个文本文件,并且在调用该方法之前在方法的第一行和一个日志语句中放了一个日志语句.
调用方法之前的日志被执行并充实到文本文件,但是不执行静态方法开始的日志!!!!!.

这是一些代码,然后我会告诉你我试图解决这个问题.

public interface IHandler<T> where T : IMessage
{
    Task Handle(T args);
}

public class RequestAddedAppMonitorHandler : IHandler<RequestAdded>
{
    public Task Handle(RequestAdded args)
    {
        return Task.Factory.StartNew(() =>
        {
            try
            {
                GoogleNotification notification = CreateAndroidPartnerAppNotification(deviceId);

                // this statment is executed, and the text log file will contains this line
                TracingSystem.TraceInformation("Before Send Google Notification");  

                SendersFacade.PartnerSender.Send(notification).Wait();
            }
            catch (Exception ex)
            {
                TracingSystem.TraceException(ex);
            }
        }); …

我有一个.net web api 2方法,我试图让我的代码的某些部分在一个单独的线程中做一些事情,但是当我在任务上调用.Wait()方法之后,它永远不会到达下一行.我必须忽略一些东西,但我似乎无法找到它.这是一个非常简单的问题版本.Ok()行永远不会被击中.有什么建议？

public IHttpActionResult Get() {

    var attachTask = AttachNewTasksAsync();

    //do something else

    attachTask.Wait();

    return Ok();
}

public async System.Threading.Tasks.Task AttachNewTasksAsync()
{
    await System.Threading.Tasks.Task.Delay(10000);
}

我想同时启动一个Task对象集合,等待所有对象完成.以下代码显示了我想要的行为.

public class Program
{
    class TaskTest
    {
        private Task createPauseTask(int ms)
        {
            // works well
            return Task.Run(async () =>
            // subsitution: return new Task(async () =>
            {
                Console.WriteLine($"Start {ms} ms pause");
                await Task.Delay(ms);
                Console.WriteLine($"{ms} ms are elapsed");
            });
        }

        public async Task Start()
        {
            var taskList= new List<Task>(new[]
            {
                createPauseTask(1000),
                createPauseTask(2000)
            });
            // taskList.ForEach(x => x.Start());
            await Task.WhenAll(taskList);
            Console.WriteLine("------------");
        }
    }

    public static void Main()
    {
        var t = new TaskTest();
        Task.Run(() => t.Start());
        Console.ReadKey();
    }
} …

我有一个控制器方法，它看起来像这样：

[HttpPut, Route("cqs/command")]
public HttpResponseMessage Command([ValueProvider(typeof(HeaderValueProviderFactory))] string typeName)
{
    object reply = null;
    var code = HttpStatusCode.OK;
    try
    {
        var cmdObject = DeserializeRequest(typeName);
        var method = _commandMethod.MakeGenericMethod(type);
        method.Invoke(this, new object[] { request });
    }
    catch (Exception exception)
    {
        code = HttpStatusCode.InternalServerError;
        reply = exception;
    }

    var responseMsg = new HttpResponseMessage(code);
    if (reply != null)
    {
        responseMsg.Headers.Add("X-TypeName", reply.GetType().AssemblyQualifiedName);
        var replyJson = JsonConvert.SerializeObject(reply);
        responseMsg.Content = new StringContent(replyJson, Encoding.UTF8, "application/json");
    }
    return responseMsg;
}

其中调用以下方法：

private void ExecuteCommand<T>(T command) where T : Command …

我在Singleton类中有一个方法,它将从不同的线程调用.但我需要逐个执行它们.喜欢

将从多个线程调用ImageUtil.Instance.LoadImage(imageID)方法.但我想逐个加载图片.因此,一次只能加载一个图像.

public class ImageUtil
{
    #region Singleton Implementation
    private ImageUtil()
    {
        taskList = new List<Task<object>>();
    }

    public static ImageUtil Instance { get { return Nested.instance; } }

    private class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as before field init
        static Nested()
        {
        }

        internal static readonly ImageUtil instance = new ImageUtil();
    }

    #endregion

    Queue<Task<Object>> taskList;
    bool isProcessing;
    public async Task<Object> LoadImage(String imageID)
    {
        //Here what I need to put to …

关于任务的 .Net 文章显示了以下两个代码片段，一个使用 wait，另一个使用 Task.Wait，并表示两者“功能等效”。

那么这在技术上是不是不正确呢？有人可以澄清一下吗？

另外，如果任务应该是异步的并构成异步编程 (TPL) 的基础，那么为什么 ASP.Net 无论如何都允许同步等待它们呢？这不会违反他们的主要用途吗？

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task …