Question

最近我看到如下代码将两个ValueObjects合并到一个新的ValueObject：

public class SomeValueObject
{
    public readonly string A;
    public readonly string B;

    public SomeValueObject(string a, string b)
    {
        A = a;
        B = b;
    }

    public static SomeValueObject Merge(SomeValueObject preferred, SomeValueObject fallback)
    {
        return new SomeValueObject(
            preferred.A ?? fallback.A,
            preferred.B ?? fallback.B);
    }
}

然后在应用层内部调用代码。

我的问题：

这是一个很好的做法，就像在示例中那样合并ValueObjects，还是应该使用Util类？

当我想，那时可能还有其他静态方法，例如要从两个或多个其他ValueObject的属性创建一些ValueObject，我宁愿为此功能创建一个Util类。或者在返回的ValueObject的静态方法中执行此操作是一个好习惯吗？

public class SomeValueObject
{
    public readonly string A;
    public readonly string B;

    public SomeValueObject(string a, string b)
    {
        A = a;
        B = b;
    }

    public static SomeValueObject Merge(SomeValueObject preferred, SomeValueObject fallback)
    {
        return new SomeValueObject(
            preferred.A ?? fallback.A,
            preferred.B ?? fallback.B);
    }

    public static SomeValueObject FromOtherObjects(SomeOtherValueObject  someOtherValueObject, SomeSecondOtherValueObject someSecondOtherValueObject)
    {
        return new SomeValueObject(someOtherValueObject.Foo, someSecondOtherValueObject.bar);
    }
}

对应于问题2，我会依赖于我班级中的其他班级，但他们并不是我班级（属性）的一部分。当其中一个类也有一个SomeValueObject的方法时，我会有相互交叉依赖的类。

就个人而言，我更喜欢Util类，但我不知道这是否是开销......

Answer 1

这是一个好的做法，就像在示例中那样合并ValueObjects，还是应该使用Util类？

常见的情况是，操作值的函数是值定义的一部分，因此与它一起打包，而不是在某个单独的实用程序类中。

ValueObjects毕竟是对象 - 函数和数据都在一起。

我会依赖于我班级中的其他班级，但他们并不是我班级（属性）的一部分。当其中一个类也有一个SomeValueObject的方法时，那么我将拥有彼此交叉依赖的类。

循环依赖性（a）通常表明模型中有改进，（b）如果这两个值密切相关，则不一定是一个关键问题。

ValueObject是由类内的静态方法还是由util类合并的？使用C＃和DDD

1 个答案: