C 尖锐对象 在另一个类中仅创建和引用 1 个对象

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;
            }
        } 
    }
}

您可以有一个 Order 类和一个 OrderLine 类。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
{
}

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

class OrderLine
{
      //some code
}

class Order
{
     List<OrderLine> lstOrderLine;
     //some code
}

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

编辑：删除了尖刻和态度:)

首先，您需要一个订单(提示您将需要一个类(。现在，订单需要向用户展示。因此，添加一个类型为用户的字段。这照顾了一个订单一个用户。(请注意，用户可以下多个订单(

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

编辑：有人提出了"添加字段"是什么意思的问题。添加字段表示添加属性或私有成员。当你这样做时，你是在做构图的技术术语。组合通常被解释为"具有"关系。因此，订单"有一个用户"和"有一个订单行列表">

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());

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

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

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

那么，让我们谈谈关系的类型。

关系类型

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

1

：1 关系

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

对此有一个严格和不那么严格的版本。 从技术上讲，我只是描述了类似 1：{0 或 1} 的关系。 在真正的 1：1 关系中，如果User存在，您将要求Order存在。 如果另一个不存在，两者都不可能存在。 然而，在谈论关系数据库时，这种约束通常是放宽的(但仅限于一个方向 - 在这种情况下，如果没有User，您仍然无法拥有Order(。

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

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 个订单。 你只是不能有没有Order的OrderLine，而且每个Order可能有多个OrderLine。

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

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怎么办？ 如果您不打算比较它们，为什么还要费心创建它们呢？

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