小编Aar*_*ack的帖子

在C#6中,新字符串插值的默认文化是什么？

我已经看到了关于Invariant和Current Culture的相互矛盾的报道.

我希望得到一个明确的答案,我会不停地指责Invariant.

Windows上的Docker似乎是Windows Server 2016中内置的东西？并支持在Docker容器内运行Windows并使用Windows作为Docker容器主机.这是否支持Linux？我不这么认为,我认为它只支持运行Windows Docker容器.这似乎也由微软维护.

Docker for Windows似乎是由Docker团队创建的单独安装,用于将Linux Docker引入Windows.因此Windows可以是Docker主机,但所有容器仍然只是普通的Linux容器.这是否支持Windows容器？我不这么认为,我认为它只支持运行Linux Docker容器.这似乎也是由Docker维护的.

另一个有趣的注意事项是,用于Visual Studio的Docker Tools似乎只支持Windows的Docker Desktop而不支持Windows上的Docker.

我真正想要的是两者之间的差异,某种良好的比较.每个都试图实现什么功能,它们在哪里相似,它们在哪里不同.他们会永远不同,还是会聚在一起？

有什么区别:

• VsDevCmd.bat(VS2012的开发人员命令提示符)
• vcvarsall.bat(VS2012 x86\x64\ARM Native\Cross Tools命令提示符)

我对vcvarsall.bat有很好的理解,因为它是许多以前版本的Visual Studio的一部分.vcvarsall.bat基本上是我的msbuild的goto工具,即使在构建.NET项目时,即使它在技术上是Visual C++的一部分.

我不太了解的是VsDevCmd.bat.VS2012似乎是新的,我不确定它的目的是什么.我注意到它不在像vcvarsall.bat这样的Visual C++文件夹中,但它位于Visual Studio Tools文件夹中.我现在应该在这个工具中做我的.NET msbuild吗？如果是这样,我如何设置相同类型的x64\x86\ARM默认值,如vcvarsall.bat.

这是一个非常非常简单的功能,它回归确定性.如果我将其编译为原生,则不再具有确定性.如何使其本地编译和确定性？

CREATE FUNCTION [hash].[HashDelimiter2]()
RETURNS NCHAR(1)
WITH SCHEMABINDING
AS BEGIN
        RETURN N';'
END
GO

/* This does indeed result in YES */
SELECT IS_DETERMINISTIC
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_NAME = 'HashDelimiter2'



/* But then compile it native and it's no longer deterministic */
CREATE FUNCTION [hash].[HashDelimiter3]()
RETURNS NCHAR(1)
WITH NATIVE_COMPILATION, SCHEMABINDING
AS BEGIN ATOMIC WITH (
    TRANSACTION ISOLATION LEVEL = SNAPSHOT,
    LANGUAGE = N'English'
)
    RETURN N';'
END
GO

/* This results in NO */
SELECT IS_DETERMINISTIC
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_NAME …

从Visual Studio 2015开始,所有解决方案都会创建一个隐藏的".vs"文件夹,其中包含各种内容,如applicationhost.config,.suo文件等...

出于提供信息的目的,我正在运行TFS 2013更新4,而我无法控制系统,因此无法升级系统.

我知道我可以去每个解决方案文件夹并在其中添加一个带有".vs*"或类似内容的.tfsignore文件来忽略该文件夹,但我正在寻找的是如何在根目录下添加.tfsignore将忽略所有".vs"文件夹及其下的文件,无论它们位于各个子目录中的哪个位置.

谢谢.

所以我编写了一个Powershell脚本来获取任何给定exe\dll的平台.我对汇编标题不够熟悉,无法确定文件是否包含本机代码.我试图不调用corflags,peverify,ildasm或任何其他外部可执行文件.

有没有一种简单的方法来实现这一目标？这是我到目前为止用于确定程序集是本机还是.NET以及它是为其构建的平台的Powershell代码.我想添加能力,如果它的.NET也确定它是否是混合模式.

# Gets the Platform of a any Assembly native or managed.
# Examples:
#   Get-Platform "C:\vs\projects\bestprojectever\bin\debug\mysweetproj.dll"
#   Get-Platform (dir *.dll | select -first 1) 

param([Parameter(Mandatory=$true, ValueFromPipeline=$true)] $assemblyPath)

$platform = "Unknown"
$resolvedPath = Resolve-Path -literalPath $assemblyPath

