C#语言入门详解笔记（7）—P17字段，属性，索引器，常量

最新推荐文章于 2023-07-19 16:52:30 发布
最新推荐文章于 2023-07-19 16:52:30 发布
阅读量342 收藏
点赞数
分类专栏： C# 学习 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31121227/article/details/112131273
版权
学习 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
C#
14 篇文章 4 订阅
订阅专栏

C#语言入门详解_哔哩哔哩_bilibiliC#语言入门详解搬运，随youtube上进度更新。刘老师的C#视频教程到30集就告一段落了，感谢刘老师在这5年间的付出。能上youtube的同学可以去刘老师的主页观看，https://www.youtube.com/channel/UCmvAggiJGwJGSzAtqFRBQ7g重新上传，修复31P无声音问题https://www.bilibili.com/video/BV1wx411K7rb目录

1、字段

1.1、什么是字段

1.2、字段的声明

1.3、字段的初始值

1.4、只读字段

2、属性

2.1、什么是属性

2.2、属性的声明

2.3、属性与字段的关系

 3、索引器（概述）

3.1、什么是索引器

3.2、索引器的声明

4、常量

4.1、什么是常量

4.2、常量的声明

4.3、各种“只读”的应用场景

1、字段

1.1、什么是字段

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

field：田地，地方的意思；表示在内存中开辟一块空间存放数据

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

例子：C语言程序——ID和Name就是字段

声明的时候一定要卸载类体里面，不能写在函数体中（函数体中叫局部变量）

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

帮助实例或者对象保存数据的，实例字段的组合是表示对象当前的状态

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

  • 静态字段表示某个数据类型当前的状态
  • 例子：实例字段和静态字段的功能
    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;     //实例的状态，年龄小，学习差

            //Student.ReportAmount();  //类型的状态，学生的数量

            List<Student> stuList = new List<Student>();
            for (int i = 0; i < 100; i++)
            {
                Student stu = new Student();
                stu.Age = 24;
                stu.Score = i;
                stuList.Add(stu);
            }

            int totalAge = 0;
            int totalScore = 0;
            foreach (var stu in stuList)
            {
                totalAge += stu.Age;
                totalScore += stu.Score;
            }

            Student.AverageAge = totalAge / Student.Amount;
            Student.AverageScore = totalScore / Student.Amount;

            Student.ReportAmount();       //类型的状态，学生的数量
            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++; //每次创建实例Amount都+1
        }

        public static void ReportAmount()
        {
            Console.WriteLine(Student.Amount);
        }

        public static void ReportAverageAge()
        {
            Console.WriteLine(Student.AverageAge);
        }
        public static void ReportAverageScore()
        {
            Console.WriteLine(Student.AverageScore);
        }
    }

1.2、字段的声明

（1）参见C#语言定义文档

field_declaration：
    attribute_{opt}（可选）  field-modifier_{opt}（字段修饰符，可选）  type variable_declarators（变量声明器） ;

field_modifier
    : 'new'
    | 'public'
    | 'protected'
    | 'internal'
    | 'private'
    | 'static'
    | 'readonly'
    | 'volatile'
    | field_modifier_unsafe
    ;

variable_declarators
    : variable_declarator (',' variable_declarator)*
    ;

variable_declarator
    : identifier ('=' variable_initializer)?
    ;

variable_initializer
    : expression
    | array_initializer
    ;

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

（3）字段的名字一定是名词

1.3、字段的初始值

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

（2）实例字段初始化的实际——对象创建时

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

两种设置初值的方法的等价的

当一个数据类型被加载时，静态构造器会被调用，只调用这一次。

1.4、只读字段

（1）实例只读字段

只读字段只有一次赋值机会，在实例构造器中初始化，之后无法被修改

class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student(1);
            Console.WriteLine(stu1.ID); 
        }
    }
    class Student
    {
        public readonly int ID;
        public int Age = 0;
        public int Score; 

        public Student(int id)
        {
            this.ID = id;
        }

    }

（2）静态只读字段

 类的静态只读字段。

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Brush.DefaultColor.Red);
            Console.WriteLine(Brush.DefaultColor.Green);
            Console.WriteLine(Brush.DefaultColor.Blue);
        }
    }

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

    static Brush //静态构造器
    {
        public static readonly Color DefaultColor = new Color() { Red = 0, Green = 0, Blue = 0 };
    }

2、属性

2.1、什么是属性

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

（2）属性是字段的自然扩展

  • 从命名上看，field更偏向于实例对象在内存中的布局，property更偏向于反映现实世界对象的特征

  • 对外：暴露数据，数据可以是存储在字段里的，也可以是动态计算出来的

  • 对内：保护字段不被非法值“污染”

