[游戏开发]Unity 3D学习（基础篇）——C#基础入门

主要按照Siki学院基础教程学习，下面对学习内容进行记录，以备后续查询。
课程总共117讲，在本博客中只记录重点知识和学习经验。

1 基础知识

1.1 快捷键

添加注释：Ctrl+k\Ctrl+c
取消注释：Ctrl+k\Ctrl+u

1.2 Hello World

using System;//引入命名空间

/*
 多行注释格式
 */ 
namespace _001_开始//命名空间与项目名保持一致
{
    class Program//类名与文件名保持一致
    {
        static void Main(string[] args)//定义方法（函数）
        {
            Console.WriteLine("Hello World!");//WriteLine方法的作用是将Hello World！显示在控制台上
            Console.WriteLine("Hello World!");
            Console.WriteLine("王强"); //WriteLine和Write的区别在于，writeline会自动换行，write不会自动换行
            Console.Write("\n");
            Console.Write("你好\t李慧颖\n");
            // \n,\t都是转义字符
            Console.Write("1\n\t2\n3");
        }
    }
}

1.3 变量：整型（int）、浮点型（double）、字符型（char）、字符串类型（string）

浮点数比整型存储数据大、但是精度低，只能存储6位小数，后面的采用科学计数法表示

包括变量申明和变量调用。

命名规则：

• 变量包括字母、数字、下划线，数字不能作为开头
• 变量不能和关键字重名

命名规范：

• 驼峰命名法（Camel）：第一个单词首字母小写，剩下单词首字母大写，e.g.,enemyHp
• Pascal命名规范：所有单词首字母大写，如果使用缩写，全部大写,e.g.,EnemyHp

1.4 字符类型：字符<—>ASCII码、字符串、转义字符

A——Z（26）：65-90，a——z：97-122
常见转义字符："\n" 换行、"\t" 制表符、"\v" 垂直制表符、"\"->\、" " “->”

Console.WriteLine(@"C:\\a\\b\\c");//其中 @ 可以使转义字符生效

1.5 字符串拼接和数字加和

Console.WriteLine("123" + "456");
Console.WriteLine(123 + 456);

1.6 获得用户输入

• 读取一个字符串

string str = Console.ReadLine();//读取一行输入数据，返回一个字符串

• 读取一个整型数据

//读取用户输入
string str = Console.ReadLine();
//读取一个整型数据（将str转换成整型数据）
int str2int = Convert.ToInt32(str);
//显示数学计算结果
Console.WriteLine(str2int + 1);

//或者可以合并程序
int str2int_1 = Convert.ToInt32(Console.ReadLine());

1.7 两个变量数据交换

using System;

namespace _007_交换变量
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("输入一个整数a:");
            int a = Convert.ToInt32(Console.ReadLine());
            Console.Write("输入另一个整数b:");
            int b = Convert.ToInt32(Console.ReadLine());
            //输出原a,b的值
            Console.WriteLine("a=" + a + " and " + "b=" + b);
            交换a,b两个变量的值，不借助辅助变量
            //a = a + b;
            //b = a - b;
            //a = a - b;
            //交换a、b两个变量的值，借助辅助变量
            int c = a;
            a = b;
            b = c;
            //再次输出a,b两个变量的值
            Console.WriteLine("a=" + a + " and " + "b=" + b);
        }
    }
}

1.8 字符串的格式化输出

Console.WriteLine("{0}+{1}={2}", a, b, a + b);
//Console.WriteLine(格式化字符串（含替代标记），替代值0，替代值1，···)

1.9 数学运算符

（1）算数运算符

将一个两位数的个位和十位分离出来

using System;

namespace _009_算数运算符
{
    class Program
    {
        static void Main(string[] args)
        {
            //将一个两位数的个位和十位区分开
            //获取用户输入
            int a, b;
            Console.Write("输入一个两位数：");
            int num = Convert.ToInt32(Console.ReadLine());
            a = num / 10;
            b = num % 10;
            Console.WriteLine("{0}的十位是：{1}，{0}的个位是：{2}", num, a, b);
        }
    }
}

（2）自增自减运算符

using System;

namespace _009_算数运算符
{
    class Program
    {
        static void Main(string[] args)
        {
            //自增运算符
			int c = 5;
			int d, e;
            
			d=c++;
			e=++c;
			Console.WriteLine("d的值是：{0}，e的值是：{1}", d, e);
        }
    }
}

（3）逻辑运算符和关系运算符

using System;

namespace _010_关系运算符和布尔类型
{
    class Program
    {
        static void Main(string[] args)
        {
        	//bool 类型
            bool a = true;
            bool b = false;
            //关系运算符
            bool c = 45 < 50;
            Console.WriteLine(c);
            Console.WriteLine(60==61);
            //逻辑运算符
            bool d = (3 < 4) && (5 >= 6);// true && false
            bool e = (5 >= 5) || (6 > 6);// true || false
            bool f = !(7 > 8);// ! false
            Console.WriteLine(d);
            Console.WriteLine(e);
            Console.WriteLine(f);
        }
    }
}

练习 1：写一个程序判断，一个人是否是青年人？

using System;

namespace _010_关系运算符和布尔类型
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入一个人的年龄：");
            int age = Convert.ToInt32(Console.ReadLine());
            if (age >= 18 && age <= 60)
            {
                Console.WriteLine("这个人是青年人");
            }
            else 
            {
                Console.WriteLine("这个人不是青年人");
            }
        }
    }
}

