【C#学习01】 -基础知识语法

最新推荐文章于 2024-04-26 23:25:13 发布

Freedom_Bule

最新推荐文章于 2024-04-26 23:25:13 发布

阅读量703

点赞数 1

分类专栏： C# 文章标签： c# 后端

本文链接：https://blog.csdn.net/qq_41488943/article/details/112248764

版权

C# 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

语言特点

C# 语法高度重视表达，但学习起来也很简单轻松。任何熟悉 C、C++、Java 或 JavaScript 的人都可以立即认出 C# 的大括号语法。通常情况下，了解上述任何一种语言的开发者都可在短时间内使用 C# 高效工作。 C# 可提供强大的功能，例如可以为 null 的类型、委托、Lambda 表达式、模式匹配和安全直接内存访问。 C# 支持泛型方法和类型，因此增强了类型安全性和性能。 C# 可提供迭代器，使集合类的实现者可以定义客户端代码的自定义行为。语言集成查询 (LINQ) 表达式让强类型查询成为最高级的语言构造。

作为面向对象的语言，C# 支持封装、继承和多态性这些概念。虽然类可能会直接继承一个父类，但可以实现任意数量的接口。若要用方法重写父类中的虚方法，必须使用 override 关键字，以免发生意外重定义。在 C# 中，结构就像是轻量级类，是可以实现接口但不支持继承的堆栈分配类型。 C# 还可提供记录，这些记录是主要用于存储数据值的类类型。

简单的运行情况如下
```
using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello, World");
    }
}
```
```
Hello, World
```
程序结构

c# 中的关键组织结构概念包括程序、命名空间、类型、成员和程序集。程序声明类型，而类型则包含成员，并被整理到命名空间中。类型示例包括类、结构和接口。成员示例包括字段、方法、属性和事件。编译完的 C# 程序实际上会打包到程序集中。程序集的文件扩展名通常为 .exe 或 .dll，具体取决于实现的是***应用程序***还是***库***。
使用举例

using System;

namespace Acme.Collections
{
    public class Stack<T>
    {
        Entry _top;
        
        public void Push(T data)
        {
            _top = new Entry(_top, data);
        }

        public T Pop()
        {
            if (_top == null)
            {
                throw new InvalidOperationException();
            }
            T result = _top.Data;
            _top = _top.Next;
            
            return result;
        }

        class Entry
        {
            public Entry Next { get; set; }
            public T Data { get; set; }
            
            public Entry(Entry next, T data)
            {
                Next = next;
                Data = data;
            }
        }
    }
}

此类的完全限定的名称为 Acme.Collections.Stack。此类包含多个成员：一个 top 字段、两个方法（Push 和 Pop）和一个 Entry 嵌套类。 Entry 类还包含三个成员：一个 next 字段、一个 data 字段和一个构造函数。 Stack 是泛型类。它具有一个类型参数 T，在使用时替换为具体类型。

需要注意的是：

序集包含中间语言 (IL) 指令形式的可执行代码和元数据形式的符号信息。执行前，.NET 公共语言运行时的实时 (JIT) 编译器会将程序集中的 IL 代码转换为特定于处理器的代码。由于程序集是包含代码和元数据的自描述功能单元，因此无需在 C# 中使用 #include 指令和头文件。只需在编译程序时引用特定的程序集，即可在 C# 程序中使用此程序集中包含的公共类型和成员 - 这是C#的突出特点，也是其简单的重要原因

C#程序结构

一个完整的C#程序主要包括以下的部分：

命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释

一个简单的实例程序如下所示

using System;

namespace HelloWorldApplication         //命名空间的名字可以自定义
{
    class Program                       //类的名字也可以自定义
    {
        static void Main(string[] args)             //主函数入口main方法
        {
            Console.WriteLine("hello world");       //输出换行
            Console.Write("this is a test");        //输出不换行
            Console.ReadKey();                      //等待用户按下任意键退出，防止程序一闪而过
            Console.Read();                         //读取键盘输入的第一个字符，再次按下回车键才退出
        }
    }
}

需要注意的点如下

C# 是大小写敏感的。
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称。

