命名规则

1、变量命名采用 camel（驼峰命名法）；第一个单词小写，从第二个单词开始的每个单词首字母大小
2、类命名采用Pascal命名法；每个单词的首字母大小
3、接口命名规则也采用Pascal命名法，通常以I开头，并将其后面的每个单词首字母大写
4、常量的命名负责：通常将定义常量的单词虽有字母大写。例如定义π值，可以将其定义成一个常量以保证在整个程序的使用值时统一的，直接定义成PI即可。
5、方法的命名规则，方法命名采用Pascal命名法，一般采用动词命名。例如实现添加用户信息操作的方法，AddUserInfo

数据类型

将某个数据保留两位小数

 double re = 3.33333333333;
 //保留两位小数
string s= re.ToString("0.00");
re = Convert.ToDouble(s);
Console.WriteLine($"=====平均值：{s}");

变量的三要素：

概念：表示一个数据储存空间，内存地址的别名。
作用：内存地址是一串十六进制数。非常不好记忆；通过变量可以快速找到数据

变量类型：规定变量的数据类型
变量名称：有意义，好记忆
变量的值：变量对应的内存数据

对齐代码：

Ctrl+K+D

快速标注区域

Ctrl+K+S

注释：

单行注释：单独的一条语句
文档注释：方法、类等。注意三个///的使用

使用选择：
关键性的语句要添加注释。
类名前应该使用文档注释，说明类的简单功能和使用方法。
复杂方法前面应该使用文档注释，说明方法的功能、参数的含义、返回值等。

MSDN:

常用问题可以到MSDN中查找https://docs.microsoft.com/zh-cn/

控制台(Console)：

ReadLine();获取控制台的输入数据字（符串类型）

变量折叠：

#region
#endregion

        #region 01.练习1
        /// <summary>
        /// 
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)// 程序的入口方法
        {
            int a = 20;
            Console.WriteLine(a);
            Console.WriteLine("你好，义昆");

            // 调用类
            //MyClass.Properties.Caluator nexx = new MyFirstConsoleApp.Properties.Caluator();
            MyClass.Caluator Add = new MyClass.Caluator();
            int result = Add.Add(10,20);
            Console.WriteLine(result);
            Console.ReadLine();

            test1();
        }
        #endregion

折叠后

字符串的格式化：

Console.WriteLine(string.Format("姓名：{0} 成绩：{1}",name,score));

运行结果：

{0},{1}都代表占位符，运行时会寻找逗号后的对应个数变量进行占位符替换
name替换{0}
score替换{1}

字符创格式化新特性（.NET 4.6支持，建议使用）

Console.WriteLine($"姓名：{name} 分数：{score}");

运行结果：
同上。

运算符

注意运算顺序：

            int i = 200;
            Console.WriteLine("I++后的值  {i++}");// 先输出再自加1
            Console.WriteLine("I++后的值  {i}");

            int j = 200;
            Console.WriteLine($"I++后的值  {++j}");//先自加1再输出

结果：

数据类型自动转换的实现

自动转换条件：
两种类型必须是指类型（整型和浮点类型）
目标类型必须大于要转换的类型，例如double 大于 int
这个过程是程序运行中，编译器自动完成的，我们无需干预

Parse的使用

 //只有有效的字符类型，才能转换成对应的值。有效的：也就是说字符串内容必须符合目标类型
//字符串转值类型
     double a = double.Parse("100.5");
     float b = float.Parse("20.36");
     int c = int.Parse("200");

    //int a = int.Parse("19.56");// 这里会出错，无法执行
    int d = (int)double.parse("19.56");
    double e = int.Parse("190");


//值类型转字符串
    string s1 = a.ToString();//s1的值为100.5
    string s2 = b.ToString();//s2的值为20.36

总结：
目标类型 变量 = 目标类型.Parse(“字符串的有效表示”);

万能转换器的使用（Convert）

