C# 学习记录 基础篇

C#的开始

命名空间

命名空间是程序的内部的组织系统，向外公开的组织系统

命名空间好比是不同储存的仓库，using关键字 就像把仓库的钥匙，命名空间的名称可以对应着仓库名称，特定的钥匙可以打开指定的仓库名称，从而在仓库中获取所需的物品

using系统命名空间

引入系统空间来使用

using [命名空间名称]

namespace用户自定义命名空间

自行创建的命名空间，可以控制空间内里的类和方法，可以引用 用户自定义命名空间 里的 类和方法

namespace [命名空间名];

类

一种数据结构，存储数据成员、方法成员和其它类等内容，便于调用

[类修饰符] class [类名] [基类 或 接口]
{
    
    
    [类体，内容区块]
}

Main方法

Main方法是程序的入口点，程序中必须有一个Main方法

static void Main(string[] args)
{
    
    
	[方法体，内容区块]
}

Main方法创建要求：

• 方法必须静态 static
• 方法名Main 首字母必须为大写
• 返回值是 void 或 int
• 命令行参数可选（在使用命令行参数的使用）

标识符

标识符用来标识 类名、变量名、方法名、数组名、文件名的有效字符序列

命名规则：

• 首字母必须为 字母 或 下划线 _
• 其余部分可以有：字母、数字、下划线 _

程序命名规范 （好习惯）

项目名：公司+产品名

命名空间名：公司名称 / 产品名称

接口名：名称前缀加 字母 I（大写I）

类名：功能以及操作的说明

方法名：动宾短语，行为的说明

成员变量：名称前缀加 字符 _ （下划线）

//系统命名空间
using System;
//用户自定义命名空间
namespace _2._2._1
{
    
    
    //类
    class Program
    {
    
    
        //Main方法，入口方法
        static void Main(string[] args)
        {
    
    
            //输出Hello World!
            Console.WriteLine("Hello World!");
            Console.ReadLine();

        }

    }
}

变量

一个变量就是存储区(内存)中的一个存储单元

变量的命名规则：

• 变量名只能由数字、字母和下划线组成
• 变量名第一个符号只能是字母和下划线，不能是数字
• 不能使用关键字作为变量名

声明变量

声明变量是根据类型分配空间来初始化内存空间

声明语法：

1. 变量类型 变量名 = 数值；
2. 变量类型 变量名；变量名 = 数值；
3. 变量类型 变量名1，…，变量名n；

赋值变量

使用赋值运算符=来给变量赋值，左边为值右边为变量

int i;
i = 4;

变量的作用域

成员变量

类内定义的变量称为成员变量，成员变量限于类中有效

也可以声明静态的变量，在类型前面添加static关键字，可跨类使用变量！

局部变量

类方法中定义变量或循环范围内，变量会仅限于范围内的使用

数值类型

数值类型决定了变量类型，值类型是从System.ValueType类继承来的

特性：

• 值类型变量都存储在栈中
• 访问值类型变量时，一般都是直接访问实例
• 每个值类型变量都有自己的数据副本，因此不会影响其他变量
• 复制值类型变量时，复制的是变量的值，而不是变量的地址
• 值类型变量不能为null，必须具有一个确定的值

整数类型

类型	说明	范围
sbyte	8位有字符	-128~127
short	16位有字符	-32768~32767
int	32位有字符	···
long	64位有字符	···
byte	8位无字符	0~255
ushort	16位无字符	0~65535
uint	32位无字符	0~4294967295
ulong	64位无字符	···

浮点型

类型	说明
float	7位数
double	16位数

布尔型

bool 关键字 布尔类型 主要分为true（真）、false（假）值

枚举型

枚举型具有相同性质的 常量，可以将多个不同的名称组成

enum 枚举名{
    
    
    //定义常量区块
    list1 = value1;
    list2 = value2;
    ·····
    listN = valueN;
}

//调用
枚举名.listN

类型转换

隐式转换

不需要声明就能进行类型转换

显示转换

需要强制转换，要明确转换类型

• （类型名）表达式
• Convert.To类型名（表达式）（常用的）
• 类型名.Parse（表达式）

装箱