编译执行方式

使用IDE执行

如果使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：

启动 Visual Studio。
在菜单栏上，选择 File -> New -> Project。
从模板中选择 Visual C#，然后选择 Windows。
选择 Console Application。
为您的项目制定一个名称，然后点击 OK 按钮。
新项目会出现在解决方案资源管理器（Solution Explorer）中。
在代码编辑器（Code Editor）中编写代码。
点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 Hello World。

执行情况如下

使用命令行的方式

也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：

打开一个文本编辑器，添加上面提到的代码。
保存文件为 helloworld.cs。
打开命令提示符工具，定位到文件所保存的目录。
键入 csc helloworld.cs 并按下 enter 键来编译代码。
如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件。
接下来，键入 helloworld 来执行程序。
将看到 “Hello World” 打印在屏幕上。

小技巧

首先进行注释：选中需要注释的代码，然后先进行CTRL+K键结合，然后进行CTRL+C就可以注释选中的代码。
取消注释就是：选中需要取消注释的代码，然后及逆行CTRL+K键，然后进行CTRL+U就可以取消注释选中的代码。

C#基本语法

标识符

标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：（同C或者C++语言的类型相同类似）

标识符必须以字母、下划线或 **@** 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。 – 这点是挺重要的
标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ’ / \。
标识符不能是 C# 关键字。除非它们有一个 @ 前缀。例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
不能与C#的类库名称相同。

常用的关键字如下

保留关键字

abstract	as	base	bool	break	byte	case
catch	char	checked	class	const	continue	decimal
default	delegate	do	double	else	enum	event
explicit	extern	false	finally	fixed	float	for
foreach	goto	if	implicit	in	in (generic modifier)	int
interface	internal	is	lock	long	namespace	new
null	object	operator	out	out (generic modifier)	override	params
private	protected	public	readonly	ref	return	sbyte
sealed	short	sizeof	stackalloc	static	string	struct
switch	this	throw	true	try	typeof	uint
ulong	unchecked	unsafe	ushort	using	virtual	void
volatile	while

上下文关键字

add	alias	ascending	descending	dynamic	from	get
global	group	into	join	let	orderby	partial (type)
partial (method)	remove	select	set

一个简单的示例如下

using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // 成员变量
        double length;	//声明长度
        double width;	//声明宽度
        public void Acceptdetails()		//赋值的方法
        {
            length = 4.5;    
            width = 3.5;	
        }
        public double GetArea()			//计算的方法
        {
            return length * width;
        }
        public void Display()			//打印的方法
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
   
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();	//实体化
            r.Acceptdetails();				//使用rectang方法
            r.Display();					//使用display方法
            Console.ReadLine();
        }
    }
}

这段代码中，逻辑如下：

首先进入 Main 方法，创建一个名称为 r 的实例。
然后调用 Acceptdetails 给 r 进行赋值。
最后调用 Display 方法打印结果。
而用于计算的 GetArea 方法在在调用 Display 时直接打印出来。

C#中的数据类型

值的类型

bool	布尔值	True 或 False	False
byte	8 位无符号整数	0 到 255	0
char	16 位 Unicode 字符	U +0000 到 U +ffff	‘\0’
decimal	128 位精确的十进制值，28-29 有效位数	(-7.9 x 1028 到 7.9 x 1028) / 100 到 28	0.0M
double	64 位双精度浮点型	(+/-)5.0 x 10-324 到 (+/-)1.7 x 10308	0.0D
float	32 位单精度浮点型	-3.4 x 1038 到 + 3.4 x 1038	0.0F
int	32 位有符号整数类型	-2,147,483,648 到 2,147,483,647	0
long	64 位有符号整数类型	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
sbyte	8 位有符号整数类型	-128 到 127	0
short	16 位有符号整数类型	-32,768 到 32,767	0
uint	32 位无符号整数类型	0 到 4,294,967,295	0
ulong	64 位无符号整数类型	0 到 18,446,744,073,709,551,615	0
ushort	16 位无符号整数类型	0 到 65,535	0

需要注意的是c#中byte占一个字节，char占两个字节；C和C++中是char占一个字节为最小量