（4）运算符的优先级
()>乘除>加减>移位>条件> 逻辑
（5）练习 1：键盘输入一个三位数，并按数字的相反方向输出

using System;

namespace _011_Practice2
{
    class Program
    {
        static void Main(string[] args)
        {
            //从键盘输入一个三位正整数，按数字的相反方向输出
            Console.WriteLine("请输入一个三位数正整数：");
            int a = Convert.ToInt32(Console.ReadLine());
            int ge,shi,bai;
            ge = a % 10;//提取个位 122%10=2
            shi = (a/10) % 10;//提取十位 122%
            bai = a / 100;//提取百位

            Console.WriteLine("反方向输出后的结果是：" + ge+shi+bai);
        }
    }
}

（6）练习 2：输入一个五位数，输出十位和千位组成的两位数所对应的字母

using System;

namespace _012_Practice3
{
    class Program
    {
        static void Main(string[] args)
        {
            //输入一个五位数，输出十位和千位组成的两位数
            Console.WriteLine("请输入一个五位数：");
            int num = Convert.ToInt32(Console.ReadLine());
            int ge, shi, bai, qian, wan,result;
            ge = num % 10;
            shi = (num / 10) % 10;
            bai = (num / 100) % 10;
            qian = (num / 1000) % 10;
            wan = num / 10000;

            result = qian * 10 + shi;
            char c = (char)result;
            Console.WriteLine("得到的两位数所对应的ASCII码为：" + c);
        }
    }
}

2 流程控制

2.1 分支语句

2.1.1 IF条件语句

if (bool条件判断语句)
{
	条件满足时执行的程序;
}
else 
{
    条件不满足时执行的程序;
}

如果程序语句只有一条，可以省略括号

练习 1：商场举办了送礼活动，年龄在18岁到30岁都可以参与活动，年龄是奇数的可以得奖（IF语句嵌套）

using System;

namespace _013_IF语句
{
    class Program
    {
        static void Main(string[] args)
        {
            //商场举办了送礼活动，年龄在18岁到30岁都可以参与活动，年龄是奇数的可以得奖
            Console.WriteLine("请输入顾客的年龄");
            int age = Convert.ToInt32(Console.ReadLine());

            if (age >= 18 && age <= 30)
            {
                if (age % 2 != 0)
                {
                    Console.WriteLine("该顾客可以参加活动，并获得礼品奖励");
                }
                else
                {
                    Console.WriteLine("该顾客能参加活动，但无礼品奖励");
                }
            }
            else 
            {
                Console.WriteLine("该顾客不能参加活动");
            }

        }
    }

练习 2：获取一个坐标，判断是在哪一个象限、原点或坐标轴上

using System;

namespace _012_Practice3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("输入x坐标");
            int x = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("输入y坐标");
            int y = Convert.ToInt32(Console.ReadLine());

            if (x == 0 && y == 0)
            {
                Console.WriteLine("坐标位于原点");
            }
            else if (x > 0)
            {
                if (y > 0)
                {
                    Console.WriteLine("坐标位于第一象限");
                }
                else if (y<0)
                {
                    Console.WriteLine("坐标位于第四象限");
                }
                else
                {
                    Console.WriteLine("坐标位于x正半轴");
                }
            }
            else if (x<0)
            {
                if (y > 0)
                {
                    Console.WriteLine("坐标位于第三象限");
                }
                else if (y < 0)
                {
                    Console.WriteLine("坐标位于第二象限");
                }
                else
                {
                    Console.WriteLine("坐标位于x负半轴");
                }
            }
            else
            {
                if(y>0)
                {
                    Console.WriteLine("坐标位于y正半轴");
                }
                else
                {
                    Console.WriteLine("坐标位于y负半轴");
                }
            }
        }
    }
}

练习 3：输入三个整数，并按照从小到大的顺序排列并输出（冒泡排序法）

using System;

namespace _012_Practice3
{
    class Program
    {
        static void Main(string[] args)
        {
			Console.WriteLine("请依次输入三个整数：");
            int num_1 = Convert.ToInt32(Console.ReadLine());
            int num_2 = Convert.ToInt32(Console.ReadLine());
            int num_3 = Convert.ToInt32(Console.ReadLine());
            int a;

            if (num_1>num_2)
            {
                a = num_1;
                num_1 = num_2;
                num_2 = a;
            }
            if(num_2>num_3)
            {
                a = num_2;
                num_2 = num_3;
                num_3 = a;
            }
            if (num_1 > num_2)
            {
                a = num_1;
                num_1 = num_2;
                num_2 = a;
            }

            Console.WriteLine(num_1);
            Console.WriteLine(num_2);
            Console.WriteLine(num_3);

        }
    }
}

练习 4：输入一个浮点数m和一个整数k，如果k=0,浮点数只保留整数部分
如果k=1,浮点数四舍五入保留一位小数。

using System;

namespace _012_Practice3
{
    class Program
    {
        static void Main(string[] args)
        {
			Console.Write("请输入一个浮点数m:");
            double m = Convert.ToDouble(Console.ReadLine());
            Console.Write("请输入一个整数（0 or 1）:");
            int k = Convert.ToInt32(Console.ReadLine());
            double temp;

            if (k==0)
            {
                temp = Math.Floor(m);
            }
            else
            {
                //temp = Math.Round(m * 10) / 10;
                temp = ((int)((m + 0.05) * 10))/10.0;
            }
            Console.WriteLine("更新后的m为：" + temp);
        }
    }
}

