小编Bru*_*eis的帖子

为什么关系数据库比面向对象的数据库更常见？

如果面向对象编程范例如此广泛,我们不应该看到很多OODBMS吗？它们不会比RDBMS + OR/M表现更好吗？

我一直认为在F#中我们需要rec为每个递归函数使用关键字,例如:

let rec factorial = function
| 0 -> 1
| k when k > 0 ->  k * (factorial (k - 1))
| failwith "oops!"

今天我正在玩F#,我想出了类似如下的代码:

let MyRecordType =
    { Something     : float;
      SomethingElse : int }
    with
        static member factorial = function
            | 0 -> 1
            | k when k > 0 ->  k * (MyRecordType.factorial (k - 1))
            | failwith "oops!"

如你所见,我刚刚定义了一个递归函数,但我最初看起来像是一个错误:我忘了通过关键字将函数声明为递归函数rec.

但令我惊讶的是它汇编了!还有更多:如果你添加rec关键字,那么这是一个语法错误!

type MyRecordType =
    { …

(很长一段时间)我一直在寻找一个如何使用Fluent NHibernate 正确实现一对一映射的示例.

我找到的大多数资源都说:

我认为你的意思是多对一的

然而,没有人真正举例说明如何正确实现一对一关系.

那么,你能用Fluent NHibernate给出一对一的映射示例吗？

注意:我对那些说"你的模型是什么,你可能真的需要HasMany "的人不感兴趣.不,谢谢,我只需要一对一的例子.

更确切地说,我知道语法.这是我自己搜索唯一能找到的东西.我正在寻找的是一个更完整的例子,包括一个((非常)简单的)数据库设置,以及参与该关系的所有实体的整个映射,我认为它对Stack Overflow来说具有合理的大小.

我在ASP.NET MVC中有一个多租户应用程序.将要提供的应用程序实例仅仅是主机名的功能(我认为这与stackexchange一致).

应用程序的每个实例可能具有不同的文化设置(甚至"自动",以阅读浏览器的语言并尝试使用它),并将相应地进行本地化.

在这种情况下,我想对我的一些操作做一些输出缓存.所以,我的问题是:

1. 如果输出完全取决于主机名(即忽略本地化要求),那么实现多租户ASP.NET MVC应用程序的输出缓存有哪些可能性？

2. 与(1)相同,但现在考虑输出还取决于培养设置？

3. 与(2)相同,但考虑到输出可能随传递给动作的参数而变化？

在这种情况下,我正在考虑所有站点都从一个IIS网站运行.

我有一个类MyClass,我想覆盖List实例的方法ToString():

class MyClass
{
    public string Property1 { get; set; }
    public int Property2 { get; set; }
    /* ... */
    public override string ToString()
    {
        return Property1.ToString() + "-" + Property2.ToString();
    }
}

我想要以下内容:

var list = new List<MyClass>
            {
                new MyClass { Property1 = "A", Property2 = 1 },
                new MyClass { Property1 = "Z", Property2 = 2 },
            };

Console.WriteLine(list.ToString());   /* prints: A-1,Z-2 */

有可能这样做吗？或者我必须继承List <MyClass>来覆盖我的子类中的方法ToString()？我可以使用扩展方法解决这个问题(即,是否可以使用扩展方法覆盖方法)？

谢谢!

考虑以下用Java编写的类:

class NonNegativeDouble {
    private final double value;
    public NonNegativeDouble(double value) {
        this.value = Math.abs(value);
    }
    public double getValue() { return value; }
}

它定义了一个名为final的字段value,该字段在构造函数中初始化,方法是将其参数称为alike并对其应用函数.

我想在Scala中写一些类似的东西.起初,我尝试过:

class NonNegativeDouble(value: Double) {
  def value = Math.abs(value)
}

但编译器抱怨:错误:重载方法值需要结果类型

显然编译器认为表达式中value的表达式Math.abs(value)是指被定义的方法.因此,定义的方法是递归的,所以我需要声明它的返回类型.所以,我写的代码没有按照我的预期去做:我想value在里面Math.abs(value)引用构造函数参数value,而不是指定义的方法.这是因为如果编译器隐式添加一个this.到Math.abs(this.value).

添加val或var(或private ...变体)构造函数参数似乎没有帮助.

所以,我的问题是:我可以定义一个与构造函数参数同名的属性,但可能是一个不同的值？如果是这样,怎么样？如果没有,为什么？

谢谢!

我读了很多次

从F#或任何其他.NET语言生成的程序集(几乎)难以区分.

然后我在.NET 4(beta 2)上试验F#和C#interop.我用以下类创建了一个新的解决方案和一个C#项目:

public class MyClass {
    public static int Add(int a, int b) { return a + b; }
}

然后,在F#项目上,在引用C#项目之后,我尝试了:

MyClsas.Add(4, 5) |> printfn "%d" // prints 9 (no kidding!)

到现在为止还挺好.然后又出现了我多次读过的另一句话(也许在不同的书上):

将参数传递给其他.NET库中的函数时,使用类似".MethodName(parm1,parm2)"的语法,即参数作为元组传递.

将其添加到我曾经在SO上阅读的内容(但是无法找到它链接到的),在OP试图创建使用的问题[ 4, 5, 6 ](当他的意思[4; 5; 6])时:

"逗号是'元组创建运算符',因为其他一切都使用了分号."

然后我将我的课修改为以下内容:

public class MyClass {
    public static int Add(int a, int b) { return a + b; }
    public static int Add(Tuple<int, int> a) { return a.Item1; }
}

现在我尝试在F#上使用它:

MyClass.Add(4, 5) …

如何在模块内部编写函数或作为某种类型的静态成员之间做出决定？

例如,在F#的源代码中,有许多类型与同名模块一起定义,如下所示:

type MyType = // ...

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module MyType = // ...

为什么不简单地将操作定义为MyType类型的静态成员？

我必须索引应该一起搜索的不同类型的数据(文本文档,论坛消息,用户配置文件数据等)(即,单个搜索将返回不同类型数据的结果).

• 拥有多个索引的优点和缺点是什么,每种索引对应一种？

• 以及为各种数据提供单一索引的优缺点？

谢谢.

问题

虽然我将在这里谈论的代码我在F#中编写,但它基于.NET 4框架,而不是特别依赖于F#的任何特殊性(至少看起来如此!).

我的磁盘上有一些数据,我应该从网络更新,将最新版本保存到磁盘:

type MyData =
    { field1 : int;
      field2 : float }

type MyDataGroup =
    { Data : MyData[];
      Id : int }

// load : int -> MyDataGroup
let load dataId =
    let data = ... // reads from disk
    { Data = data;
      Id = dataId }

// update : MyDataGroup -> MyDataGroup
let update dg =
    let newData = ... // reads from the network and process
                      // newData : MyData[]

    { dg with …