小编Vin*_*cio的帖子

反正这个代码可以重构吗？唯一的区别是订单的顺序.

Idealy我想使用委托/ lambda表达式,因此代码是可重用的,但我不知道如何有条件地添加和删除查询运算符OrderBy和OrderByDescending

var linq = new NorthwindDataContext();

        var query1 = linq.Customers
            .Where(c => c.ContactName.StartsWith("a"))
            .SelectMany(cus=>cus.Orders)
            .OrderBy(ord => ord.OrderDate)
            .Select(ord => ord.CustomerID);

        var query2 = linq.Customers
            .Where(c => c.ContactName.StartsWith("a"))
            .SelectMany(cus => cus.Orders)
            .OrderByDescending(ord => ord.OrderDate)
            .Select(ord => ord.CustomerID);

我在生产中遇到了这个代码,我觉得这可能会给我们带来麻烦.

internal static readonly MyObject Instance = new MyObject();

两次调用Instance字段将返回具有相同哈希码的两个对象.这些物体有可能不同吗？

我对CLI的了解表明它们是相同的,因为哈希码是相同的.

有人可以澄清吗？

我已经阅读了几篇关于Ninject for MVC3项目设置的文章.

有人说你的Global.asax.cs应该继承自NinjectHttpApplication,其他人则在通过Application_Start()构造StandardKernel时注册模块.

我个人使用NuGet,它以不同的方式创建AppStart_NinjectMVC3类,并使用它启动它

[assembly: WebActivator.PreApplicationStartMethod(typeof(MyApp.AppStart_NinjectMVC3), "Start")]

每个都有任何优点/缺点吗？

在调用DoStuffToDictionary(dictionaryTwo)时,可以安全地假设方法体内的操作包括索引器,LINQ扩展方法也是线程安全的吗？

用不同的方式表达这个问题,是否会出现交叉线程异常或死锁？

var dictionaryOne = new ConcurrentDictionary<int,int>();
var dictionaryTwo = new Dictionary<int,int>();

DoStuffToDictionary(dictionaryOne);
DoStuffToDictionary(dictionaryTwo);

void DoStuffToDictionary(IDictionary<int,int> items) {
   // Manipulate dictionary    

   if (items[0] == -1) {
     items[0] = 0; // Dumb example, but are indexers like this OK?
  }
}

我在尝试将复杂类型添加到Mongo中的现有文档时遇到了麻烦.

我有以下两个班级.

public class UserObjectCollection {

    [BsonId]
    public Guid UserId { get; set; }

    public Dictionary<string, object> UserObjects { get; set; }

    public UserObjectCollection() {
        UserObjects = new Dictionary<string, object>();
    }
}

public class ComplexClass {
    public string Bar { get; set; }
    public int Foo { get; set; }
}

然后我创建一个新的插入对象.

var bd = new UserObjectCollection() {
    UserId = Guid.NewGuid(),
    UserObjects = {
        { "data", 12 },
        { "data2", 123 },
        { "data3", new ComplexClass() { Bar= "bar", Foo=1234 …

卸载模块后如何恢复PowerShell别名.

到目前为止,我所拥有的代码虽然单独执行Set-Alias命令,却无法正常工作.它将定义存储在局部变量中,该变量在OnRemove触发事件时可用.

$orig_cd = (Get-Alias -Name 'cd').Definition
$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
    Set-Alias -Name 'cd' -Value $orig_cd -Force -Option AllScope -Scope Global
}

我还要提一下,我正在覆盖现有的cd命令别名

Set-Alias -Name cd -Value cdX -Force -Option AllScope -Scope Global

这是模块的源代码https://github.com/vincpa/z/blob/master/z.psm1

更新

Write-Host在OnRemove处理程序中添加命令会显示值$orig_cd确实是Set-Location.

我先说我不打算开始一场火焰战:-)

我知道标签的语义含义,例如<article>提供文件,但是使用它们会带来什么好处？

搜索引擎会以不同方式看待它们吗？如果没有,还有什么其他好处？

我有一个使用 web.debug.config 文件转换的 web.config 文件。尝试通过 System.Configuration.ConfigurationManager.AppSettings 访问这些值并没有产生任何结果。

我的 web.config appSettings 是空的。

<configuration>
    <appSettings>
    </appSettings>
</configuration>

我应用的 web.debug.config 转换。这是一个示例。

<configuration>
    <appSettings>
        <add key="CommonURL" value="localhost/mysite/" xdt:Transform="Insert" />
    </appSettings>
</configuration>

这是尝试获取此值的代码，该值返回 null。

var cu = System.Configuration.ConfigurationManager.AppSettings["CommonURL"];

知道为什么会这样吗？

我在异步方法中抛出异常时遇到了一些我无法理解的行为.

以下代码将在调用ThrowNow方法时立即抛出异常.如果我将该行注释掉并直接抛出异常,那么吞没异常并且不会在Unobserved事件处理程序中引发异常.

public static async void ThrowNow(Exception ex){
    throw ex;
}

public static async Task TestExAsync()
{
    ThrowNow(new System.Exception("Testing")); // Throws exception immediately
    //throw new System.Exception("Testing");   // Exception is swallowed, not raised in unobserved event

    await Task.Delay(1000);
}

void Main()
{  
    var task = TestExAsync();
}

更令人困惑的是,如果我async从ThrowNow方法中删除关键字,则会再次吞下异常.

我认为异步方法同步运行,直到达到阻塞方法.在这种情况下,似乎删除async关键字使其行为异步.

我很难尝试使用外部依赖项对F#代码进行单元测试.

在C#(我的背景)中,您通常会有一个传入依赖关系的类,然后重新使用它.为我的示例代码道歉,它是愚蠢的,但我只是想说明我的观点.

public class Foo {

  IDependency d;
  public Foo(IDependency d) { this.d = d; }

  public int DoStuff(string bar) { return d.DoSomethingToStuff(bar); }

  public int DoMoreStuff(string bar) { 
     int i = d.DoSomethingToStuff(bar);
     return d.DoSomethingElseToStuff(bar, i);
  }
}

我试图用F#实用,避免使用类和接口(除非我需要与其他.NET语言互操作).

所以我在这种情况下的方法是将模块和一些函数与依赖项作为函数传入.我在这里发现了这个技术

module Foo

  let doStuff bar somethingFunc =
    somethingFunc bar

  let doMoreStuff bar somethingFunc somethingElseFunc =
    let i = somethingFunc bar
    somethingElseFunc bar i

我对这段代码的两个问题是:

1. 我需要继续传递我的依赖关系.在C#中,它在构造函数中传递并重新使用.你可以想象如果somethingFunc在几个地方使用它会多快失控.

2. 如何对依赖项执行进行单元测试？再次在C#中,我使用了一个模拟框架并断言某些方法被调用.

如何在F#世界中解决这些问题？