C#基础-4

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace Wrox2
{
    //什么是强类型语言
    //一种强制类型定义的语言，一旦某一个变量被定义类型，如果不经过强制转换，则它永远就是该数据类型了，强类型语言包括Java、.net 、Python、C++等
    // 举个例子：定义了一个整数，如果不进行强制的类型转换，则不可以将该整数转化为字符串。


    //什么是弱类型语言
    //一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。弱类型语言包括vb 、PHP、javascript等
    class Program
    {
        static void Fex1()
        {
            var A = 6;
            var B = "6";
            //SumResult = A + B;
           // MinResult = A - B；
        }
        
    }

    //类和结构
    //其实都是创建对象得模板，每个对象都包含数据，和提供了处理和访问数据得方法
    //类定义了类的每个对象（实例）可以包含什么数据和功能
    //试下
    class PhoneCustoment
    {
        public const string DayofsendingBill = "Monday";
        public int CustomerID;
       // public string CustomerName;
        public string FirstName;    
        public string LastName;
    }//一个类表示一个顾客，定义字段包含顾客信息，并可以实例化类的一个对象
    //结构与类不同的地方就是结构不需在堆上分配空间，直接存储在栈上，并且结构不支持继承
    struct PhoneCustomerStruct
    {
        public const string DayofSendingBill = "Monday";
        public int CustomerID;
        public string FirstName;
        public string LastName;
    }

    //对于类和结构，都是使用NEW来声明实例，创建对象并对其初始化
    class PhoneCus
    {
        static void Main()
        {
            var myCu = new PhoneCustoment();
            var myCustomer2 = new PhoneCustomerStruct();

        }

    }
    class Program2
    {
        //类包含成员，可以是静态（static）或实例成员，静态属于类，实例属于对象。静态字段对每个对象都是相同的，而实例字段都可以有不同的值
        //成员种类
        //字段：是类的数据成员，他是类型的一个变量，该类型是类的一个成员
        //常量：与类相关，编译器使用真实值代替常量
        //方法：与特定类相关的函数
        //属性：可从客户端访问的函数，方式与类的公共字段相似
        //构造函数：在实例化对象时自动调用的特殊函数，必须与所属类同名，且不能返回类型，常用于初始化字段的值
        //索引器：允许对象用访问数组的方式访问
        //运算符：加减
        //事件：是类的成员，在发生某些行为时可以让对象通知调用方
        //析构函数：
        //类型：包含内部类



        static void Fex1()
        {
            //一旦实例化对象后，就可以使用Object.FieldName来访问字段
            var customer1 = new PhoneCustoment();
            customer1.FirstName = "Simen";
        }


            //常量与类的关联方式和变量与类的关联方式相同，使用Const关键字声明常量。如果声明为Public那么就可以在类的外部访问
            class Customer2
            {
            public string FirstName;
            public string LastName;
            public string CustomerID;
             }



        //readonly修饰符 为了保证对象的字段不能改变，可以用readonly只读
        //只读字段在程序运行期间通过构造函数指定，当作为类成员时，需要把static分配给该字段
    
    
        public class DocumentEditor
        {
            private static readonly uint s_maxDocuments;
            static DocumentEditor()
            {
                s_maxDocuments = 10;
            }

            private readonly DateTime _CreationTime;
            public DocumentEditor()
            {
                _CreationTime = DateTime.Now;
            }//在构造函数中不必给只读字段赋值，它的值就是其数据类型的默认值
            //最好不要把字段声明为public，如果修改类的公共成员，那么每个调用程序也要修改
            //最好声明为private，使用属性来访问字段

        }






        static void Fex2()
        {
            //属性时是一个方法或一对方法，在客户端代码看来它是一个字段
            

        }
        class PhoneCustomer
        {
           /* private string _firstName;
            public string FifstName
            {
                get { return _firstName; }
                set { _firstName = value; }
            }*/ //get访问器不带任何参数，且必须返回属性声明的类型，也不应为set访问器指定任何显示参数，只带一个参数其类型属性相同value
            private int age;
            public int Age
            {
                get { return age; }
                set { age = value; }
            }


            private string _firstName;
            public string FifstName
            {
                get => _firstName;
                set =>_firstName = value;
            }//具有表达式的属性访问器，省略return


            public int Age1 { get; set; }//自动实现
            public int Age2 { get; set; } = 10;//初始化

            public string Name
            {
                get => _firstName;
                private set => _firstName = value;
            }//属性的访问修饰符有公开/私有/受保护的
            //在属性中省略Set访问器就可以创建只读属性，readonly
            


            //自动实现只读属性
            public string Id { get; } = Guid.NewGuid().ToString();
            //在后台编译器会创建一个只读字段和属性，其get访问器可访问这个字段，初始化器会进入构造函数的代码并在调用之前调用
            
            public class Person
            {
                
                public Person(string name) =>Name = name;
                public string Name { get;  }
            
            }

            //只有get访问器的属性可以使用表达式体属性实现，只是需要后跟lambda操作符
            public class Person1
            {
                public void Person(string firstName,string lastName)
                {
                    string FirstName = firstName;
                    string LastName = lastName;
                }
                public string FirstName { get; }
                public string LastName { get; }
                public string FullName => $"{FirstName} {LastName}";
            }


            //不可变的类型，如果类型包含可以改变的成员，就是一个可变的类型。使用readonly,编译器在状态修改时报错。
            //状态只能在初始化时设置，例如string类
        
        }
         

        static void Fex3()
        {
            //var关键字可用于隐式类型化的变量，与new一起使用可以创建匿名类型
            //匿名类型只是一个继承自Object且没有名称的类
            var caption = new
            {
                FirstName = "Jame",
                MiddleName = "M",
                LastName = "Kirk"
            };//如果创建另一个对象，那么两者类型相同。所设置的值来自另一个对象则可以推断匿名类型成员的名称，简化初始化器

            var doctor = new
            {
               FirstName= caption.FirstName,
               MiddleName= caption.MiddleName,
               LastName= caption.LastName,
            };//caption对象的属性名投射到新对象douctor。

        }



        static void Fex4()
        {

        }
        //如何区分函数和方法
        //函数成员不仅包括方法，也包含类或结构的非数据成员，如索引器/构造函数/析构函数


        //方法的定义包括任意方法修饰符，返回值的类型，然后依次是方法名，输入参数的列表

        public bool IsSquare(Rectangle rect)
        {
            return (rect.Height == rect.Width);
        }//无返回值可用void 不带参数仍需要带小括号

        //简化
        public bool IsSquare1(Rectangle rect)=>rect.Height == rect.Width;

        //调用方法
        public class Math
        {
            public int Value { get;  }
            public int GetSquare() => Value * Value;
            public int GetSquareof(int x) => x * x;

         }
     }
          //类利用main类调用静态方法并实例化一个对象，来调用实例成员
    class MathSample
    {
        public class Math
        {
            public int Value { get; set; }
            public int GetSquare() => Value * Value;
            public static int GetSquareof(int x) => x * x;
            public static double GetPi() => 3.14159;

        }
        static void Main()
        {
            Console.WriteLine($"Pi is {Math.GetPi()}");
            int X = Math.GetSquareof(5);
            Console.WriteLine($"Square of 5 is {X}");
            var math = new Math();
            math.Value = 30;//只读情况会报错
            Console.WriteLine($"Value field of math variable contions {math.Value}");
            Console.WriteLine($"Square of 30 is {math.GetSquare()}");
        }


        //方法的重载，只需要声明同名但参数个数或类型不同的方法即可
        class ResultDisplayer
        {
            public void DisplayResult(string result)
            {
                //
            }
            public void DisplayResult(int  result)
            {
                //
            }

        }//参数类型不同，参数数量也可以不同
        class Myclass
        {
            public int Dosomething(int x)
            {
                return 0;//
            }
            public int Dosomething(int x,int y)
            {
                return 0;//
            }
        }


        //个数可变的参数 params关键字 可以使用任意数量的参数
        public void AnyNas(params int[] data)
        {
            foreach(var x in data)
            {
                Console.WriteLine(x);
            }
        }
    }