第一章 .NET基础-C#基础

一.1.1. 基础语法

一.1.1.1. 注释符

一.1.1.1.1. 注释符的作用

l 注释

l 解释

一.1.1.1.2. C#中的3中注释符

l 单行注释 //

l 多上注释 /* 要注释的内容 */

l 文档注释 ///用来解释类或者方法

如下：

namespace _注释符的使用

{

    class Program

    {

        static void Main(string[] args)

        {

            //这行代码的作用是将Hello World打印到控制台当中

            //  Console.WriteLine("Hello World");

            //这行代码的作用是暂停当前这个程序

            // Console.ReadKey();

            /*

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");

            Console.WriteLine("Hello World");*/

        }

        /// <summary>

        /// 这个方法的作用就是求两个整数之间的最大值

        /// </summary>

        /// <param name="n1">第一个整数</param>

        /// <param name="n2">第二个整数</param>

        /// <returns>返回比较大的那个数字</returns>

        public static int GetMax(int n1, int n2)

        {

            return n1 > n2 ? n1 : n2;

        }

    }

一.1.1.1.3. 波浪线

l 如果你代码中出现了红色的波浪线，意味着你的代码出现了语法错误。

l 如果你代码中出现了绿色的波浪线，说明了你的代码语法并没有错误，只不过提示你有可能会出现错误，属于警告线。

一.1.1.2. 变量

一.1.1.2.1. C#中常用的数据

l int: (整数)               

n 1，250，520

l double: (小数)        

n 3.1415926，1.4142135623731

l char : (字符)           

n ‘A’   ‘b’   ‘a’  ‘钱 ‘

l string : (字符串)        

n “老赵” ，“HelloWorld”   "a"

l decimal:(金钱小数)存储金钱   

n 5.62m

l decimal d=5.55m;

l double和decimal都是小数 但是精度不同

l float;

一.1.1.2.2. 变量的声明方法

l 数据类型    变量名称;

n int  age;

n 变量的赋值    age=18;

l 定义时赋值,数据类型    变量名称=值;

n int age = 18;

l 如果一次要声明多个相同类型的变量可用逗号分隔.

n string  zsName,lsName;

l 变量一定要先声明,再赋值,才能使用.

一.1.1.2.3. 变量的命名

l 命名规则：

n 必须以“字母”_或@符号开头.--不要以数字开头

n 后面可以跟任意“字母”、数字、下划线.

l 注意:

n 你起的变量名不要与c#系统中的关键字重复.

n 在c#中,大小写是敏感的.

n 同一个变量名不允许重复定义(先这么认为,不严谨)

l 定义变量时，变量名要有意义

l C# 变量命名编码规范——Camel 命名法：

n 首个单词的首字母小写，其余单词的首字母大写。

l Pascal命名命名规范:每一个单词第一字母都大写

l 如果使用到英文单词的缩写，全部用大写！

一.1.1.2.4. 变量的命名规则

l Pascal 规则
每个单词开头的字母大写(如 TestCounter).

l Camel 规则
除了第一个单词外的其他单词的开头字母大写. 如. testCounter.

l Upper 规则
仅用于一两个字符长的常量的缩写命名,超过三个字符长度应该应用Pascal规则.

例如：

代码如下:

public class Math
{
public const PI = ...
public const E = ...
public const FeigenBaumNumber = ...
}

l 具体的规则总结如下：

• 类命名指导 

n - 类名应该为名词及名词短语，尽可能使用完整的词.

n - 使用Pascal规则

n - 不要使用类前缀 - 不要使用下划线字符 (_)。

n - 有时候需要提供以字母 I 开始的类名称，虽然该类不是接口。只要 I 是作为类名称组成部分的整个单词的第一个字母，这便是适当的。例如，类名称 IdentityStore 就是适当的。

n - 在适当的地方，使用复合单词命名派生的类。派生类名称的第二个部分应当是基类的名称。例如，ApplicationException 对于从名为 Exception 的类派生的类是适当的名称，原因是 ApplicationException 是一种 Exception。请在应用该规则时进行合理的判断。例如，Button 对于从 Control 派生的类是适当的名称。尽管按钮是一种控件，但是将 Control 作为类名称的一部分将使名称不必要地加长。

• 接口命名规则

n - 接口名称应该为名词及名词短语或者描述其行为的形容词，尽可能使用完整的词. (Example IComponent or IEnumberable)

n - 使用Pascal规则

n - 使用字符I为前缀，并紧跟一个大写字母（即接口名的第一个字母大写）
例如：

代码如下:

interface ICompare
{
int Compare();
}

• 枚举命名规则

n - 对于 Enum 类型和值名称使用 Pascal 大小写。
- 少用缩写。

n - 不要在 Enum 类型名称上使用 Enum 后缀。

n - 对大多数 Enum 类型使用单数名称，但是对作为位域的 Enum 类型使用复数名称。

n - 总是将 FlagsAttribute 添加到位域 Enum 类型。

• 变量命名

n - 在简单的循环语句中计数器变量使用 i, j, k, l, m, n

n - 使用 Camel 命名规则

• 方法命名

n - 使用Pascal规则

n - 对方法名采用一致的动词/宾语或宾语/动词顺序。例如，将动词置于前面时，所使用的名称诸如 InsertWidget 和 InsertSprocket；将宾语置于前面时，所使用的名称诸如 WidgetInsert 和 SprocketInsert。

n - 推荐名称应该为动词或动词短语.例如Save，SaveCustomer，而不要使用CustomerSave

n - 不要在方法中重复类的名称。例如，如果某个类已命名为 Book，则不要将某个方法称为 Book.CloseBook，而可以将方法命名为 Book.Close。

• 属性命名

n - 名称应该为名词及名词短语

n - 使用Pascal规则

n - 对于bool型属性或者变量使用Is（is）作为前缀，不要使用Flag后缀，例如应该使用IsDeleted,而不要使用DeleteFlag

• 集合命名

n - 名称应该为名词及名词短语

n - 使用Pascal规则

n - 名称后面追加“Collection”

• 事件命名

n - event handlers命名使用 EventHandler 后缀.

n - 两个参数分别使用 sender 及 e

n - 使用Pascal规则

n - 事件参数使用EventArgs 后缀

n - 事件命名使用语法时态反映其激发的状态，例如 Changed，Changing.

n - 考虑使用动词命名. 变量命名

n - 在简单的循环语句中计数器变量使用 i, j, k, l, m, n

n - 使用 Camel 命名规则

自定义的属性以Attribute结尾

代码如下:

public class AuthorAttribute : Attribute
{
}
自定义的异常以Exception结尾

代码如下:

public class AppException : Exception
{
}

• 其它常用的编码规则

n 代码的缩进。要用Tab，而不要用space.

n 局部变量的名称要有意义。不要用x，y，z等等（除用于For循环变量中可使用i，j，k，l，m，n）。

n 所有的成员变量声明在类的顶端，用一个换行把它和方法分开。

n 用有意义的名字命名namespace，如：产品名、公司名。

n 始终使用"{ }"包含if下的语句，即使只有一条语句。

n 把相似的内容放在一起，比如数据成员、属性、方法、事件等，并适当的使用#region…#endregion。

命名规范的总结用表格表示如下：

2 与类相关

2 与变量名相关

2 与ADO.NET相关

2 与页面控件相关

一.1.1.3. 字符串中的转义

l 能在字符串中输出双引号吗?

n 在屏幕上显示:   c#中的字符串用” ”号包含起来

l \+一个字符,组成转译字符.一般用于表示特殊符号

l @字在字符串前面表示不转译

l 常用的转译符:\n \b \\ \t \”

一.1.1.4. 算术运算符及算术表达式

l 算术运算符:  + - * / %(取余数 取模)

l 算术表达式:由算术运算符连接起来的式子.

n 如:1+1    a-b(变量ab前面已声明并赋初值)

l 优先级:先乘除,后加减,有括号先算括号里的,相同级别的从左至右运算   int a=((1+5)+3)*2

l 小括号可以无限制的套用,但一定要成对出现.

一.1.1.5. 类型自动转换规则

l 参与运算(算术运算和赋值运算)的操作数和结果类型必须一致. 当不一致时,满足下面条件时，系统自动完成类型转换       (隐式转换)

l 两种类型兼容

n 例如：int 和 double 兼容(都是数字类型)

n 目标类型大于源类型

u 例如：double > int

l 对于表达式

n 如果一个操作数为double型，则整个表达式可提升为double型

n 比如前面打8.8折的练习题.

n 求10/3商(Remainder)要想得到3.333的处理.

一.1.1.6. 强制类型转换

l 语法:

n (数据类型名)待转换的值;

l 如:

n int  b  = (int)3.14;

l 强制类型转换,数据类型一定要相兼容 下面的写法对吗？

n int number = (int)”3.14”;（错误）

l 谨记:

n int 转double 隐式转换,多小数,

n double转int显示转换,丢精度.

一.1.1.7. 类型转型

l Convert不再仅是内存级别的转换，而是考虑数据意义的转换。Convert是一个加工、改造的过程。

l 通过 Convert.ToInt32(能转换成int类型的数据)来把其他类型数据转换成int类型。

l 一切类型都可以转换为string类型。

l int.Parse(“3”);

一.1.2. 运算符

一.1.2.0.1. 算术运算符和复合赋值运算符

l ++  自加一     有前加和后加  

l --   自减一   有前减和后减

n 一元运算符++/-- 比二元的 +- 优先级高

l +=   -=    *=   /=    %=

l 对于+-*/%=都需要两个操作数才能进行运算的这些运算符,我们叫做二元运算符

l 对于像++ -- 这样的只需要一个操作数就能进行运算的运算符,我们叫做一元运算符.

一.1.2.0.2. 关系运算符

l >，<

l ==(等于,相等)，!=(不等)

l >=(大于等于,包含)，<=(小于等于,包含)

l 布尔(bool)类型:

n bool值只有两个

u 真:true

u 假:false

l 关系运算的结果是布尔类型的

一.1.2.0.3. 逻辑运算符

l &&(逻辑与) ||(逻辑或)  !(逻辑非)

l 表达式1&&表达式2:当表达式1、2全为true时,其表达式的结果为true

l 表达式1||表达式2:当表达式1、2有一个为true时,其结果为true

l !表达式:如果表达式的结果为true,则取反后为false,反之为true

l 优先级(画个表格)

表达式1&&表达式2

逻辑或 ||

表达式1||表达式2

逻辑非 !

!表达式

一.1.2.0.4. If| if else | if else if语法结构

一.1.2.0.4.1. if结构的基本语法:

if(条件)

{

语句1;语句2;......

}

用一对大括号来组成语句块

一.1.2.0.4.2. If else结构的基本语法:

if(条件)

{

语句1;

}

else

{

语句2;

}

一.1.2.0.4.3. If else if 结构的基本语法

if(条件)

{

语句1;

}

else if(条件)

{

语句2;

}

一.1.3. 流程控制

一.1.3.1. 循环结构

一.1.3.1.1. While循环

l 语法:

while(循环条件)

{

循环体;

}

l 特点：先判断，再执行，循环一次都不执行

一.1.3.1.2. do while 循环

l 语法

do{循环体;}

while(条件);

l 特点：为先执行,再判断，循环会执行一次

一.1.3.1.3. For循环

l 语法:

for(表达式1;表达式2;表达式3)

{

循环体;

};

一.1.3.2. Continue和break

l Continue立即结束本次循环,判断循环条件,如果成立,则进入下一次循环,否则退出循环.

l Breatk用于循环中,退出当前循环.

一.1.3.3. 三元表达式

C#中有一个三元运算符“?:”，语法为：条件表达式？表达式1：表达式2；
该操作首先求出条件表达式的值(bool类型)，为true时调用表达式1，为flase时调用表达式2。其逻辑为：“如果为真执行第一个，否则执行第二个。”
例如:

a=3>4?3:4;输出为4。
a=3<4?3:4;输出为3。

一.1.3.4. try-catch的使用

try

{

有可能出现错误的代码;

}

catch

{

如果try中的代码出现异常,则进去catch中

}

finally

{

最后执行的代码

}

在 try 块中获取并使用资源，在 catch 块中处理异常情况，并在 finally 块中释放资源。

throw:

注意：

关于 try catch finally 与 return 的使用关系，可以参照一下链接

https://blog.csdn.net/u010533180/article/details/53064257

一.1.4. 复杂数据类型

一.1.4.1. 常量\枚举\结构的运用

一.1.4.1.1. 理论：

l 常量：

const  类型 常量名 = 常量值

确定数量、确定值的几个取值：东西南北、男女、上中下。

l 枚举： 

enum Gender{male,female}

字符串与枚举的转换：(Gender)(Enum.Parse( typeof(Gender),“male”));每一个值都对应一个数字

l 结构体：

访问修饰符struct结构名

{

  定义结构成员

}

一.1.4.1.2. 实操：

l const

tatic void Main(string[] args)

{

       const int  PI = 3.14;

       PI = 3.20;

}

l enum

enum QQStatus{online,offline,hidden}

QQStatus status = QQStatus.online;

l 结构体和枚举的运用

?定义一个结构类型Person,有三个成员,分别为姓名,性别,年龄 性别用枚举类型

–声明两个Person类型的变量,分别表示 张三 男  18岁/ 小兰 女 16岁

class Program

