小编Roy*_*mir的帖子

basicHttpBindingWCF中是否支持PerSession服务行为的价值？

我在哪里可以找到一个表格,总结每个绑定及其选项的所有信息？？

• 假设

  A级{}

  B级:A {}

泛型类不支持协方差.

含义 - 我们不能做这样的事情:

MyConverter<B> x1= new MyConverter<B>();
MyConverter<A> x2= x1;  

多数民众赞成并理解.

从我的阅读 - 我明白Covariance将可用:

"如果你使用支持通用接口在通用类上实现 - 那么通过这些接口可以访问T类型对象实例".

我只有一个问题.

我见过许多"转换器"类的例子Stack.

但是从来没有理解"如果我只想从A的引用中使用一个B实例怎么办？"

所以我尝试了一些代码:

创建B对象+值--->使用Generic Converter for B--->使用协方差流来获取它的A参考--->现在你可以将它用作A或B.

我的问题 :

这是正确的方法吗(仅对1个对象使用协方差)？

ps代码正常工作并编译好.http://i.stack.imgur.com/PJ6QO.png

我最近一直在询问/阅读很多关于这个话题的内容 - 我深入研究了一些事情,以便尽我所能地理解它们.

扫描互联网,我很难以一种简单的方式理解- 术语呼叫网站(@dlr).我一直在这里读到CallSite是:

一个网站说

调用方法的位置.

一本书说:

呼叫网站.这是DLR的一种原子 - 可以被视为单个单元的最小代码片段.一个表达式可能包含许多呼叫站点,但行为是以自然方式构建的,一次评估一个呼叫站点.对于剩下的讨论,我们一次只考虑一个呼叫站点.有一个呼叫站点的小例子可以参考,所以这里有一个非常简单的例子,其中d当然是动态类型的变量

d.Foo(10); 调用站点在代码中表示为System.Runtime.CompilerServices.CallSite.

另一本书说:

编译器发出的代码最终会生成一个描述操作的表达式树,由DLR在运行时绑定的调用站点管理.呼叫站点本质上充当呼叫者和被呼叫者之间的中介.

对不起,我不能看到这3个解释组合成一个简单的解释.

我很乐意得到一个简单的解释:

我可以解释一下我的妻子 - 电话网站是什么？

在阅读了很多关于nodejs的内容后,我仍然问自己:

什么是利益在asp.net HttpAsync请求？

唯一的限制(如我所见)是限制的并发请求数IIS.

我试着描绘我目前如何理解它:

任何帮助？

• 有什么异步操作.net/ado.net 不能做那个nodejs可以吗？

我在想 ,

为什么我会永远想通过一个true在构造函数中AutoResetEvent ？

我创建了一个waitHandle任何打电话的人WaitOne()都会等待.

如果我用a来实例true,它就好像是立即发出信号 - 这就像没有等待的正常流程一样.

  EventWaitHandle _waitHandle = new AutoResetEvent (false);

void Main()
{
  new Thread (Waiter).Start();
    Thread.Sleep (1000);                   
    _waitHandle.Set();                    

Console.ReadLine();
}
  void Waiter()
  {
    Console.WriteLine ("AAA");
    _waitHandle.WaitOne();                 
    Console.WriteLine ("BBBB");
  }

输出:

AAA...(delay)...BBB

改为: EventWaitHandle _waitHandle = new AutoResetEvent (true);并且输出将是:

AAABBB

问题:

• 我为什么要这样做？(通过true)？

我想从wep api actionfilter返回一个json对象.我怎样才能做到这一点？

我可以从操作返回对象,但我需要在某些条件下从actionfilter返回一些数据.

提前致谢.

编辑:1当我更改如下代码时,浏览器仍然加载没有任何响应,并以超时错误结束.

  public class ValidationActionFilter : ActionFilterAttribute
{