try {
    $architecture = [System.Reflection.AssemblyName]::GetAssemblyName($resolvedPath) | Select-Object -ExpandProperty ProcessorArchitecture
    switch ($architecture) {
        MSIL { $platform = "AnyCPU Managed" }
        X86 { $platform = "x86 Managed" }
        Amd64 { $platform = "x64 Managed" }
        IA64 { $platform = "Itanium Managed" }
        default { $platform …

我正在使用Visual Studio 2012 Update 1和.NET 4.5这里是代码.

void Test(Action a) { }
void Test(Func<int> a) { }
void TestError()
{
    bool throwException = true;
    //Resolves to Test(Action a)
    Test(() =>
    {
    });
    //Resolves to Test(Action a)
    Test(() =>
    {
        if (throwException) throw new Exception();
    });
    //Resolves to Test(Func<int> a)
    //(This seems like a bug since there is no return value)
    Test(() =>
    {
        throw new Exception();
    });
    //Resolves to Test(Action a)
    //(With warning unreachable code detected)
    Test(() =>
    {
        throw new …

我已经编写了一个复制该问题的示例测试。这不是我的实际代码，我尝试编写一个小代码。如果将边界容量增加到迭代次数，从而有效地使其没有边界，则不会出现死锁，如果将最大并行度设置为较小的数字（例如 1），则不会出现死锁。

再说一次，我知道下面的代码不是很好，但我实际发现的代码要大得多并且难以理解。基本上有一个与远程资源的连接的阻塞对象池，并且流中的几个块使用了该连接。

关于如何解决这个问题有什么想法吗？乍一看，这似乎是数据流的问题。当我中断查看线程时，我看到许多线程在 Add 上被阻塞，0 个线程在 take 上被阻塞。addBlocks 出站队列中有几个项目尚未传播到 takeblock，因此它被卡住或死锁。

    var blockingCollection = new BlockingCollection<int>(10000);

    var takeBlock = new ActionBlock<int>((i) =>
    {
        int j = blockingCollection.Take();

    }, new ExecutionDataflowBlockOptions()
           {
              MaxDegreeOfParallelism = 20,
              SingleProducerConstrained = true
           });

    var addBlock = new TransformBlock<int, int>((i) => 
    {
        blockingCollection.Add(i);
        return i;

    }, new ExecutionDataflowBlockOptions()
           {
              MaxDegreeOfParallelism = 20
           });

    addBlock.LinkTo(takeBlock, new DataflowLinkOptions()
          {
             PropagateCompletion = true
          });

    for (int i = 0; i < 100000; i++)
    {
        addBlock.Post(i);
    }

    addBlock.Complete();
    await addBlock.Completion; …

最初，我使用的是适用于Docker的Visual Studio 2017工具，因为当将Docker支持添加到ASP.NET时，这是Visual Studio早期版本中的默认设置。

最近，我升级到了Visual Studio 2017 15.8.0预览版2，我注意到有一种使用进行docker构建的全新方法launchSettings.json。

旧方法有一个特殊的*.dcprojwhos项目的SDK属性指向<Project Sdk="Microsoft.NET.Sdk.Web">。在此项目中，有一个docker-compose.yml和a docker-compose.override.yml指向我的ASP.Net的Dockerfile。这非常灵活，使我可以进行大量的自定义操作，例如添加如下的卷挂架。

docker-compose.override.yml:

version: '3.5'
services:
  sample.container:
    volumes:
    - type: bind
      source: C:\config
      target: /config
      read_only: true
      volume:
        nocopy: true

这很棒，因为它允许我在调试过程中轻松指向容器中没有的配置文件。

现在，Visual Studio中使用了新的docker工具，launchSettings.json并且<PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="0.2.1686908" />在*.csproj文件中不再使用compose文件，它将Dockerfile直接启动。下面是我的副本launchSettings.json。

我真的希望有人可以告诉我如何以这种新方式将自定义卷安装添加到launchSettings.json文件中，请参阅以下Docker部分。

launchSettings.json:

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:55836",
      "sslPort": 44354
    } …

引用Scala 的文档：

def span(p: (A) => Boolean): (Seq[A], Seq[A])

根据谓词将此可迭代集合拆分为前缀/后缀对。

注意：c span p 等价于（但可能比）（c takeWhile p, c dropWhile p）等价，前提是谓词 p 的计算不会引起任何副作用。

注意：对于不同的运行可能会返回不同的结果，除非对基础集合类型进行了排序。

• p - 测试谓词
• 返回 - 由这个可迭代集合的最长前缀组成的一对，其元素都满足 p，以及这个可迭代集合的其余部分。
• 定义类 - IterableOps ？可迭代的OnceOps
• 注意 - 重用：调用此方法后，应丢弃调用它的迭代器，只使用返回的迭代器。使用旧迭代器是未定义的，可能会发生变化，并且也可能导致对新迭代器的更改。

在查看Seq的F# 文档时，我没有看到任何等效内容。

groupBy、partition、splitAt，它们都不符合我想要做的。这就像同时执行 takeWhile 和 skipWhile，但不需要两次迭代，您只需要一个函数将返回 (takeWhile, skipWhile) 元组的迭代。

输出应与以下函数匹配

module List
let span (predicate: 'a -> bool) (list: 'a list): ('a list * 'a list) =
    (list |> List.takeWhile predicate, list |> List.skipWhile predicate)

但只需要一次迭代，因为我的序列可能是无限的。

[1;2;3;4] |> List.span (fun …