装箱允许将值类型隐式转换成引用类型

int i = 2020;
object obj = i;//装箱

拆箱

拆箱允许将引用类型显示转换为值类型

int i = 2020;
object obj = i;
int j = (int)obj;//拆箱

常量

常量是固定不变的量，是在声明的时候就已经固定了

表达式

表达式是由运算符合操作数组成的

运算符

算术运算符

运算符的符号 ：+、-、*、/、%

赋值运算符

赋值运算符为变量、属性、事件等元素赋新值

名称	运算符	运算规则	意义
赋值	=	将表达式赋值给变量	将右边的值给左边
加赋值	+=	x+=y	x = x + y
减赋值	-=	x-=y	x = x - y
除赋值	/=	x/=y	x = x / y
乘赋值	*=	x*=y	x = x * y
模赋值	%=	x%=y	x = x%y
位与赋值	&=	x &= y	x = x & y
位或赋值	|=	x|=y	x = x | y
右移赋值	>>=	x>>=y	x = x>>y
左移赋值	<<=	x<<=y	x = x<<y
异或赋值	^=	x^=y	x = x ^y

关系运算符

关系运算符用来比较并得出真、假、相同

修饰符	运算符	说明
bool	>	比较左边是否大于右边
bool	<	比较右边是否大于左边
bool	==	比较双方是否相同
bool	>=	比较左边是否大于等于右边
bool	<=	比较右边是否大于等于左边
bool	!=	比较双方是否不相同

逻辑运算符

逻辑运算符是组合的关系运算结构构成的表达式

运算符	含义	说明
&&、&	与	双方为真，则真
||	或	一方为真，则真
！	非	本身为真，则假

例子：

bool a = true , b = false , c = true , d = false;

a && b //结果为false
a && c //结果为true
a && d //结果为false

a || b //结果为true
a || c //结果为true
a || d //结果为true

!a //结果为false
!b //结果为true
!c //结果为false
!d //结果为true

位运算符

位运算符完全针对位方面进行操作的。

位与

用 “&” 代表，两个整型变量，两个二进制1是对应相同字符则为1

5 & 7 == 5(0000 101)

0000 0101（5）
0000 0111（7）

位或

用 “ | ” 代表，两个整型变量，两个二进制0是对应的相同字符则为1

3 | 6 == 7（0000 0111）

0000 0011（3）
0000 0110（6）

取反

用 “ ~ ” 代表，是将进制中的0和1调换

~7 == 8

0111 → 1000

异或

用 “ ^ ” 代表，两个二进制 同时为0 或 同时为1 时，则为 0

10 ^ 3 == 9（0000 1001）

0000 1010（10）
0000 0011（3）

位移

用“ >> ”或“ << ”表示，以二进制移位

左移

48 << 2 == 45 * 2 * 2 = 192

0011 0000
1100 0000

右移

48 >> 2 == 48 / (2 * 2) = 12
0011 0000
0000 1100

负数则补1

其他特殊运算符

is运算符

用于检查变量是否为指定的类型

int i = 3;
bool isint = i is int;

i为整型：true，否则false

条件运算符

用“ ?: ” 根据布尔值返回两个值中的一个，1则 true ，2则 false

bool iscompare = 3 > 2;

String yeson = iscompare? “是” : “不是”

也可以

Console.WriteLine(“3>2? {0}”,3>2?“true”:”false”);

new运算符

用于创建一个新的类型实例 ,实例有以下形式：

对象（类型、值类型）：String str = new String(“你好”);

数组 : int[] a = new int[20];

代表 : int i = new int(); （只是个代表）

typeof运算符

用于获取系统原型对象的类型，也是Type对象，Type类包含相关的类型和引用类型的信息等

Type mytype = typeof(int);
Console.WriteLine(mytype);

结果：System.Int32

运算符优先级

可决定代码执行的先后顺序，一下表有大到小（上到下）

类型	运算符
基本	x.y、f(x)、a[x]、x++、x–、new、typeof、checked、unchecked
一元	+、-、!、~、++x、(T)x
乘除	*、/、%
加减	+、-
位移	<<、>>
比较	<、>、<=、>=、is、as
相等	== 、!=
位与	&
位异或	^
位或	|
逻辑与	&&
逻辑或	||
条件	?:
赋值	=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=