（3）属性由Get/Set方法对进化而来（三个例子讲解进化过程）

  • 举例1：学生3年龄200污染了字段，但是从结果（平均年龄=80）看不出异常
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student();
            stu1.Age = 20;

            Student stu2 = new Student();
            stu2.Age = 20;

            Student stu3 = new Student();
            stu3.Age = 200;   //污染字段

            int avgAge = (stu1.Age + stu2.Age + stu3.Age) / 3;
            Console.WriteLine(avgAge);
        }
    }
    class Student
    {
        public int Age;
    }
  • 举例2：为了防止异常值污染，隐藏字段，用方法来设置。此时值不规范则会报错
class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu1 = new Student();
                stu1.SetAge(20);

                Student stu2 = new Student();
                stu2.SetAge(20);

                Student stu3 = new Student();
                stu3.SetAge(200);

                int avgAge = (stu1.GetAge() + stu2.GetAge() + stu3.GetAge()) / 3;
                Console.WriteLine(avgAge);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message); //打印异常
            }
        }
    }
    class Student
    {
        private int age; //隐藏字段，编程规范建议小写

        public int GetAge()
        {
            return this.age;
        }

        public void SetAge(int value)
        {
            if (value >= 0 && value <= 120)
            {
                this.age = value;
            }
            else
            {
                throw new Exception("Age value has error");
            }
        }
    }

运行结果：

  • 举例3：微软提供的便捷写法，get/set方法对
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 avgAge = (stu1.Age + stu2.Age + stu3.Age) / 3;
                Console.WriteLine(avgAge);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
    class Student
    {
        private int age; //隐藏字段，编程规范建议小写

        public int GetAge()
        {
            return this.age;
        }

        public int Age //微软提供的快捷写法
        {
            get 
            {
                return this.age; 
            }
            set 
            {
                if (value >= 0 && value <= 120)  //微软准备的value，叫上下文关键字
                {
                    this.age = value;
                }
                else
                {
                    throw new Exception("Age value has error");
                }
            }
        }
    }

（4）又一个“语法糖”——属性背后的秘密

“语法糖”：在编程语言中可能有一小段非常简单的逻辑，这段逻辑背后隐藏了比较复杂的逻辑；之所以做隐藏，是为了方便程序员编写程序；前面学过的foreach循环和这里的属性都是语法糖。

使用反编译器观察程序（没找到vs2019的反编译器）。视频50分钟。

2.2、属性的声明

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

property_declaration
    : attributes_{opt}  property-modifiers_{opt} type member_name property_body
    ;

property_modifier
    : 'new'
    | 'public'                      最常见的修饰符
    | 'protected'
    | 'internal'
    | 'private'
    | 'static'
    | 'virtual'
    | 'sealed'
    | 'override'
    | 'abstract'
    | 'extern'
    | property_modifier_unsafe
    ;

property_body
    : '{' accessor_declarations '}' property_initializer?
    | '=>' expression ';'
    ;

property_initializer
    : '=' variable_initializer ';'
    ;

（2）简略声明——只有访问器（查看IL代码）

完整声明和简略声明写法对比；

propfull，按两下tab键；prop，按两下tab键

    class Student
    {
        private int myVar;

        public int MyProperty
        {
            get { return myVar; }
            set { myVar = value; }
        }

    }
    class Student
    {
        public int MyProperty { get; set; }
    }

（3）动态计算值得属性

属性比字段更优越的地方就是这个。

//主动计算CanWork值
class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student stu1 = new Student();
                stu1.Age = 12;

                Console.WriteLine(stu1.CanWork);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }

    class Student
    {
        private int age;

        public int Age
        {
            get { return age; }
            set { age = value;
                this.CalculateCanWork();
            }
        }

        private bool canWork;

        public bool CanWork
        {
            get { return canWork; }
        }

        private void CalculateCanWork()
        {
            if (this.age>=16)
            {
                this.canWork = true;
            }
            else
            {
                this.canWork = false;
            }
        }
    }

（4）注意实例属性和静态属性

静态属性使用static修饰，属于类型而不是实例。

（5）属性的名字一定是名词

（6）只读属性——只有getter没有setter

  • 尽管语法上正确，几乎没有人使用“只写属性，因为属性得主要目的是通过向外暴露数据而表示对象/类型得状态”

2.3、属性与字段的关系

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

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

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

 3、索引器（概述）