2.1.2 Switch分支语句

switch (num)//Switch语句语法
{
    case 1:
        Console.WriteLine("苹果");
        break;
    case 2:
        Console.WriteLine("梨");
        break;
    case 3:
        Console.WriteLine("柚子");
        break;
    case 4:
        Console.WriteLine("梨");
        break;
    default:
        Console.WriteLine("没有您想要的商品");
        break;
}

• default可以没有
• 每一个case后面一般都有 break

Switch还可以变形，如果不同的选择对应同一种结果，可以合并程序。

using System;

namespace _014_Switch语句
{
    class Program
    {
        static void Main(string[] args)
        {
            //输入星期几，显示对应的课程
            Console.WriteLine("请输入今天是星期几：");
            int weekNum = Convert.ToInt32(Console.ReadLine());

            switch (weekNum)
            {
                case 1:
                case 2:
                    Console.WriteLine("Arduino");
                    break;
                case 3:
                case 4:
                case 5:
                    Console.WriteLine("C++");
                    break;
                case 6:
                case 7:
                    Console.WriteLine("Scratch");
                    break;
            }
        }
    }
}

练习：

using System;

namespace _014_Switch语句
{
    class Program
    {
        static void Main(string[] args)
        {
            //用户输入两个整数，在输入一个0~3之间的数，0代表加法，1代表减法，2代表乘法，3代表除法
            Console.WriteLine("请依次输入两个整数：");
            int a = Convert.ToInt32(Console.ReadLine());
            int b = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("请输入一个判断数：");
            int select = Convert.ToInt32(Console.ReadLine());
            int result;

            switch (select)
            {
                case 0:
                    result = a + b;
                    Console.WriteLine("计算结果为：" + result);
                    break;
                case 1:
                    result = a - b;
                    Console.WriteLine("计算结果为：" + result);
                    break;
                case 2:
                    result = a * b;
                    Console.WriteLine("计算结果为：" + result);
                    break;
                case 3:
                    result = a / b;
                    Console.WriteLine("计算结果为：" + result);
                    break;
            }
        }
    }
}

2.2 循环语句

2.2.1 While循环语句

while(判断语句)
//满足条件执行循环体
{
    循环体;
}

练习：

using System;

namespace _016_While循环
{
    class Program
    {
        static void Main(string[] args)
        {
            //练习：计算 1+2+···+n的结果
            Console.WriteLine("请输入n的值：");
            int n = Convert.ToInt32(Console.ReadLine());
            int i = 1;
            int sum = 0;
            while(i<=n)
            {
                sum += i;
                i++;
            }

            Console.WriteLine("求和结果为：" + sum);
        }
    }
}

3n+1问题：对于任意大于1的自然数，若n为奇数，将n变为3n+1，否则变成n的一半。经过若干次这样的变化，n一定会最终变成1，比如，7 ->22 ->11 ->34 ->17 ->52 ->26 ->13 -> 40 ->20 ->10 ->5 ->16 ->8 ->4 ->2 ->1
要求：（1）输入一个数n
（2）输出变化到1所需的次数

using System;

namespace _017_While练习题
{
    class Program
    {
        static void Main(string[] args)
        {
            //3n+1 问题
            Console.Write("输入一个数：");
            int num = Convert.ToInt32(Console.ReadLine());
            int i = 0;
            while(num!=1)
            {
                if (num%2==1)
                {
                    num = 3 * num + 1;
                }
                else
                {
                    num = num / 2;
                }
                i++;
                Console.WriteLine("变换后的值为："+num);
            }
            Console.WriteLine("输出变换的次数：" + i);
        }
    }
}

2.2.2 For 循环

for(初始化;条件表达式;增量表达式)
{
    循环体;
}

• for循环三个部分都可以省略，使用break跳出循环
• 作用域的概念，一个作用域中定义的变量会在此作用域中的程序执行完销毁。

练习：将 n 和 m 之间的奇数和偶数分别输出

using System;

namespace _018_for循环
{
    class Program
    {
        static void Main(string[] args)
        {
			int n = Convert.ToInt32(Console.ReadLine());
            int m = Convert.ToInt32(Console.ReadLine());
            string a="", b="";
            for (int i = n; i <= m; i++)
            {
                if (i % 2 == 1)
                {
                    a += i + " ";
                }
                else
                {
                    b += i + " ";
                }
            }
            Console.WriteLine(a);
            Console.WriteLine(b);

        }
    }
}

2.2.3 Do_While循环

do
{
    循环体;
} while (判断条件);

区别：do_while至少执行一次循环体，while可能一次循环体也不执行

2.2.4 循环标志位

标志位的作用类似触发器，一旦遇到不再进行判断
练习：输入一个未知位数的整数，反向输出一个新的整数，不保留原数字末尾的零。

using System;