字符（Char）

Char类主要用来存储单个字符，占用16位（字节2）的内存空间

注意：

Char只是定义 Unicode字符 ， Unicode字符是计算机通用的字符编码

常用方法

方法	说明
IsControl（char）	是否属于控制字符类型
IsDigit（cahr ）	是否属于十进制数字类型
IsHighSurrogate（cahr ）	指定Char对象是否为高代理项
IsLetter（cahr ）	是否属于字母
IsLetterOrDigit（cahr ）	是否属于 字母 || 十进制数字
IsLower（cahr ）	是否属于 小写字母
IsLowSurrogate（cahr ）	指定Char对象是否为底代理项
IsNumber（cahr ）	是否属于数字
IsPunctuation（cahr ）	是否属于标点符号
IsSeparator（cahr ）	是否属于分隔符
IsSurrogate（cahr ）	是否属于代理项字符
IsSurrogatePair（cahr ）	Char对象是否形成代理项对
IsSymbol（cahr ）	是否属于符号字符
IsUpper（cahr ）	是否属于大写字母
IsWhiteSpace（cahr ）	是否属于空白
Parse（cahr ）	将制定字符串 转换为 等效Unicode字符
ToLower（cahr ）	将Unicode字符 转换为 小写等效项
ToLowerInvariant （cahr ）	使用固定区域性的大小写规则，将Unicode字符的值 转换为 小写等效项
ToString（cahr ）	将实例的值 转换为 等效的字符串
ToUpper（cahr ）	将Unicode字符的值 转换为 大写等效项
ToUpperInvariant（cahr ）	使用固定区域性的大小写规则，将Unicode字符的值 转换为 大写等效项
TryParse（cahr ）	将指定字符串的值 转换为 Unicode字符的值

代码例子：

static void Main(string[] args)
{
    
    
            char a = 'a';
            char b = '8';
            char c = 'C';
            char d = ',';
            char e = ' ';
            char f = '|';
            Console.WriteLine("a={0}\nb={1}\nc={2}\nd={3}\ne={4}", a,b,c,d,e);
            Console.WriteLine("IsControl是否属于控制字符类型。 \ta?{0}\tb?{1}", Char.IsControl(a),Char.IsControl(b));
            Console.WriteLine("IsDigit是否属于十进制数字类型。\ta?{0}\tb?{1}", Char.IsDigit(a), Char.IsDigit(b));
            Console.WriteLine("IsHighSurrogate指定Char对象是否为高代理项。\ta?{0}\tb?{1}", Char.IsHighSurrogate(a), Char.IsHighSurrogate(b));
            Console.WriteLine("IsLetter 是否属于字母。\ta?{0}\tb?{1}", Char.IsLetter(a), Char.IsLetter(b));
            Console.WriteLine("IsLetterOrDigit 是否属于 字母 || 十进制数字。\ta?{0}\tb?{1}", Char.IsLetterOrDigit(a), Char.IsLetterOrDigit(b));
            Console.WriteLine("IsLower  是否属于 小写字母。\ta?{0}\tc?{1}", Char.IsLower(a), Char.IsLower(c));
            Console.WriteLine("IsLowSurrogate   指定Char对象是否为底代理项。\ta?{0}\tc?{1}", Char.IsLowSurrogate(a), Char.IsLowSurrogate(c));
            Console.WriteLine("IsNumber    是否属于数字。\ta?{0}\tb?{1}", Char.IsNumber(a), Char.IsNumber(b));
            Console.WriteLine("IsPunctuation    是否属于标点符号。\ta?{0}\td?{1}", Char.IsPunctuation(a), Char.IsPunctuation(d));
            Console.WriteLine("IsSeparator     是否属于分隔符。\ta?{0}\tf?{1}", Char.IsSeparator(a), Char.IsSeparator(f));
            Console.WriteLine("IsWhiteSpace    是否属于空白。\ta?{0}\te?{1}", Char.IsWhiteSpace(a), Char.IsWhiteSpace(e));
            Console.WriteLine("IsUpper     是否属于大写字母。\ta?{0}\tc?{1}", Char.IsUpper(a), Char.IsUpper(c));
            Console.WriteLine("IsUpper     是否属于大写字母。\ta?{0}\tc?{1}", Char.IsUpper(a), Char.IsUpper(c));
}