3.1、什么是索引器

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

  •  索引器一般情况用在集合类型；

  • 初学者很少有机会写索引器。

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu["Math"] = 90;
            var mathScore = stu["Math"];
            Console.WriteLine(mathScore);
        }
    }
    class Student
    {
        private Dictionary<string, int> scoreDictionary = new Dictionary<string, int>();

        //int? 可空类型
        public int? this[string subject]
        {
            get {
                if (this.scoreDictionary.ContainsKey(subject)) //查找是否包含此科目
                {
                    return this.scoreDictionary[subject];       //如果包含就返回科目成绩
                }
                else
                {
                    return null;                                //不包含返回null
                }
            }
            set {
                if (value.HasValue == false)
                {
                    throw new Exception("Score cannot be null");    //  这一部是防止用户输入一个null值
                }

                if (this.scoreDictionary.ContainsKey(subject))
                {
                    this.scoreDictionary[subject] = value.Value;
                }
                else
                {
                    this.scoreDictionary.Add(subject, value.Value);   //如果不包含就创建科目并赋值
                }
            }
        }
    }

3.2、索引器的声明

（1）参见C#语言定义文档

（2）注意：没有静态索引器

4、常量

4.1、什么是常量

（1）常量（constant）是表示常量值（即，可以在编译时计算的值）的类成员

Math.PI就是一个常量；使用常量可以提高程序运行效率

int.MaxValue也是一个常量

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

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

（3）注意区分成员常量与局部常量

成员常量：Math.PI和int.MaxValue

局部常量：

        static void Main(string[] args)
        {
            const int x = 100;
        }

4.2、常量的声明

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(WASPEC.WebsiteURL);
        }
    }
    class WASPEC
    {
        public const string WebsiteURL = "https://www.baidu.com";
    }

 

 4.3、各种“只读”的应用场景

（1）为了提高程序可读性的执行效率——常量

（2）为了防止对象的值被改变——只读字段

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

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