// 要求字符串或者要转换的类型，必须是符合目标类型
    double a = Convert.ToDouble("1596.3695");
    float b = Convert.ToSingle("5635.36");
    int c = Convert.ToInt32(562);
    DateTime dt = Convert.ToDateTime("2021-10-20");

//非有效类型时转换
c = (int) Convert.ToDouble（"500.5"）;

产生随机数

 //产生随机数
      //1、创建能够产生随机数的对象
      Random r = new Random();
      //2、让产生随机数的对象调用方法来产生随机数
      // 产生的随机数包含最小值但不包含最大值
      for (int i = 0; i < 100; i++)
      {
          int result = r.Next(1, 100);
          Console.WriteLine(result);
      }

      Console.Read();

枚举

public enum 枚举名
{
    值1、
    值2、
    值3、
    值4、
..........
}

Public:访问修饰符。公开的公共的，访问等级最高
enum:枚举关键字
枚举名：要符合pascal命名法

将枚举声明到命名空间下，类的外面，所有的类都可以使用枚举；

枚举类型转换（将字符串转为枚举类型）：

public enum Gender
{
    男，女
}
string s = "男"；
Gender g=(Gender)Enum.Parse(typeof(Gender),s);
ConSole.Write(g);//输出结果为“男”

结构

public struct 结构名
{
    string str；
    int number;
}

字符串添加

            string[] names = { "老杨", "老周", "老马", "老虎", "老牛", "老邹" };
            string str = null;
            for (int i = 0; i < names.Length - 1; i++)
            {

                str += names[i] + "|";
            }
            Console.WriteLine(str + names[names.Length - 1]);
            Console.ReadKey();

数组反转

数组的第一个元素与最后一个元素进行交换；第二个元素与倒数第二个元素进行交换，依次进行替换，总共循环数组长度的一半次数

 string[] names = { "a", "b", "c", "d", "e", "f", "g" };
            for (int i = 0; i < names.Length / 2; i++)
            {
                string temp = names[i];//先寄存前面元素的值
                names[i] = names[names.Length - 1 - i];//再将后面元素的值赋值给前面元素的值
                names[i] = temp;//再将前面元素的值赋值给后面的元素达到反转的目的

            }
            for (int i = 0; i < names.Length; i++)
            {
                Console.WriteLine(names[i]);
            }

            Console.ReadKey();

冒泡排序

将一个数组中的元素按照从大到小或者从小到大的顺序进行排序

class Program
    {
        static void Main(string[] args)
        {
            //对数组进行升序排列
            int[] nums = { 9, 8, 70, 60, 5, 4, 3, 2, 1, 0 };
            for (int i = 0; i < nums.Length-1; i++)
            {
                //所有循环执行完后，也就是能够达到排序的目的
                for (int j = 0; j < nums.Length - 1-i; j++)
                {
                    if (nums[j]>nums[j+1])
                    {
                        int temp=nums[j];//先寄存较大的数值
                        nums[j ] = nums[j+1];//再用小的值进行替换
                        nums[j + 1] = temp;//再将较大的值替换到下一位，达到反转目的
                    }
                }
            }
            //依次打印数组
            for (int i = 0; i < nums.Length; i++)
            {
                Console.WriteLine(nums[i]);
            }
            Console.ReadKey();
        }
    }

方法

public static 返回值类型 方法名（[参数列表]）
{
    方法体；
}

public ：访问修饰符，公开的公共的，哪都可以访问
static:静态的
返回值类型：如果不需要返回值，则写void
方法名：根据pascal命名法，每个单词的首字母大写其余小写
参数列表：完成这个方法所必须提供给这个方法的条件，如果没有参数，小括号不能省略

方法调用：类名.方法名（参数）；

如果调用者想要得到被调用者的值：返回值
1、不管实参还是形参，都是在内存中开辟了空间的。
2、方法的功能一定要单一，方法中最忌讳的就是出现提示用户输入的字眼。

out,ref,parames 三个高级参数