namespace _020_编程题
{
    class Program
    {
        static void Main(string[] args)
        {
            //输入一个未知位数的整数，从个位开始，依次输出各位数字
            int n = Convert.ToInt32(Console.ReadLine());
            string b = "";
            bool meet = false;//循环标志位
            while (n % 10 != 0 || n / 10 != 0)
            {
                int i = n % 10;//依次输出各个位数字
                if(meet==false)
                {
                    if(i!=0)
                    {
                        b += i;
                        meet = true;
                    }
                }
                else
                {
                    b += i;
                }
                n /= 10;
            }
            Console.WriteLine(Convert.ToInt32(b));//输出新数字
        }
    }
}

2.2.5 Console.Read与Readline

• 相同点：
  都可以接受控制台输入
• 不同点
  （1）Read只能读取一个字符，ReadLine可以读取一个字符串
  （2）Read返回字符对应的ASCII码，Readline返回字符串型（string）数据
  （3）Readline直接读取字符串，Read从缓冲区读取数据（缓冲区数据通过控制台，按回车键输入）

练习1：读取一串字符，字符串以 @ 结尾，区分数字和字母，并计算数字加和

using System;

namespace _022_编程练习_区分字母和数字
{
    class Program
    {
        static void Main(string[] args)
        {
            //采用read读取单个字符，返回对应的ASCII码，read也可以接受“回车”
            //在控制台输入字符时，回车将字符送入缓冲区，read从缓冲区读取字符
            //读取一串字符，字符串以 @ 结尾，区分数字和字母，并计算数字加和
            //方法一：单字符操作
            char a = (char)Console.Read();
            int sum = 0;
            while (a != '@')//也可以采用 do_while 语句，可以省略循环外部的第一次读取语句
            {
                if (a >= '0' && a <= '9')
                {
                    Console.WriteLine(a);
                    sum += (a - '0');
                }
                a = (char)Console.Read();
            }
            Console.WriteLine(sum);

            //方法二：字符串操作
            string b = Console.ReadLine();
            int sum_1 = 0;
            for(int i=0;b[i]!='@';i++)
            {
                if(b[i]>='0' && b[i]<='9')
                {
                    sum_1 += (b[i]-'0');
                }
            }
            Console.WriteLine(sum_1);
        }
    }
}

练习2：输入一个整数，输出这个整数因数的个数和所有因数

using System;

namespace _023_编程练习_因数和质数
{
    class Program
    {
        static void Main(string[] args)
        {
            //输入一个整数，输出这个整数的因数个数和所有因数
            int a = Convert.ToInt32(Console.ReadLine());
            int sum = 0;
            string c = "";
            for(int i=1;i<=a;i++)
            {
                if(a%i==0)
                {               
                    sum++;
                    c += i + " ";
                }
            }
            Console.WriteLine(sum);
            Console.WriteLine(c);
        }
    }
}

2.2.6 Continue 和 Break

Continue 结束本次循环，Break 跳出当前循环（Break常与Switch语句合用）

2.27 循环嵌套

//输出等腰三角形
int n = Convert.ToInt32(Console.ReadLine());
for (int i = 1; i <= n; i++)
{
    for (int j = 1; j <= n - i; j++)
    {
        Console.Write(" ");
    }
    for (int j = 1; j <= 2 * i - 1; j++)
    {
        Console.Write('*');
    }
    for (int j = 1; j <= n - i; j++)
    {
        Console.Write(" ");
    }
    Console.WriteLine();
}

2.2.8 随机数生成

Random rd = new Random(UnCheck((Int)DateTime.Now.Ticks));//类引用
int num = rd.Next(1, 101);//生成[1,101)之间的随机数

Random rd=new Random()用系统时间做随机种子并不保险，如果应用程序在一个较快的计算机上运行，则该计算机的系统时钟可能没有时间在此构造函数的调用之间进行更改，Random 的不同实例的种子值可能相同。

这种情况下，我们就需要另外的算法来保证产生的数字的随机性。我们可以自行设定触发的种子，一般都是用UnCheck((Int)DateTime.Now.Ticks)（以100毫秒做基础单位的时间数量单位）做为参数种子，避免产生重复随机数。在这里，我们首先使用系统时间作为随机种子，然后将上一次产生的随机数跟循环变量和一个与系统时间有关的整型参数相乘，以之作为随机种子，从而得到了每次都不同的随机种子，保证了产生足够"随机"的随机数。

2.2.9 数据的显式转换和隐式转换（自动转换）

• 隐式变换
  自动转换，不需要多余代码
• 显式变换
  int a=5;
  char c=‘a’;
  c=(char)a;

3 数组

3.1 数组定义和声明

C#中数组定义：

数据类型[] 数组名={数组元素0,数组元素1,数组元素2,···}
数据类型包括：int, double, char, string

int[] ages={12,45,60};

按照默认值进行赋值：

int[] ages;
ages=new int[10];//数组长度为10，默认元素为0

char和string类型的数组默认值为null

数组元素调用：

int a=ages[1];//a=45

3.2 数组遍历

3.2.1 获取数组长度

int[] ages = { 34, 12, 56, 78, 98, 52, 12, 24 };
int L=ages.Length;

3.2.2 采用For循环遍历

int[] ages = { 34, 12, 56, 78, 98, 52, 12, 24 };
for(int i = 0; i < 8; i++)
{
    Console.WriteLine(ages[i]);
}

3.2.3 采用While循环遍历

int[] ages = { 34, 12, 56, 78, 98, 52, 12, 24 };
int i=0;
while (i < 8)
{
    Console.WriteLine(ages[i]);
    i++;
}

