小编red*_*alx的帖子

我正在寻找有关 ASP.NET Core Web 应用程序的拒绝服务 (DoS) 保护/缓解的最佳实践建议/指南（可能来自 Microsoft？）。

到目前为止我发现的主要两个选项是：

• AspNetCoreRateLimit（ASP.NET Core 中间件）
• 动态 IP 限制（IIS 模块 - 假设站点托管在 IIS 中）。

在选择其中一个选项而不是另一个选项时，似乎需要考虑许多优点和缺点，因此最好了解这些选项是什么，以及 AspNetCoreRateLimit 是否打算与动态 IP 限制一起使用。

另请注意，AspNetCoreRateLimit 不是 Microsoft ASP.NET Core 版本的一部分，因此我很想知道 Microsoft 的官方指南是什么。

.NET框架的Math函数主要在双精度浮点数上运行,没有单精度(浮点)重载.在高性能方案中处理单精度数据时,这会导致不必要的转换,并且计算的功能比所需的更精确,因此性能会受到一定程度的影响.

有没有办法避免一些额外的CPU开销？例如,是否有一个带浮点重载的开源数学库,它直接调用底层的FPU指令？(我的理解是这需要CLR的支持).实际上我不确定现代CPU是否只有单精度指令.

这个问题部分受到关于优化sigmoid函数的问题的启发:

C#中的数学优化

这个问题涉及一个非常具体和常见的场景,其中字典被用于多线程环境中的项目的按需缓存.为了避免线程锁定,最好在同步锁之外测试现有的缓存项,但是如果我们随后必须添加一个项,那么它就算作对字典的写入,因此我在stackoverflow上读到的大多数建议都是你需要锁定读取和写入,因为调用add()可能会改变字典的内部状态.

但是,通过Microsoft的AjaxControlToolkit(scriptObjectBuilder类),代码确实在任何锁之外执行TryGet(),并且只锁定Add()新项到字典.我可以看到,如果放置项目的存储桶在添加后永远不会更改,这可能是怎么可能的,但我怀疑这是错误的,可能是错误的来源.

谢谢.

更新 通过.Net文档我认为所描述的模式确实是错误的.但是我想知道Dictionary的特定实现是否允许它以及AjaxControlToolkit是否依赖于此(这将是可疑的).在检查Reflector中的代码时我很确定这确实是错误的,Dictionary.Resize()方法重新分配桶的数量并移动桶项,因此TryGet()中间的任何线程都可能正在工作在不稳定的数据.

更新 已在codeplex上针对AjaxControlToolkit记录缺陷.看到:

• ScriptObjectBuilder中可能存在的线程安全错误
• ScriptObjectBuilder中的线程安全问题.

Windows中的特殊文件夹是否有明确的指南？互联网搜索产生了一些信息,例如

• 维基百科:特殊文件夹
• Windows 7客户端软件徽标计划

我正在寻找的是每个文件夹的解释,它的预期目的,使用场景和存在的动机(例如,本地应用程序设置为该应用程序设置提供的不是).我认为,对文件夹的需求/使用矩阵/表格会很方便.

我正在大量使用Parallel Extensions,我刚刚遇到一种情况,即使用线程本地存储可能是合理的,允许工作线程重用对象.因此,我查看了ThreadStatic属性,该属性将静态字段/变量标记为每个线程具有唯一值.

在我看来,使用PE与ThreadStatic属性是不明智的,而不保证PE重用线程.也就是说,如果在某种程度上创建和销毁线程,那么变量(以及它们指向的对象)是否会在线程本地存储中保留一段不确定的时间,从而导致内存泄漏？或者线程存储可能与线程相关联并在线程处理时被丢弃？但是,您仍然可能在池中存在长期存在的线程,并且会从线程所使用的各种代码中累积线程本地存储.

是否有更好的方法来获取PE的线程本地存储？

谢谢.

我有一个伪随机数生成器的实现，特别是 George Marsaglia 的 XOR-Shift RNG。我的实现在这里：

FastRandom.cs

事实证明，第一个随机样本与种子非常密切相关，如果您查看 Reinitialise(int seed) 方法，这一点非常明显。这不好。我提出的解决方案是将种子的各个部分混合如下：

