【C#本质论六】类-从设计的角度去认知（封装）（下）-阿里云开发者社区

属性作为虚字段

属性还能这么玩儿：属性可以不支持字段，也就是当做虚字段玩儿，也就是根本没往内存中写入Name这个字段值！属性被当成方法实现了，其实不太建议这么玩儿。

namespace AddisonWesley.Michaelis.EssentialCSharp.Chapter06.Listing06_22
{
    using System;
    using System.IO;
    public class Program
    {
        public static void Main()
        {
            Employee employee1 = new Employee();
            employee1.Name = "Inigo Montoya";
            System.Console.WriteLine(employee1.Name);
            // ...
        }
    }
    class Employee
    {
        // FirstName property
        public string FirstName
        {
            get
            {
                return _FirstName;
            }
            set
            {
                _FirstName = value;
            }
        }
        private string _FirstName;
        // LastName property
        public string LastName
        {
            get => _LastName;
            set => _LastName = value;
        }
        private string _LastName;
        // ...
        // Name property
        public string Name
        {
            get
            {
                return $"{ FirstName } { LastName }";
            }
            set
            {
                // Split the assigned value into 
                // first and last names
                string[] names;
                names = value.Split(new char[] { ' ' });
                if(names.Length == 2)
                {
                    FirstName = names[0];
                    LastName = names[1];
                }
                else
                {
                    // Throw an exception if the full 
                    // name was not assigned
                    throw new System.ArgumentException(
                        $"Assigned value '{ value }' is invalid",
                        "value");
                }
            }
        }
        public string Initials => $"{ FirstName[0] } { LastName[0] }";
        // Title property
        public string Title { get; set; }
        // Manager property
        public Employee Manager { get; set; }
    }
}

由此引发的思考就是：为啥不能用ref和out来修饰属性呢，你想啊，如果属性被当成虚字段使，内存中根本没地址，怎么传递地址啊，ref是需要初始化的，你这就相当于没有初始化字段。

属性的内部构造

事实上，通过观察IL代码，属性就是一种方法实现，我可以理解其为一种语法糖：

构造器和终结器

其实构造函数都比较熟悉了，就聊一点儿需要注意的地方：

构造函数赋值优先于字段声明赋值，所以构造函数的赋值会覆盖字段声明赋值
C#编译器默认支持无参构造函数，一旦显式添加，即使是手动添加无参的，编译器也不会再提供默认的

构造函数可以重载，一个使用规范是：要优先调用可选参数的方法而不是重载。

对象初始化器

对象初始化器，其实就是一种语法糖，需要注意的是，初始化时会按顺序赋值：

public static void Main()
        {
            Employee employee = new Employee("Inigo", "Montoya") 
                { Title = "Computer Nerd", Salary = "Not enough" };
        }

同样集合初始化器也一个道理，注意，会按顺序添加哦！

构造函数链

构造函数可以互相调用，避免代码冗余：

