小编i3a*_*non的帖子

使用10gen mondgo db c#driver.I有以下课程

[BsonId]
public ObjectId Id { get; set; }
public int AttemptId { get; set; }
public int UserId { get; set; }
public int QId { get; set; }
public string UserInput { get; set; }  
public string Feedback{ get; set; }

默认情况下,如果我没有发送UserInput或Feedback(任何字符串)的值,mongodb将它们作为null.string.empty在插入或获取数据时是否有任何方法可以覆盖它.尝试过设置,[BsonDefaultValue("")]但这也没有用.

根据我对接口的理解,为了使用它们,你必须通过在冒号后面添加接口的名称来声明一个类正在实现它,然后实现这些方法.

我目前正在学习枚举器,IEnumerable等等,这让我很困惑.这是我的意思的一个例子:

static IEnumerable<int> Fibs(int fibCount)
{
    for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++) {
        yield return prevFib;
        int newFib = prevFib + curFib;
        prevFib = curFib;
        curFib = newFib;
    }
}

IEnumerable似乎是一个普通的接口,我甚至检查了方法定义,这就是它的样子.

我怎么可能在方法定义中使用接口作为类型/返回类型,何时/如何知道我应该使用某些接口作为此示例中的类型？

编辑:我真的怀疑它与yield关键字有什么关系,因为很多接口都以这种方式用作属性,例如在模型中的MVC中,并像它一样传递给Views.例:

public IEnumerable<Category> Categories {get;set;}

请参阅下面的代码

1. persons = Items.Select(item => componentResolver.ResolvePerson(new TridionUri(item.Id))).ToList();
2. persons.Each(person => person.AdditionalInfo); // gives null reference exception

ResolvePerson看起来像:

public Person ResolvePerson(TridionUri personUri)
{
    Person person = publicationResolverService.GetPerson(personUri);
    if (author != null)
    {
        person.Id = personUri.ItemId.ToString();
    }
    return person;
}

现在的问题是,"项目"包含一个人不存在的ID.所以我的'ResolvePerson'返回null.这导致第2行中的例外.我只能控制ResolvePerson方法.有没有办法可以跳过没有人在场的personUri而不是返回null？

Action直接指定或Func<Task>使用.NET TPL Dataflow有ActionBlock什么区别？

直接行动:

new ActionBlock<Message[]>(x => DoSomething(x))

任务:

new ActionBlock<Message[]>(x => Task.Run(() => DoSomething(x)))

我试图了解并行执行方面的差异(MaxDegreeOfParallelism> 1).

我尝试了async/await的一些东西,但我真的没有得到它.我想要开始的所有内容是同时从两个不同的线程写入控制台.这是代码:

static void Main(string[] args)
{
    DoSomethingAsync();

    for (int i = 0; i < 1000; i++)
        Console.Write(".");

    Console.ReadLine();
}

static async void DoSomethingAsync()
{
    Console.WriteLine("DoSomethingAsync enter");

    //This does not seem good
    await Task.Delay(1);

    for (int i = 0; i < 1000; i++)
        Console.Write("X");

    Console.WriteLine("DoSomethingAsync exit");
}

使用Threads很容易但是使用async/await我只能在完成这个奇怪的操作时完成它

await Task.Delay(1);

我看到的大多数基本例子都使用过它 但是,当你想做一些不同步的时间时,该怎么做？你不能等待任何东西,因此所有代码都在主线程上运行.如何在不使用Task.Delay()的情况下实现与此代码相同的行为？

我试图通过局部变量获得线程结果.

有代码:

static void Main() 
{   
    long res1 = 0, res2 = 0;

    long n1 = 5000, n2 = 10000; 

    Thread t1 = new Thread(() => 
    { 
        res1 = Factorial(n1); 
    }); 

    Thread t2 = new Thread(() => { res2=Factorial(n2); }); 

    t1.Start();  
    t2.Start(); 
    t1.Join();  
    t2.Join(); 

    Console.WriteLine("Factorial of {0} equals {1}", n1, res1); 
    Console.WriteLine("Factorial of {0} equals {1}", n2, res2); 
} 