3.2.4 采用foreach遍历（特定方法+只能正序遍历）

int[] ages = { 34, 12, 56, 78, 98, 52, 12, 24 };
foreach(int temp in ages)
{
    Console.WriteLine(temp);
}

3.3 字符串操作

字符串可以看作一个字符数组

3.3.1 字符串遍历

string name = "  abcD,Efg";;
for(int i = 0; i < name.Length; i++)
{
    Console.WriteLine(name[i]);
}

3.3.2 字符串常用方法

string str1 = name.ToLower();//小写
string str2 = name.ToUpper();//大写
string str3 = name.Trim();//去除字符串前面和后面的空格
string str4 = name.TrimEnd();//去除字符串后面的空格
string str5 = name.TrimStart();//去除字符串前面的空格

3.3.3 字符串分割

string[] str6Array = name.Split(',');//以","为分隔符分割字符串，形成新的数组

3.3.4 字符串转换

字符串可以获取其中某个元素的值，但是不能修改。如果需要修改，需要将其转换为字符数组。

char[] str7Array = name.ToCharArray();

3.3.5 系统方法排序

C#中提供了对数组（整数、字符串、字符）数组排序的方法
Array.Sort(intArray);

举例：

• 对一组数字排序

//系统排序
//初始化
Console.WriteLine("输入一组字符串：");
string str = Console.ReadLine();
string[] strArray = str.Split(' ');
int[] intArray = new int[strArray.Length];

for (int i = 0; i < strArray.Length; i++)
{
    intArray[i] = Convert.ToInt32(strArray[i]);
}

Array.Sort(intArray);
foreach (int temp in intArray)
{
    Console.Write(temp + " ");
}

• 对一组字符进行排序

char[] charArray = { 'a', 'b', 'd', 'c' };
Array.Sort(charArray);
foreach(char temp in charArray)
{
    Console.Write(temp + " ");
}

3.3.6 练习1-插入字符

using System;

namespace _027_数组
{
    class Program
    {
        static void Main(string[] args)
        {
			//目前有一组从小到大排列好的字符串，新输入一个数，让整个数组依然有序
            //初始化
            Console.WriteLine("输入一个从小到大排列好的整数数组");
            string str_1 = Console.ReadLine();
            Console.WriteLine("输入要插入的数字");
            int num = Convert.ToInt32(Console.ReadLine());
            int Index=0;
            string result = "";

            string[] strArray = str_1.Split(' ');//将输入的字符串以' '为分隔符切片
            int[] intArray = new int[strArray.Length+1];
            for(int i = 0; i < strArray.Length; i++)
            {
                intArray[i] = Convert.ToInt32(strArray[i]);//将字符数组变为整数数组           
            }

            //找到插入值的索引号
            if (num < intArray[0])
            {
                Index = 0;
            }
            else if (num >= intArray[strArray.Length - 1])
            {
                intArray[strArray.Length] = num;
                Index = strArray.Length;
            }
            else
            {
                for (int i = 0; i < strArray.Length; i++)
                {
                    if((intArray[i]<num)&&(intArray[i+1] >= num))
                    {
                        Index = i + 1;
                        break;
                    }
                }
            }

            //将插入值插入到数组中，并将其后的数字后移一位
            if (Index != strArray.Length)
            {
                for (int i= strArray.Length; i > Index; i--)
                {
                    int temp = intArray[i];
                    intArray[i] = intArray[i-1];
                    intArray[i-1] = temp;
                }
                intArray[Index] = num;
            }

            //输出最后结果
            for(int i = 0; i < intArray.Length; i++)
            {
                result += intArray[i] + " ";
            }
            Console.WriteLine(result);
        }
    }
}

3.3.7 练习2-排序

• 嵌套循环遍历

//用户输入一组数据，将每一个数提取出来，并按照从小到大顺序排列输出
string str = Console.ReadLine();
string[] strArray = str.Split(' ');
for (int i = 0; i < strArray.Length; i++)
{
    for (int j = i + 1; j < strArray.Length; j++)
    {

        if (Convert.ToInt32(strArray[i]) > Convert.ToInt32(strArray[j]))
        {
            string a = strArray[i];
            strArray[i] = strArray[j];
            strArray[j] = a;
        }
    }
}
string result = "";
for (int i = 0; i < strArray.Length; i++)
{
    result += strArray[i] + " ";
}
Console.WriteLine(result);

• 冒泡排序法（带检测标志位）

//冒泡排序
//初始化
Console.WriteLine("请输入一串整数字符串：");
string str = Console.ReadLine();
string[] strArray = str.Split(' ');
int[] intArray = new int[strArray.Length];
for(int i = 0; i < strArray.Length; i++)
{
    intArray[i] = Convert.ToInt32(strArray[i]);
}

//排序
for(int i = 0; i < intArray.Length - 1; i++)//排序轮次
{
    bool isChange = false;//排序标志位，检查本轮是否有数字交换
    for(int j=0;j< intArray.Length - 1 - i; j++)//数组遍历
    {
        //冒泡排序
        if (intArray[j] > intArray[j+1])
        {
            int temp = intArray[j];
            intArray[j] = intArray[j + 1];
            intArray[j + 1] = temp;
            isChange = true;
        }
    }
    if (isChange == false)//如果没有数字交换，退出循环
    {
        break;
    }
}

