C#知识学习—13 字段，属性，索引器，常量

type

status

date

slug

summary

本节内容

字段

属性

索引器

常量

字段

什么是字段

字段（field）是一种标识与对象或类型（类与结构体）关联的变量

字段是类型的成员，旧称“成员变量”

与对象关联的字段亦称“实例字段”（修饰实例）

与类型关联的字段称为“静态字段”，由static修饰（修饰数据类型）

字段的声明

参见C#语言定义文档

尽管字段声明带有分号，但它不是语句

字段的名字一定是名词

字段的初始值

无显式初始化时，字段获得其类型的默认值，所以字段“永远都不会未被初始化”

实例字段初始化的时机–对象创建时

静态字段初始化的时机–类型被加载（load）时

只读字段

实例只读字段

静态只读字段

变量：存储数据

filed ：田地，空间。

语句出现在函数体里面，字段声明出现在类里


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            /*
              Student stu1 = new Student();
              stu1.Age = 40;
              stu1.Score = 90;
 
              Student stu2 = new Student();
              stu2.Age = 24;
              stu2.Score = 60;*/
 
            List<Student> students = new List<Student>();
            for (int i = 0; i < 100; i++)
            {
                Student student = new Student();
                student.Age = 24;
                student.Score = i;
                students.Add(student);
            }
            int totalAge = 0;
            int totalScore = 0;
            foreach (Student student in students)
            {
                totalAge += student.Age;
                totalScore += student.Score;
            }
            Student.AverageAge = totalAge / Student.Amount;
            Student.AverageScore = totalScore / Student.Amount;
 
 
 
            Student.RepoerAmount();
            Student.ReportAverageAge();
            Student.ReportAverageScore();
 
        }
    }
    class Student
    {
        public int Age;
        public int Score;
 
        public static int AverageAge;
        public static int AverageScore;
        public static int Amount;
 
        public Student()
        {
            Student.Amount++;
        }
        public static void RepoerAmount()
        {
            Console.WriteLine(Student.Amount);
        }
        public static void ReportAverageAge()
        {
            Console.WriteLine(Student.AverageAge);
        }
        public static void ReportAverageScore()
        {
            Console.WriteLine(Student.AverageScore);
        }
    }
}

实例构造器可以执行多次，静态构造器只执行一次


class Student
{
    public int Age;
    public int Score;
 
    public static int AverageAge;
    public static int AverageScore;
    public static int Amount;
 
    public Student()
    {
        Student.Amount++;
    }
    static Student() // 静态
    {
 
    }
 
}

readonly 只读，保存初始化后不能改变的值


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student(1);
            Console.WriteLine(Brush.DefaultColor.Red);
            Console.WriteLine(Brush.DefaultColor.Green);
            Console.WriteLine(Brush.DefaultColor.Blue);
            // 报错
            //Brush.DefaultColor = new Color() { Red = 0, Green = 0, Blue = 0 };
 
 
        }
    }
    class Student
    {
        public int Age;
        public int Score;
        public readonly int ID;
 
        public static int AverageAge;
        public static int AverageScore;
        public static int Amount;
 
        public Student(int id)
        {
            Student.Amount++;
            // 初始化
            this.ID = id;
        }
        static Student()
        {
 
        }
 
    }
    struct Color
    {
        public int Red;
        public int Green;
        public int Blue;
    }
    class Brush
    {
        // public static readonly Color DefaultColor = new Color() { Red = 0, Green = 0, Blue = 0 };
        public static readonly Color DefaultColor;// 换为静态构造函数
        static Brush()
        {
            Brush.DefaultColor = new Color() { Red = 0, Green = 0, Blue = 0 };
        }
    }
}

属性

什么是属性

属性（property）是一种用于访问对象或类型的特征的成员，特征反应了状态

属性是字段的自然扩展

从命名上看，field更偏向于实例对象在内存中的布局，property更偏向于反映现实世界对象的特征
对外：暴露数据，数据是可以存储在字段里的，也可以是动态计算出来的
对内：保护字段不被非法值“污染”

属性由Get/Set方法对进化而来

又一个“语法糖”–属性背后的秘密

属性的声明

完整声明–后台（back）成员变量与访问器（注意使用code snipaste和refactor工具）

简略声明–是有访问器（查看IL代码）

动态计算值的属性

注意实例属性和静态属性

属性的名字一定是名词

只读属性-- 只有getter没有setter

尽管语法上正确，几乎没有人使用"只读属性"，因为属性的目的主要是通过向外暴露数据而标识对象/ 类型的状态

属性与字段的关系

一般情况下，他们都用于表示实体（对象或类型）的状态

属性大多数情况下是字段的包装器（wrapper）

