在本文中，我们展示了如何在C#中创建和使用对象。
对象是C#程序的基本构建块。
对象是数据和方法的组合。数据和方法称为对象的成员。在C#中，所有类型都是对象。
对象是从模板创建的。模板是用class、struct或record关键字定义的。我们说我们从这些创建对象实例模板。
对象的属性和方法使用点运算符访问。构造函数是用于创建对象的专门方法。
C#结构对象
结构是一种值类型。该类型是用struct关键字定义的。结构旨在表示点、矩形、颜色等轻量级对象。
var p = new Point(2, 5);
Console.WriteLine(p);
public struct Point
{
private int x;
private int y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public override string ToString()
{
return $"Point x:{x}, y:{y}";
}
}
在程序中，我们从Point结构中创建了一个轻量级对象。我们还覆盖了ToString方法，它提供了对象的人类可读表示。
$ dotnet run Point x:2, y:5
原始类型是对象
C#原始类型是对象。在引擎盖下，它们是结构。
float x = 12.3f; int y = 34; bool z = false; Console.WriteLine(x.GetType()); Console.WriteLine(y.GetType()); Console.WriteLine(z.GetType()); Console.WriteLine(y.Equals(34));
我们将三种基本类型分配给三个变量。
Console.WriteLine(x.GetType()); Console.WriteLine(y.GetType()); Console.WriteLine(z.GetType()); Console.WriteLine(y.Equals(34));
float、int和bool类型是对象。我们对这些对象调用GetType和Equals方法。
C#对象的ToString方法
每个对象都有一个ToString方法。它返回一个对象的人类可读表示。默认实现返回Object类型的完全限定名称。请注意，当我们使用对象作为参数调用Console.WriteLine方法时，将调用ToString。
var b = new Being();
var o = new Object();
Console.WriteLine(o.ToString());
Console.WriteLine(b.ToString());
Console.WriteLine(b);
class Being
{
public override string ToString()
{
return "This is Being class";
}
}
我们有一个Being类，我们在其中覆盖了ToString方法的默认实现。
public override string ToString()
{
return "This is Being class";
}
创建的每个类都继承自基础对象。ToString方法属于这个对象类。我们使用override关键字来通知我们正在覆盖一个方法。
var b = new Being(); var o = new Object();
我们创建了一个自定义对象和一个内置对象。
Console.WriteLine(o.ToString()); Console.WriteLine(b.ToString());
我们对这两个对象调用ToString方法。
Console.WriteLine(b);
正如我们之前指定的，将对象作为参数传递给Console.WriteLine将调用其ToString方法。这次，我们隐式调用了该方法。
$ dotnet run System.Object This is Being class This is Being class
C#对象属性
对象属性是捆绑在类实例中的数据。对象属性称为实例变量或成员字段。实例变量是在对象模板中定义的变量，模板中的每个对象都有一个单独的副本。
var u1 = new User();
u1.name = "John Doe";
u1.occupation = "gardener";
var u2 = new User();
u2.name = "Roger Roe";
u2.occupation = "driver";
Console.WriteLine(u1);
Console.WriteLine(u2);
class User
{
public string? name;
public string? occupation;
public override string ToString()
{
return $"{name} is a {occupation}";
}
}
我们有一个包含两个成员字段的User类。
class User
{
public string? name;
public string? occupation;
public override string ToString()
{
return $"{name} is a {occupation}";
}
}
我们声明了姓名和职业成员字段。public关键字指定成员字段可在类块外访问。
var u1 = new User(); u1.name = "John Doe"; u1.occupation = "gardener";
我们创建了一个User类的实例并设置了name和occupation属性。我们使用点运算符来访问对象的属性。
Console.WriteLine(u1); Console.WriteLine(u2);
我们将两个用户对象打印到控制台。
$ dotnet run John Doe is a gardener Roger Roe is a driver
C#对象方法
方法是在对象模板主体内定义的函数。它们用于对我们对象的属性执行操作。
var c = new Circle();
c.SetRadius(5);
Console.WriteLine(c.Area());
class Circle
{
private int radius;
public void SetRadius(int radius)
{
this.radius = radius;
}
public double Area()
{
return this.radius * this.radius * Math.PI;
}
}
在代码示例中，我们有一个Circle类。我们定义了两种方法。
private int radius;
我们有一个成员字段。它是圆的半径。private关键字是访问说明符。它表明该变量仅限于外部世界。如果我们想从外部修改这个变量，我们必须使用公开可用的SetRadius方法。
public void SetRadius(int radius)
{
this.radius = radius;
}
这是SetRadius方法。this变量是一个特殊的变量，我们用它来访问方法中的成员字段。this.radius是一个实例变量，而radius是一个局部变量，只在SetRadius方法内部有效。
var c = new Circle(); c.SetRadius(5);
我们创建了一个Circle类的实例，并通过调用圆对象上的SetRadius方法来设置它的半径。我们使用点运算符来调用该方法。
public double Area()
{
return this.radius * this.radius * Math.PI;
}
Area方法返回圆的面积。Math.PI是一个内置常量。
$ dotnet run 78.5398163397448
C#对象构造函数
构造函数用于初始化字段。
var name = "Lenka";
var dob = new DateTime(1990, 3, 5);
var u = new User(name, dob);
Console.WriteLine(u);
class User
{
private DateTime Born;
private string Name;
public User(string Name, DateTime Born)
{
this.Name = Name;
this.Born = Born;
}
public override string ToString() =>
$"{this.Name} was born on {this.Born.ToShortDateString()}";
}
User类有一个构造函数。
var u = new User(name, dob);
我们创建了User对象，给它的构造函数传递了两个值。这是调用对象的构造函数的时候。
public User(string Name, DateTime Born)
{
this.Name = Name;
this.Born = Born;
}
在构造方法中，我们初始化了两个属性：Name和Born。由于属性和构造函数参数的名称相同，因此this关键字是必需的。用于引用类的属性。
$ dotnet run Lenka was born on 3/5/1990
C#对象自动实现的属性
C#具有自动实现或自动属性。使用自动属性，编译器透明地为我们提供支持字段。
var u = new User();
u.Name = "John Doe";
u.Occupation = "gardener";
Console.WriteLine($"{u.Name} is a {u.Occupation}");
struct User
{
public string? Name { get; set; }
public string? Occupation { get; set; }
}
这段代码要短得多。我们有一个User结构，其中有两个属性：Name和Occupation。
var u = new User();
u.Name = "John Doe";
u.Occupation = "gardener";
Console.WriteLine($"{u.Name} is a {u.Occupation}");
我们通常像往常一样使用这些属性。
public string? Name { get; set; }
public string? Occupation { get; set; }
这里我们有两个自动属性。没有访问器的实现，也没有成员字段。编译器为我们自动生成它们。
$ dotnet run John Doe is a gardener
C#对象解构
解构是将类型拆包成单个部分；例如，将元组放入其项目或将对象放入其属性。
要解构类实例，我们必须实现Deconstruct方法。
var u = new User("John", "Doe", "gardener");
var (fname, lname, occupation) = u;
Console.WriteLine($"{fname} {lname} is a(n) {occupation}");
var (fn, ln) = u;
Console.WriteLine($"{fn} {ln}");
class User
{
string FirstName { get; set; }
string LastName { get; set; }
string Occupation { get; set; }
public User(string fname, string lname, string occupation)
{
FirstName = fname;
LastName = lname;
Occupation = occupation;
}
public void Deconstruct(out string fname, out string lname)
{
fname = FirstName;
lname = LastName;
}
public void Deconstruct(out string fname, out string lname,
out string occupation)
{
fname = FirstName;
lname = LastName;
occupation = Occupation;
}
}
我们可以有多个Deconstruct方法。
var u = new User("John", "Doe", "gardener");
var (fname, lname, occupation) = u;
在这里，我们将User类型解构为三个变量。
var (fn, ln) = u;
Console.WriteLine($"{fn} {ln}");
在这里，我们将用户解构为两个变量。
public void Deconstruct(out string fname, out string lname)
{
fname = FirstName;
lname = LastName;
}
被解构的变量有out修饰符。
$ dotnet run John Doe is a(n) gardener John Doe
C#记录对象
记录是一种引用类型，其主要目的是保存数据。记录允许我们快速创建对象。
var users = new List<User>
{
new ("John", "Doe", 1230),
new ("Lucy", "Novak", 670),
new ("Ben", "Walter", 2050),
new ("Robin", "Brown", 2300),
new ("Amy", "Doe", 1250),
new ("Joe", "Draker", 1190),
new ("Janet", "Doe", 980),
new ("Albert", "Novak", 1930),
};
users.ForEach(Console.WriteLine);
Console.WriteLine(users[0].FirstName);
Console.WriteLine(users[0].LastName);
Console.WriteLine(users[0].Salary);
record User(string FirstName, string LastName, int Salary);
在示例中，我们有一个Userobject.s列表
var users = new List<User>
{
new ("John", "Doe", 1230),
new ("Lucy", "Novak", 670),
new ("Ben", "Walter", 2050),
new ("Robin", "Brown", 2300),
new ("Amy", "Doe", 1250),
new ("Joe", "Draker", 1190),
new ("Janet", "Doe", 980),
new ("Albert", "Novak", 1930),
};
创建对象列表。当类型已知时，目标类型的新表达式不需要构造函数的类型规范。编译器从赋值操作的左侧推断类型。
Console.WriteLine(users[0].FirstName); Console.WriteLine(users[0].LastName); Console.WriteLine(users[0].Salary);
我们使用点运算符访问记录对象的三个属性。
record User(string FirstName, string LastName, int Salary);
记录在一行中定义。一条记录为我们自动生成几个方法，包括Object.Equals和Object.ToString。
$ dotnet run
User { FirstName = John, LastName = Doe, Salary = 1230 }
User { FirstName = Lucy, LastName = Novak, Salary = 670 }
User { FirstName = Ben, LastName = Walter, Salary = 2050 }
User { FirstName = Robin, LastName = Brown, Salary = 2300 }
User { FirstName = Amy, LastName = Doe, Salary = 1250 }
User { FirstName = Joe, LastName = Draker, Salary = 1190 }
User { FirstName = Janet, LastName = Doe, Salary = 980 }
User { FirstName = Albert, LastName = Novak, Salary = 1930 }
John
Doe
1230
在本文中，我们使用了C#中的对象。
列出所有C#教程。