   {

       public enum Gender {femal,meal};

       public struct person { public string name; public int age; public  Gender  gender;}

       static void Main(string[] args)

       {

           //定义一个结构类型Person,有三个成员,分别为姓名,性别,年龄 性别用枚举类型

           //声明两个Person类型的变量,分别表示 张三 男  18岁/ 小兰 女 16岁

           person p1 = new person();

           p1.name = "张三";

           p1.gender = Gender.femal;

           p1.age = 18;

           person p2 = new person();

           p2.name = "小兰";

           p2.gender = Gender.meal;

           p2.age = 16;

           Console.WriteLine("大家好，我是{0}，是个{1}生,今年{2}岁",p1.name,p1.gender,p1.age);

           Console.WriteLine("大家好，我是{0}，是个{1}生,今年{2}岁", p2.name, p2.gender, p2.age);

           Console.ReadKey();

       }    

   }

一.1.4.2. 数组

一.1.4.2.1. 理论

保存多个值;几乎任意类型都可以声明数组; int[] nums = new int[3]；int[] nums = {5,3,8}；

in[]nums=new int[3]{1,2,3}；int[]nums=new int[]{2,3,5};

int[] nums = new int[3]{5,3,8}//个数和声明数必须一致

int[] nums = new int[5]{5,3,8}//错误

int[] nums = new int[]{5,3,8}//正确,可以省略数组个字

数组的声明:以上四种

使用索引器访问指定编号位置的元素，访问数组元素：nums[0]、nums[1]。索引从0开始。取到的元素的类型就是数组元素的类型。还可以对数组元素进行赋值。

常见问题:求平均值,求最大值,求和,排序

Array排序 和反序

一.1.4.2.2. 实操

数组里面都是人的名字,分割成:例如:老杨|老苏|老邹…”

string names = "";

string[] name = new string[8] { "老杨", "老苏", "老邹", "老虎", "老牛", "老蒋", "老王", "老马" };

for (int i = 0; i < name.Length - 1; i++)

{

    names += name[i] + "|";

}

Console.Write(names + name[name.Length - 1]);

Console.ReadKey();

将一个整数数组的每一个元素进行如下的处理：如果元素是正数则将这个位置的元素的值加1，如果元素是负数则将这个位置的元素的值减1,如果元素是0,则不变。

for (int i = 0; i < num.Length; i++)