_x = (uint)(  (seed * 2147483647) 
           ^ ((seed << 16 | seed >> 48) * 28111) 
           ^ ((seed << 32 | seed >> 32) * 69001)
           ^ ((seed << 48 | seed >> 16) * 45083));

因此，我通过将种子位与四个素数相乘并进行异或运算以形成 _x 来显着削弱任何相关性。我还在乘法之前旋转种子的位，以确保不同幅度的位在 32 位值的整个值范围内混合。

四向轮换似乎是什么都不做和每一次可能的轮换（32）之间的一个很好的平衡。质数是“悬而未决”——足够的大小和位结构可以将位混在一起并将它们“散布”在整个 32 位上，而不管起始种子如何。

我应该使用更大的素数吗？是否有解决这个问题的标准方法，也许有更正式的基础？我试图以最小的 CPU 开销来做到这一点。

谢谢

=== 更新 ===

我决定使用一些设置位更好地分布在所有 32 位上的素数。结果是我可以省略移位，因为乘法可以达到相同的效果（散列整个 32 位范围内的位），所以我只需将四个乘积相加即可得到最终种子......

_x = (uint)(  (seed * 1431655781) 
            + (seed * 1183186591) 
            + (seed * …

顺序GUID是唯一的,但是是通过订单创建的; 该顺序略有异常,与使用标准.NET Guid比较器时获得的顺序不同.

我正在寻找一个C#Guid比较器,它将根据顺序GUID的规则进行排序.

==更新==

我特别指的是由SQL Server中的NewSequentialId()创建的顺序GUID,虽然我现在意识到标准的Win32 API调用UuidCreateSequential()使用与SQL Server不同的方案(我假设它们在我写这个问题时是相同的) .

==更新2 ==

petelids给出了以下答案,例如List <System.Data.SqlGuid> .Sort()给出以下序列(使用每个4位位置1的GUID的初始列表)...

01000000-0000-0000-0000-000000000000
10000000-0000-0000-0000-000000000000
00010000-0000-0000-0000-000000000000
00100000-0000-0000-0000-000000000000
00000100-0000-0000-0000-000000000000
00001000-0000-0000-0000-000000000000
00000001-0000-0000-0000-000000000000
00000010-0000-0000-0000-000000000000
00000000-0100-0000-0000-000000000000
00000000-1000-0000-0000-000000000000
00000000-0001-0000-0000-000000000000
00000000-0010-0000-0000-000000000000
00000000-0000-0100-0000-000000000000
00000000-0000-1000-0000-000000000000
00000000-0000-0001-0000-000000000000
00000000-0000-0010-0000-000000000000
00000000-0000-0000-0001-000000000000
00000000-0000-0000-0010-000000000000
00000000-0000-0000-0100-000000000000
00000000-0000-0000-1000-000000000000
00000000-0000-0000-0000-000000000001
00000000-0000-0000-0000-000000000010
00000000-0000-0000-0000-000000000100
00000000-0000-0000-0000-000000001000
00000000-0000-0000-0000-000000010000
00000000-0000-0000-0000-000000100000
00000000-0000-0000-0000-000001000000
00000000-0000-0000-0000-000010000000
00000000-0000-0000-0000-000100000000
00000000-0000-0000-0000-001000000000
00000000-0000-0000-0000-010000000000
00000000-0000-0000-0000-100000000000

与List <System.Guid>返回的以下顺序相反..Sort()

00000000-0000-0000-0000-000000000001
00000000-0000-0000-0000-000000000010
00000000-0000-0000-0000-000000000100
00000000-0000-0000-0000-000000001000
00000000-0000-0000-0000-000000010000
00000000-0000-0000-0000-000000100000
00000000-0000-0000-0000-000001000000
00000000-0000-0000-0000-000010000000
00000000-0000-0000-0000-000100000000
00000000-0000-0000-0000-001000000000
00000000-0000-0000-0000-010000000000
00000000-0000-0000-0000-100000000000
00000000-0000-0000-0001-000000000000
00000000-0000-0000-0010-000000000000
00000000-0000-0000-0100-000000000000
00000000-0000-0000-1000-000000000000
00000000-0000-0001-0000-000000000000
00000000-0000-0010-0000-000000000000
00000000-0000-0100-0000-000000000000
00000000-0000-1000-0000-000000000000
00000000-0001-0000-0000-000000000000
00000000-0010-0000-0000-000000000000
00000000-0100-0000-0000-000000000000
00000000-1000-0000-0000-000000000000
00000001-0000-0000-0000-000000000000
00000010-0000-0000-0000-000000000000
00000100-0000-0000-0000-000000000000
00001000-0000-0000-0000-000000000000
00010000-0000-0000-0000-000000000000
00100000-0000-0000-0000-000000000000 …

关于在.NET和C#中解析ISO8601日期/时间,有很多SO问题和答案.然而,在任何地方似乎都没有"明确的"答案,即提供正式正确的ISO8601解析器的答案,该解析器将正确解析ISO8601中的所有可能的格式变体,并且不允许非ISO8601变体.

这个SO答案是迄今为止最接近的比赛......

如何从ISO 8601格式创建.NET DateTime

Microsoft 实现了他们自己的紧凑二进制 XML 编码 (MC-NBFX)，这是 WCF 中的一个选项，用于比标准 XML 文本编码更有效地传送 XML 信息集（例如 SOAP 请求和响应）。

我想使用相同的编码，例如以紧凑的二进制形式将大型 XML 文件保存到磁盘。

我开始于：

XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(@"<Foo><Bar>abc</Bar></Foo>");

using(FileStream fs = new FileStream("c:/tmp/foo.bin", FileMode.Create))
{
    using(XmlDictionaryWriter xbw = XmlDictionaryWriter.CreateBinaryWriter(fs))
    {
        xmlDoc.WriteTo(xbw);
    }
}

这确实输出了一个 MC-NBFX 格式的文件，但是如果我用重复的字符串（例如元素名称）对 XML 文档进行编码，这些名称会在二进制文件中多次出现。

XmlDictionaryWriter 的要点在于它允许定义字符串字典并用字符串 ID 替换流中的字符串。实际上有两个字典，一个可以传递给 CreateBinaryWriter() 并且旨在成为预定/静态字典。我尝试插入这样一个静态字典，但编码器忽略了它：

XmlDictionary xmlDictionary = new XmlDictionary();
xmlDictionary.Add("Foo");
xmlDictionary.Add("Bar");

using(XmlDictionaryWriter xbw = XmlDictionaryWriter.CreateBinaryWriter(fs, xmlDictionary))
{
    xmlDoc.WriteTo(xbw);
}

第二种类型的字典是动态的，据说在编写过程中添加了字符串。要使用此机制，需要使用（并且可能覆盖）XmlBinaryWriterSession。例如：

XmlBinaryWriterSession writerSession = new XmlBinaryWriterSession();
using(XmlDictionaryWriter xbw = XmlDictionaryWriter.CreateBinaryWriter(fs, null, writerSession))
{
    xmlDoc.WriteTo(xbw);
}

同样，这对输出没有影响，仍然会出现重复的字符串，并且在写入完成后 …

ConcurrentDictionary.GetOrAdd(TKey,Func <TKey,TValue>)接受一个工厂函数,允许将项目的延迟实例化放入字典中.

定义一个自己调用GetOrAdd()的工厂函数是安全的,即在'父'GetOrAdd()的上下文中调用GetOrAdd.

以下代码演示了该模式; 它确实有效,但它安全吗？

class Program
{
    static ConcurrentDictionary<string,object> __dict = new ConcurrentDictionary<string, object>();

    static void Main(string[] args)
    {
        Foo foo = GetOrAddFoo();
        Console.WriteLine(foo._name);
        Console.WriteLine(foo._bar._name);
        Console.ReadKey();
    }

    static Bar GetOrAddBar()
    {
        Console.WriteLine("GetOrAddBar: enter");
        Func<string,Bar> factoryFn = (x) => LoadBar(x);
        Bar bar = __dict.GetOrAdd("bar", factoryFn) as Bar;
        Console.WriteLine("GetOrAddBar: exit");
        return bar;
    }

    static Foo GetOrAddFoo()
    {
        Console.WriteLine("GetOrAddFoo: enter");
        Func<string,Foo> factoryFn = (x) => LoadFoo(x);
        Foo foo = __dict.GetOrAdd("foo", factoryFn) as Foo;
        Console.WriteLine("GetOrAddFoo: exit");
        return foo;
    }

    static Bar LoadBar(string …