C# 在同一类的构造函数中传递类的对象

如何使用say StudentId=1和Name=“Alex”初始化这样的类

---

您可以添加另一个手动提供值的构造函数：

public Student(int id, string name)
{
    StudentId = id;
    Name = name;
}

---

初始代码不起作用的原因是，当您创建一个需要另一个相同类型实例的对象时，依赖关系链会无限大，并且您永远不会有一个起点

---

通过使用手动构造函数，您可以手动创建一个起点，换句话说，一个其他对象可以依赖的初始对象。因此，您消除了无限依赖链。

您不能像这样初始化一个类：它需要一个自身的实例才能被初始化，这是一个鸡和蛋的问题

请注意，您不能构造派生类并将其传递给

学生的构造函数，因为派生类必须调用复制构造函数

解决此问题的唯一方法是添加一个与现有构造函数不同的构造函数，并调用它：

public Student(int id, string name) {
    StudentId = id;
    Name = name;
}

或添加默认构造函数，并使用属性初始值设定项调用它：

public Student() {}
...
var student = new Student {Id = 1, Name = "Alex" };

您需要某种方法在没有构造函数的情况下初始化对象。因此，使用带有内联初始化的默认构造函数来创建初始student，然后允许您使用它的现有实例创建其他
student
对象

using System;

public class Program
{
    public static void Main()
    {
        var s = new Student {
            StudentId = 1,
            Name = "Alex"
        };

        var s2 = new Student(s);

        Console.WriteLine(s2.StudentId);
        Console.WriteLine(s2.Name);
    }
}

class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }

    public Student() {}

    public Student(Student student)
    {
        StudentId = student.StudentId;
        Name = student.Name;
    }
}

您的代码令人困惑，您只需要传入构造函数参数而不是对象，但按照您尝试的方式，您需要在主程序中创建的实例上设置第一个属性，然后像这样传递实例，但您还需要添加一个无参数构造函数：

class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }

    // Note: parameterless constructor here
    public Student()
    {


    }

    public Student(Student student)
    {
        StudentId = student.StudentId;
        Name = student.Name;
    }
}
static void Main(string[] args)
{
        Student s = new Student(); // parameter less constructor
        s.StudentId = 1;
        s.Name = "Alex";

       Student s2 = new Student(s);
}

但请注意这将使您的代码能够编译甚至工作，但这对于做简单的事情来说是太多额外的东西，而且内存效率不高，因为我们创建了一个额外的实例，根本不需要它

因此，您只需要在构造函数中为
StudentId
和
Name
等设置参数

这样，您的构造函数看起来像：

public Student(int studentId, string name)
{
    StudentId = studentId;
    Name = name;
}

希望它能给你解决这个问题的方法

谢谢
 
公共班级学生
public class Student
{ 
  public int Id {get; set;}
  public string Name {get; set; }

  public Student(object o) 
  {
    Student student = o as Student;
    if (student != null)
    {
       Id = student.Id;
       Name = student.Name;
    }

    // other cases to build a User copy
    string json = o as string;
    if (json != null) 
    {
         Student student = JsonConvert.Deserialize<Student>(json);
         Id = student.Id;
         Name = student.Name;
    }

  }

  public Student() 
      : this(null)
  {

  }

  public Student(int id, string name) 
      this(null)
  {
      Id = id;
      Name = name;
  }
}



static void Main(string[] args) 
{
     Student student = new Student(7634, "Jim");

     // build a copy
     Student copy = new Student(student);
}

{ 
公共int Id{get；set；}
公共字符串名称{get；set；}
公立学生（对象o）
{
学生=o为学生；
如果（学生！=null）
{
Id=student.Id；
Name=student.Name；
}
//生成用户副本的其他情况
字符串json=o作为字符串；
if（json！=null）
{
Student=JsonConvert.Deserialize（json）；
Id=student.Id；
Name=student.Name；
}
}
公立学生（）
：此（空）
{
}
公立学生（整数id，字符串名称）
此（空）
{
Id=Id；
名称=名称；
}
}
静态void Main（字符串[]参数）
{
学生=新生（7634，“吉姆”）；
//复制
学生副本=新学生（学生）；
}
让一个类的唯一构造函数需要该类的一个实例是没有意义的，为了使用它，您肯定需要其他类型的构造函数（否则您永远无法创建该初始实例）

但是，有一件事是有意义的，那就是使用一个从现有类创建类的新实例

下面的示例没有定义任何显式构造函数，因此使用默认构造函数并显式设置类值：

class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }

    public static Student CreateFrom(Student student)
    {
        return new Student { StudentId = student.StudentId, Name = student.Name };
    }
}

要使用此方法，请首先创建学生：

var studentOne = new Student { StudentId = 1, Name = "Bob"};

然后，要从这个学生创建一个新学生，我们可以调用静态方法：

var studentTwo = Student.CreateFrom(studentOne);


但是现在我们有两个学生具有相同的Id。也许这不是我们真正想要的，所以最好有一个只读的
StudentId
，它可以从一个私有的静态备份字段自动设置。我们可以使用一个对象来确保我们不会将同一id分配给多个学生。我们还可以覆盖
ToString
方法，以便它显示学生的Id和姓名：

class Student
{
    // This lock object is used to ensure we don't 
    // assign the same Id to more than one student
    private static readonly object IdLocker = new object();

    // This keeps track of next available student Id
    private static int nextStudentId;

    // Read only
    public int StudentId { get; }

    public string Name { get; set; }

    // Default constructor automatically sets the student Id
    public Student()
    {
        lock (IdLocker)
        {
            // Assign student id and incrment the next avaialable
            StudentId = nextStudentId;
            nextStudentId++;
        }
    }

    public static Student CreateFrom(Student student)
    {
        return new Student { Name = student.Name };
    }

    public override string ToString()
    {
        return $"Student {StudentId}: {Name}";
    }
}

现在我们不需要设置id，我们可以看到它会自动为我们递增：

private static void Main()
{
    var studentOne = new Student { Name = "Bob" };
    var studentTwo = Student.CreateFrom(studentOne);

    Console.WriteLine(studentOne);
    Console.WriteLine(studentTwo);

    Console.Write("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}

输出

嗯，您需要一些默认构造函数，否则，
var s=new Student（）{StudentId=1，Name=“Alex”}
所说的“手动”构造函数是指不需要类实例的构造函数吗？我以前从未听说过“手动构造器”这个词。即使添加一个显式的默认构造函数也可以解决这个问题。@RufusL请原谅我的术语，我的意思是一个构造函数，您可以手动设置值，从而手动设置它。如果它有一个正式的术语，我会很高兴如果你让我知道，这样我可以编辑我的答案。哦，我明白了。我只听说过“默认构造函数”，它不接受任何参数。我只是想知道这是不是一个新学期。
private static void Main()
{
    var studentOne = new Student { Name = "Bob" };
    var studentTwo = Student.CreateFrom(studentOne);

    Console.WriteLine(studentOne);
    Console.WriteLine(studentTwo);

    Console.Write("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}