//输出
foreach(int temp in intArray)
{
    Console.Write(temp + " ");
}

3.3.8 练习3-回文

		//判断一个字符串是否是回文
		Console.WriteLine("请输入一个字符串：");
		string str = Console.ReadLine();
		bool isHuiwen = true;
		//方法1：字符数组整体比较
		char[] charArray = str.ToCharArray();
		char[] backArray = new char[charArray.Length];
		for (int i = 0; i < charArray.Length; i++)
		{
		    backArray[i] = charArray[str.Length - 1 - i];
		}
		for (int i = 0; i < charArray.Length; i++)
		{
		    if (backArray[i] != charArray[i])
		    {
		        isHuiwen = false;
		        break;
		    }
		}
		if (isHuiwen == true)
		{
		    Console.WriteLine("这个字符串是回文");
		}
		else
		{
		    Console.WriteLine("这个字符串不是回文");
		}
		//方法2：字符串中单字符比较
		for (int i = 0; i < str.Length / 2; i++)
		{
		    if (str[i] != str[str.Length - 1 - i])
		    {
		        isHuiwen = false;
		        break;
		    }
		}
		if (isHuiwen == true)
		{
		    Console.WriteLine("这个字符串是回文");
		}
		else
		{
		    Console.WriteLine("这个字符串不是回文");
		}
		//方法3：字符串比较
		string back = "";
		for(int i = 0; i < str.Length; i++)
		{
		    back += str[str.Length-1-i] + "";
		}
		if (str != back)
		    isHuiwen = false;
		if (isHuiwen == true)
		{
		    Console.WriteLine("这个字符串是回文");
		}
		else
		{
		    Console.WriteLine("这个字符串不是回文");
		}

4 模拟法

通过程序模拟事件的发生来预测结果。
练习：
张三每个月从妈妈那里获取300元，计算当月花销，将剩余的整百金额存储到妈妈手中，自己留下零钱。如此经过12个月，妈妈会将存储的钱以120%的比例还给张三，问张三最终有多少钱？

using System;

namespace _029_模拟法
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入12个月的预算：");
            string budget = Console.ReadLine();
            string[] budgetArray = budget.Split(' ');//转换成字符串数组
            int[] budgetInt = new int[budgetArray.Length];
            for(int i = 0; i < budgetInt.Length; i++)
            {
                budgetInt[i] = Convert.ToInt32(budgetArray[i]);//转换为整数数组
            }

            //正式程序
            int residue=0;//每个月剩余的钱
            bool isExceed = false;//是否超出预算
            int Index=0;//定位标签
            int storage = 0;//存储的钱

            for(int i=0;i< budgetInt.Length; i++)
            {
                if (residue + 300 - budgetInt[i] < 0)
                {
                    Index = i+1;
                    isExceed = true;
                    break;
                }
                else if ((residue + 300 - budgetInt[i]) / 100 > 0)
                {
                    storage += (residue + 300 - budgetInt[i]) / 100 * 100;
                    residue = (residue + 300 - budgetInt[i]) % 100;
                }
                else
                {
                    residue= (residue + 300 - budgetInt[i]) % 100;
                }
            }
            if (isExceed == false)
            {
                Console.WriteLine("张三最终会有：" + (residue + storage * 1.2));
            }
            else
            {
                Console.WriteLine(-Index);
            }

        }
    }
}

5 函数（Function）

5.1 函数定义与调用

目的：避免重复执行一段代码
函数定义：

static void（bool,int,string） 函数名(参数类型 参数名1，参数类型 参数名2)
{
函数体；
return 返回值；
}

static是修饰符，表示静态方法
void代表返回值为空，函数类型应该和返回值类型保持一致

static bool VerifyUsername(string username,string username2="a")//形参，形参可以指定默认值
{
    Console.WriteLine("校验用户名"+username);
    return true;
}

函数中的return可以起到break的作用，return之后的代码不再执行

函数调用：

VerifyUsername(参数1，参数2);//实参

如果有返回值的话：

bool a=VerifyUsername("张三","李四");

练习：判断真素数

using System;

namespace _030_函数
{
    class Program
    {
        //获得输入
        static int[] GetInput()
        {
            Console.WriteLine("请输入一个整数数组：");
            string str = Console.ReadLine();
            string[] strArray = str.Split(' ');
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
                intArray[i] = Convert.ToInt32(strArray[i]);
            }
            return intArray;
        }

        //判断是否是素数
        static bool IsSu(int number)
        {
            bool isSu = true;
            for (int j = 2; j < number; j++)
            {
                if (number % j == 0)
                {
                    isSu = false;
                    break;
                }
            }
            return isSu;
        }

        static void Main(string[] args)
        {

            int[] intArray=GetInput();//调用输入
            int M = intArray[0];
            int N = intArray[1];


            for(int i = M; i <= N; i++)
            {
                bool isSu = IsSu(i);//调用判断素数
                if (isSu)
                {
                    int temp = i;
                    int number = 0;
                    while (temp / 10 != 0|| temp%10!=0)
                    {
                        number = number * 10 + temp % 10;
                        temp = temp / 10;
                    }

                    bool isSuFan = IsSu(number);//调用判断素数
                    if (isSuFan)
                    {
                        Console.Write(i + " ");
                    }
                }
                
            }
        }
    }
}

5.2 函数中的参数数组