      {

          Console.WriteLine(num[i]);

      }

      Console.WriteLine("----------------------------");

for (int i = 0; i < num.Length; i++)

     { 

          if(num[i]<0)

          {

              num[i]--;

          }

          else if (num[i] > 0)

          {

              num[i]++;

          }

          else

          {

          }

         <br>                  Console.WriteLine("现在的值是：{0}",num[i]);

     }<br>                 Console.ReadKey();

 将一个字符串数组的元素的顺序进行反转。{“我”,“是”,”好人”} {“好人”,”是”,”我”}。第i个和第length-i-1个进行交换

string  [] str = {"我","是","好人" };

for (int i = 0; i < str.Length/2; i++)

{

   string temp = str[i];

   str[i] = str[str.Length - 1 - i];

   str[str.Length - 1 - i] = temp;  

}

for (int i = 0; i < str.Length; i++)

{

    Console.Write(str[i]);

}

   Console.ReadKey();

从一个整数数组中取出最大的整数,最小整数,总和,平均值

int[] num = { 51, 21, 82, 41, 10, -5 };

int max = 0;

int min = 0;

int sum = 0;

for (int i = 0; i < num.Length; i++)

{

    if (num[i] > max)

    {

        max = num[i];

    }

    else if (num[i] < min)

    {

        min = num[i];

    }

    sum = sum + num[i];

}

Console.WriteLine("最大的整数是：{0},最小的整数是：{1}", max, min);

Console.WriteLine("总和是{0}，平均值是:{1}", sum, sum /num.Length);

Console.ReadKey();

一.1.5. 函数

一.1.5.1. 语法介绍

一.1.5.1.1. 为什么使用函数？

l 如果想要重复执行某段代码，那就需要写重复的代码

l 目前我们写的代码越来越多，结构非常混乱，不容易阅读

所以函数就来了，函数就是方法

一.1.5.1.2. 函数体介绍

一.1.5.1.3. 函数的定义和使用

一.1.5.1.4. 带参和无参

一.1.5.1.5. 参数不确定长度的方法

一.1.5.1.6. 

一.1.5.1.7. 结构函数

一.1.5.1.8. 函数的重载（Overload）:函数名相同，参数不同，返回值无所谓

一.1.5.1.9. 委托

一.1.5.2. 函数实践

using System;

namespace 函数定义使用

{