引用的类型

关于装箱和拆箱

装箱：值类型转换为对象类型, 实例：

int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）

拆箱：之前由值类型转换而来的对象类型再转回值类型, 实例：

int val = 8;
object obj = val;//先装箱
int nval = （int）obj;//再拆箱

只有装过箱的数据才能拆箱

C#类型转换

类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：

隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。

类型之间的转换 - Convert 和 Parse

string locstr = 123.ToString();

//如果要将"locstr"转成整型数

//方法一: 用 Convert 
int i = Convert.ToInt16(locstr);

//方法二: 用 Parse
int ii = int.Parse(locstr);

note：

使用convert的时候存在四舍五入的情况，而使用int的时候不会有这种情况
parse更多的是将两种完全不同的类型进行转换，如将string转黄为int类型 – 常用于提取url中存在的数字

string a = "123";
int x = int.Parse(a);

使用数据转换的经验之谈

对于转换对象，Convert.ToInt32() 可以为多种类型（例出数字类型外 bool，DateTime 等），int.TryParse() 和 int.Parse() 只能是整型字符串类型（即各种整型 ToString() 之后的形式，不能为浮点型，否则 int.Parse() 就会出现输入的字符串格式不正确的错误，int.TryParse() 也会返回 false，输出参数为 0 ，(int)只能是数字类型（例 float,int,uint等）；
对于空值 NULL，从运行报错的角度讲，(int) 强制转换和 int.Parse() 都不能接受 NULL；Convert.ToInt32() 其实是在转换前先做了一个判断，参数如果为 NULL，则直接返回 0，否则就调用 int.Parse() 进行转换，int.TryParse() 其实是对 int.Parse() 做了一个异常处理，如果出现异常则返回 false，并且将输出参数返回 0；
针对于浮点型的取舍问题，浮点型只有 Convert.ToInt32() 和 (int) 能进行转换，但是也是进行取舍了的，Convert.ToInt32() 采取的取舍是进行四舍五入，而 (int) 则是截取浮点型的整数部分，忽略小数部分，例如 Convert.ToInt32(1.499d) 和 (int)1.499d 都返回 1，Convert.ToInt32(1.5d) 返回 2，而 (int)1.5d 还是返回 1；
关于溢出，将大的数据类型转换为小的数据类型时 Convert.ToInt32() 和 int.Parse() 都会报溢出错误，值对于 Int32 太大或太小，而 (int) 不报错，但是返回值为 -1。

如此可见，我们在进行数据转换前选择转换方法要谨慎，如果是数字类型可以考虑直接用(int)强制转换，如果是整型字符串类型的，考虑用 int.Parse() 进行转换，如果不是这两种类型，再考虑用 Convert.ToInt32() 进行转换。

C#中的变量

一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。

我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类：

类型	举例
整数类型	sbyte、byte、short、ushort、int、uint、long、ulong 和 char
浮点型	float 和 double
十进制类型	decimal
布尔类型	true 或 false 值，指定的值
空类型	可为空值的数据类型

note：定义和声明方式与c和C++类似

C#中的常量

C#中常量包含这个整数常量，字符常量，字符串常量，浮点常量；定义方式使用const关键字定义。表明这是不可变的常量

using System;

public class ConsteTest
{
	class Sample Class
	{
		public int x;
         public int y;
         public const int c1 = 5;
         public const int c2 = c1 + 5;
         
         public SampleClass(int p1, int p2)
         {
         	x = p1;
         	y = p1;
         }
	}
	
	static void Main()
	{
		//入口关键自形式
	}
}

需要注意的点

const 作为静态常量，需要在声明的时候就初始化。如

const double a = 3.14;		//正确的声明化
const int b;				//错误的声明化

readonly作为只读类型动态常量，需要在运行的时候确定值，只能在声明或者构造函数中初始化，只能在类中定义。如下所示

class Program
{
    readonly int a=1;  // 声明时初始化
    readonly int b;    // 构造函数中初始化
    Program()
    {
        b=2;
    }
    static void Main()
    {
    }
}

经验之谈