参数数组与数组参数的区别：

• 形式不同
  参数数组：static int Add1(params int[] array)
  可以输入任意个参数，系统自动转换为数组的形式
  …
  数组参数：static int Add1(int[] array)
  输入的参数必须是一个数组的形式
• 示例：

数组参数：

using System;

namespace _031_参数数组
{
    class Program
    {
        //多数加法器
        static int Add1(int[] array)
        {
            int sum=0;
            foreach(int temp in array)
            {
                sum += temp;
            }
            return sum;
        }
        static void Main(string[] args)
        {
            int[] a = { 1, 2, 3, 4, 5 };
            int b = Add1(a);
            Console.WriteLine(b);
        }
    }
}

参数数组：

using System;

namespace _031_参数数组
{
    class Program
    {
        //多数加法器
        static int Add1(params int[] array)
        {
            int sum=0;
            foreach(int temp in array)
            {
                sum += temp;
            }
            return sum;
        }
        static void Main(string[] args)
        {
            int b = Add1(1,2,3,4,5);
            Console.WriteLine(b);
        }
    }
}

• params 参数必须放在最后一个形参位置

5.3 函数的重载（Overload）

为什么要使用函数重载？
假设我们有一个函数用来实现求得一个数组的最大值

static int MaxValue(int[] intArray)
{
…
return;
}

这个函数只能用来处理int数组，如果想处理double类型的话需要再定义一个函数

static double MaxValue(double[] doubleArray)
{
…
return;
}

函数名相同，参数不同，这个叫做函数的重载（编译器根据你传递过来的实参的类型去识别应该调用哪一个函数）

示例：分别求得整数数组和浮点数数组中的最大值

using System;

namespace _033_函数的重载
{
    class Program
    {
        static int MaxValue(int[] array)
        {
            int max=array[0];
            for(int i = 1; i < array.Length; i++)
            {
                if (max < array[i])
                {
                    max = array[i];
                }
            }
            return max;

        }
        static double MaxValue(double[] array)//函数重载
        {
            double max = array[0];
            for (int i = 1; i < array.Length; i++)
            {
                if (max < array[i])
                {
                    max = array[i];
                }
            }
            return max;
        }
        static void Main(string[] args)
        {
            int[] intArray = { 1, 2, 3, 4, 5, 6, 8, 9 };
            double[] doubleArray = { 1.0, 3.0, 5.0, 8.0, 15.3 };
            Console.WriteLine(MaxValue(intArray));
            Console.WriteLine(MaxValue(doubleArray));
        }
    }
}

5.4 递归函数

示例：$f(n)=f(n?1)+f(n?2),f(0)=2,f(1)=3,求f(40)?$

• 方法1：循环求解

int a0 = 2, a1 = 3;
int a2 = 0;
for (int i = 2; i <= 40; i++)
{
	a2 = a0 + a1;
	a0 = a1;
	a1 = a2;
}
Console.WriteLine(a2);

• 方法2：递归求解

static int F(int n)
{
    if (n == 0)
    {
        return 2;
    }
    if (n == 1)
    {
        return 3;
    }
    int res= F(n - 1) + F(n - 2);
    return res;
}

static void Main(string[] args)
{
	//方法3：递归
	int fn = F(40);
	Console.WriteLine(fn);
}

练习1：求阶乘（10）

static int JieCheng(int n)
{
    if (n == 1)
        return 1;
    int res = n * JieCheng(n - 1);
    return res;
}

static void Main(string[] args)
{
	//阶乘
    int result = JieCheng(10);
    Console.WriteLine(result);
}

练习2：$1!+2!+?+10!=?$

• 方法1：循环求解

Console.WriteLine("请输入一个数字：");
int n = Convert.ToInt32(Console.ReadLine());
int result = 0;
for (int i = 1; i <= n; i++)
{
    int jiecheng = 1;
    for (int j = 1; j <= i; j++)
    {
        jiecheng = jiecheng * j;
    }
    result += jiecheng;
}

Console.WriteLine(result);

• 方法2：递归求解（使用两个递归函数）

 //求阶乘
 static int JieCheng(int n)
 {
     if (n == 1)
         return 1;
     int res = n * JieCheng(n - 1);
     return res;
 }
 //求前n个数阶乘的和
 static int SumJC(int n)
 {
     if (n == 1)
         return 1;
     return SumJC(n - 1) + JieCheng(n);
 }
 //主函数
 static void Main(string[] args)
{
	Console.WriteLine("请输入一个数字：");
    int n = Convert.ToInt32(Console.ReadLine());
    int result = SumJC(n);
    Console.WriteLine(result);
}

6 常量

const int PI=3.1415926;//const 变量类型 变量名

（常量的所有字母一般都使用大写）

7 枚举类型

7.1 定义和调用

声明枚举类型：

enum <enum_name>
{
	value1,value2,value3,···，valuen
}

定义或调用枚举类型

<enum_name> 变量名=<enum_name>.<value1>;

7.1 枚举类型特点

枚举列表中每一个符号代表一个整数值，一个比它前面符号大的整数值。默认情况下，第一个枚举符号的值是0，可以修改默认的值

举例：

enum Week
{
    Mon,Tue,Wed,Thu,Fri,Sat,Sun
    //周一（Monday）、周二（Tuesday）、周三（Wednesday）、周四（Thursday）、周五（Friday）、周六（Saturday）、周日（Sunday）
}