out：如果在一个方法中，返回多个相同类型的参数，可以考虑返回数组。
但如果返回多个不同类型的参数时，返回数组是不可行的，可以考虑out参数；
out参数就侧重于在一个方法中返回多个不同类型的值
ref:
能将一个变量带入方法中进行改变，改变完成后，再将改变后的值带出方法，不需要写函数返回值
Params
可将实参列表汇总跟可变参数数组类型一致的元素都当做数组的元素去处理。
数组必须是一维数组，不允许将params修饰符与ref和out修饰符组合起来使用。
方法的形参列表中只能出现一个Params参数
Params参数，必须是形参列表的最后一个参数，否则编译器将无法识别。导致报错
例如：public static void Test(string name,params int[] score，int ID )这是错误用法，编译器无法辨别传入的参数是Score还是ID

调用—-out：

    int[] numbers =new int[] { 0, 2, 3, 5, 6, 9 };
    int max, min, sun, avg ;
    string str1;
    Console.WriteLine(str1);

方法—-out：

public static void Test(int[] nums,out int max,out int min, out int sum ,out int avg,out string str)
        {
            //out参数要求在方法的内部，必须为其赋值
            max = nums[0];
            min = nums[1];
            sum = 0;
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i]>max)
                {
                    max = nums[i];
                }
                if (nums[i]<min)
                {
                    min = nums[i];
                }
                sum += nums[i];

            }
            avg = sum / nums.Length;
            str = "运算结束";
        }

调用——-ref

 static void Main(string[] args)
        {
            int n1=20, n2=30;
            Test(ref n1, ref n2);
            Console.WriteLine($"{n1}========{n2}");
            Console.Read();
        }

方法——-ref

 /// <summary>
        /// 输入两个参数，方法内交换两个参数的值
        /// </summary>
        /// <param name="n1">参数_1</param>
        /// <param name="n2">参数_2</param>
        public static void Test(ref int n1,ref int n2)
        {
            int temp = n1;
            n1 = n2;
            n2 = temp;
        }

调用——-Params

static void Main(string[] args)
        {
            int[] score = { 99, 88, 99 };
            Test("龚义昆",99,88,77,66,55,44,99,33);
            Console.ReadKey();


        }

方法——-Params

 public static void  Test(string name,params int[] score )
        {
            int sum = 0;
            for (int i = 0; i < score.Length; i++)
            {
                sum += score[i];

            }
            Console.WriteLine($"{name}--这次的考试成绩是:{sum}");
        }

方法的重载

概念：同一个类中声明相同方法名的方法，但是返回值以及形参类型不同，就是方法的重载；
参数不同分为两种类型
1、如果参数的个数相同，那么参数的类型不能相同
2、如果参数的类型相同，那么参数的个数不能相同

方法的重载跟返回值没有关系

调用

       static void Main(string[] args)
        {
            string str= M1("sss====", "sasasa0as");
            int re = M1(25,66);
            double dd = M1(20.36,56.3);

            Console.WriteLine(str);
            Console.ReadKey();
        }

方法

       public static int  M1 (int n1,int n2)// int类型相加
        {
            int result = n1 + n2;
            return result;

        }
       public static int  M1 (int n1,int n2，int n3)// int类型相加
        {
            int result = n1 + n2 + n3;
            return result;

        }
        public static double M1(double d1, double d2)//Double类型相加
        {
            double result = d1 + d2;
            return result;
        }
        public static string M1(string s1, string s2)//string类型相加
        {
            string result = s1 + s2;
            return result;
        }

方法的递归

方法自己调用自己；

调用

        static void Main(string[] args)
        {
            TellStory();
            Console.ReadKey();
        }

方法

        public  static void TellStory()
        {
            //int i = 0;
            Console.WriteLine("从前有座山");
            Console.WriteLine("山里有座庙");
            Console.WriteLine("庙里有个老和尚");
            i++;
            if (i>=10)
            {
                return;
            }
            TellStory();
        }