【C#基础】C# 基础语法解析

哈桑indie

已于 2023-02-13 19:49:45 修改

阅读量1.6k

点赞数 13

分类专栏： C#/.NET系列文章文章标签： c# 开发语言微软 .netcore

于 2023-02-09 16:13:42 首次发布

本文链接：https://blog.csdn.net/weixin_61361738/article/details/128926672

版权

C#/.NET系列文章专栏收录该内容

28 篇文章 69 订阅

订阅专栏

序号	系列文章
0	【C#基础】初识编程语言C#
1	【C#基础】C# 程序通用结构

文章目录

前言
基础语法
结语

前言

😄 大家好，我是writer桑，前面一章已经学习了C#的程序结构，那本章就开始学习C#程序中的基础语法，希望看完大家能够有所收获，感谢支持！

基础语法

首先 C# 作为一门面向对象的编程语言，有着许多区别于其他语言不同的地方，其中包括关键字的运用、类成员、标识符等等。本章从这几个方面进行学习，以便对搭建 C# 程序有个初步的认识。

首先以下面 Square 程序的实现做示例，以借此讨论 C# 的基础语法。

using System;		// using 指令 

namespace SquareApplication		// namespace 命名空间
{
    internal class Square
    {
        // 成员字段
        private double length;
        private 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 ExecuteSquare
    {
        // Main 方法的声明
        static void Main(string[] args)
        {
            Square s = new Square();	// 创建类型的新实例
            s.Acceptdetails();
            s.Display();
            Console.ReadLine();
        }
    }
}

1. using 关键字

在 C# 程序中 using 关键字有导入命名空间、创建别名、释放资源三种用法。

1，using 指令导入指定的命名空间

using System;

using 指令允许使用在命名空间中定义的类型，而无需指定该类型的完全限定命名空间。using 指令以基本形式从单个命名空间导入所有类型。
程序中 using System 表示导入 System 命名空间，同时一个程序允许有多个 using 指令的存在，这种用法类似于 Python 中的 Import 语法。

2， using 别名指令为名称空间或类型创建别名。

using systext = System.Text;
// using systext;  // 编译器错误：未能找到类型或命名空间名"systext"

创建 using 别名指令，以便更易于将标识符限定为命名空间或类型。在任何 using 指令中，都必须使用完全限定的命名空间或类型，而无需考虑它之前的 using 指令。
注意，using 指令的声明中不能使用 using 别名。否则会生成编译器错误；而且 using 别名指令的右侧不能有开放式泛型类型。例如，不能为 List<T> 创建 using 别名，但可以为 List<int> 创建 using 别名。

3， using 语句定义一个范围，在此范围的末尾将释放对象。

// 注意 Square 类需要继承 IDisposable 接口
using (Square s = new Square())
{
    // use s..
    // 离开这个代码块资源会自动释放
}

在程序编译阶段，编译器会自动将using语句生成为try-catch-finally语句，并在finally块中调用对象的Dispose方法，来清理资源。
using 语句提供可确保正确使用 IDisposable 对象的方便语法。 await using 语句可确保正确使用 IAsyncDisposable 对象。 C# 语言支持实现 System.IAsyncDisposable 接口的异步可释放类型。

2. namespace 关键字

在 C# 程序中 namespace 关键字用于声明命名空间，在后来的版本中有新的用法。

1，namespace 关键字用于声明包含一组相关对象的作用域。可以使用命名空间来组织代码元素并创建全局唯一类型。

namespace SquareApplication
{
    class Square
    {
        public void SquareMethod()
        {
            System.Console.WriteLine(
            "SquareMethod inside SquareNamespace");
        }
    }
}

其他文件可以直接使用 using 指令引用 SquareApplication 命名空间。
命名空间的名称必须是有效的 C# 标识符名称。

2，从 C# 10 开始，可以为该文件中定义的所有类型声明一个命名空间，如以下示例所示：

namespace SquareApplication;

class Square
{
	public void SquareMethod()
	{
	    System.Console.WriteLine(
	    "SquareMethod inside SquareNamespace");
	}
}

这种新语法的优点是更简单，这节省了水平空间且不必使用大括号。提高了代码的可读性。

3. class 关键字

在 C# 程序中 class 关键字主要用于声明类

类是可在一个单元中就将字段和方法及其他函数成员结合起来的数据结构，在 C# 程序中属于最基本的类型。示例如下：

class Square
{
    // Square details
}

class ExecuteSquare
{
    // ExecuteSquare details
}

用 class 关键字声明的类型为引用类型，方便其它代码创建类实例对象。
使用 class 关键字声明的类名称必须是有效的 C# 标识符名称。
class 关键字前面是访问级别，默认为 internal 类型，即同一个程序集的对象可以访问。

4. 成员字段

成员字段也就是在类范围中声明的变量

变量声明语法： <data_type> <var_name>；在 Square 类中声明了 width 和 length 两个成员字段：

private double length;		
private double width;

成员字段是在类范围声明的变量。变量是类的属性或数据成员，用于存储数据。
变量的 data_type 声明必须是有效的 C# 数据类型，var_name 名称必须是有效的 C# 标识符名称。
data_type 前面是变量的访问级别，默认为 private 类型，即对象本身在对象内部可以访问。

5. 成员方法

成员方法也即类中定义的可以执行的函数

方法声明语法：<Access Specifier> <Return Type> <Method Name>(Parameter List) { Method Body } ； Square 类包含了三个成员方法： AcceptDetails、GetArea 和 Display。

// 成员方法
public void Acceptdetails()
{
	// Method Body
}

public double GetArea()
{
	// Method Body
}

public void Display()
{
    // Method Body 
}

成员方法定义类执行的操作。方法可接受提供输入数据的参数，并可通过参数返回输出数据。方法还可以不使用参数而直接返回值。
在声明语法中 Access Specifier、Return Type、Method Name 分别表示访问说明、返回类型、方法名称。其中返回类型和名称必须声明，访问权限默认为 private，即对象本身在对象内部可以访问。

6. Main 方法

在 C# 程序中 Main 方法是定义程序的入口点

在示例程序中，ExecuteSquare 类声明了 Main 方法：

static void Main(string[] args)
{
    // Main Method Body
}

Main 方法是程序控制开始和结束的位置，它决定着当前类具体的行为。
Main 在类或结构中声，Main 必须是 static，它不需要是 public。且封闭类或结构不一定要是静态的。
Main 的返回类型可以是 void、int、Task 或 Task<int>。
在 C# 9 之前程序必须声明 Main 方法，否则会报编译器错误，而在 C# 9 之后（包含 C# 9）则可以使用顶级语句，无需应用程序中显式声明 Main 方法。

7. new 关键字

在 C# 程序中可以使用 new 关键字创建实例、声明修饰符、作为类型约束。

1，new 运算符创建类型的新实例

// 创建类型的新实例 
Square s = new Square() 
{
    // 在这设定初始值
};

使用 new 运算符创建类型的新实例的同时会调用该类型的某个构造函数
使用带有new运算符的对象或集合初始值设定项会实例化和初始化一个语句中的对象

2，new 关键字用作成员声明修饰符

// 使用 DerivedC.Invoke 隐藏了 BaseC.Invoke。
// 字段 x 不受影响，因为未使用类似名称将其隐藏。
public class BaseC
{
    public int x;
    public void Invoke() { }
}

public class DerivedC : BaseC
{
    new public void Invoke() { }
}

new 修饰符可以显式隐藏从基类继承的成员
隐藏继承的成员时，该成员的派生版本将替换基类版本

3，new 关键字用作泛型类型约束

class ItemFactory<T> where T : new()
{
	public T GetNewItem()
    {
        return new T();
    }
}

new 约束指定泛型类或方法声明中的类型实参必须有公共的无参数构造函数。
若要使用 new 约束，则该类型不能为抽象类型。

8. 标识符

标识符是分配给类型（类、接口、结构、记录、委托或枚举）、成员、变量或命名空间的名称。以下是 C# 标识符命名规则和约定：

命名规则:

有效标识符必须遵循以下规则：

标识符必须以字母或下划线 ( _ ) 开头。
标识符可以包含 Unicode 字母字符、十进制数字字符、Unicode 连接字符、Unicode 组合字符或 Unicode 格式字符。
可以在标识符上使用 @ 前缀来声明与 C# 关键字匹配的标识符。 @ 不是标识符名称的一部分。例如，@if 声明名为 if 的标识符。这些逐字标识符主要用于与使用其他语言声明的标识符的互操作性。

命名约定:

除了规则之外，C # 程序的类型名称、命名空间和所有公共成员也应当遵循PascalCase（变量命名方法）。以下为常见的约定：

接口名称以大写字母 I 开头。
属性类型以单词 Attribute 结尾。
枚举类型对非标记使用单数名词，对标记使用复数名词。
标识符不应包含两个连续的下划线 ( _ ) 字符。这些名称保留给编译器生成的标识符。

9. 关键字

关键字是预定义的保留标识符，对编译器有特殊意义。除非前面有 @ 前缀，否则不能在程序中用作标识符。例如，@if 是有效标识符，而 if 则不是，因为 if 是关键字。

1，第一个表列出了是 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	int	interface
internal	is	lock	long	namespace	new	null
object	operator	out	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