默认 Mon=0，Tue=1,Wed=2，··· ，Sun=6
想要输出数值，采用如下程序：

Week day = Week.Fri;
int a = (int)day;
Console.WriteLine(a);

枚举列表中的元素对应的数值也能改变

enum Week
{
    Mon=5,Tue,Wed,Thu,Fri,Sat,Sun
    //周一（Monday）、周二（Tuesday）、周三（Wednesday）、周四（Thursday）、周五（Friday）、周六（Saturday）、周日（Sunday）
}

此时， Mon=5，Tue=6,Wed=7，··· ，Sun=12

8 结构体

8.1 结构体定义和调用

定义（声明）：

struct <name>
{
	访问权限 type typename;
	访问权限 type typename;
	访问权限 type typename;
}

示例：

struct StudentInfo
{
    public int age;
    public string name;
    public int grade;
    public int id;
}

调用：

static void Main(string[] args)
{
    StudentInfo student1;
    student1.age = 10;
    student1.name = "XiaoQiang";
    student1.grade = 2;
    student1.id = 12345;
    Console.WriteLine(student1.id);
}

定义一个结构体数组（用来存储多个结构体变量）：

 StudentInfo[] student = new StudentInfo[10];
 student[0].age = 10;

8.2 练习:定义并打印三维物体坐标

• 方法1：函数中使用结构体

//定义结构体，得到三维物体坐标属性
struct Position
{
    public double x;
    public double y;
    public double z;
}
//定义函数，打印坐标
static void PrintPosition(Position p)
{
    Console.WriteLine(p.x + "," + p.y + "," + p.z);
}
//主程序
static void Main(string[] args)
{
	Position p1;
    p1.x = 100;
    p1.y = 12.2;
    p1.z = 16.3;
    PrintPosition(p1);
}

• 方法2：结构体中定义函数

//定义坐标获取和坐标打印结构体
struct Position
{
    public double x;
    public double y;
    public double z;
    //结构体中定义的函数 修饰符为public,不需要形参，访问的是调用值的属性
    public void PrintPosition()
    {
        Console.WriteLine(x + "," + y + "," + z);
    }
}
//主程序
static void Main(string[] args)
{
	Position p1;
    p1.x = 100;
    p1.y = 12.2;
    p1.z = 16.3;
    p1.PrintPosition();
}

8.3 练习：输出人的名字

//定义一个人的名字
struct CustomerName
{
    public string firstName;
    public string lastName;
    public string FullName()
    {
        return firstName + lastName;
    }
}
//主程序
static void Main(string[] args)
{
	CustomerName name;
    name.firstName = "三";
    name.lastName = "张";
    Console.WriteLine(name.FullName());
}

8.4 结构体定义一个三维向量，并输出向量的模

using System;

namespace _037_结构体练习
{
    class Program
    {
        struct Vector3
        {
            public double x;
            public double y;
            public double z;
            public double Distance()
            {
                double temp = x * x + y * y + z * z;
                return Math.Sqrt(temp);
            }        
        }
        static void Main(string[] args)
        {
            Vector3 v1;
            v1.x = 5;
            v1.y = 15;
            v1.z = 20;
            v1.Distance();
            Console.WriteLine(v1.Distance());
        }
    }
}

9 委托（delegate）

委托的作用类似于函数调用，委托的定义制定了一个返回类型和一个参数列表。
定义了委托之后，就可以指定该委托类型的变量，接着可以把一个返回类型和参数列表与委托一样的函数赋值给这个变量。

• 委托的定义

delegate double Mydelegate(double para1, double para2);

包括返回类型、参数列表和委托名

• 委托声明

Mydelegate delegate1;
delegate1 = Multiply;

示例：委托一个乘法函数

using System;

namespace _038_委托
{
    class Program
    {
        static double Multiply(double para1,double para2)
        {
            return para1 * para2;
        }
        static double Divide(double para1,double para2)
        {
            return para1 / para2;
        }
        delegate double Mydelegate(double para1, double para2);
        static void Main(string[] args)
        {
            Mydelegate delegate1;
            delegate1 = Multiply;
            Console.WriteLine(delegate1(2, 4));
        }
    }
}

• 练习1：
  将某一个函数作为另一个函数的内置变量（通过委托实现）

using System;

namespace _039_委托练习
{
    delegate void OndieDelegate();
    class Program
    {
        static void Play(OndieDelegate onDie)
        {
            Console.WriteLine("做任务");
            Console.WriteLine("战斗");
            Console.WriteLine("死亡");
            onDie();


        }
        static void ShowDieUI()
        {
            Console.WriteLine("死亡后的UI界面显示");
            Console.WriteLine("返回首页 或 重新游戏 UI显示");
        }
        static void Main(string[] args)
        {
            Play(ShowDieUI);
        }
    }
}

10 类（class）

10.1 类的定义和使用

class Enemy//类中可以定义字段和方法
{
    public string name;//只有public的字段才可以通过对象访问
    int hp;
}

类的声明（对象的定义）

Enemy enemy1 = new Enemy();//enemy1就是定义的一个对象
enemy1.name = "Wq";//对象可以访问public的字段

类的继承

public class Csharp_study : MonoBehaviour{}//MonoBehaviour继承自UnityEngine

暂时结束，日后再进行补充