Eladei's questions

任务：注册某些对象，并以一定的频率向它们请求信息，以便随后根据请求输出给用户。

最初的想法是将主题领域划分为 2 个上下文：

1. 有关对象的当前信息的上下文；
2. 调查背景

轮询微服务将查询数据并使用轮询结果发布事件。反过来，有关对象的当前信息的微服务将获取事件并更新其本地数据库。

但是使用这种方法，以下几点让我感到困惑：上下文之间的数据重复。在轮询上下文中，目标对象可以包含一组稍微不同的属性：轮询间隔、优先级等。但是，关键数据集（被轮询对象返回的内容）仍然与信息上下文（显示相同的数据）相交）。

看了一本关于 msdn 的好书的一部分，其中微服务被视为一种逻辑结构，有时可以由具有共享数据库访问权限的多个服务（物理实现）组成： https ://docs.microsoft.com/en-us/dotnet /architecture/ microservices/architect-microservice-container-applications/logical-versus-physical-architecture

根据这篇文章，建议使用第二种方法：

将上下文组合成一个微服务，包括：

1. 显示对象信息的服务
2. 轮询服务 - 更新有关对象的信息

问题：根据所描述的，就微服务架构而言，哪种方法更可取？

UPD将来需要显示从请求的对象累积的一段时间内的统计信息（Statistics Service）。但是对于当前的信息服务来说，如此广泛的数据是完全没有必要的。

情况：

有一个系统细分为以下上下文（使用战略 DDD 模式）：

1. 识别和访问的上下文（识别和授权）
2. 某些对象的注册上下文
3. 轮询上下文（用于获取有关已注册对象的信息）

基于指定的任务分工，我决定构建一个基于微服务架构的系统。

一个任务：

系统安全

问题：

基于上述背景，出现了如何维护这样一个系统的安全性的问题。在这种情况下，事实证明所有服务的标识和授权都位于一个节点中。在我看来，我的观点是：

1. 这是不安全的——这个节点的故障会降低整个系统的安全性；
2. 微服务变得不那么自主；

谁有搭建微服务架构的经验，请告诉我：这种情况下如何保证安全性更好？

有一个服务器列表。每个服务器都有自己的玩家列表。玩家名单以及服务器数据会定期更改。为每个玩家保留单独的统计数据。

为了收集有关服务器和玩家的信息，我创建了一个单独的上下文。决定申请CQRS。

为了显示统计信息，我创建了一个单独的读取模型。这里的一切都很简单——通常的读取操作。

有一个关于信息记录领域的问题。

接收统计数据处理时最好应用什么：

1. 使用一组聚合、事件和其他战术模板形成一个成熟的领域模型

2. 使用普通交易脚本（Transaction Script）

我倾向于使用事务脚本：

• 易于实施
• 海量数据一次性更新

在这种情况下使用DDD让我感到困惑：

• 我无法想象在处理统计信息时使用 DDD 方法——可能有大量抽象
• 存储库涉及一次编辑一个聚合。假设我的服务器播放器是具有相应统计信息的单独聚合。如果需要更新大量玩家的信息，数据库的负载会很大。

另一方面：

• DDD 将允许您正确封装数据验证逻辑。

• 随着时间的推移，事务脚本很难维护。

我真的需要你的建议）

使用一个数据库时，我遇到了以下示例。

假设我们有一个图书馆数据库（出于商业机密的原因，我无法给出真实数据库中的示例）。

假设有一个主键是复合的 Book 表（方法 #1）：

• 存放图书的图书馆的 ID
• 图书所属目录的id
• 图书编号

同时，库 id 作为主键的组成部分出现在许多其他表中。

从我的角度来看，可以使用 GUID 作为主键（方法编号 2），并使用库 id 和参考 id 作为复合外键。

上述两种方法的优缺点是什么？

情况：

系统中有一定的实体，由若干参数描述。

每个参数由三个组件组成：

• 预约;
• 意义;
• 单位。

如果我正确理解 DDD 方法，那么值对象就是描述实体或另一个值对象（例如货币）的东西。

在这种情况下，所有三个组件都描述了参数并且必须是值对象。

但是，系统必须能够构造附加参数。因此，计量单位应取自特定的参考书。

问题：

我不太明白：如果度量单位必须是值对象，那么如何实现这种场景，这本质上不允许ID的存在？

毕竟，使用参数类型和度量单位仅表示为它们的 ID 的参数会容易得多。

情况：我有以下单位：

• 车
• 引擎
• 轮子
• 身体
• 汽车的型号
• 发动机型号
• 车轮模型
• 身体模型

每个单元都有自己的 ID。车内是发动机、车轮和车身的标识符。每个设备单元都包含相应型号的标识符。

有一条规则：在汽车上安装发动机、车轮和车身时，它们的型号必须与汽车的型号兼容。即子设备模型的某些参数必须与机器模型的相应参数相匹配。

假设发动机已经安装在汽车上。我决定更换发动机型号。引擎单元已更改并已保存到数据库中。但发动机型号必须与汽车型号兼容。事实证明，机器和引擎单元之间应该存在最终一致性（最终一致性）。

