C#基础

● 区分大小写

● 强类型的语言

● #region 可以产生折叠#endregion

● 100U,100UL,100L,1.5M, m=实数

● @"C:\Program Files\Windows"

● 用点引用名字空间：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的确是一种类型，不初始化也可以

● 反射？！