Question

我需要在商店场景应用程序中实现1 .. *和1..1关系。（类：成员，订单，OrderLine，产品，程序，用户）我如何处理只有1个订单的1个用户可以有很多OrderLines（最好使用List结构？

这是我的用户类：

namespace ConsoleApplication1
{
    public class User
    {

        private string ffName;
        private string llName;
        private int id = 0;

        //Constructor
        public User(string firstName, string lastName)
        {
            fName = firstName;
            lName = lastName;
        }
        public User() {}

        //Overrides
        public override bool Equals(object obj)
        {
            return obj.ToString() == this.ToString();
        }
        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
        public override string ToString()
        {
            string myUser;
            myUser = string.Format("First Name: {0}; Last Name: {1}", fName, lName);
            return myUser;     
        }

        // Properties
        public string fName
        {
            get
            {
                return ffName;
            }
            set
            {
                ffName = value;
            }
        }
        public string lName
        {
            get
            {
                return llName;
            }
            set
            {
                llName = value;
            }
        } 
    }
}

Answer 1

您必须将Order和OrderLine类实现为：

class OrderLine
{
      //some code
}


class Order
{
     List<OrderLine> lstOrderLine;

     //some code
}

然后将Order类添加到您的用户类。

Answer 2

您可以拥有Order类和OrderLine类。 Order类将具有OrderLines列表，而User类可以具有Order成员。

类似的东西：

public class User
    {

        private string ffName;
        private string llName;
        private int id = 0;
        private Order order = null;

        //Constructor
        public User(string firstName, string lastName)
        {
            fName = firstName;
            lName = lastName;
        }
...
}

public class Order
{
 List<OrderLine> orderLines = null;
}

public class OrderLine
{
}

Answer 3

编辑：删除了讽刺和态度：）

首先你需要一个订单（暗示你需要一个类）。现在订单需要附加到用户。因此，添加User类型的字段。这照顾一个订单一个用户。（请注意，用户可以生成多个订单）

所以现在你的订单缺少了。添加另一个成员变量，该变量是行类型列表。现在，在您的订单中，您需要添加添加，删除和查询订单行的方法。

编辑：提出了“添加字段”的含义。添加字段意味着添加属性或私有成员。当你这样做时，你正在做组成的技术术语。组成通常被解释为“具有”关系。所以订单“有一个用户”和“有一个订单行列表”

Class User()
{
    public string firstName { get; set; }
    public string lastName {get; set; }
    public int id { get; set;}
}

Class OrderLine()
{

}

Class Order()
{
    private List<OrderLine> orderLines;
    public User submitter { get; set;}

    public Order()
    {
         orderLines = new List<OrderLine>();
    }

    public void AddOrderLine(OrderLine newOrderLine)
    {
         this.orderLines.Add(newOrderLine);
    }

    public IList<OrderLine> GetOrderLines()
    { 
         return this.orderLines;
    }
}

实施例

User customer1 = new User();
// Initialize customer1 values...
Order someOrder = new Order();
someOrder.submitter = customer1;
someOrder.AddOrderLine(new OrderLine());

编辑：将会员类更改为用户类

Answer 4

您最近的评论澄清了您的问题：

创建每一个并不难，我只是不明白如何让关系与1 .. *或1..1一起工作。如果我创建订单，我可以随时创建另一个订单

所以，让我们谈谈关系的类型。

关系类型

关系类型不涉及系统中实体的绝对数量。他们只是谈论关系中的实体数量与其他实体。

1：1关系

这意味着两个实体类型必须成对存在。如果存在一个类型A的实体，则只能存在一个类型B的实体。例如，您的User和Order。没有User订单就不能存在，而User只能有一个Order。这并不意味着只有一个User - 可能有42个用户。这仅表示如果存在Order，则User也必须存在，并且User只能有一个Order。

有一个严格且不太严格的版本。从技术上讲，我刚刚描述了类似于1：{0或1}的关系。在实际的1：1关系中，如果Order存在，则要求 User存在。如果对方不存在，也不会存在。但是，在谈论关系数据库时，这种约束通常会放松（但只能在一个方向上 - 在这种情况下，如果没有Order，您仍然无法拥有User。

您可以使用以下代码对此关系进行建模：

public class User
{
    public Order Order { get; set; }
}

public class Order
{
    // You could put a reference here back to the User if you want...
}

请注意，仅为Order仅支持一个User有点奇怪。使其成为1:*更有意义。但如果这是你的任务要求，那么你就是这样做的。

1：*关系

这类似于1：1的关系。但它放宽了一些限制，因此如果存在类型A的实体，则可以存在任何类型B（包括零）的类型。示例是Order和OrderLine。同样，对于存在多少实体类型没有限制。 系统中可能有57个订单。如果没有OrderLine，您就无法拥有Order，每OrderLine可能会有多个Order。

您可以使用以下代码对此关系进行建模：

public class Order
{
    public List<OrderLine> OrderLines { get; set; }
}

public class OrderLine
{
    // You could put a reference here back to the Order if you want...
}

在代码中实施关系概念

我不能代表你的任务，所以请确保你支持我在这里所说的内容，反对你的任务要求。

您不应该在代码中尝试强制执行这样的基本关系概念。数据库更好，有更好的（声明性）语言来描述关系，并且将成为系统的最终数据源。

相反，你应该只做一个遵循关系的软模型（如上面的代码示例所做的那样），让数据库对这些约束进行真正的监管。

示例：

您不应该尝试在代码中限制Order类型的构造，并且您不应该要求User来构建Order（作为代码实体）。
您不应要求Order来创建OrderLine（作为代码实体）。

尝试在代码中加入这些限制条件无需购买任何东西。当您将实体持久保存到数据库时，数据库将为您确保这些关系（假设您已正确设置它，您将学会这样做）。您的错误将被捕获，您将学习很快避免这些类型错误的习惯。

试图在代码中加入这些限制会伤害你。编写程序会比较困难，为代码编写单元测试会更难。

例如，考虑比较OrderLine值的算法或测试。也许您希望它与假设的 OrderLine进行比较。如果您的代码中存在关系限制，则还必须创建一个假设的Order和User。您是否还将假设的User和Order与真实的User和Order进行比较？如果您的算法不关心它来自哪个{{1}}或{{1}}怎么办？如果你不打算比较它们，为什么要开始创建它们呢？

所以：别担心。轻松地模拟您的关系，以便在您的对象之间轻松导航，并让数据库为您进行严格的关系验证。

C Sharp Object仅在另一个类中创建和引用一个对象

4 个答案: