声明：个人学习笔记，一些共性的编程基础知识拷贝于菜鸟教程，但进行了相应的删减和改动并加入了自己的理解。

本文同步发表在我的个人博客上，欢迎访问。传送门

文章目录

一、C# 语言及特点
二、.NET Framenwork
三、面向对象的概念
- 1、面向过程——>怎么做？
- 2、面向对象——>谁来做？
四、类和对象
- 1、类
- 2、对象
- 3、类和对象的关系
五、类的设计
六、Hello World
七、宇宙第一IDE
- 使用 Visual Studio编译执行 C# 程序步骤
八、C# 基本语法
- 1、标识符
- 2、关键字
- 3、注释
九、C# 数据类型
- 1、值类型
- 2、引用类型（Reference types）
- 3、指针类型（Pointer types）
十、类型转换
十一、C# 变量
十二、C# 常量
十三、运算符
- 1、算术运算符
- 2、关系运算符
- 3、逻辑运算符
- 4、位运算符
- 5、赋值运算符
- 6、其他运算符
十四、运算符优先级

一、C# 语言及特点

C#是微软公司开发的一种面向对象的、运行于.NET Framenwork和.NET Core（完全开源、跨平台）之上的高级程序设计语言。
C#是一种安全的、稳定的、简单的、优雅的、由C和C++衍生出来的面向对象的编程语言。他继承了C、C++强大的功能的同时去掉了一些复杂特性，完善了C和C++的缺点和不足。
C#是面向对象的编程语言。

二、.NET Framenwork

.NET是什么？

.NET是一种用于构建多种应用的免费开源开发平台，可以使用多种语言，编辑器和库开发Web应用、Web API和微服务、云中的无服务器函数、云原生应用、移动应用、桌面应用、Windows WPF、Windows窗体、通用 Windows平台 (UWP)、游戏、物联网 (IoT)、机器学习、控制台应用、Windows服务。

C#和.NET的关系

.NET 是一个开发平台，而 C# 是一种在 .NET 开发平台上使用的编程语言类似于舞台和表演者的关系，C#是这个舞台上最闪耀的表演者！

三、面向对象的概念

我是从C开始入门学习编程的，目前还没有系统学习C++或者JAVA，C#是面向对象的编程语言，所以在这里需要简单的学习一下面向对象的哲学思想。

1、面向过程——>怎么做？

把完成一个需求的所有步骤从头到尾逐步实现
根据开发需求，将一个一个功能封装成一个又一个函数
按照需求顺序执行调用不同的函数

特点

注重步骤和过程，不注重职责分工
如果需求复杂，代码会变得很复杂
没有固定的套路，难度很大！！！

2、面向对象——>谁来做？

相较于函数，面向对象是更大的封装，根据职责，在一个对象中封装不同的方法

在完成某一个需求前，首先确定职责，要做的事情（方法）
根据指责确定不同的对象，在对象内部封装不同的方法（多个）
最后完成代码，就是顺序的让不同对象调用不同的方法

特点

注重对象和职责，不同的对象承担不同的对象承担不同的职责
更加适应对复杂的需求变化，是专门应对复杂项目的开发，提供固定套路
需要在面向过程的基础上，在学习一些面向对象的语法。

四、类和对象

类和对象是面向对象编程的两个核心概念

1、类

类是一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
特征被称为属性
行为被称为方法

类就相当于制造汽车的图纸，是一个模版，是负责创建对象的。

2、对象

对象是由类创造出来的一个具体存在，可以直接使用
由哪一类创造出来的对象就拥有哪一类中定义的属性和方法

对象就相当于图纸制造的汽车

3、类和对象的关系

类是模版，对象是根据类这个模版创建出来的，应该先有类，再有对象
类只有一个，而对象可以有很多个
类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少。

五、类的设计

分析需求，确定程序中需要包含哪些类？

分工设计各类，设计一个类需要满足以下三个要素：

类名：这类事物的名称，满足大驼峰命名法
属性：这类事物具有怎样的特征
方法：这类事物具有怎样的行为

例如：

张三今年18岁，身高175cm，他每天早晨跑完步吃早饭。

李四今年20岁，身高180cm，他早晨不跑步，但吃早饭。

类：人

对象1：张三

特征：

名字：张三

年龄：18岁

身高：175cm

行为：

跑步

吃早饭

对象2：李四

特征：

名字：李四

年龄：20岁

身高：180cm

行为：

不跑步

吃早饭

六、Hello World

using System;//引用命名空间，类似于一个百宝箱（系统的百宝箱）
namespace HelloWorldApplication//声明一系列的类，创建一个自己的百宝箱（文件夹）
{
    
    
    /* 类名为 HelloWorld */
    class HelloWorld
    {
    
    
        /* main函数（方法） */
        static void Main(string[] args)
        {
    
    
            /* 我的第一个 C# 程序 */
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }
    }
}