运行结果

a=a
b=8
c=C
d=,
e=
IsControl是否属于控制字符类型。         a?False b?False
IsDigit是否属于十进制数字类型。 a?False b?True
IsHighSurrogate指定Char对象是否为高代理项。     a?False b?False
IsLetter?是否属于字母。 a?True  b?False
IsLetterOrDigit 是否属于 字母 || 十进制数字。   a?True  b?True
IsLower  是否属于 小写字母。    a?True  c?False
IsLowSurrogate   指定Char对象是否为底代理项。   a?False c?False
IsNumber    是否属于数字。      a?False b?True
IsPunctuation    是否属于标点符号。     a?False d?True
IsSeparator?    是否属于分隔符。        a?False f?False
IsWhiteSpace?   是否属于空白。  a?False e?True
IsUpper ?   是否属于大写字母。  a?False c?True
IsUpper ?   是否属于大写字母。  a?False c?True

转义字符

代表特殊的字符变量，是以反斜杠开头的\,后随有字符

转义符	说明
\n	回车换行
\t	横向跳到下一制表位置
\"	双引号
\b	退格
\r	回车
\f	换页
\\	反斜线符
\'	单引号符

字符串（String）

String能表示多个字符的组合。而char只能一个字符

比较字符串

方法

修饰符	方法	说明
int	compare（string str ,string str2）	比较两字符串是否相同，str大则为1，相同为0，str小为-1
int	compare（string str ,string str2 , bool ignorCase）	比较两字符串是否相同，忽略大小写，str大则为1，相同为0，str小为-1
int	str.CompareTo（string str2）	比较两字符串是否相同，str大则为1，相同为0，str小为-1
bool	str.Equals（string str2）	比较两字符串是否相同（区分大小写）
bool	Equals（string str , string str2）	比较两字符串是否相同（区分大小写）

格式化字符串

Format（） 静态方法，用于将字符串数据格式化成指定的格式

格式规范

格式说明符	名称
C 、c	货币
D、d	Decimal
E、e	指数
F、f	定点
N、n	Number
P、p	百分比
“X”、“x”	十六进制

public static string Format(string format , object obj);

format： 用来指定字符串需要用的格式
obj： 被格式化的对象

截取字符串

Substring（） 方法，截取字符串中指定位置和指定长度的子字符串

public string Substring(int startindex , int length);

startindex： 截取开始的索引位置
**length： ** 截取子字符串的字符数

分割字符串

Split（） 方法，用于分割字符串

public string[] Split(params char[] separator);

separator： 数组，包含分隔符

插入字符串

Insert（） 方法，用于向字符串插入新元素

public string Insert(int strartindex , string value);

strartindex： 插入指定索引位置
value： 要插入的字符串

填充字符串

PadLeft（） 方法，在字符串的左侧对字符串进行填充

PadRight（） 方法，在字符串的右侧对字符串进行填充

public string PadLeft(int totalWidth , char paddingCahr);
public string PadRight(int totalWidth , char paddingCahr);

**totalWidth： ** 填充字符串的长度
paddingCahr： 要指定的填充字符，可填充空格

删除字符串

Remove（） 方法，用于从一个字符串的指定位置开始，删除指定数量的字符

public Stirng Remove(int startIndex);
public Stirng Remove(int startIndex , int count);

startIndex： 指定删除的索引位置
count： 指定删除数量

复制字符串

CopyTo（） 方法，将字符串某部分复制到另一个数组中

public void CopyTo(int sourceIndex , char[] destination , int destinationindex , int count);

sourceIndex： 要复制的开始索引位置
destination： 指定存放数组
destinationindex： 指定目标数组中开始存放的索引位置
count： 复制字符的个数

替换字符串

Replace（） 方法，用于将字符串中的某个字符或字符串进行转换其他字符 Replace

public string Replace(char OChar , char NChar);
public string Replace(string OValue , string NValue);

