● 区分大小写
● 强类型的语言
● #region 可以产生折叠#endregion
● 100U,100UL,100L,1.5M, m=实数
● @"C:Program FilesWindows"
● 用点引用名字空间：Level1.Level2.myVariable
● using Level1;
using L = Level1;
● Convert.ToBoolean(v); Convert.ToString(v);
● enum BlendType { SrcAlpha, DstAlpha, }; == enum BlendType : int { SrcAlpha, DstAlpha, };
也可以自定义类型：enum BlendType : byte { SrcAlpha, DstAlpha, }
BlendType e = BlendType.SrcAlpha;
● 变量也有 ToString() 函数。
● BlendType e2 = Enum.Parse(typeof(BlendType), "SrcAlpha"); //从字符串转换为枚举
● struct ROUTE{
public BlendType me; //public前缀
};
● Console.WriteLine("Name with index of {0}: {1}", i, friendName[i]); // {0}和{1}
● int[] arr = {1,2,3,4,5};
int[] arr = new int[5];
int[] arr = new int[5]{1,2,3,4,5};
int[] arr; arr = new int[5];
● foreach (int a in arr) { // foreach
Console.WriteLine(a);
}
● int[,] arr = {{1,2,3},{4,5,6}};// 二维数组(每行个数一样)
foreach (int a in arr) { // foreach 访问多维数组
Console.WriteLine(a);//输出：1,2,3,4,5,6
}
● int[,,] arr = new int[3][4][5]; arr[0,1,1] = 5; //三维数组(每行个数一样)
● int[][] arr; //锯齿数组，多维数组(每行个数可以不一样)
arr = new int[2][];
arr[0] = new int[3];//第0行是一个个数为3的数组
arr[1] = new int[4];//第1行是一个个数为4的数组
foreach (int[] a in arr) {//遍历锯齿数组
foreach(int v in a) {
Console.WriteLine(v);
}
}
● params 关键字(只能用于函数的最后一个参数)
static int MaxValue(params int[] arr) {
}
调用：MaxValue(1,2,3,4,5);
● ref 关键字
static int Double(ref int v) {
v *= 2;
}
Double(ref v);//调用时也必须要加ref
● out 关键字(与ref 类似，但有重要区别)
static int Double(out int v) {
v *= 2;
}
Double(out v);//调用时也必须加out
1. 把未赋值的变量作为ref是非法的，但可以做为out
2. 传递变量给out，则out看作是未赋值的，因为在函数内部他要被赋值
● Delegate
delegate int MYDELEGATE(int a, int b); //定义一个delegate类型
int multiply(int a, int b) { return a * b; }//一个普通的函数
MYDELEGATE d;
d = new MYDELEGATE(multiply);//new一个，并指向multiply函数
d(1,2);//通过委托调用函数
● 垃圾回收
● 静态构造函数
● 静态类
● 可删除对象 IDisposable，继承他则必须实现 Dispose() 方法
● using (MyDis p = new MyDis())//这种用法会在块结束后自动调用 p的 Dispose() 方法
{
}
● 所有的类都继承于Object，如果没有显示地继承，就是从这个类继承。
● 引用类型、值类型
● class MyClass {}//默认是internal
internal class MyClass {} //internal类只能在本项目中访问
public class MyClass {}
public abstract class MyClass {}
public sealed class MyClass {}
public class MyClass : MyBase, IInterface {}//ok
public class MyClass : IInterface, MyBase {} // not ok
internal可以继承public，反之不行。
public interface MyClass {}
interface 不可以使用 abstract，sealed。
● 接口不是类，所以没有继承System.Object
● base关键字:
public class Apple : Frute
{
public Apple() : base(0) {}
}
● this关键字：构造函数调用另一个构造函数：
public class Apple
{
public Apple() : this(5) {}
public Apple(int price) {}
}
● 接口与抽象类的区别
● 抽象成员和非抽象成员
● 类是引用类型，结构体是值类型
public readonly int MYINT = 0; 表示这个字段只能在构造函数中赋值，或者是直接=一个值
public static int myint;
public const int cmyint = 0; //const 就是静态的，但不可以加static
public virtual void DoSomething() {} //该方法可以被重写
public override void DoSomething() {} //重写了父类的方法
public abstract void DoSomething() {} //该方法必须被重写，只能用于abstract类
public sealed void DoSomething() {}//派生类不可以重写他
public override sealed void DoSomething() {}//当前正在重写，但以后的派生类就不可以了
public extern void DoSomething() {} //此函数的实现在其他地方
● C#类成员分为属性和字段。属性就是具有get和set的字段。
public class MyClass {
public int myScore; //myScore称为字段，也就是Field
public int Score { //Score称为属性，也就是Property，他用来操作myScore
get { return myScore; }
protected set { myScore = value; }//可以额外对set添加访问权限，value是关键字
};
public int Score { get; set; }//自动属性
};
public class Frute { public void Eat() { /*do something*/ } }
public class Apple : Frute { public void Eat() {} }//隐藏基类成员
public class Apple : Frute { new public void Eat() {} }//显示地隐藏基类成员，基类的方法如果是virtual，也是一样
public class Frute
{
public class Ohter//在类内部再定义类
{
}
}
● 接口
public interface IInterface { void DoSomething(); }
public interface Frute : IInterface { void DoSomething() {} }//隐式实现接口函数，可以使用Frute对象来调用这个函数
public interface Frute : IInterface { void IInterface.DoSomething {} }//显式实现接口函数，只能使用IInterface对象来调用这个函数
● 部分类定义
public partial class Frute {}//部分类定义，可以把类的不同部分定义在不同的文件中
public partial class Frute : IInterface1 {}
public partial class Frute : IInterface2 {} //这样分2次定义Frute类后，相当于 Frute 同时继承 IInterface1 和 IInterface2
public partial class Apple : Frute {}
public partial class Apple : Frute {}//2部分定义类Apple，因为只能从一个类继承，所以他们写的基类必须相同
● 部分类函数
public class Frute {
public partial Eat();
pubic partial Eat() {}
}
注意：如果一个部分函数没有实现，所有调用这个函数的代码都会被忽略。这个很好啊
● 匿名函数(闭包？)
myconnect.handler += delegate(int i) { /* do something */ }
● 初始化器
● 类型推理（C# 3.0支持，类似于C++的auto，是其他技术的基础）
var v = 5; //编译器会知道v应该是int类型，var自身并不是一种类型，必须初始化
● 匿名类型
Curry curry = new Curry {//匿名类型，Curry是没有定义的类型
name = "answer",
age = 28,
};
curr = new {//更为简单的形式
name = "answer",
age = 28,
};
● 动态变量（即类型不固定的变量，C#4.0以上支持，有代价）
dynamic v; // 与var不同，dynamic的确是一种类型，不初始化也可以
● 反射？！