C#笔记
目录刘铁猛网课
005 C#语言基本元素概览、初识变量与方法、算法简介
-
构成C#语言的基本元素
- 关键字（Keyword）
- 操作符（Operator）
- 标识符（Identifier）
- 标点符号
- 文本
- 注释与空白
-
简要介绍类型、变量与方法
-
算法简介
构成C#语言的基本元素
- 关键字（Keyword）
- 操作符（Operator）
- 标识符（Identifier）
- 什么是合法的标识符
- 怎样阅读语言定义文档
- 大小写规范
- 驼峰法
- 每个首字母大写
- 命名规范
- 什么是合法的标识符
- 标点符号
- 文本（字面值）
- 整数
- 多种后缀（int,long）
- 实数
- 多种后缀（float,double）
- 字符（char 仅单个字符）
- 字符串（string 任意个字符）
- 布尔
- 空（null）
- 整数
- 注释与空白
- 单行注释
- 块注释
- 空白
初识类型、变量和方法
初识变量类型（Type）
亦称数据类型（Data Type）
using System;
public class P
{
static void Main()
{
var x = 3;
//var x = 3.0F;
Console.WriteLine(x.GetType().Name);
}
}
变量是存放数据的地方，简称”数据“
- 变量的声明
- 变量的使用
using System;
namespace BianLiang
{
internal class Program
{
static void Main(string[] args)
{
//变量的声明
double x;
//变量的使用
x = 3.0;
}
}
}
方法（旧称函数）是处理数据的逻辑，又称为”算法“
- 方法的声明
- 方法的调用
using System;
namespace method
{
internal class Program
{
static void Main(string[] args)
{ //将类实例化，方面调用类内方法
Calculater c = new Calculater();
int x = c.Add(2,3);
Console.WriteLine(x);
string day = c.Today();
Console.WriteLine(day);
c.PrintSum(2,3);
}
}
public class Calculater
{ //有输入，有输出的声明
public int Add(int a , int b)
{
int result = a + b;
return result;
}
//无输入，有输出的声明
public string Today()
{
int day = DateTime.Now.Day;
return day.ToString();
}
//有输入，无输出的声明
public void PrintSum(int a , int b)
{
int result = a + b;
Console.WriteLine(result);
}
}
}
程序=数据+算法
- 有了变量和方法就可以写有意义的程序了
算法简介
- 循环初体验
- 递归初体验
using System;
namespace Program
{
public class p
{
static void Main()
{
Calculator c = new Calculator();
c.PrintXTo1(10);
c.PrintXTo1Loop(10);
}
}
public class Calculator
{ //循环
public void PrintXTo1(int x)
{
if (x == 1)
{
Console.WriteLine(x);
}
else
{
Console.WriteLine(x);
PrintXTo1(x - 1);
}
}
//递归
public void PrintXTo1Loop(int x)
{
for (int i = x; i > 0; i--)
{
Console.WriteLine(i);
}
}
}
}
- 计算1-100
using System;
namespace Sum1ToN
{
internal class Program
{
static void Main(string[] args)
{
Caculator c = new Caculator();
int a = c.SumFrom1ToXLoop(100);
Console.WriteLine(a);
int b = c.SumFrom1ToX(100);
Console.WriteLine(b);
}
}
public class Caculator
{ //循环计算1——X
public int SumFrom1ToXLoop(int x)
{
int result = 0;
for(int i = 0; i <= x; i++)
{
result += i;
}
return result;
}
//递归计算1—-X
public int SumFrom1ToX(int x)
{
int result = 0;
return (x == 0) ? result : x + SumFrom1ToX(x-1);
}
public int Fate1ToX(int x)
{
return (1 + x) * x / 2;
}
}
}
作业
- 对照视频完成示例，并能默写
- 完成汉诺塔问题
006，007详解类型、变量与对象(重要)
006详解类型、变量与对象上
- 什么是类型（Type）
- 类型在C#语言中的作用
- C#语言的类型系统
- 变量、对象与内存
什么是类型（Type）
-
又名数据类型（Data Type）
- A data type is a homogeneous collection of values,effective presented,equipped with a set of operations which manipulate these values.
-
是数据在内存中存储时的”型号“
-
小内存容纳大尺寸数据会丢失准确度、发生错误
-
大内存容纳小尺寸数据会导致浪费
-
编程语言的数据类型与数学中的数据类型不完全相同
- 例子3/4
-
强类型语言与弱类型语言的比较
-
C语言示例：if条件
#include<stdio.h> int x = 100; int main() { if(x = 200) { printf("%d",x); } } -
JavaScript示例：动态类型
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> <script> function ButtonClicked(){ //弱类型 var myVar = 100; myVar = "Mr.OKay!"; alert(myVar); } </script> </head> <body> <h1>Hello,JavaScript</h1> <button type="button" onclick="ButtonClicked()">显示日期</button> </body> </html> -
C#语言对弱类型/动态类型的模仿
//强类型 //好处：保护数据 using System; namespace _06 { internal class Program { static void Main(string[] args) { int x; x = 100; long y; y = 100L; //x = 100L; 小内存容纳大尺寸数据会丢失准确度、发生错误 bool b; //b = 100; 无法将整数直接转换成bool //if(x = 200) 无法将整数直接转换成bool //{ // Console.WriteLine("It's Ok!"); //} } } }using System; namespace _06 { internal class Program { static void Main(string[] args) { //使用dynamic模仿动态类型 dynamic myVar = 100; Console.WriteLine(myVar); myVar = "Mr.Okay!"; Console.WriteLine(myVar); } } }
-
注意：知识的全面性，需关注硬件，操作系统等知识
类型在C#语言中的作用
-
一个C#类型中所包含的信息有：
-
存储此类型变量所需的内存空间大小
-
此类型的值可表示的最大、最小值范围
-
此类型所包含的成员（如方法、属性、事件等）
-
此类型由何基类派生而来
-
程序允许的时候，此类型的变量分配在内存的什么位置
-
Stack简介
-
Stack overflow
//栈 using System; namespace StackOverflow { internal class Program { static void Main(string[] args) { //例子1 BadGuy bg = new BadGuy(); bg.BadMethod(); //例子2 //int* p = stackalloc int[9999999]; } } class BadGuy { public void BadMethod() { int x = 100; this.BadMethod(); } } } -
Heap简介
-
使用Performance Monitor
-
关于内存泄漏
-
-
此类型所允许的操作（运算）
-
程序的静态与动态（非执行与执行）
- 静态
- 编辑器与编译器（类型中有什么成员）
- 动态
- 运行器
- 反射
007详解类型、变量与对象下
C#语言的类型系统
-
C#的五大数据类型
-
类（Classes）：Window,Form,Console
using System; using System.Windows.Forms; namespace example { internal class Program { static void Main(string[] args) { Type myType = typeof(Form); Console.WriteLine(myType.FullName); Console.WriteLine(myType.IsClass); //Form; F12转到定义/F1转到帮助文档 } } } -
结构体(Structures)
//int long 结构体类型 -
枚举（Enumerations）
using System; using System.Windows.Forms; namespace example { internal class Program { static void Main(string[] args) { Form f = new Form(); //FormWindowState是枚举类型 f.WindowState = FormWindowState.Minimized; f.ShowDialog(); } } }
-
接口（Interfaces）
-
委托（Delegates）
-
-
C#类型的派生谱系
蓝色：都是真正的数据类型，很常用；基本的数据类型，是构成其他的数据类型的基本单元
C#都有哪些数据类型？
C#包括两大数据类型：引用类型，值类型。其中引用类型包括类，接口和委托，值类型包括结构体和枚举类型。所有类型都以Object为基类型。
变量、对象与内存
-
什么是变量
-
表面上来看（从C#代码的上下问行文上来看），变量的用途是存储数据
-
实际上，变量表示了存储位置，并且每个变量都有一个类型，以决定什么样的值能够存入变量
- 变量名表示（对应着）变量的值在内存中的存储位置
using System; namespace myexample { internal class Program { static void Main(string[] args) { int x; x = 100; } } } -
变量一共有7种
-
静态变量
using System; namespace myexample { internal class Program { static void Main(string[] args) { int x = Student.Amount; } class Student { //静态变量 public static int Amount; } } } -
实例变量（成员变量，字段）
using System; namespace myexample { internal class Program { static void Main(string[] args) { Student stu = new Student(); stu.Age = 1; } class Student { //实例变量 public int Age; public string Name; } } } -
数组元素
int[] arry = new int[100]; -
值参数
class Student { //x,y为值参数 public double Add(double x,double y) { return x+y; } } -
引用参数
public double Add(ref double x , double y) -
输出形参
public double Add(out double x , double y) -
局部变量
using System; namespace myexample { internal class Program { static void Main(string[] args) { //局部变量 int x; } class Student { public double Add(double x,double y) { //局部变量 double result = x + y; return result; } } } }
-
-
狭义的变量指局部变量，因为其他种类的变量都有自己约定名称
- 简单地讲，局部变量就是方法体（函数体）里声明的变量
-
变量的声明
-
有效的$$修饰符组合_{opt}$$类型 变量名 $$初始化器_{opt}$$
int a = 100;
-
-
变量+以变量名所对应的内存地址为起点、以其数据类型所要求的存储空间为长度的一块内存区域
-
-
值类型的变量
- 以byte/$$sbyte$$/short/$$ushort$$为例内存.xlsx
- -100存储，100对应的二进制按位取反再加1
- 高高低低原则
- 值类型没有实例，所谓“实例”与变量合而为一
- 以byte/$$sbyte$$/short/$$ushort$$为例内存.xlsx
-
引用类型的变量与实例
-
引用类型变量与实例的关系：引用类型变量存储的数据是对象的内存地址
using System; namespace Neicun { internal class Program { static void Main(string[] args) { Student stu; stu = new Student(); Student stu2; stu2 = new Student(); } class Student { uint ID; ushort Score; } } }
-
-
局部变量是在stack上分配内存
-
变量的默认值
-
常量（值不可改变的变量）
-
装箱与拆箱（Boxing & $$Unboxing$$）
-
装箱
- 把栈上的值类型的值，封装成一个object类型的实例，放在堆上
-
拆箱
- 将堆上的object类型的实例里面的值，根据要求，拆成目标的数据类型，储存在栈上
-
注意：装箱和拆箱都会损失性能。
using System; namespace Neicun { internal class Program { static void Main(string[] args) { //装箱 int x = 100; object obj = x; //拆箱 int y = 0; y = (int)obj; } } }
-
008，009方法的定义、调用与调试
008方法的定义、调用与调试上
009方法的定义、调用与调试下
010，011，012 操作符详解
010操作符详解 上
011操作符详解 中
new
using System;
namespace ConsoleApp1
{
internal class OperatorExample
{
static void Main(string[] args)
{
//int x = 100 显式变量
var x = 100; //隐式变量
Console.WriteLine(x.GetType().Name);
}
}
}
-
new在内存中创建类型的实例，并调用它的实例构造器
-
在new左边若有赋值操作符，new把类型的实例在内存中的地址，通过赋值操作符传递给变量
-
附加：new也可以调用初始化器{}
using System; using System.Windows.Forms; namespace ConsoleApp1 { internal class OperatorExample { static void Main(string[] args) { // //new在内存中创建类型的实例，并调用它的实例构造器 //在new左边若有赋值操作符，new把类型的实例在内存中的地址，通过赋值操作符传递给变量 //附加：new也可以调用初始化器{} Form myform = new Form() {Text = "Hello" , FormBorderStyle = FormBorderStyle.SizableToolWindow }; //myform.Text = "hello"; myform.ShowDialog(); //new Form(){Text = "Hello" }.ShowDialog ; } } } -
不是所有class创建实例都需要new
using System; using System.Windows.Forms; namespace ConsoleApp1 { internal class OperatorExample { static void Main(string[] args) { //string的例子 int x = 100; string name = "Tim"; //string name = new string(); //int的例子 int[] array = new int[3]; int[] myArray = {1,2,3,4}; } } } -
new创建匿名类型的实例，使用var推断隐式变量类型
using System; using System.Windows.Forms; namespace ConsoleApp1 { internal class OperatorExample { static void Main(string[] args) { Form myForm = new Form() {Text = "Hello"}; var person = new { Name = "My.Okay" , Age = 34 }; Console.WriteLine(person.Name); Console.WriteLine(person.Age); Console.WriteLine(person.GetType().Name); } } } -
特殊：new作为修饰符
checked&unchecked
- 操作符
using System;
using System.Windows.Forms;
namespace ConsoleApp1
{
internal class OperatorExample
{
static void Main(string[] args)
{ //溢出示范
uint x = uint.MaxValue;
Console.WriteLine(x);
string binstring = Convert.ToString(x,2);
Console.WriteLine(binstring);
try
{
uint y = checked(x + 1);
//uint y = unchecked(x + 1);
Console.WriteLine(y);
}
catch(OverflowException ex)
{
Console.WriteLine("There's overflow!");
}
}
}
}
-
上下文
using System; using System.Windows.Forms; namespace ConsoleApp1 { internal class OperatorExample { static void Main(string[] args) { //溢出示范 uint x = uint.MaxValue; Console.WriteLine(x); string binstring = Convert.ToString(x,2); Console.WriteLine(binstring); checked { try { uint y = x + 1; //uint y = unchecked(x + 1); Console.WriteLine(y); } catch (OverflowException ex) { Console.WriteLine("There's overflow!"); } } } } }
delegate（操作符（过时））
用于声明匿名方法
$$Lamda$$表达式生成匿名方法
$$sizeof$$
获取一个对象在内存中所占字节数的尺寸
- 默认情况下，只能获取基本数据类型的实例，在内存中所占字节数（仅结构体类型，除了string,object）
- 非默认情况下，可以获取自定义结构体类型的实例所占字节数，但需要在不安全的环境下运行
//默认情况下，只能获取基本数据类型的实例，在内存中所占字节数（仅结构体类型，除了string,object）
using System;
namespace Progam
{
class Size
{
static void Main(string[] args)
{
//int x = sizeof(int);
//int x = sizeof(double);
//int x = sizeof(decimal);
int x = sizeof(uint);
Console.WriteLine(x);
}
}
}
using System;
namespace Progam
{
class Pro
{
static void Main(string[] args)
{
//int x = sizeof(int);
//int x = sizeof(double);
//int x = sizeof(decimal);
unsafe
{
int x = sizeof(Student);
Console.WriteLine(x);
}
}
}
struct Student
{
int ID;
long Score;
}
}
->
using System;
namespace Progam
{
class Pro
{
static void Main(string[] args)
{
unsafe
{
Student stu;
stu.ID = 1;
stu.Score = 99;
Student* pStu = &stu;
pStu->Score = 100; //间接访问
（*pStu).Score = 1000;
Console.WriteLine(stu.Score);//直接访问
}
}
}
struct Student
{
public int ID;
public long Score;
}
}
+-
using System;
namespace Add
{
class Add
{
static void Main(string[] args)
{
//+,-
int x = 100;
//int y = +x;
//int y = -x;
int y = -(-x);
Console.WriteLine(y);
//使用不当会溢出
Console.WriteLine(int.MinValue);
Console.WriteLine(int.MaxValue);
int x = int.MinValue;
int y = checked(-x);
Console.WriteLine(x);
Console.WriteLine(y);
}
}
}
~
using System;
namespace Fan
{
class Fan
{
static void Main(string[] args)
{
//int x = 12345678;
//int y = ~x;
//Console.WriteLine(y);
//string xStr = Convert.ToString(x,2).PadLeft(32,'0');
//string yStr = Convert.ToString(y,2).PadLeft(32,'0');
//Console.WriteLine(xStr);
//Console.WriteLine(yStr);
int x = int.MinValue;
int y = -x; // -x 相当于 ~x+1
Console.WriteLine(y);
string xStr = Convert.ToString(x,2).PadLeft(32,'0');
Console.WriteLine(xStr);
}
}
}
！
using System;
using System.Windows.Forms;
namespace ConsoleApp1
{
internal class OperatorExample
{
static void Main(string[] args)
{
Student stu = new Student(null);
Console.WriteLine(stu.Name);
}
}
class Student
{
public Student(string initName)
{
if(!string.IsNullOrEmpty(initName))
{
this.Name = initName;
}
else
{
throw new ArgumentException("initName cannot be null or empty");
}
}
public string Name;
}
}
-- 与++
012操作符详解 下
$$（T）X$$
导入
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
string str1 = Console.ReadLine();
string str2 = Console.ReadLine();
//字符串相加
Console.WriteLine(str1+str2);
}
}
}
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
string str1 = Console.ReadLine();
string str2 = Console.ReadLine();
int x = Convert.ToInt32(str1);
int y = Convert.ToInt32(str2);
Console.WriteLine(x + y);
}
}
}
类型转换
-
隐式(implicit)类型转换
-
不丢失精度的转换
using System; namespace DonversionExample { internal class OperatorExample { static void Main(string[] args) { int x = int.MaxValue; long y = x; Console.WriteLine(y); } } }
-
子类向父类的转换
using System; namespace DonversionExample { internal class OperatorExample { static void Main(string[] args) { Teacher t = new Teacher(); //在使用变量引用实例的成员时，只能访问变量中的类型的成员。 Human h = t; Animal a = h; a.Eat(); } } class Animal { public void Eat() { Console.WriteLine("Eating..........."); } } class Human : Animal { public void Think() { Console.WriteLine("Who I am?"); } } class Teacher : Human { public void Teach() { Console.WriteLine("I teach programming."); } } } -
装箱
-
-
显式(explicit)类型转换
-
有可能丢失精度（甚至发生错误）的转换，即cast
using System; namespace DonversionExample { internal class OperatorExample { static void Main(string[] args) { Console.WriteLine(ushort.MaxValue); uint x = 65536; ushort y = (ushort)x; Console.WriteLine(y); } } }
-
拆箱
-
使用Convert类
-
$$ToString$$方法与各数据类型的Parse/$$TryParse$$方法
namespace WpfApp1 { /// <summary> /// Interaction logic for MainWindow.xaml /// </summary> public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void btn_Click(object sender, RoutedEventArgs e) { double x = double.Parse(this.tb1.Text); double y = double.Parse(this.tb2.Text); double result = x + y; this.tb3.Text = System.Convert.ToString(result); } } }
-
-
自定义类型转换操作符
- 示例
//自定义显式类型转换操作符 using System; namespace DonversionExample { internal class OperatorExample { static void Main(string[] args) { Stone stone = new Stone(); stone.Age = 5000; Monkey wukong = (Monkey) stone; Console.WriteLine(wukong.Age); } } class Stone { public int Age; public static explicit operator Monkey(Stone stone) { Monkey m = new Monkey(); m.Age = stone.Age/500; return m; } } class Monkey { public int Age; } }//自定义隐式类型转换操作符 using System; namespace DonversionExample { internal class OperatorExample { static void Main(string[] args) { Stone stone = new Stone(); stone.Age = 5000; Monkey wukong = stone; Console.WriteLine(wukong.Age); } } class Stone { public int Age; public static implicit operator Monkey(Stone stone) { Monkey m = new Monkey(); m.Age = stone.Age/500; return m; } } class Monkey { public int Age; } }
+,-,*
注意数值提升
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
var x = 3 * 4;
//var x = 3.0 * 4.0;
Console.WriteLine(x.GetType().FullName);
Console.WriteLine(x);
}
}
}
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
//int x = 5;
//int y = 4;
//int z = x / y;
//注意，在整数除法中，不能除0
//double x = -5.0;
//double y = 0.0;
//double z = x / y;
//double a = double.PositiveInfinity;
//double b = double.NegativeInfinity;
//z = a / b;
double z = (double)5 / 4;
Console.WriteLine(z);
}
}
}
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
for(int i = 0; i < 100; i++)
{
Console.WriteLine(i%10);
}
Console.WriteLine(5.5%1);
}
}
}
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
var x = 3.0 + 4;
Console.WriteLine(x.GetType().FullName);
Console.WriteLine(x);
string s1 = "123";
string s2 = "abc";
string s3 = s1 + s2;
Console.WriteLine(s3);
}
}
}
位移操作符 << 与>>
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{ //在不产生溢出的情况下，<< 1(n) 相当于将原始数据X2(2n)，
// >> 1(n)相当于将原始数据/2(2n)
int x = 7;
int y = x << 2;
//int y = x >> 2;
string strX = Convert.ToString(x , 2).PadLeft(32 , '0');
string strY = Convert.ToString(y , 2).PadLeft(32 , '0');
Console.WriteLine(strX);
Console.WriteLine(strY);
Console.WriteLine(y);
}
}
}
关系运算符 <，>，>=，<=， ==与!=
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
int x = 5;
double y = 4.0;
var result = x == y;
Console.WriteLine(result.GetType().FullName);
Console.WriteLine(result);
//可以比较字符，字符是整型数据类型
char char1 = 'a';
char char2 = 'A';
var result2 = char1 > char2;
ushort u1 = (ushort)char1;
ushort u2 = (ushort)char2;
Console.WriteLine(u1);
Console.WriteLine(u2);
Console.WriteLine(result2.GetType().FullName);
Console.WriteLine(result2);
//可以比较字符串是否相等
string str1 = "abc";
string str2 = "ABC";
Console.WriteLine(str1 == str2);
Console.WriteLine(str1.ToLower() == str2.ToLower());
int Y = string.Compare(str1, str2);
Console.WriteLine(Y);
}
}
}
is与as
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
//is
Teacher t = new Teacher();
var result = t is Teacher;
Console.WriteLine(result.GetType().FullName);
Console.WriteLine(result);
Car car = new Car();
var result2 = car is Object;
Console.WriteLine(result2);
//as
object o = new Teacher();
if(o is Teacher)
{
Teacher T = (Teacher)o;
T.Teach();
}
Teacher H = o as Teacher;
if(H != null)
{
H.Teach();
}
}
}
class Animal
{
public void Eat()
{
Console.WriteLine("Eating...........");
}
}
class Human : Animal
{
public void Think()
{
Console.WriteLine("Who I am?");
}
}
class Teacher : Human
{
public void Teach()
{
Console.WriteLine("I teach programming.");
}
}
class Car
{
public void Run()
{
Console.WriteLine("Runing......");
}
}
}
&(按位与)，|(按位或)，^（按位异或）
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
int x = 7;
int y = 28;
int z = x & y;
//int z = x | y;
//int z = x ^ y;
string strX = Convert.ToString(x,2).PadLeft(32 , '0');
string strY = Convert.ToString(y,2).PadLeft(32 , '0');
string strZ = Convert.ToString(z,2).PadLeft(32 , '0');
Console.WriteLine(strX);
Console.WriteLine(strY);
Console.WriteLine(strZ);
}
}
}
&&(条件与) 于||(条件或)
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
int x = 5;
int y = 4;
int a = 3;
int b = 200;
if(x > y && a < b)
{
Console.WriteLine("Hello");
}
//条件与的短路
//if(x < y && a++ > 3)
if(x > y && a++ > 3)
{
Console.WriteLine("hello");
}
////if(x < y && ++a > 3)
//if(x > y && a++ > 3 )
//{
// Console.WriteLine("hellO");
//}
Console.WriteLine(a);
}
}
}
null合并 ??
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
Nullable<int> x = null;
//x = 100;
Console.WriteLine(x);
Console.WriteLine(x.HasValue);
//int? y = null;
//y = 100;
//Console.WriteLine(x);
//Console.WriteLine(x.Value);
int? y = null;
int z = y ?? 1;
Console.WriteLine(z);
}
}
}
条件?:
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
int x = 80;
string str = String.Empty;
if(x >= 60)
{
str = "Pass";
}
else
{
str = "Failed";
}
str = (x >= 60) ? "Pass" : "Failed";
Console.WriteLine(str);
}
}
}
赋值和lambda表达式
using System;
namespace DonversionExample
{
internal class OperatorExample
{
static void Main(string[] args)
{
int x = 5;
//x = x + 1;
//x += 1;
x <<= 2;
Console.WriteLine(x);
int a = 5;
int b = 6;
int c = 7;
int A = a += b *= c;
Console.WriteLine(A);
}
}
}
013 表达式与语法详解1
表达式的定义
-
C#语言中表达式的分类
-
A value. Every value has an associated type 任何能得到值得运算（回顾操作符和结果类型）
using System; namespace ExpressionExample { class Program { static void Main() { //经过操作符的运算之后，得到的结果不一定和操作数是一种数据结构 var x = 3 < 5; Console.WriteLine(x); Console.WriteLine(x.GetType().FullName); } } }各种操作符运算后数据类型
- 成员访问操作符x.y
//与成员本身的数据类型有关 using System; namespace ExpressionExample { class Program { static void Main() { Student student = new Student(); var x = student.ID; var y = student.Name; } class Student { public int ID; public string Name; } } }- 函数调用操作符f(x)
using System; namespace ExpressionExample { class Program { static void Main() { //与函数的返回值有关 var x = Math.Pow(2,3); Console.WriteLine(x.GetType().FullName); //public static extern double Pow(double x, double y); } } }- 成员访问操作符a[]
using System; using System.Collections.Generic; namespace ExpressionExample { class Program { static void Main() { //和成员本身的数据类型有关 List<int> intList = new List<int>() {1 , 2 ,3 }; double[] doubleArray = new double[] { 1.0, 2.0, 3.0 }; var x = intList[1]; var y = doubleArray[1]; Console.WriteLine(x.GetType().FullName); Console.WriteLine(x.GetType().FullName); } } }- x++,x--,++x,--x
using System; namespace ExpressionExample { class Program { static void Main() { var x = 100; var y = 100; //打印操作符应用后的结果，而非变量的值 Console.WriteLine(x++); Console.WriteLine(x); Console.WriteLine(--y); Console.WriteLine(y); } } }- new
using System; using System.Windows.Forms; namespace ConsoleApp1 { internal class Program { static void Main(string[] args) { //实例的数据类型 Console.WriteLine((new Form()).GetType().FullName); } } }- typeof
- 得到type数据类型
- default
using System; namespace ConsoleApp1 { internal class Program { static void Main(string[] args) { //得到的是default操作的数据类型，即操作数的数据类型 var x = default(Int32); Console.WriteLine(x); Console.WriteLine(x.GetType().FullName); } } }- checked,unchecked
using System; namespace ConsoleApp1 { internal class Program { static void Main(string[] args) { //得到的是checked/unchecked操作的数据类型，即操作数的数据类型 var x = checked(100 + 200); Console.WriteLine(x.GetType().FullName); } } }-
-
- (一元)
- 操作数的数据类型
-
- !
- 得到布尔类型
- ~
- 操作数的数据类型
- (T)x
- 转换目标的数据类型
- 算数操作符(+ , - , * , / , %)
- 当操作数数据类型相同时，得到的是操作数的数据类型
- 当操作数数据类型不同时，得到的是精度高的操作数的数据类型
- 位移操作符<<,>>
using System; namespace ConsoleApp1 { internal class Program { static void Main(string[] args) { //得到的是左边的操作数的数据类型 long x = 100; Console.WriteLine((x << 2).GetType().FullName); } } }- 关系,类型检测(< , > , <= , >= , is , == , =!)
- 得到布尔类型
- as
- 成功获得右边操作数的数据类型
- 失败获得null
- 逻辑"与" ，XOR ， OR(& , ^ , |)
- 操作数的数据类型相同
- 条件AND/OR(&& , ||）
- 布尔类型
-
A variable. Every variable has an associated type.
-
A namespace
-
A type
-
A method group 例如:Console.WriteLine，这是一组方法，重载决策决定具体调用哪个
-
A null literal
-
A anonymous function
-
A property access
-
A event access
-
An indexer access
-
Nothing 对返回值为void的方法的调用
-
-
复合表达式的求值
- 注意操作符的优先级和同操作符的运算方向
-
参考C#语言定义文档
- 仅作参考，不必深究——毕竟我们是在学习语言、不是去实现这门语言