曾小鱼一号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
17_字段、属性、索引器、常量
little__rookie的博客
04-06 86
字段（field）是一种表示与对象或类关联的变量的成员。 ● 对于实例字段，它初始化的时机是在实例创建时 ○ 声明实例字段时初始化值与在实例构造器里面初识化实例字段是一样的 ● 对于静态字段，它初始化的时机是在运行环境加载该数据类型时 ○ 即静态构造器初始化时 ○ 声明静态字段时设置初始化值与在静态构造器里面初始化静态字段其实是一样的 数据类型被运行环境加载时，它的静态构造器将会被调用，且只被调用一次。 什么是属性 当你这样写的时候，属性自带一个字段（或者说 自动属性/简略声明） public int P
第 17 节 字段、属性、索引器、常量
qq_48015123的博客
09-04 200
第17节 字段、属性、索引器、常量一级目录二级目录三级目录 类的成员 一级目录 二级目录 三级目录
C#学习笔记（十一）字段、属性、索引器、常量
xiaoyaolangwj的博客
04-02 443
字段、属性、索引器、常量：这四者放在一起：因为它们都表达数据。一个程序的本质就是：数据+算法。 C#的类型成员：类或者结构体。 1、字段 定义： 字段（field）是一种表示与对象或类型（类与结构体）关联的变量。定义中的两个关键字：对象 或者 类型。那么可以把字段分为两类： 与对象关联的字段：实例字段，因为对象是实例化出来的。表述每个对象个体的差异性。 与类型关联的字段：静态字段，由static修饰的，静止的。表述整个类的族群特性。 一个可适用于不同个体对象的差异性，实例化不同对象...
C#属性
weixin_39899255的博客
01-31 167
C# 属性在某一方面来说还是蛮好用的 VS自动属性快捷方式: prop //这个时候感觉和定义字段的时候差不多 public int MyProperty { get; set; } propg // 只读属性(get only) public int MyProperty { get; private set; } propfull //当想要执行多一点操作的时候，我一般用这个定义 private int myVar; public int MyProperty
C# 属性
最新发布
Liz的博客
07-19 1110
实例属性 静态属性 只读属性 动态计算属性值（主动计算+被动计算）
最新版axios入门教程——17.17-axios拦截器工作原理(Av756328321,P17).rar
11-07
在本教程中，我们将深入探讨 Axios 的拦截器机制，它是 Axios 的一个重要特性，允许我们在请求发送前或响应接收后执行额外的操作。 **1. Axios 拦截器的基本概念** 拦截器是 Axios 提供的一种功能，可以注册在请求...
用单片机制作的篮球比赛计时器
08-02
篮球比赛计时器是比赛中不可或缺的一部分，特别是在专业和业余赛事中。本文将深入探讨如何使用单片机技术来设计一个适用于篮球比赛的计时设备。单片机，全称为单片微型计算机，是一种集成电路，集成了CPU、内存、...
单片机学习之蜂鸣器驱动
01-20
　实验板中，单片机P17脚输出接Q1基极，通过控制Q1导通或截止来控制蜂鸣器上是否有电流，从而发出声音，要用单片机控制蜂鸣器发出不同频率的声音，采用无源的蜂鸣器，如果用有源蜂鸣器，可以会因为二种不同频率声音...
基础电子中的单片机学习之蜂鸣器驱动
10-21
在单片机实验中，通常会使用P17这样的IO口连接到三极管Q1的基极，通过控制三极管的导通和截止，来控制流经蜂鸣器的电流，进而实现声音的开关。对于想要通过单片机控制蜂鸣器发出不同频率声音的应用，无源蜂鸣器更为...
H3C无线控制器产品 配置指导(E3703P61_R2509P61_R3709P61_R2609P61_R3509P61_R3120P17)-6W108.chm
08-08
H3C无线控制器产品 配置指导(E3703P61_R2509P61_R3709P61_R2609P61_R3509P61_R3120P17)-6W108
propfull.snipt
09-20
Visual studio 2008 本身不带 代码段 propfull. 找了一圈。发现这个文件。有需要的可以下载 主要完成下面的功能，写类的时候非常有用哦。 private int myVar; public int MyProperty { get { return myVar; } set { myVar = value; } }
C#程序设计基础教程与实训_15.modifier
07-09
　　初学者在学习程序的过程中很重要的一个学习方法就是读源代码，但如果对语言本身的了解不够，在阅读源码的过程中会遇到很大的困难。磨刀不误砍柴功，制作《C#语言参考视频》教程的目的在于帮助初学者打下坚实的语言基础，降低程序学习的难度。<br><br>　　本教程由广西机电职业技术学院的陈广老师录制，供学生课后自学用，教程以手把手的方式，通过简单实例入手，层层深入，对C#语言进行了详细而全面地讲解。<br>本教程面向的对象为：<br>1、看过一些初级C#教程，对基本语法，三大结构理解没有困难的人员。<br>2、学习过其它语言，想转入到C#进行学习的人员。
17 字段，属性，索引器，常量
yyOOOOO的博客
11-12 928
字段 1 什么是字段 ·字段（field）是一种表示与对象或类型（类或结构体）关联的变量 ·字段是类型的成员，旧称“成员变量” ·与对象关联的字段亦称“实例字段”（实例字段的组合是用来表示对象当前的状态） 对于实例字段而言，初始化的时机是在实例被创建的时候（每次创建实例都可以执行初始化） 即实例构造函数执行的时候 ·与类型关联的字段称为“静态字段”，由static修饰（静态字...
C#面向对象学习总结
run__ning的博客
12-16 509
对事物进行分析和总结，抽象出共同的特征和行为，封装成类，再把类进行实例化。这种设计思想就叫面向对象。方法重载：方法名相同，参数的类型不同，或者参数的个数不同 方法重载的作用：少取方法名，构造方法是给属性赋初始值，文件读写基本步骤FileStream fs=new FileStream("Path",FileMode.枚举值,FileAccess.枚举值);
C# 封装
祈离的专栏
12-24 3749
 面向对象思想有三个核心要素：封装、继承与多态。如能正确理解这三要素，那么基本上可以算是在编程中建立了面向对象思想。在第二节中我曾介绍，在C#中，所有数据类型的实例都是“对象”，不过最能体现对象特质的类型，还是“类”，同时它也是C#中最重要、最频繁使用的类型。接下来，我将通过介绍C#的类，来充分理解对象封装的概念。所谓“对象”，形象地说，我们可以把它理解为一块积木。设计积木的人需要设计
C#中“public string Name { get； set； }”什么意思？
热门推荐
lzzw的学习之路
01-20 2万+
在工作看到这样一段代码： public class PlacementPoint { public PlacementPoint(); public PlacementPoint(object value); public string Name { get; set; } public object Value { get; set; } public bool IsPort { get; set; }.
C#中类的属性访问器--get和set分析
小宇飞刀的BLOG
02-13 3708
解释一： 属性的访问器包含与获取（读取或计算）或设置（写）属性有关的可执行语句。访问器声明可以包含 get 访问器或 set 访问器，或者两者均包含。声明采用下列形式之一： get { ... } set { ... } get 访问器 get 访问器体与方法体相似。它必须返回属性类型的值。执行 get 访问器相当于读取字段的值。以下是返回私有字段 name 的值的 get...
C# 实用快捷键
余道长的博客
05-06 397
Propfull Tab Tab private int myVar; public int MyProperty { get { return myVar; } set { myVar = value; } } Prop Tab Tab public int MyProperty { get; set; } ..

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值