输出:

Factorial of 5000 equals 0
Factorial of 10000 equals 0

为什么这段代码返回0？

这是阶乘函数:

static long Factorial(long n) 
{ 
    long res = …

我的AsyncController中有以下异步方法:

public async Task<Dashboard> GetFeeds()
{
    var movies = new HttpClient().GetStringAsync("http://netflix/api/MyMovies");
    var tweets = new HttpClient().GetStringAsync("http://twitter/api/MyTweets");

    await Task.WhenAll(movies, tweets);

    Dashboard dash = new Dashboard();
    dash.Movies = Deserialize<Movies >(movies.Result);
    dash.Tweets = Deserialize<Tweets >(tweets.Result);

    return dash; 
}

在这个方法中做不同的调用API,一个具有彼此不同的返回时间.我无法理解的Task<>是因为我必须等待两人的回归才能更新我的客户？因为我正在创造新的线程.

想象一下我在PartialView中播放每个API的返回,我认为结果会得到:

- 首先我会有我的电影列表(它只需要5s), - >显示给我的用户

- 然后我的推文列表 - >显示给我的用户

但我看到的是:

- 虽然Twitter请求没有结束,但我没有在屏幕上为我的用户播放我从Netflix获得的数据.

最大的问题是:A Task<>仅用于加快处理速度吗？

我根据我订购的每个API的周转时间无法在屏幕上播放信息？

这是对我的方法的调用

public async Task<ActionResult> Index()
{
    var feeds = await GetFeeds();

    return View(feeds);
}

我承认,我很困惑,或者,也许你不明白这个概念Task<>.

我只是想知道，是否有更好的方法来初始化 C# 多维对象数组（引用类型）。

这是我的代码：

Board = new Field[BoardHeight, BoardWidth];

for (int i = 0; i < BoardHeight; i++)
{
    for (int j = 0; j < BoardWidth; j++)
    {
        Board[i, j] = new Field();
    }
}

如果我可以摆脱 for/for 循环并用单行替换它？那太好了。

我们有一个泛型Job类,它有一个HeavyTask像这样的抽象方法:

abstract class Job {
    private Task m_task; 
    protected abstract void HeavyTask(); 

    public void StartJob(){
        m_task = Task.Run(() => HeavyTask());
    }
    public async Task WaitJob(){
        await m_task; 
    }
}

派生类重写该HeavyTask函数并使其异步:

class JobFoo : Job {
    protected override async void HeavyTask()
    {
        await Task.Delay(1000);
        Debug.WriteLine("JobFoo is done");
    }
}

然后,当我们使用这种方法时,似乎HeavyTask()没有等待:

Job job = new JobFoo();
job.StartJob();
await job.WaitJob();
Debug.WriteLine("All Done");

输出:

所有完成
JobFoo已完成

如果我们没有async覆盖HeavyTask,那么它按预期工作.但我不能保证那些超越的Job人不会做出的HeavyTask async.我想明白为什么不能等待它成功,有没有办法确保它等待？如果可以的话,你能否解释一下如何将非异步函数覆盖为async是一个好习惯,如上所示？

我有一个要包装的函数，以便可以使用async / await模式：

wcfClientService.GetSomeString(parameter);

这是来自WCF客户端的呼叫，我正在尝试使其异步，但这并不重要（我知道WCF支持异步，但是假设我们无权访问WCF代码）。

我正在尝试用该Task<T>.Factory.FromAsync方法包装该方法，但似乎无法正确处理它：

private Task<string> WrapWcfServiceAsyncTask(uint parameter)
{
    Func<uint, string> func = i => { return wcfClientService.GetSomeString(parameter); };

    var t = Task<string>.Factory.FromAsync(
                                           // What goes here?
                                          );
    return t;
}

甚至更好的是，有人可以编写一个将方法作为参数并包装并Task<T>为其返回的方法吗？