我找不到在我刚刚创建的新Facebook应用程序中打开/关闭沙箱模式的设置.是否必须打开或关闭其他内容才能让我看到此设置？

有关功能和含义的区别是什么

TaskCompletionSource + SetResult vs Task + FromResult

在SendAsync方法？

protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    if (request.RequestUri.Scheme != Uri.UriSchemeHttps)
    {
        var response = new HttpResponseMessage(HttpStatusCode.Forbidden) {ReasonPhrase = "HTTPS Required"};
        var taskCompletionSource = new TaskCompletionSource<HttpResponseMessage>();
        taskCompletionSource.SetResult(response);
        return taskCompletionSource.Task;
    }
    return base.SendAsync(request, cancellationToken);
}

protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
    if (!request.RequestUri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
    {
        HttpResponseMessage reply = request.CreateErrorResponse(HttpStatusCode.BadRequest, "HTTPS is required for security reason.");
        return Task.FromResult(reply);
    }

    return base.SendAsync(request, cancellationToken);
}

现在我正在开发一个Web应用程序的原型,它聚合了来自大量用户的大量文本条目.必须经常显示此数据并经常更新.目前,我将内容存储在MySQL数据库中,并使用NHibernate ORM层与数据库进行交互.我有一个为用户,角色,提交,标签,通知等定义的表.我喜欢这个解决方案,因为它运行良好,我的代码看起来很好,理智,但我也担心MySQL将如何执行大小我们的数据库达到了很多.我觉得它可能很难以足够快的速度执行连接操作.

这让我想到了非关系型数据库系统,如MongoDB,CouchDB,Cassandra或Hadoop.不幸的是,我也没有经验.我在MongoDB上看过一些好评,看起来很有趣.我很乐意花时间学习如果一个人走的路.我非常感谢任何一个提供积分或问题时,没有关系dbms？

使用protobuf-net.dll版本1.0.0.280

当我反序列化DateTime(包裹在一个对象中)时,日期/时间是可以的,但DateTime.Kind属性是'未指定'

考虑这个测试用例来序列化/反序列化DateTime.

[TestMethod]
public void TestDateTimeSerialization()
{
    var obj = new DateTimeWrapper {Date = DateTime.UtcNow};
    obj.Date = DateTime.SpecifyKind(obj.Date, DateTimeKind.Utc);
    var serialized = obj.SerializeProto();
    var deserialized = serialized.DeserializeProto<DateTimeWrapper>();
    Assert.AreEqual(DateTimeKind.Utc, deserialized.Date.Kind);
}

public static byte[] SerializeProto<T>(this T item) where T : class
{
    using (var ms = new MemoryStream())
    {
        Serializer.Serialize(ms, item);
        return ms.ToArray();
    }
}

