DDD-навигация к сущностям внутри aggregate root через составную идентификацию

у меня есть совокупный корень Products который содержит список сущностей Selection, который в свою очередь содержит список сущностей, называемых Features.

• совокупный корень Product имеет идентичность только имя
• сущности Selection имеет идентификатор имени (и соответствующий идентификатор продукта)
• сущности Feature имеет идентификатор имени (а также соответствующий идентификатор выбора)

где личность для сущностей строятся следующим образом:

var productId = new ProductId("dedisvr");
var selectionId = new SelectionId("os",productId);
var featureId = new FeatureId("windowsstd",selectionId);

обратите внимание, что зависимое удостоверение принимает удостоверение родителя как часть составного.

идея заключается в том, что это будет частью продукта, который может быть идентифицирован с помощью специфической особенностью в выборе, т. е. ToString() для вышеуказанного объекта featureId вернется dedisvr-os-windowsstd.

все существует в агрегате продукта, где бизнес-логика используется для обеспечения инвариантности на связи между выборками и объектами. В моем домене нет смысла для функции существовать без выбора, а выбор без связанного продукта.

при запросе продукта для связанных функций возвращается объект Feature, но C# internal ключевое слово используется для скрытия любых методов, которые могут мутировать сущность, и, таким образом, убедитесь, что сущность неизменяема для вызывающей службы приложений (в другой сборке из домена код.)

эти два вышеуказанных утверждения предусмотрены двумя функциями:

class Product
{
    /* snip a load of other code */

    public void AddFeature(FeatureIdentity identity, string description, string specification, Prices prices)
    {
       // snip...
    }

    public IEnumerable<Feature> GetFeaturesMemberOf(SelectionIdentity identity);
    {
       // snip...
    }
}

у меня есть агрегатный корень под названием Service order, это будет содержать строку конфигурации, которая будет ссылаться на Feature внутри Product совокупный корень FeatureId. Это может происходить в совершенно ином ограниченном контексте.

так как FeatureId содержит поля SelectionId и ProductId я буду знать, как перейти к функции через агрегат корень.

мои вопросы:

составные идентичности, сформированные с идентичностью родителя-хорошая или плохая практика?

в другом примере кода DDD, где идентификаторы определяются как классы, я еще не видел никаких композитов, сформированных из локального идентификатора сущности и его родительского идентификатора. Я думаю, что это хорошее свойство, так как мы всегда можем перейти к этой сущности (всегда через aggregate root) со знанием пути туда (Product - > Selection - > Feature).

в то время как мой код с составной цепочкой идентичности с родителем имеет смысл и позволяет мне перемещаться к сущности через корневую совокупность, не видя других примеров кода, где идентичности формируются аналогично с композитами, заставляет меня очень нервничать - любая причина для этого или это плохая практика?

ссылки на внутренние объекты - временные или долгосрочные?

на Синей книги упоминает ссылки на сущности в агрегате допустимы, но должны быть только переходными (в блоке кода). В моем случае мне нужно хранить ссылки на эти объекты для использования в будущем, хранение не является временным.

однако необходимость хранить эту ссылку предназначена только для целей отчетности и поиска, и даже если я хотел бы получить дочернюю сущность bu navigate через корень, возвращаемые сущности неизменяемы, поэтому я не вижу никакого вреда может быть сделано или инварианты сломанный.

правильно ли мое мышление, и если да, то почему упоминается, что ссылки на дочерние сущности преходящи?

исходный код ниже:

public class ProductIdentity : IEquatable<ProductIdentity>
{
    readonly string name;

    public ProductIdentity(string name)
    {
        this.name = name;
    }

    public bool Equals(ProductIdentity other)
    {
        return this.name.Equals(other.name);
    }

    public string Name
    {
        get { return this.name; }
    }

    public override int GetHashCode()
    {
        return this.name.GetHashCode();
    }

    public SelectionIdentity NewSelectionIdentity(string name)
    {
        return new SelectionIdentity(name, this);
    }

    public override string ToString()
    {
        return this.name;
    }
}

public class SelectionIdentity : IEquatable<SelectionIdentity>
{
    readonly string name;
    readonly ProductIdentity productIdentity;

    public SelectionIdentity(string name, ProductIdentity productIdentity)
    {
        this.productIdentity = productIdentity;
        this.name = name;
    }

    public bool Equals(SelectionIdentity other)
    {
        return (this.name == other.name) && (this.productIdentity == other.productIdentity);
    }

    public override int GetHashCode()
    {
        return this.name.GetHashCode();
    }

    public override string ToString()
    {
        return this.productIdentity.ToString() + "-" + this.name;
    }

    public FeatureIdentity NewFeatureIdentity(string name)
    {
        return new FeatureIdentity(name, this);
    }
}

public class FeatureIdentity : IEquatable<FeatureIdentity>
{
    readonly SelectionIdentity selection;
    readonly string name;

    public FeatureIdentity(string name, SelectionIdentity selection)
    {
        this.selection = selection;
        this.name = name;
    }

    public bool BelongsTo(SelectionIdentity other)
    {
        return this.selection.Equals(other);
    }

    public bool Equals(FeatureIdentity other)
    {
        return this.selection.Equals(other.selection) && this.name == other.name;
    }

    public SelectionIdentity SelectionId
    {
        get { return this.selection; }
    }

    public string Name
    {
        get { return this.name; }
    }

    public override int GetHashCode()
    {
        return this.name.GetHashCode();
    }

    public override string ToString()
    {
        return this.SelectionId.ToString() + "-" + this.name; 
    }
}