OChar： 要替换的字符
NChar： 替换后的新字符
OValue： 要替换的字符串
NValue： 替换后的新字符串

例子：

static void Main(string[] args)
{
    
    
    String str = new string("Hello World!");
    Console.WriteLine("str = " + str);

    Console.WriteLine("格式化字符串:(C){0:c}", 12);

    Console.WriteLine("截取字符串(6, 5){0}", str.Substring(6, 5));

    char[] ch = new char[] {
    
     'o', 'e' };
    String[] tmp = str.Split(ch);
    Console.WriteLine("分割字符串(o , e) Hello World!");
    for (int i = 0; i < tmp.Length; i++)
    {
    
    
        Console.WriteLine("分割组{0} : {1}", i, tmp[i]);
    }

    Console.WriteLine("插入字符串(12,Sanscan):" + str.Insert(12, "Sanscan"));

    Console.WriteLine("填充字符串左(5,'C'):" + str.PadLeft(5, 'C'));
    Console.WriteLine("填充字符串右(5,'C'):" + str.PadRight(5, 'C'));

    Console.WriteLine("删除字符串(5):" + str.Remove(5));
    Console.WriteLine("删除字符串(5 , 3):" + str.Remove(5, 3));

    char[] ch2 = new char[str.Length];
    str.CopyTo(5, ch2, 0, 3);
    Console.WriteLine("复制字符串(5, ch2, 0, 3):" );
    for (int i = 0; i < ch2.Length; i++)
    {
    
    
        Console.Write(ch2[i]);
    }
    Console.WriteLine();

    Console.WriteLine("替换字符('H',h):"+str.Replace('H','h'));
    Console.WriteLine("替换字符(Wor,wcr):" + str.Replace("Wor", "wcr"));

}

运行结果

str = Hello World!
格式化字符串:(C)￥12.00
截取字符串(6, 5)World
分割字符串(o , e) Hello World!
分割组0 : H
分割组1 : ll
分割组2 :  W
分割组3 : rld!
插入字符串(12,Sanscan):Hello World!Sanscan
填充字符串左(5,'C'):Hello World!
填充字符串右(5,'C'):Hello World!
删除字符串(5):Hello
删除字符串(5 , 3):Hellorld!
复制字符串(5, ch2, 0, 3):
 Wo
替换字符('H',h):hello World!
替换字符(Wor,wcr):Hello wcrld!

可变字符串类

该对象有固定的长度，可以通过+可以附加新字符，可提高频繁添加字符的效率！

区别：追加字符无需新对象的附加，而是在它本身对象追加字符串

StringBuilder类的定义（构造方法）

StringBuilder（）

StringBuilder（int capacity）

StringBuilder（string value）

StringBuilder（int capacity , int maxCapacity）

StringBuilder（string value , int capacity）

StringBuilder（string value , int startlndex , int length , int capacity）

capacity： 定义初始大小
value： 初始值 字符串
maxCapacity： 最大存储大小
startlndex： 指定索引的开始位置
length： 指定索引可

方法

方法	说明
StringBuilder.Append（str）	将字符串或文本追加到指定对象末尾
StringBuilder.AppendFormat（格式 , object）	自定义变量的格式并将它们追加到对象末尾
StringBuilder.Insert（int , String）	将字符串或对象添加到指定位置
StringBuilder.Remove（int index , int length）	移除对象指定数量的字符，从index开始移除length个
StringBuilder.Replace（String , String）	用另一个指定字符来替换对象内的字符(前者被修改为后者)

static void Main(String[] args) 
{
    
    
           StringBuilder str = new StringBuilder("123");
           Console.WriteLine(str);

           str.Append("456");
           Console.WriteLine(str);

           str.AppendFormat("{0:C}","789");
           Console.WriteLine(str);

           str.Insert(0, "111排列：");
           Console.WriteLine(str);

           str.Remove(0, 3);
           Console.WriteLine(str);

           str.Replace("排列","顺序队列"); 
           Console.WriteLine(str);

}

运行结果

123
123456
123456789
111排列：123456789
排列：123456789
顺序队列：123456789

---

以上是个人学习后写出来的代码分享，如果有问题可在下面留言！