public class Employee
    {
        public Employee(string firstName, string lastName)
        {
            FirstName = firstName;
            LastName = lastName;
        }
        public Employee(
            int id, string firstName, string lastName)
            : this(firstName, lastName)  //实际情况是参数少的调用参数多的
        {
            Id = id;
        }
        public Employee(int id)
        {
            Id = id;
        }
        public int Id { get; private set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Salary { get; set; } = "Not Enough";
        // ...
    }

通常做法是这样的：

public Employee(string firstName, string lastName):this(firstName, lastName,"add")
        {
            FirstName = firstName;
            LastName = lastName;
        }
        public Employee(string firstName, string lastName,string test=null) 
        {
            FirstName = firstName;
            LastName = lastName;
        }

注意：调用方的参数一定要包含被调用方的全部参数！，例如这样调用：

集中初始化和解构函数

集中初始化没什么好说的，就是把所有属性参数什么的在一个函数里一次性初始化，通常是构造函数。而解构函数就是通过Deconstruct方法：

public void Deconstruct(
            out int id, out string firstName, 
            out string lastName, out string salary)
        {
           (id, firstName, lastName, salary) = 
                (Id, FirstName, LastName, Salary);
        }

调用的时候：

employee.Deconstruct(out id, out firstName,out lastName, out salary);

C#7.0后支持直接将对象解构为元组，无需方法调用：

(_,firstName,lastName,salary) = employee

静态

静态字段、方法已经在前文说明了，这里简单说一下其特性：

静态字段的作用域为其所属的类。
无论是方法（静态、实例）还是字段（静态、实例），都不能同名，方法重载除外，是说这四种都不能重名！
和普通构造函数一样，静态构造函数赋值优先于静态字段声明！
静态类不包含任何实例成员：包括字段、方法等。

有个地方需要注意：最好在声明时进行静态初始化（而不要使用静态构造函数）：静态构造函数在首次访问类的任何成员之前执行，无论该成员是静态字段，是其他静态成员，还是实例构造函数。为支持这个设计，编译器添加代码来检查类型的所有静态成员和构造函数，确保首先运行静态构造函数。如果没有静态构造函数，编译器会将所有静态成员初始化为它们的默认值，而且不会添加对静态构造函数的检查。结果是静态字段会在访问前得到初始化，但不一定在调用静态方法或任何实例构造函数之前。有时对静态成员进行初始化的代价比较高，而且访问前确实没必要初始化，所以这个设计能带来一定的性能提升。有鉴于此，请考虑要么以内联方式初始化静态字段（而不要使用静态构造函数），要么在声明时初始化。

局部变量、实例字段和静态字段

局部变量如果使用前没有赋值会报错，静态字段则会使用默认值，实例字段如果在对象生成后也会使用默认值：

静态方法和实例方法

实例方法可以直接调用静态方法，静态方法不能通过this调用实例方法，只能实例化一个对象，再调用实例方法：

public static void fecond()
        {
            Class1 ct = new Class1();
            ct.second();
        }

const和readonly

const就是常量的意思，默认为静态字段，而且只限于字面值类型（int，long，string）。此时再声明static反而会报错。而readly也可以用来声明字段，值得注意的是，只能声明字段，而不能声明局部变量！readonly表明字段值只能从构造函数中修改或者初始化器指定，但其实只读自动属性一用，readonly就没啥用了。

扩展方法和特殊类

包括：扩展方法、嵌套类、分部类及分部方法：其实这一部分，我觉得可以用两个字概述：解耦，做的事情无非就是将耦合度降低。

扩展方法

扩展方法在上文提到过，感觉实则没有任何用处，需要注意的是，即使不在一个程序集的类也可以添加。

public class Program
    {
        public static void Main()
        {
            DirectoryInfo directory = new DirectoryInfo(".\\Source");
            directory.CopyTo(".\\Target",
                SearchOption.TopDirectoryOnly, "*");     
        }
    }
    public static class DirectoryInfoExtension
    {
        public static void CopyTo(
            this DirectoryInfo sourceDirectory, string target,
            SearchOption option, string searchPattern)  //扩展方法的声明，需要this关键字。
        {                   
        }
     }

嵌套类

一般类的访问修饰符可以定义为默认的internal 或者public，而内嵌类就有比较多的选择，可以是为protected、internal、public以及默认的private。嵌套类可以访问外部类的方法、属性、字段而不管访问修饰符的限制

namespace AddisonWesley.Michaelis.EssentialCSharp.Chapter06.Listing06_46
{
    using System;
    public class Program
    {
        // Define a nested class for processing the command line
        private class CommandLine
        {
            public CommandLine(string[] arguments)
            {
               //
            }
            public string Action;
            public string Id;
            public string FirstName;
            public string LastName;
        }
        public static void Main(string[] args)
        {
            CommandLine commandLine = new CommandLine(args);
        }
    }
}

分部类和分部方法

无非就是把类和方法分别放到不同的文件中去，

namespace AddisonWesley.Michaelis.EssentialCSharp
{
// We dont fully implement our switch block here
#pragma warning disable CS1522
    using System;
    // File: Program.cs
    partial class Program
    {
        static void Main(string[] args)
        {
            CommandLine commandLine = new CommandLine(args);
            switch(commandLine.Action)
            {
                // ...
            }
        }
    }
    // File: Program+CommandLine.cs
    partial class Program
    {
        // Define a nested class for processing the command line
        private class CommandLine
        {
            public CommandLine(string[] args)
            {
                //not implemented
            }
            // ...
            public int Action
            {
                get { throw new NotImplementedException(); }
                set { throw new NotImplementedException(); }
            }
        }
    }
#pragma warning restore CS1522
}

使用关键字partial ，这里就不深入探讨了。

本篇博客从学习到完成历时两天，感觉学到了特别多的干货和东西，最重要的就是从设计的角度去认知为什么要这么设计类，希望能帮助到大家。

【C#本质论六】类-从设计的角度去认知（封装）（下）

属性作为虚字段

属性的内部构造

构造器和终结器

对象初始化器

构造函数链

集中初始化和解构函数

静态

局部变量、实例字段和静态字段

静态方法和实例方法

const和readonly

扩展方法和特殊类

扩展方法

嵌套类

分部类和分部方法

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C#本质论 六】类-从设计的角度去认知（封装）（下）

属性作为虚字段

属性的内部构造

构造器和终结器

对象初始化器

构造函数链

集中初始化和解构函数

静态

局部变量、实例字段和静态字段

静态方法和实例方法

const和readonly

扩展方法和特殊类

扩展方法

嵌套类

分部类和分部方法

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C#本质论六】类-从设计的角度去认知（封装）（下）