public static T DeserializeProto<T>(this byte[] raw) where T : class, new()
{
    using (var ms = new MemoryStream(raw))
    {
        return Serializer.Deserialize<T>(ms); …

我一直在看到Cancellation.Register与结果中的using子句一起使用的代码CancellationTokenRegistration:

using (CancellationTokenRegistration ctr = token.Register(() => wc.CancelAsync()))
{
    await wc.DownloadStringAsync(new Uri("http://www.hamster.com"));
}

我得到你应该确保你Dispose的IDisposable,但为什么它甚至工具IDisposable？有什么资源需要发布？它认为平等的唯一方法.

如果你不这样做Dispose会怎么样？你泄漏了什么？

我正在寻找一种缓存异步操作结果的优雅方法.

我第一次有这样的同步方法:

public String GetStuff(String url)
{
    WebRequest request = WebRequest.Create(url);
    using (var response = request.GetResponse())
    using (var sr = new StreamReader(response.GetResponseStream()))
        return sr.ReadToEnd();
}

然后我让它异步:

public async Task<String> GetStuffAsync(String url)
{
    WebRequest request = WebRequest.Create(url);
    using (var response = await request.GetResponseAsync())
    using (var sr = new StreamReader(response.GetResponseStream()))
        return await sr.ReadToEndAsync();
}

然后我决定我应该缓存结果,所以我不需要经常在外面查询:

ConcurrentDictionary<String, String> _cache = new ConcurrentDictionary<String, String>();

public async Task<String> GetStuffAsync(String url)
{
    return _cache.GetOrAdd(url, await GetStuffInternalAsync(url));
}

private async Task<String> GetStuffInternalAsync(String url)
{
    WebRequest request = …

我最近从已弃用的v1.9转移到了新的MongoDB C#驱动程序v2.0.

现在,当我序列化一个有字典的类时,我有时遇到以下情况BsonSerializationException:

MongoDB.Bson.BsonSerializationException:使用DictionaryRepresentation.Document时,键值必须序列化为字符串.

这是一个最小的重现:

class Hamster
{
    public ObjectId Id { get; private set; }
    public Dictionary<DateTime,int> Dictionary { get; private set; }
    public Hamster()
    {
        Id = ObjectId.GenerateNewId();
        Dictionary = new Dictionary<DateTime, int>();
        Dictionary[DateTime.UtcNow] = 0;
    }
}

static void Main()
{
    Console.WriteLine(new Hamster().ToJson());
}

当我取消,内容如下异步方法调用Cancel()我的方法CancellationTokenSource,它最终会停下来.但是由于该行Console.WriteLine(await reader.ReadLineAsync());需要相当多的时间来完成,我还尝试将CancellationToken传递给ReadLineAsync()它(期望它返回一个空字符串),以使该方法对我的Cancel()调用更具响应性.但是我不能错过一个CancellationToken到ReadLineAsync().

我可以取消打电话给Console.WriteLine()或Streamreader.ReadLineAsync()如果是,我该怎么办？

为什么ReadLineAsync()不接受CancellationToken？我认为将Async方法赋予可选CancellationToken参数是一个好习惯,即使该方法在取消后仍然完成.

StreamReader reader = new StreamReader(dataStream);
while (!reader.EndOfStream)
{
    if (ct.IsCancellationRequested){
        ct.ThrowIfCancellationRequested();
        break;
    }
    else
    {
        Console.WriteLine(await reader.ReadLineAsync());
    }
}

更新 如下面的评论中所述,Console.WriteLine()由于每行40.000个字符的输入字符串格式不正确,单独调用已占用几秒钟.打破这个问题可以解决我的响应时间问题,但是我仍然对如何取消这个长时间运行的语句的任何建议或解决方法感兴趣,如果由于某种原因打算将40.000个字符写入一行(例如将整个字符串转储到一份文件).

我曾经多次断言我对async/await的理解,经常就我是否正确进行辩论.如果有人能够证实或否认我的理解,并清除任何误解,以便我不传播错误信息,我真的很感激.

高级别的理解

async/ await是一种在编写异步代码时避免回调地狱的方法.正在执行异步方法的线程在遇到线程池时将返回线程池await,并在等待的操作完成后将执行该操作.

低级别的理解

JIT会将异步方法拆分为await点周围的离散部分,允许在保留方法状态的情况下重新进入方法.在封面下,这涉及某种状态机.

与并发的关系

async/ await并不意味着任何形式的并发.使用async/ 编写的应用程序await可以完全是单线程的,同时仍然可以获得所有好处,就像node.js尽管有回调一样.与node.js不同,.NET是多线程的,因此通过使用async/ await,您可以获得非阻塞IO的好处,而无需使用回调,同时还具有多个执行线程.

好处

async/ await释放线程以在等待IO完成时执行其他操作.它还可以与TPL一起使用,以在多个线程上执行CPU绑定工作,或者在UI线程之外执行CPU绑定工作.

为了从非阻塞IO中受益,需要在API之上构建异步方法,这些API 实际上利用了最终由OS提供的非阻塞IO.

滥用

这是我理解中最大的争论点.很多人认为在a中Task使用阻塞操作并使用async/ await会带来性能提升.通过创建一个额外的线程来处理操作,将原始线程返回到线程池,然后在任务完成后恢复原始方法,所有发生的都是不必要的上下文切换,而不是真正释放线程来完成其他工作.虽然这并不像TPL那样滥用async/ await,但这种心态似乎源于对async/ 的误解await.

我最近遇到过很多async方法,其中方法同步执行,但无论如何都返回一个Task,因此可以等待它们,例如

public virtual Task CreateAsync(TUser user)
{
    ThrowIfDisposed();
    if (user == null) throw new ArgumentNullException("user");
    Context.Save(user);
    Context.Flush();
    return Task.FromResult(0);
}

当然最好将可能长时间运行的操作分派给一个线程并返回仍处于活动状态的任务,以便真正等待:

public virtual Task CreateAsync(TUser user)
{
    ThrowIfDisposed();
    if (user == null) throw new ArgumentNullException("user");
    return Task.Run(() =>
    {
        Context.Save(user);
        Context.Flush();
    });
}

不过,我有点怀疑,只是脱掉TPL线程并不是最安全的做法.有关这两种不同模式的评论吗？