小编moa*_*ate的帖子

当我向具有可为空属性的 T4 模板提供对象时，除非我明确编写为模板生成<#= obj.Property ?? string.Empty #>的ToStringWithCulture(object objectToConvert)方法，否则ArgumentNullException如果该属性为空，则抛出异常。是否有任何简洁或优雅的方法来覆盖此行为，以便我不必在我的模板中使用 null 合并？

我想在用于C#消费的F#类的实现中使用计算表达式.互操作类本身是一个单例(一个实例连接在容器中)并用于跨线程(Web请求).

构建器本身仅包含方法,并且没有后备字段或状态.

鉴于F#中的以下习惯:

module A = 
    let private build = new SomeBuilder()

这是否意味着可以同时评估与一个构建器关联的多个表达式而没有问题？

我有一个字符串,我想使用一个活动模式来匹配.我注意到当值是函数的输入时,我必须重复相同的函数调用.有没有办法不必继续调用函数？

let (|A|B|C|X|) stringValue =
        match stringValue with
        | value when compareCaseInsensitive stringValue "a" -> A
        | value when compareCaseInsensitive stringValue "b" -> B
        | value when compareCaseInsensitive stringValue "c" -> C
        | _ -> X stringValue

在下面的代码中,输出将是相同的.

function dateObject() {
    this.date = new Date();
}

var wrapper = {
    dateObj: new dateObject()
};

console.log(wrapper.dateObj.date);

setTimeout(function () {
    console.log(wrapper.dateObj.date);
}, 3000);

我实际上偶然发现了这个检查,以确保财产的价值不会改变,但现在我很好奇.有没有办法让一个属性不是一个函数,而是一个函数的评估,每次都是新的？我问,因为你可以用其他语言来做(想想System.DateTime用C#).

给出以下代码:

var strings = Enumerable.Range(0, 100).Select(i => i.ToString());
int outValue = 0;
var someEnumerable = strings.Where(s => int.TryParse(s, out outValue))
                            .Select(s => outValue);
outValue = 3;
//enumerating over someEnumerable here shows ints from 0 to 99

我能够看到每次迭代的out参数的"快照".为什么这个工作正常而不是我看到100 3(延迟执行)或100 99(访问修改后的闭包)？

当你想要返回一个闭包时,我理解嵌套函数的好处.但是当一个函数从未在它定义的函数之外使用时,是否需要保持嵌套的成本？

考虑:

let private validate number = 
    number > 100

let validateAndPrint (i : int) = 
    printfn "%i Greater than 100: %s" i ((validate i).ToString())

与:

let validateAndPrint (i : int) = 
    let validate number = 
        number > 100
    printfn "%i Greater than 100: %s" i ((validate i).ToString())

这里的问题通常是当我有一些这些内部函数时,我只需要根据执行路径调用其中一个函数(通常不会禁止将这些函数保密或嵌套并测试排列).

validateAndPrint 也可以重写更多tdd-friendly以接受验证功能:

let validateAndPrint validate i = ...

..但如果validation签名包含内部或私人类型,则考虑将所有内容公开并且参数列表爆炸.

任何重要的差异？

我正在为一个接受输入的对象编写测试,将一些函数组合在一起,通过组合函数运行输入,并返回结果.

这是一组极为简化的对象和函数,反映了我的设计:

type Result =
| Success of string

let internal add5 x = x + 5

let internal mapResult number =
    Success (number.ToString())

type public InteropGuy internal (add, map) = 
    member this.Add5AndMap number =
        number |> (add >> map)

type InteropGuyFactory() =
    member this.CreateInteropGuy () =
        new InteropGuy(add5, mapResult)

该类被设计用于C#interop,它解释了结构,但是这个问题仍然适用于组成函数参数的任何测试函数.

在测试编写功能时,我无法找到一种优雅的方法来保持内部函数的实现细节不会进入测试条件,或者换句话说,隔离链中的一个链接而不是在输入后检查输出完全通过管道输送.如果我只是检查输出,那么每个函数的测试将依赖于下游函数正常工作,如果链末端的函数停止工作,则所有测试都将失败.我能做的最好的事情是将函数存根以返回某个值,然后将其下游函数存根,存储下游函数的输入,然后断言存储的值等于存根函数的输出:

[<TestClass>]
type InteropGuyTests() = 

    [<TestMethod>]
    member this.``Add5AndMap passes add5 result into map function``() = 

        let add5 _ = 13

        let tempResult = ref 0
        let mapResult result = …