问题：如何正确解决新发动机型号与已安装发动机的车型之间的冲突？

PS最简单的方法是在更改单元模型之前在应用服务中提前进行此类检查。但是，应用程序服务不应具有域模型逻辑。

情况：需要生成设备，例如推土机。推土机是一个单元，由一组节点（发动机、车身、车轮等）组成。每个节点都是具有自己标识符的单独聚合。

根据 Vaughn Vernon 的《实现基于域的设计方法》一书，您应该避免在单个事务中更改多个聚合。

在这种情况下，最简单的方法是在单个事务中一次创建推土机的所有节点，然后创建推土机本身，该推土机存储指向其节点的链接。

澄清：可以在应用服务中实现的推土机生成方法的示例算法：

1. 实例化电机组件
2. 创建实体装配的实例
3. 实例化一个车轮组件...
4. 推土机的形成。

问题：这种违反 DDD 建议的行为是否可以接受？如果没有，实现这种情况的最佳方法是什么？

初始状态：

有一本书具有给定的一组属性。书是精华。

public class Book {
    public Book(BookID id, string name, string author, double price) {
        ID = id;
        SetName(name);
        SetAuthor(author);
        SetPrice(price);
    }

    public BookID ID { get; }

    public string Name  { get; private set; }

    public string Author { get; private set; }

    public double Price { get; private set; }

    public void ChangeName(string name) {
        SetName(name);
    }

    public void ChangeAuthor(string author) {
        SetAuthor(author);
    }

    public void ChangePrice(double price) {
        SetPrice(price);
    }

    private void SetName(string name) {
        if(name == null || name.Length == 0) {
            throw new ArgumentException("Укажите название книги");
        }
    }

    private void SetAuthor(string author) {
        if(author == null || author.Length == 0) {
            throw new ArgumentException("Укажите автора книги");
        }
    }

    private void SetPrice(double price) {
        if(price < 0) {
            throw new ArgumentException("Стоимость книги должна быть >=0");
        }
    }
}

public class BookID {
    public int ID {get;}

    public BookID(int bookID) {
        ID = bookID;
    }
}

在本例中，这本书只有 4 个参数：

1. 实体 ID
2. 姓名
3. 作者
4. 价格

在这种情况下，使用构造函数来初始化 Book 实体很方便。

情况

让这本书有大约 20 个参数。情况比较抽象。在一本书的情况下，它可能不是。但是，在确定设备型号和其他类似情况时可能会出现这种情况。

在大量参数的情况下，为方便起见，我将创建一个单独的类BookProperties，其中将呈现本书的属性，但不保证它们的正确性。然后BookProperties我会在 Book 实体的构造函数中放置一个类的实例，在其中执行验证。

以下是此方法的示例代码。为方便起见，使用与以前相同数量的参数。

public class Book {
    public Book(BookID id, BookProperties bookProperties) {
        ID = id;
        SetName(bookProperties.Name);
        SetAuthor(bookProperties.Author);
        SetPrice(bookProperties.Price);
    }

    public BookID ID { get; }

    public string Name  { get; private set; }

    public string Author { get; private set; }

    public double Price { get; private set; }

    public void ChangeName(string name) {
        SetName(name);
    }

    public void ChangeAuthor(string author) {
        SetAuthor(author);
    }

    public void ChangePrice(double price) {
        SetPrice(price);
    }

    private void SetName(string name) {
        if(name == null || name.Length == 0) {
            throw new ArgumentException("Укажите название книги");
        }
    }

    private void SetAuthor(string author) {
        if(author == null || author.Length == 0) {
            throw new ArgumentException("Укажите автора книги");
        }
    }

    private void SetPrice(double price) {
        if(price < 0) {
            throw new ArgumentException("Стоимость книги должна быть >=0");
        }
    }
}

public class BookID {
    public int ID {get;}

    public BookID(int bookID) {
        ID = bookID;
    }
}

public class BookProperties {
    public string Name  { get; set; }

    public string Author { get; set; }

    public double Price { get; set; }
}

该类BookProperties仅用于方便创建 Book 实体。

问题：

这种方法在多大程度上与 DDD 相矛盾，这种方法总体上有多正确？

大家好）我正在开发一个使用 DDD 的系统。

该系统有2个模块：

1. 配置模块。他从事新设备的注册工作：设备本身、型号和其他参数。
2. 用于检查设备缺陷的模块。

1. 每个设备类型描述一个特定的实体类。同时，在创建实体类的对象时，需要对其参数进行验证。在系统中注册新设备以使用适当的存储库（存储库）将其保存在数据库中结束。

2. 在检查模块中，将从列表中选择的设备从数据库加载到程序中。使用基于 ID 的适当存储库，返回设备以进行故障排除。在存储库的输出端，设备实体类的相应对象被加载到诊断中。但是，要创建这样的对象，必须对其进行验证。

问题出现了：如果最初将关于实体的正确信息写入数据库，那么验证从数据库中提取的信息需要多少？验证本身由内置到相应设备实体对象中的验证器类执行。

