做些技术积累，高手不要见笑。因为C#有点Java和C++杂交的味道，太容易让人记混了。
指定声明的类型和类型成员的可访问性。
public：
访问不受限制, 任何地方都可以访问。
protected：
访问仅限于类或派生类。
private：
访问仅限于类
internal：
访问仅限于当前程序集。
protected internal：
访问仅限于当前程序集或派生类。
-----------------------------------------------------------
一个成员或类型只能有一个访问修饰符
命名空间上不允许使用访问修饰符。命名空间没有访问限制。
不嵌套在其他类型中的*类型的可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。
类中成员的默认可访问性是private
命名空间中的类型可访问性只能是 internal 或 public。这些类型的默认可访问性是 internal。
------------------------------------------------------------
abstract:
抽象类
不能被实例化
可包含抽象方法和抽象属性
派生类必须实现抽象基类的所有抽象成员，通过重写抽象成员实现。
------------------------------------------------------------
Sealed
密封类
不能被继承 , 可防止意外的继承
abstract 修饰符与密封类一起使用是错误的。
结构是隐式密封的，因此它们不能被继承。
ps：我晕，Java中final关键字的翻版。
-------------------------------------------------------------
static
静态类：
仅包含静态成员。
不能被实例化。不能使用 new 关键字创建静态类的实例
是密封的。
不能包含实例构造函数, 可包含静态构造函数
-------------------------------------------------------------
成员修饰符
abstract：
方法或属性不能实现。都是隐式虚拟，且在派生类中必须实现。
const
它指定字段（域）成员或局部变量的值是常数，不能被修改。
不允许在常数声明中使用 static 修饰符 。
event：
声明事件。
extern:
指示方法在外部实现.
virtual:
virtual:
指示一个方法或属性可以被派生类改写.
override:
对由基类继承的虚（ virtual ）、抽象（abstract）的成员的新实现.
readonly:
指示一个域成员只能在声明时以及相同类的构造函数中被赋值.
static:
指示一个成员属于类,而不是属于类的实例.
可用于域成员、方法、属性、操作符、构造函数
可用于域成员、方法、属性、操作符、构造函数
-----------------------------------------------------------
此段摘自：
1，整型
C# 支持九种整型：
其中char类型比较特殊。虽然属于整型类别。但是以下两个方面不同于其他整型：
1）不存在从其他类型到
2，浮点型
浮点型精度较低，不推荐两个浮点型之间比较大小的判断。
3，decimal类型
decimal类型是采用四舍六入五考虑的银行家舍入法进行计算的。
4，值类型
C# 支持九种整型：
sbyte、byte、short、ushort、int、uint、long、ulong和 char。其中char类型比较特殊。虽然属于整型类别。但是以下两个方面不同于其他整型：
1）不存在从其他类型到
char类型的隐式转换。具体说来，即使 sbyte、byte和 ushort类型具有完全可以用 char类型来表示的值范围，也不存在从 sbyte、byte或 ushort到 char的隐式转换。2）char类型的常数必须写成字符或带有强制转换为类型 char的整数。例如，(char)10与 '"x000A'是相同的。2，浮点型
C#的浮点型包括：float和double。
float类型可表示精度为 7 位、在大约 1.5 × 10−45 到 3.4 × 1038 的范围内的值。double类型可表示精度为 15 位或 16 位、在大约 5.0 × 10−324 到 1.7 × 10308 的范围内的值。浮点型精度较低，不推荐两个浮点型之间比较大小的判断。
3，decimal类型
decimal 类型是适合财务和货币计算的 128 位数据类型。
decimal类型可以表示具有 28 或 29 个有效数字、从 1.0 × 10-28 到大约 7.9 × 1028 范围内的值。decimal类型是采用四舍六入五考虑的银行家舍入法进行计算的。
4，值类型
PS： 这图不错！
------------------------------------------------------------------
const 、 readonly区别
const 字段只能在该字段的声明中初始化。
readonly 字段可以在声明或构造函数中初始化。
因此，根据所使用的构造函数，readonly 字段可能具有不同的值。
const 字段为编译时常数
readonly 字段可用于运行时常数
const 字段类外通过类名访问
readonly 字段通过类实例（实例变量）或类（静态变量）访问
------------------------------------------------------------------
对于那些本质上应该是常量，但是却无法使用const来声明的地方，可以使用static readonly
下面是一段关于C#继承与封装的程序，不过我估计这应该是最老的一个写法了，现在C#的语法糖，应该
已经有更方便的实现方式了，只不过我还没接触到。
namespace test{
public class Student{
private string student_id; //学号
private string student_name; //姓名
public static string information="---------学生上课情况表----------";
public Student(string id,string name) //构造函数
{
student_id=id;
student_name=name;
}
public string StudentID // 用于访问私有字段 student_id的属性
{
get
{ return student_id;}
set
{ student_id=value;}
}
public string StudentName // 用于访问私有字段 student_name的属性
{
get
{ return student_name;}
set
{ student_name=value;}
}
public string AddressClass(int i)
{
string CAddress;
if(i==1)
CAddress="2楼"; //研究生在2楼上课
else
CAddress="3楼"; //本科生在3楼上课
return CAddress;
}
}
public class Graduate:Student{
public Graduate(string i, string j, string tn): base( i, j )
{ teacher_name=tn; }
public string TeacherName // 用于访问私有字段 student_name的属性
{
get
{ return teacher_name;}
set
{ teacher_name=value;}
}
private string teacher_name; //导师名
}
class AppStudent
{
public static void Main(){
Console.WriteLine("{0}",Student.information);
Graduate gs=new Graduate("2007480***","哈哈","施杨");
Console.WriteLine("研究生学号＝{0}",gs.StudentID); //调用属性StudentID
Console.WriteLine("研究生姓名＝{0}",gs.StudentName); //调用属性StudentName
Console.WriteLine("研究生上课地点＝{0}",gs.AddressClass(1)); //调用方法
Console.WriteLine("教师姓名＝{0}",gs.TeacherName);
Console.ReadLine();
}
}
}
----------------------------------------------------------------------------------
base关键字
using System;
namespace test{
class BaseClass{
public void TestMethod(){
Console.WriteLine("BaseClass:: TestMethod");
}
}
class DerivedClass:BaseClass{
new public void TestMethod(){
base. TestMethod(); //base访问基类中被隐藏的方法
Console.WriteLine("DerivedClass:: TestMethod");
}
}
class App
{
public static void Main(){
DerivedClass t =new DerivedClass();
t.TestMethod(); //调用DerivedClass:: TestMethod（）
((BaseClass)t). TestMethod(); //调用BaseClass:: TestMethod（）
Console.ReadLine();
}
}
}
using System;
namespace test{
class Test{
static void F(params int[] args){
Console.WriteLine("# of arguments: {0}", args.Length);
for (int i = 0; i < args.Length; i++)
Console.WriteLine("\t args[{0}] = {1}", i, args[i]);
}
static void Main(){
F( );
F(1, 2);
F(1, 2, 3);
F(new int[] {1, 2, 3, 4});
Console.ReadLine();
}
}
}
base 关键字用于从派生类中访问基类的成员
----------------------------------------------------------------------------------
方法的覆写与调用
namespace test{
class BaseClass{
public void TestMethod(){
Console.WriteLine("BaseClass:: TestMethod");
}
}
class DerivedClass:BaseClass{
new public void TestMethod(){
base. TestMethod(); //base访问基类中被隐藏的方法
Console.WriteLine("DerivedClass:: TestMethod");
}
}
class App
{
public static void Main(){
DerivedClass t =new DerivedClass();
t.TestMethod(); //调用DerivedClass:: TestMethod（）
((BaseClass)t). TestMethod(); //调用BaseClass:: TestMethod（）
Console.ReadLine();
}
}
}
-------------------------------------------------------------------------------
引用参数：
ref修饰符声明，不创建新的存储位置
变量被作为实参传递前，自身必须被明确赋值。
引用参数被认为是初始化过的。
out修饰符声明,不创建新的存储位置
变量被作为实参传递前，自身不需要明确地赋值。
调用后，实参变量被认为已被明确赋值
输出参数被认为是未初始化过的。
返回之前，必须为每一个输出参数明确地赋值。
实现多值返回
参量参数：
params修饰符声明
一个参量参数必须是形式参数列表中的最后一个
参量参数的类型必须是一个单维数组类型。
例如，类型int[]可以被用作参量参数类型，但是类型int[,]不能用。
namespace test{
class Test{
static void F(params int[] args){
Console.WriteLine("# of arguments: {0}", args.Length);
for (int i = 0; i < args.Length; i++)
Console.WriteLine("\t args[{0}] = {1}", i, args[i]);
}
static void Main(){
F( );
F(1, 2);
F(1, 2, 3);
F(new int[] {1, 2, 3, 4});
Console.ReadLine();
}
}
}
PS:Java里没有，个人觉得有点多余。
--------------------------------------------------------------------------------
多态上要强于Java，因为Java中的子类中如果有与父类同名同参的方法，必须覆写，否则报错，而C#可以new一个方法，从而实现
在不改变父类方法的同时，新开辟一块内存空间，保存子类的同名同参方法。但是同样Java中的继承机制也没有C#复杂，但是也不失
简练，子类不用重写父类方法，就可以用super调用。Java中的接口对应C#中的虚函数。相对而言，比较习惯用Java的接口。
as运算符的功能与强制类型转换类似。
可将一个对象强制转换为另一类型。
如果源类型无法转换为目标类型，则首先将其置为null，然后再转换为目标类型
本文转自施杨博客园博客，原文链接：http://www.cnblogs.com/shiyangxt/archive/2009/05/03/1447865.html，如需转载请自行联系原作者