    public override void OnActionExecuting(HttpActionContext actionContext)
    {


        var modelState = actionContext.ModelState;
        if (!modelState.IsValid)
        {
            List<string> arr = new List<string>();
            foreach (var key in modelState.Keys)
            {
                var state = modelState[key];
                if (state.Errors.Any())
                {
                    string er = state.Errors.First().ErrorMessage;
                    if (!string.IsNullOrEmpty(er))
                    {
                        arr.Add(er);
                    }
                }
            }               

           var output =  new Result() { Status = Status.Error.ToString(), Data = null, Message = arr };
            actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.BadRequest, output, actionContext.ControllerContext.Configuration.Formatters.JsonFormatter);
        }     


    }
}

我非常清楚以下用法:

Function.prototype.bind.apply(f,arguments)

说明-使用原始(如果存在的话)bind方法在f 与arguments(其中它的第一项将被用作上下文this)

此代码可用于(例如)通过带参数的构造函数创建新函数

示例:

function newCall(Cls) {
    return new (Function.prototype.bind.apply(Cls, arguments));
 }

执行:

var s = newCall(Something, a, b, c);

但我遇到了这个:Function.prototype.apply.bind(f,arguments)//单词交换

题 :

因为很难理解它的含义 - 在什么用法/场景中我会使用这个代码？

我最近一直在处理异步等待(阅读包括Stephen和Jon最后两章在内的所有可能的文章),但我得出结论,我不知道它是否100%正确. - 因此我的问题.

由于 async只允许单词等待出现,我将async不谈.

AFAIU等待着继续.而不是编写功能(连续)代码,编写同步代码.(我想把它称为可回调代码)

因此,当编译器到达时await- 它将代码分成2个部分,并在第一部分完成后注册要执行的第二部分(我不知道为什么callback不使用该字- 这正是所做的).(同时工作 - 线程回来做其他事情).

但看看这段代码:

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           string st= await workTask;
           //do something with st
        }

 public    Task <string> SimulateWork()
        {
            return ...
        }

当线程到达时await workTask;,将方法拆分为2个部分.所以在SimulateWork完成之后 - 方法的继续:AKA://do something with st- 被执行.

一切都好

但是,如果方法是:

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           await workTask; //i …

我问了一个问题,并在这里得到了关于性能问题的答案,我收集了大量数据.(用linq创建)

好吧,让我们把它放在一边.

但是Marc建议的一个有趣(和天才)优化是Batchifylinq查询.

/*1*/ static IEnumerable<T> Batchify<T>(this IEnumerable<T> source, int count)
/*2*/    {
/*3*/      var list = new List<T>(count);
/*4*/      foreach(var item in source)
/*5*/         {
/*6*/           list.Add(item);
/*7*/           if(list.Count == count)
/*8*/             {
/*9*/               foreach (var x in list) yield return x;
/*10*/              list.Clear();
/*11*/            }
/*12*/        }
/*13*/      foreach (var item in list) yield return item;
/*14*/    }

在这里,Batchify的目的是确保我们不会在每次操作之间花费相当多的时间来帮助服务器 - 数据是以1000个批量发明的,并且每个批次都可以非常快速地获得.

现在,我明白了什么是做,但我不能看出其中的差别,因为我可能会丢失其实际运作方式.(有时候你认为你知道的东西......直到......) …

我正在学习Dapper如何在幕后工作.

但是我看到这种处理模式对我来说是不了解的.

大致一般 - 这是如何QueryAsync实现:

/*1*/   public async Task<IEnumerable<T>> QueryAsync<T>(string sql, Func<IDataRecord, T> projector, DbConnection _conn, dynamic param = null)
/*2*/   {
/*3*/   
/*4*/       DbDataReader reader = null;
/*5*/       bool wasClosed = _conn.State == ConnectionState.Closed;
/*6*/       try
/*7*/       {
/*8*/   
/*9*/           using (var cmd = _conn.CreateCommand())
/*10*/          {
/*11*/          if (param!=null)
/*12*/              foreach (var prop in param.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
/*13*/              {
/*14*/                  var parameter = cmd.CreateParameter();
/*15*/                  parameter.ParameterName = prop.Name;
/*16*/                  parameter.Value = prop.GetValue(param, null);
/*17*/                  cmd.Parameters.Add(parameter); …