    /// <summary>

    /// 结构体函数

    /// </summary>

    struct CalculatDistance

    {

        public float x;

        public float y;

        public float z;

        /// <summary>

        /// 计算向量长度

        /// </summary>

        /// <returns></returns>

        public double Distance()

        {

            return Math.Sqrt(x * x + y * y + z * z);

        }

    }

    delegate double myDelegate(double par1, double par2);

    class Program

    {

        static void Main(string[] args)

        {

            OutPutLog();//无法无返回值

            int num1 = PlusNum(3, 4);//带固定长度参带返回值

            Console.WriteLine("调用PlusNum函数的结果是：" + num1);

            //带不固定参数长度带返回值

            int[] tempArr = new int[] { 32, 5, 866, 23, 9, 76 };

            int num2 = Sum(23, 5436, 547, 235, 658);

            Console.WriteLine("调用Sum函数直接传参的结果是：" + num2);

            int num3 = Sum(tempArr);

            Console.WriteLine("调用Sum函数传递数组的结果是：" + num3);

            //结构体函数实践

            CalculatDistance calculatDistance;

            calculatDistance.x = 3;

            calculatDistance.y = 4;

            calculatDistance.z = 5;

            Console.WriteLine("使用结构体函数计算向量的结果是：" + calculatDistance.Distance());

            //重载

            OverMath(2.3f, 34);

            OverMath(4, 5);

            //委托

            double do1 = 13.45;

            double do2 = 23.67;

            myDelegate de;

            de = Delegate1;

            de(do1, do2);

            de = Delegate2;

            de(do1, do2);

            //递归调用

            int mNum = F(40);

            Console.WriteLine("递归调用40的结果是：" + mNum);

            Console.ReadKey();

        }