using System; - using 关键字用于在程序中包含 System 命名空间。一个程序一般有多个 using 语句。
namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时类将做什么动作。
/…/ 将会被编译器忽略，且它会在程序中添加额外的注释。
Main 方法通过语句
```
 Console.WriteLine("Hello World"); 
```
指定了它的行为。

WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 “Hello World”。
Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。

以下几点值得注意：

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

七、宇宙第一IDE

Visual Studio是微软出品的跨平台集成开发环境，支持Windows、Windows 10 UWP、Windows Phone、Android、iOS、Azure、Web等各种环境的应用开发，被誉为“宇宙第一IDE”。

使用 Visual Studio编译执行 C# 程序步骤

启动 Visual Studio——>创建新项目
选择相应模版（语言选择 C#，平台选择 Windows）
选择控制台应用程序

为您的项目取一个名字，选择其存放的位置
选择相应的.NET框架
新项目会出现在解决方案资源管理器中。

在代码编辑器中编写代码。
运行程序（ctrl+F5）（只运行不调试）

八、C# 基本语法

C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。

以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。根据设计，它可能需要接受这些属性值、计算面积和显示细节。下面是一个 Rectangle（矩形）类的实现。

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();
            r.Display();
            Console.ReadLine();
        }
    }
}

1、标识符

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

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

2、关键字

关键字是对编译器有特殊意义的预定义保留标识符，他们不能程序中用作标识符

保留关键字
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

3、注释

注释：注销和解释

注释的方式

//这是单行注释

/*这是多行注释*/

/*
我也是多行注释*/

/*
我也...
*/

/// <summary>
/// 我是文档注释
/// <summary>

九、C# 数据类型

1、值类型

类型	描述	范围	默认值
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

size of

使用 sizeof计算某类型在某平台上的特定尺寸

using System;

namespace DataTypeApplication
{
    
    
   class Program
   {
    
    
      static void Main(string[] args)
      {
    
    
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

2、引用类型（Reference types）

引用类型指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。

内置的 引用类型有：object、dynamic 和 string。

2.1、对象（Object）类型

对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

object obj;
obj = 100; // 这是装箱

2.2、动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型的语法：

dynamic <variable_name> = value;

例如：

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。

2.3、字符串（String）类型

字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。

例如：

String str = "runoob.com";

一个 @引号字符串：

@"runoob.com";

C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：

string str = @"C:\Windows";

等价于：

string str = "C:\\Windows";

@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。

string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";

用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。

3、指针类型（Pointer types）

指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。

声明指针类型的语法：

type* identifier;

例如：

char* cptr;
int* iptr;

十、类型转换

namespace TypeConversionApplication
{
    
    
    class ExplicitConversion
    {
    
    
        static void Main(string[] args)
        {
    
    
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
           
        }
    }
}

十一、C# 变量

变量就是变化的量，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。

变量的声明和定义和初始化

int d = 3, f = 5;    /* 初始化 d 和 f. */
byte z = 22;         /* 初始化 z. */
double pi = 3.14159; /* 声明 pi 的近似值 */
char x = 'x';        /* 变量 x 的值为 'x' */

变量的使用

namespace VariableDefinition
{
    
    
    class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            short a;
            int b ;
            double c;

            /* 实际初始化 */
            a = 10;
            b = 20;
            c = a + b;
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
            Console.ReadLine();
        }
    }
}

a = 10, b = 20, c = 30

十二、C# 常量

固定不变的量，和变量一样，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。

常量的声明定义和初始化

const 数据类型 常量名 = 值;

常量的使用

using System;

public class ConstTest
{
    
    
    class SampleClass
    {
    
    
        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 = p2;
        }
    }

    static void Main()
    {
    
    
        SampleClass mC = new SampleClass(11, 22);
        Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
        Console.WriteLine("c1 = {0}, c2 = {1}",
                          SampleClass.c1, SampleClass.c2);
    }
}

x = 11, y = 22
c1 = 5, c2 = 10

十三、运算符

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

1、算术运算符

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

实例

