小编Jod*_*ell的帖子

我经常对这三个术语感到困惑.这三个看起来与我相似.有人可以通过示例清楚地向我解释.

我看过类似的帖子,完全不明白.

我正在编写一个静态网站,它使用JQuery对RESTful API进行一些AJAX调用,并使用数据填充页面.

网站功能正常(并且很快),一切都很好.

当我扩展网站并添加其他页面时,我注意到我在每个页面上都复制了某些区域.

例如,每个页面共享一个共同的header元素.

<header>...Some non-trivial content...</header>

不是在每个页面上重复这个定义,而是有一些机制,通过这个机制,我可以定义此部分一次并将其包含在每个文档中.

请记住,必须静态提供页面,但可以使用任何标准的投诉浏览器功能.

有没有一个很好的方法来做到这一点,它是什么,或者,我将不得不放弃我的客户端代码的这方面的DRY原则？

编辑其他选项和下面稍微扩展的问题.

考虑一个类体的这个人为的抽象例子.它演示了执行"for"迭代的四种不同方法.

private abstract class SomeClass
{
    public void someAction();
}

void Examples()
{
    List<SomeClass> someList = new List<SomeClass>();

    //A. for
    for (int i = 0; i < someList.Count(); i++)
    {
        someList[i].someAction();
    }

    //B. foreach
    foreach (SomeClass o in someList)
    {
        o.someAction();
    }

    //C. foreach extension
    someList.ForEach(o => o.someAction());

    //D. plinq
    someList.AsParallel().ForAll(o => o.someAction());

编辑:从答案和研究中添加一些选项.

    //E. ParallelEnumerable
    ParallelEnumerable.Range(0, someList.Count - 1)
        .ForAll(i => someList[i].someAction());

    //F. ForEach Parallel Extension
    Parallel.ForEach(someList, o => o.someAction());

    //G. For Parallel Extension
    Parallel.For(0, someList.Count …

我在他的博客中使用了Stephen Cleary的AsyncLazy实现的专业化.

/// <summary>
/// Provides support for asynchronous lazy initialization.
/// This type is fully thread-safe.
/// </summary>
/// <typeparam name="T">
/// The type of object that is being asynchronously initialized.
/// </typeparam>
public sealed class AsyncLazy<T>
{
    /// <summary>
    /// The underlying lazy task.
    /// </summary>
    private readonly Lazy<Task<T>> instance;

    /// <summary>
    /// Initializes a new instance of the 
    /// <see cref="AsyncLazy&lt;T&gt;"/> class.
    /// </summary>
    /// <param name="factory">
    /// The delegate that is …

如何在序列序列中找到2个或更多序列中出现的项集？

换句话说,我希望在传递的序列中至少有2个出现不同的值.

注意: 这不是所有序列的交叉,而是所有序列对的交叉的并集.

注2: 不包括序列与自身的对或2组合.那太傻了.

我自己做了一个尝试,

public static IEnumerable<T> UnionOfIntersects<T>(
                                  this IEnumerable<IEnumerable<T>> source)
{
    var pairs =
            from s1 in source
            from s2 in source
            select new { s1 , s2 };

    var intersects = pairs
        .Where(p => p.s1 != p.s2)
        .Select(p => p.s1.Intersect(p.s2));

    return intersects.SelectMany(i => i).Distinct();
}

但是我担心这可能是次优的,我认为它包括A,B和B对的交叉点,A似乎效率低下.我也认为可能有一种更有效的方法来复合集合,因为它们是迭代的.

我在下面包含一些示例输入和输出:

{ { 1, 1, 2, 3, 4, 5, 7 }, { 5, 6, 7 }, { 2, 6, 7, 9 } , { 4 } }

回报

{ …

我一直在玩,部分重新发明轮子,这样我就能理解轮子是如何旋转的.

考虑这个泛型函数来编译和返回类型的默认构造函数.

public static Func<TConcrete> Creator<TConcrete>()
{
    // All checking removed for brevity
    var ctor = typeof(TConcrete).GetConstructor(new Type[0]);
    var lambda = Expression.Lambda<Func<TConcrete>>(Expression.New(ctor));
    return lambda.Compile();
}

我相信这将返回一个很好的类型委托,我可以用来实例化传递的类型.

现在考虑一下,我想要一个能够为一组不同类型执行此操作的函数,我将如何进行此操作？我在沿着...的路线走来走去

public static IEnumerable<Delegate> Creators(IEnumerable<Type> types)
{
    foreach (var type in types)
    {
        var ctor = type.GetConstructor(new Type[0]);
        var lamda = Expression.Lambda<Func<????>>(Expression.New(ctor));
        yield return lambda.Compile();
    }
}

从你可以看到????这是我被卡住的地方.有没有办法做到这一点,还是我的做法只是有缺陷？

编辑

如果我Stopwatch正确使用并且迭代次数增加了两个数量级,我得到了

三元花了22404ms

正常需要21403ms

这些结果更接近我的预期,让我感觉世界上的一切都是正确的(如果不是我的代码.)

三元/条件运算符实际上稍慢.

继这个问题之后,我已经部分回答了这个问题.

我在x64发布模式下编译此控制台应用程序,并启用了优化,并在没有附加调试器的情况下从命令行运行它.

using System; 
using System.Diagnostics;

class Program
{
    static void Main()
    {
        var stopwatch = new Stopwatch();

        var ternary = Looper(10, Ternary);
        var normal = Looper(10, Normal);

        if (ternary != normal)            {
            throw new Exception();
        }

        stopwatch.Start();
        ternary = Looper(10000000, Ternary);
        stopWatch.Stop();
        Console.WriteLine(
            "Ternary took {0}ms", 
            stopwatch.ElapsedMilliseconds);

        stopwatch.Start();
        normal = Looper(10000000, Normal);
        stopWatch.Stop();
        Console.WriteLine(
            "Normal took {0}ms", 
            stopwatch.ElapsedMilliseconds);

        if (ternary != normal)            {
            throw new Exception(); …

我目前正在使用MailSystem.NET SMTPClient发送电子邮件,电子邮件内容包含主题和正文中的中文字符.通过以下代码,我可以将电子邮件的正文设置为正确编码,但主题仍未编码并显示为???? 在收到的电子邮件中.

 ActiveUp.Net.Mail.Message message = new ActiveUp.Net.Mail.Message();
 ....
 message.Charset = "utf-8";
 SmtpClient.Send(message, serverName);

熟悉MailSystem.Net的人是否可以告诉我如何将主题设置为utf-8编码？谢谢.

我正在寻找帮助来创建一个正则表达式来验证满足这4个标准的字符串:

1. 该字符串必须包含空格.
2. 字符串必须以句号/句号结束.
3. 该字符串必须至少包含15个字符.
4. 该字符串不得包含3个或更多字符的重复.这是我特别挣扎的部分.

例如:

通过

• 一二三四.

失败

• 两个四个.
• 一两个人.
• 一二三四
• 一二三.
• 一二三四.

如果可能的话,你能解释一下正则表达式是如何构建的,以便让我更好地了解将来如何构建它们吗？

这是我到目前为止尝试过的,

^(.*?={15,})(\.\Z)$

但我担心它甚至没有关闭,请帮助.

我已经将Microsoft.VisualStudio.Threading导入.Net Core Web App。我专门这样做是为了利用AsyncLazy<T>。

我想确保自己做对了，所以我导入了适当的分析器。

警告和文档明确指出JoinableTaskFactory应将a 注入到我的实现中。

我的问题是，如何JoinableTaskFactory在.Net Core Web App的配置中实例化它？

简单吗

public void ConfigureServices(IServiceCollection services)
{
    // ...
        services.AddSingleton(new JoinableTaskFactory());
    // ...
}

还是，这都是错误的吗？