建议：永远使用属性（而不是字段）来暴露数据，即计算永远都是private或protected的


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu1 = new Student();
                stu1.Age = 20;
 
 
                Student stu2 = new Student();
                stu2.Age = 20;
 
                Student stu3 = new Student();
                stu3.Age = 20;
 
                int aveAge = (stu1.Age + stu2.Age + stu3.Age) / 3;
                Console.WriteLine(aveAge);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
        }
    }
    class Student
    {
        private int age;
        public int Age
        {
            get { return age; }
            set
            {
                // value上下文关键字
                if (value >= 0 && value <= 120)
                {
                    age = value;
                }
                else
                {
                    throw new Exception("Age value has error");
                }
            }
        }
 
        public int GetAge() { return age; }
        public void SetAge(int age)
        {
            if (age >= 0 && age <= 120)
            {
                this.age = age;
            }
            else
            {
                throw new Exception("Age value has error");
            };
        }
 
    }
}

快捷键 propfull


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student.Amount = 100;
                Console.WriteLine(Student.Amount);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
        }
    }
    class Student
    {
        private int age;
        //属性
        public int Age
        {
            get { return age; }
            set
            {
                // value上下文关键字
                if (value >= 0 && value <= 120)
                {
                    age = value;
                }
                else
                {
                    throw new Exception("Age value has error");
                }
            }
        }
        // 快捷键
        private static int amount;
 
        public static int Amount
        {
            get { return amount; }
            set
            {
                if (value >= 0)
                {
                    amount = value;
                }
                else
                {
                    throw new Exception("Amount must greater than 0");
                }
            }
 
 
        }
    }
}

简略声明，简单传递数据


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu = new Student();
                stu.Age = 1;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
        }
    }
    class Student
    {
        public int Age { get; set; }
    }
}

只读


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu = new Student();
                // stu.Age = 1; // 只读
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
        }
    }
    class Student
    {
 
        private int age;
 
        public int Age
        {
            // 只读方法
            get { return age; }
        }
 
        private int newAge;
 
        public int myNewAge
        {
            get { return newAge; }
            // 在Student 类内部可以访问
            private set { newAge = value; }
        }
        public void SomeMethod()
        {
            myNewAge = 20;
        }
 
    }
}

动态计算值的属性


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu = new Student();
                stu.Age = 42;
                Console.WriteLine(stu.CanWork);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
        }
    }
    class Student
    {
 
        private int age;
 
        public int Age
        {
            // 只读方法
            get { return age; }
            set
            {
                if (age >= 0 && age <= 120)
                {
                    this.CalculateCanWork1();
                    this.age = age;
                }
                else
                {
                    throw new Exception("Age value has error");
                };
            }
        }
        public bool CanWork
        {
            get
            {
                if (age >= 16)
                {
                    return true;
                }
                return false;
            }
        }
        private bool canWork1;
        public bool CanWork1 { get { return canWork1} }
        private void CalculateCanWork1()
        {
            if (this.age>=16)
            {
                this.canWork1 = true;
            }
            else
            {
                this.canWork1 = false;
 
            }
        }
    }
}

索引器（概述）

什么是索引器

索引器（indexer）是这样一种成员：它使对象能够用与数组相同的方式（即使用下标）进行索引

索引器的声明

参见C#语言定义文档

注意：没有静态索引器

快捷键：index+Tab*2

可空类型点Value才是这个类型真正的值


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            var mathScore = stu["math"];
            Console.WriteLine(mathScore==null);
            stu["math"] = 90;
            Console.WriteLine(stu["math"]);
        }
    }
    class Student
    {
        private Dictionary<string, int> scoreDictionary = new Dictionary<string, int>();
        public int? this[string subject]
        {
            get
            {
                /* return the specified index here */
                if (scoreDictionary.ContainsKey(subject))
                {
                    return scoreDictionary[subject];
                }
                else
                {
                    return null;
                }
            }
            set {
                if (value.HasValue==false)
                {
                    throw new Exception(" Score cannot be null");
 
                }
                /* set the specified index to value here */
                if (scoreDictionary.ContainsKey(subject))
                {
                    scoreDictionary[subject] = value.Value;
                }
                else
                {
                    scoreDictionary.Add(subject, value.Value);
                }
            }
        }
    }
}

常量

什么是常量

常量（constant）是标识常量值（即,可以在编译时计算的值）的类的成员

常量隶属于类型而不是对象，即没有“实例常量”

“实例常量”的角色由只读实例字段来担当

注意区分成员常量和局部常量

常量的声明

各种“只读”的应用场景

为了提高程序可读性和执行效率–常量

为了防止对象的值被改变–只读字段

向外暴露不允许修改的数据–只读属性（静态或非静态），功能和常量有一些重叠

当希望成为常量的值其类型不能被常量声明接受时（类/自定义结构体）–静态只读字段


namespace ConsoleApp4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(int.MaxValue);
           // 局部常量
            const int x = 100;
            Console.WriteLine(MyClass.url);
 
 
        }
        static double GetArea(double r)
        {
            // 成员常量
            double a = Math.PI * r * r;
            return a;
        }
    }
    class MyClass
    {
        // 成员常量
        public const string url = "MyClass";
    }
}