using System;

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

            c = a + b;
            Console.WriteLine("Line 1 - c 的值是 {0}", c);
            c = a - b;
            Console.WriteLine("Line 2 - c 的值是 {0}", c);
            c = a * b;
            Console.WriteLine("Line 3 - c 的值是 {0}", c);
            c = a / b;
            Console.WriteLine("Line 4 - c 的值是 {0}", c);
            c = a % b;
            Console.WriteLine("Line 5 - c 的值是 {0}", c);

            // ++a 先进行自增运算再赋值
            c = ++a;
            Console.WriteLine("Line 6 - c 的值是 {0}", c);

            // 此时 a 的值为 22
            // --a 先进行自减运算再赋值
            c = --a;
            Console.WriteLine("Line 7 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21

2、关系运算符

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

实例

using System;

class Program
{
    
    
  static void Main(string[] args)
  {
    
    
      int a = 21;
      int b = 10;
     
      if (a == b)
      {
    
    
          Console.WriteLine("Line 1 - a 等于 b");
      }
      else
      {
    
    
          Console.WriteLine("Line 1 - a 不等于 b");
      }
      if (a < b)
      {
    
    
          Console.WriteLine("Line 2 - a 小于 b");
      }
      else
      {
    
    
          Console.WriteLine("Line 2 - a 不小于 b");
      }
      if (a > b)
      {
    
    
          Console.WriteLine("Line 3 - a 大于 b");
      }
      else
      {
    
    
          Console.WriteLine("Line 3 - a 不大于 b");
      }
      /* 改变 a 和 b 的值 */
      a = 5;
      b = 20;
      if (a <= b)
      {
    
    
         Console.WriteLine("Line 4 - a 小于或等于 b");
      }
      if (b >= a)
      {
    
    
         Console.WriteLine("Line 5 - b 大于或等于 a");
      }
  }
}

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

3、逻辑运算符

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

实例

using System;

namespace OperatorsAppl
{
    
    
    class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
    
    
               Console.WriteLine("Line 1 - 条件为真");
            }
            if (a || b)
            {
    
    
                Console.WriteLine("Line 2 - 条件为真");
            }
            /* 改变 a 和 b 的值 */
            a = false;
            b = true;
            if (a && b)
            {
    
    
                Console.WriteLine("Line 3 - 条件为真");
            }
            else
            {
    
    
                Console.WriteLine("Line 3 - 条件不为真");
            }
            if (!(a && b))
            {
    
    
                Console.WriteLine("Line 4 - 条件为真");
            }
            Console.ReadLine();
        }
    }
}

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

4、位运算符

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 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

using System;
namespace OperatorsAppl
{
    
    
    class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            int a = 60;            /* 60 = 0011 1100 */  
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;          

             c = a & b;           /* 12 = 0000 1100 */
             Console.WriteLine("Line 1 - c 的值是 {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Line 2 - c 的值是 {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Line 3 - c 的值是 {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Line 4 - c 的值是 {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Line 5 - c 的值是 {0}", c);

             c = a >> 2;     /* 15 = 0000 1111 */
             Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

5、赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	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

实例

using System;

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

            c = a;
            Console.WriteLine("Line 1 - =  c 的值 = {0}", c);

            c += a;
            Console.WriteLine("Line 2 - += c 的值 = {0}", c);

            c -= a;
            Console.WriteLine("Line 3 - -=  c 的值 = {0}", c);

            c *= a;
            Console.WriteLine("Line 4 - *=  c 的值 = {0}", c);

            c /= a;
            Console.WriteLine("Line 5 - /=  c 的值 = {0}", c);

            c = 200;
            c %= a;
            Console.WriteLine("Line 6 - %=  c 的值 = {0}", c);

            c <<= 2;
            Console.WriteLine("Line 7 - <<=  c 的值 = {0}", c);

            c >>= 2;
            Console.WriteLine("Line 8 - >>=  c 的值 = {0}", c);

            c &= 2;
            Console.WriteLine("Line 9 - &=  c 的值 = {0}", c);

            c ^= 2;
            Console.WriteLine("Line 10 - ^=  c 的值 = {0}", c);

            c |= 2;
            Console.WriteLine("Line 11 - |=  c 的值 = {0}", c);
            Console.ReadLine();
        }
    }
}

ine 1 - =     c 的值 = 21
Line 2 - +=    c 的值 = 42
Line 3 - -=    c 的值 = 21
Line 4 - *=    c 的值 = 441
Line 5 - /=    c 的值 = 21
Line 6 - %=    c 的值 = 11
Line 7 - <<=    c 的值 = 44
Line 8 - >>=    c 的值 = 11
Line 9 - &=    c 的值 = 2
Line 10 - ^=    c 的值 = 0
Line 11 - |=    c 的值 = 2

6、其他运算符

运算符	描述	实例
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;

using System;

namespace OperatorsAppl
{
    
    
   
   class Program
   {
    
    
      static void Main(string[] args)
      {
    
    
         
         /* sizeof 运算符的实例 */
         Console.WriteLine("int 的大小是 {0}", sizeof(int));
         Console.WriteLine("short 的大小是 {0}", sizeof(short));
         Console.WriteLine("double 的大小是 {0}", sizeof(double));
         
         /* 三元运算符的实例 */
         int a, b;
         a = 10;
         b = (a == 1) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);