        /// <summary>

        /// 不带参数没有返回值的方法

        /// </summary>

        static void OutPutLog()

        {

            Console.WriteLine("这是一个无参的空方法体");

        }

        /// <summary>

        /// 返回值为int,参数类型和参数数量确定的方法

        /// </summary>

        /// <param name="a"></param>

        /// <param name="b"></param>

        /// <returns></returns>

        static int PlusNum(int a, int b)

        {

            return a + b;

        }

        /// <summary>

        /// 参数为参数数组类型，可用于不确定长度的参数传递

        /// </summary>

        /// <param name="array"></param>

        /// <returns></returns>

        static int Sum(params int[] array)

        {

            int temp = 0;

            for (int i = 0; i < array.Length; i++)

            {

                temp += array[i];

            }

            return temp;

        }

        static void OverMath(int a, int b)

        {

            Console.WriteLine("这个是两个int类型的数字相乘的结果：" + (a * b));

        }

        static void OverMath(float a, double b)

        {

            Console.WriteLine("这个是一个float 一个double类型的数字相乘的结果：" + (a * b));

        }

        static double Delegate1(double dou1, double dou2)

        {

            Console.WriteLine("计算两个数相乘的结果是:" + dou1 * dou2);

            return dou1 * dou2;

        }

        static double Delegate2(double dou1, double dou2)

        {

            Console.WriteLine("计算两个数相除的结果是:" + dou1 / dou2);

            return dou1 / dou2;

        }

        /// <summary>

        /// 递归调用

        /// </summary>

        /// <param name="n"></param>

        /// <returns></returns>

        static int F(int n)

        {

            //递归终止条件

            if (n == 0) return 2;

            if (n == 1) return 3;

            //返回值

            return F(n - 1) + F(n - 2);

        }

    }

}

第一章 .NET基础-C#基础

原文：https://www.cnblogs.com/szb-315/p/10409528.html