也许我完全误解了什么？

再会）

熟悉一个程序的设备后，我注意到它没有可以显示现实世界对象本质的类。

让我用一个例子来解释。假设我们有一台具有一组特定参数的机器。我们需要检查这些参数。该模型具有检查参数的方法，但没有具有一组参数的机器类。相反，我们从数据库中获取特定的 DataRow 并将其加载到参数验证方法中。

问题：这种方法的优点和缺点是什么？对我来说，这种方法很不寻常。我一直认为在程序中模型是首要的，数据库是信息的来源。毕竟，DataRow 对象本质上是相当抽象的。您需要知道行中列的名称。此外，在使用该程序时，我没有看到带有一组参数的特定 Car 类。总之，来自 DataRow 的数据会立即显示在屏幕上或转到方法中进行检查。

今天是个好日子！

我想这个问题之前已经被提过很多次了。我对今天的事态很感兴趣。

请告诉我，现在掌握 WPF 有什么意义吗？这项技术的前景如何？据我了解，如果项目很复杂，学习 WinForms 是没有意义的。

今天是个好日子！

出现了以下问题：

有一个类。例如 Book Book，其中定义了一组属性。

public class Book {
    string Name {get; set;}
    string Author {get; set;}
    double price {get; set;}

    // Далее определено Событие на изменение свойств книги OnBookPropertiesChanged
}

假设某个类的另一个对象订阅了Book类对象的OnBookPropertiesChanged事件。如何将 Book 类对象的某些属性的更改值传递给该对象？

同时，我想知道：有没有办法避免创建单独的事件来更改 Book 类对象的每个单独属性？事实上，Book 可以有很多属性。（据了解，它们在程序中以单独的形式输入，用于后续存储在类对象中）。

有一个选项可以做到这一点：

public interface IBook {
    string Name { get; }
    string Author { get; }
    double Price { get; }
}

public class Book : IBook {
    public string Name { get; private set; }
    public string Author { get; private set; }
    public double Price { get; private set; }

    public Book(string name, string author, double price) {
        Name = name;
        Author = author;
        Price = price;
    }

    public void UpdateBookProperties(IBook newBookProperties) {
        this.Name = newBookProperties.Name;
        this.Author = newBookProperties.Author;
        this.Price = newBookProperties.Price;

        OnBookPropertiesChanged();
    }

    public event Action<IBook> BookPropertiesChanged;

    private void OnBookPropertiesChanged() {
        if(BookPropertiesChanged != null) {
            IBook newBookProperties = 
                BookFactory.CreateBook(this.Name, this.Author, this.Price);

            BookPropertiesChanged(newBookProperties);
        }
    }
}

public class BookFactory {
    public static IBook CreateBook(string name, string author, double price) {
        return new Book(name, author, price);
    }
}

但我不喜欢这个选项。有几个原因：

1) 要更改 Book 类当前对象的任何属性，您必须创建一个新对象，在该对象中将指定新属性。

2) 因此，不可能对一本书的单个属性进行简单的更改。否则，订阅 BookPropertiesChanged 事件的对象根本看不到图书属性的更改。

您能告诉我在没有冗余代码的情况下实现这种情况的最佳方法吗？

今天是个好日子。有一个关于 C# 事件的问题。

我们有一个引擎。

引擎有模型参数ModelParams。例如，参数包括阀门数量 countOfClapans。ModelParams 有一个 paramsChanged 事件，表示模型参数发生变化。

在设计过程中，我有一个问题：如何保护模型参数不被 paramsChanged 事件处理程序通过 sender 更改？话虽这么说，我不想让模型参数属性像 {get; private set{}} 禁用在类外编辑属性的能力。

据我了解，您可以制作单独的事件来更改模型的每个参数。但是如果给定的参数很多呢？不要做相同数量的事件处理程序。

总之，我尝试将 ModelParams 类的对象与将订阅模型更改事件的其他对象（在本例中为 Cylinder 类的对象）隔离开来。

下面是一个非常简化的代码：

public class Engine {
    public ModelParams modelParams;
    public List<Cylinder> cylinders = new List<Cylinder>();


    public Engine( ModelParams modelParams ) {
        this.modelParams = modelParams;
    }
}

public class ModelParams {
    private int countOfClapans;
    private string engineType;

    public int ClapansCount {
        get { return countOfClapans; }
        set { countOfClapans = value; }
    }; 

    public int TypeOfEngine {
        get { return engineType; }
        set { engineType= value; }
    }; 


    public event EventArgs<ModelArgs> ModelChanged;

    public void OnModelChange() {
        if(modelChanged != null) {
            ModelArgs args = new ModelArgs();
            args.ClapansCount = this.ClapansCount;
            ModelChanged(this, args);
        }
    }
}

public class ModelArgs{
    private int countOfClapans;
    private string engineType;

    public int ClapansCount {
        get { return countOfClapans; }
        set { countOfClapans= value; }
    };

    public int TypeOfEngine {
        get { return engineType; }
        set { engineType= value; }
    }; 
}