         b = (a == 10) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);
         Console.ReadLine();
      }
   }
}

int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20

十四、运算符优先级

单算移关与，异或逻条赋

“单”表示单目运算符：逻辑非(!),按位取反(~),自增(++),自减(–),取地址(&),取值(*)；

“算”表示算术运算符：乘、除和求余(*,/,%)级别高于加减(+,-)；

“移”表示按位左移(<<)和位右移(>>)；

“关”表示关系运算符：大小关系(>,>=,<,<=)级别高于相等不相等关系(==,!=)；

“与”表示按位与(&)；

“异”表示按位异或(^)；

“或”表示按位或(|)；

“逻”表示逻辑运算符：逻辑与(&&)级别高于逻辑或(||)；

“条”表示条件运算符(? : )；

“赋”表示赋值运算符(=,+=,-=,*=,/=,%=,>>=,<<=,&=,^=, |=,!=)；

逗号运算符(,) 级别最低，口诀中没有表述，需另加记忆…

优先级	运算符	名称或含义	使用形式	结合方向	说明
1	后置++	后置自增运算符	变量名++	左到右
	后置–	后置自减运算符	变量名–
	[ ]	数组下标	数组名[整型表达式]
	( )	圆括号	（表达式）/函数名(形参表)
	.	成员选择（对象）	对象.成员名
	->	成员选择（指针）	对象指针->成员名
2	-	负号运算符	-表达式	右到左	单目运算符
	(类型)	强制类型转换	(数据类型)表达式
	前置++	前置自增运算符	++变量名		单目运算符
	前置–	前置自减运算符	–变量名		单目运算符
	*	取值运算符	*指针表达式		单目运算符
	&	取地址运算符	&左值表达式		单目运算符
	!	逻辑非运算符	!表达式		单目运算符
	~	按位取反运算符	~表达式		单目运算符
	sizeof	长度运算符	sizeof 表达式/sizeof(类型)
3	/	除	表达式/表达式	左到右	双目运算符
	*	乘	表达式*表达式		双目运算符
	%	余数（取模）	整型表达式%整型表达式		双目运算符
4	+	加	表达式+表达式	左到右	双目运算符
	-	减	表达式-表达式		双目运算符
5	<<	左移	表达式<<表达式	左到右	双目运算符
	>>	右移	表达式>>表达式		双目运算符
6	>	大于	表达式>表达式	左到右	双目运算符
	>=	大于等于	表达式>=表达式		双目运算符
	<	小于	表达式<表达式		双目运算符
	<=	小于等于	表达式<=表达式		双目运算符
7	==	等于	表达式==表达式	左到右	双目运算符
	!=	不等于	表达式!= 表达式		双目运算符
8	&	按位与	整型表达式&整型表达式	左到右	双目运算符
9	^	按位异或	整型表达式^整型表达式	左到右	双目运算符
10	\|	按位或	整型表达式\|整型表达式	左到右	双目运算符
11	&&	逻辑与	表达式&&表达式	左到右	双目运算符
12	\|\|	逻辑或	表达式\|\|表达式	左到右	双目运算符
13	?:	条件运算符	表达式1? 表达式2: 表达式3	右到左	三目运算符
14	=	赋值运算符	变量=表达式	右到左
	/=	除后赋值	变量/=表达式
	*=	乘后赋值	变量*=表达式
	%=	取模后赋值	变量%=表达式
	+=	加后赋值	变量+=表达式
	-=	减后赋值	变量-=表达式
	<<=	左移后赋值	变量<<=表达式
	>>=	右移后赋值	变量>>=表达式
	&=	按位与后赋值	变量&=表达式
	^=	按位异或后赋值	变量^=表达式
	\|=	按位或后赋值	变量\|=表达式
**	?:	条件运算符	表达式1? 表达式2: 表达式3	右到左	三目运算符
14	=	赋值运算符	变量=表达式	右到左
	/=	除后赋值	变量/=表达式
	*=	乘后赋值	变量*=表达式
	%=	取模后赋值	变量%=表达式
	+=	加后赋值	变量+=表达式
	-=	减后赋值	变量-=表达式
	<<=	左移后赋值	变量<<=表达式
	>>=	右移后赋值	变量>>=表达式
	&=	按位与后赋值	变量&=表达式
	^=	按位异或后赋值	变量^=表达式
	\|=	按位或后赋值	变量\|=表达式
15	,	逗号运算符	表达式,表达式,…	左到右	从左向右顺序运算

初识C#编程语言