取值永久不变，比如圆周率，一天包含的小时数，地理位置等
对程序性能要求非常苛刻

上述两种情况可以使用const常量，除此之外的其他情况都应该优先采用readonly类型声明的常量。

C# 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，与C和C++语言类似，分类如下：

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

算术运算符

常用的算术运算符如下表所示，假设A为10，B为20

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

需要注意的点

c = a++: 先将 a 赋值给 c，再对 a 进行自增运算。
c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 。
c = a–: 先将 a 赋值给 c，再对 a 进行自减运算。
c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 。

最终的结果都是a变为+1或者-1的状态，++a和a++的情况改变，代码如下

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ 先赋值再进行自增运算
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // ++a 先进行自增运算再赋值
            a = 1; // 重新初始化 a
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // a-- 先赋值再进行自减运算
            a = 1;  // 重新初始化 a
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // --a 先进行自减运算再赋值
            a = 1;  // 重新初始化 a
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();
        }
    }
}

关系运算符

表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

逻辑运算符

下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
\|\|	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A \|\| B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设如果 A = 60，且 B = 13，使用按位操作时候常以二进制格式表示，具体的例子如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

如下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：表中结果

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
\|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A \| B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

赋值运算符

下表列出了 C# 支持的赋值运算符，与C或C++语言类似

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C = A 相当于 C = C A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
\|=	按位或且赋值运算符	C \|= 2 等同于 C = C \| 2

其他运算符

与C和C++有点不同的地方是，C#提供了不同的运算符为更方便确定对象的某种类信息给。如下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。

运算符	描述	实例
sizeof()	返回数据类型的大小。	sizeof(int)，将返回 4.
typeof()	返回 class 的类型。	typeof(StreamReader);
&	返回变量的地址。	&a; 将得到变量的实际地址。
*	变量的指针。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则为 X : 否则为 Y
is	判断对象是否为某一类型。	If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。
as	强制转换，即使转换失败也不会抛出异常。	Object obj = new StringReader(“Hello”); StringReader r = obj as StringReader;

C#判断

同样是使用if … else 语句的类型，通过提供？：运算符的形式

C# 提供了以下类型的判断语句。

语句	描述
if 语句	一个 if 语句由一个布尔表达式后跟一个或多个语句组成。
if…else 语句	一个 if 语句后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句	您可以在一个 switch 语句内使用另一个 switch 语句。

? : 运算符

可以使用? :可以用来替代 if…else 语句。它的一般形式如下：

num > 0 ? num *Jc(num - 1) : 1;  //如果num>0则返回num *Jc(num - 1)，否则返回1

C#循环

与C语言类似，但是有些点不同，具体循环类型及区别如下表所示

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for/foreach 循环	多次执行一个语句序列，简化管理循环变量的代码。
do…while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环	您可以在 while、for 或 do…while 循环内使用一个或多个循环。

循环控制语句

循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁，循环控制出发如下

控制语句	描述
break 语句	终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句	引起循环跳过主体的剩余部分，立即重新开始测试条件。

需要注意的点

for和foreach的使用区别

//for 需要先要给初值，末值和步长

//foreach 不需要事先给定初值，末值和步长，程序自动遍历给定的集合体的所有值

string[] a=new string[]{"a","b"}

for(i=0;i<a.length;i++)
{
Response.write(a[i].ToString())
}

foreach(string b in a)
{
Response.write b
}

Freedom_Bule

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【C#学习01】 -基础知识语法

文章目录语言特点程序结构C#程序结构编译执行方式使用IDE执行使用命令行的方式小技巧C#基本语法标识符常用的关键字如下C#中的数据类型值的类型引用的类型关于装箱和拆箱C#类型转换使用数据转换的经验之谈C#中的变量C#中的常量需要注意的点经验之谈C# 运算符算术运算符需要注意的点关系运算符逻辑运算符位运算符赋值运算符其他运算符C#判断? : 运算符C#循环循环控制语句需要注意的点语言特点C# 语法高度重视表达，但学习起来也很简单轻松。任何熟悉 C、C++、Java 或 JavaScript 的人都可以立
复制链接

扫一扫