第一篇：C#绘图双缓冲技术总结
C#绘图双缓冲技术总结 GDI+的双缓冲问题
一直以来的误区：.net1.1 和.net 2.0 在处理控件双缓冲上是有区别的。.net 1.1 中，使用：this.SetStyle(ControlStyles.DoubleBuffer, true);.net 2.0中，使用：this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);VS2005 是2.0 怪不说老是提示参数无效，一直也不知道是这个问题，呵呵
要知道，图元无闪烁的实现和图元的绘制方法没有多少关系，只是绘制方法可以控制图元的刷新区域，使双缓冲性能更优！
导致画面闪烁的关键原因分析：
一、绘制窗口由于大小位臵状态改变进行重绘操作时
绘图窗口内容或大小每改变一次，都要调用Paint事件进行重绘操作，该操作会使画面重新刷新一次以维持窗口正常显示。刷新过程中会导致所有图元重新绘制，而各个图元的重绘操作并不会导致Paint事件发生，因此窗口的每一次刷新只会调用Paint事件一次。窗口刷新一次的过程中，每一个图元的重绘都会立即显示到窗口，因此整个窗口中，只要是图元所在的位臵，都在刷新，而刷新的时间是有差别的，闪烁现象自然会出现。
所以说，此时导致窗口闪烁现象的关键因素并不在于Paint事件调用的次数多少，而在于各个图元的重绘。根据以上分析可知，当图元数目不多时，窗口刷新的位臵也不多，窗口闪烁效果并不严重；当图元数目较多时，绘图窗口进行重绘的图元数量增加，绘图窗口每一次刷新都会导致较多的图元重新绘制，窗口的较多位臵都在刷新，闪烁现象自然就会越来越严重。特别是图元比较大绘制时间比较长时，闪烁问题会更加严重，因为时间延迟会更长。
解决上述问题的关键在于：窗口刷新一次的过程中，让所有图元同时显示到窗口。
二、进行鼠标跟踪绘制操作或者对图元进行变形操作时
当进行鼠标跟踪绘制操作或者对图元进行变形操作时，Paint事件会频繁发生，这会使窗口的刷新次数大大增加。虽然窗口刷新一次的过程中所有图元同时显示到窗口，但也会有时间延迟，因为此时窗口刷新的时间间隔远小于图元每一次显示到窗口所用的时间。因此闪烁现象并不能完全消除！
所以说，此时导致窗口闪烁现象的关键因素在于Paint事件发生的次数多少。解决此问题的关键在于：设臵窗体或控件的几个关键属性。
下面来介绍解决办法的具体细节：
解决双缓冲的关键技术：
1、设臵显示图元控件的几个属性： 必须要设臵，否则效果不是很明显！this.SetStyle(ControlStyles.OptimizedDoubleBuffer |
ControlStyles.ResizeRedraw |
ControlStyles.AllPaintingInWmPaint, true);
2、窗口刷新一次的过程中，让所有图元同时显示到窗口。
可以通过以下几种方式实现，这几种方式都涉及到Graphics对象的创建方式。
Graphics对象的创建方式：
a、在内存上创建一块和显示控件相同大小的画布，在这块画布上创建Graphics对象。
接着所有的图元都在这块画布上绘制，绘制完成以后再使用该画布覆盖显示控件的背景，从而达到“显示一次仅刷新一次”的效果！
实现代码（在OnPaint方法中）： Rectangle rect = e.ClipRectangle;Bitmap bufferimage = new Bitmap(this.Width, this.Height);Graphics g = Graphics.FromImage(bufferimage);g.Clear(this.BackColor);g.SmoothingMode = SmoothingMode.HighQuality;//高质量 g.PixelOffsetMode = PixelOffsetMode.HighQuality;//高像素偏移质量 foreach(IShape drawobject in doc.drawObjectList){ if(rect.IntersectsWith(drawobject.Rect)){ drawobject.Draw(g);if(drawobject.TrackerState == config.Module.Core.TrackerState.Selected
&& this.CurrentOperator == Enum.Operator.Transfrom)//仅当编辑节点操作时显示图元热点
{ drawobject.DrawTracker(g);} } } using(Graphics tg = e.Graphics){ tg.DrawImage(bufferimage, 0, 0);//把画布贴到画面上 }
b、直接在内存上创建Graphics对象： Rectangle rect = e.ClipRectangle;BufferedGraphicsContext currentContext = BufferedGraphicsManager.Current;BufferedGraphics myBuffer = currentContext.Allocate(e.Graphics, e.ClipRectangle);Graphics g = myBuffer.Graphics;g.SmoothingMode = SmoothingMode.HighQuality;g.PixelOffsetMode = PixelOffsetMode.HighSpeed;g.Clear(this.BackColor);foreach(IShape drawobject in doc.drawObjectList){ if(rect.IntersectsWith(drawobject.Rect)){ drawobject.Draw(g);if(drawobject.TrackerState == config.Module.Core.TrackerState.Selected && this.CurrentOperator == Enum.Operator.Transfrom)//仅当编辑节点操作时显示图元热点
{ drawobject.DrawTracker(g);} } } myBuffer.Render(e.Graphics);g.Dispose();myBuffer.Dispose();//释放资源
至此，双缓冲问题解决，两种方式的实现效果都一样，但最后一种方式的占有的内存很少，不会出现内存泄露！
手工设臵双缓冲.netframework提供了一个类BufferedGraphicsContext负责单独分配和管理图形缓冲区。每个应用程序域都有自己的默认 BufferedGraphicsContext 实例来管理此应用程序的所有默认双缓冲。大多数情况下，每个应用程序只有一个应用程序域，所以每个应用程序通常只有一个默认
BufferedGraphicsContext。默认 BufferedGraphicsContext 实例由 BufferedGraphicsManager 类管理。通过管理BufferedGraphicsContext实现双缓冲的步骤如下：
（1）获得对 BufferedGraphicsContext 类的实例的引用。（2）通过调用 BufferedGraphicsContext.Allocate 方法创建 BufferedGraphics 类的实例。
（3）通过设臵 BufferedGraphics.Graphics 属性将图形绘制到图形缓冲区。（4）当完成所有图形缓冲区中的绘制操作时，可调用
BufferedGraphics.Render 方法将缓冲区的内容呈现到与该缓冲区关联的绘图图面或者指定的绘图图面。
（5）完成呈现图形之后，对 BufferedGraphics 实例调用释放系统资源的 Dispose 方法。dataGridView 闪烁 和 listview 闪烁 的解决办法。
-----------------------DataGridView
///
//this.dataGridView1 = new System.Windows.Forms.DataGridView();(屏蔽掉)this.dataGridView1 = new DoubleBufferDataGridView();-----------------------ListView------///
//this.listView1 = new System.Windows.Forms.ListView();(屏蔽掉)this.listView1 = new DoubleBufferListView();
foreach
foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。此语句的形式如下：
foreach(type identifier in expression)statement
其中：
type
identifier 的类型。
identifier
表示集合元素的迭代变量。如果迭代变量为值类型，则无法修改的只读变量也是有效的。
expression
对象集合或数组表达式。集合元素的类型必须可以转换为 identifier 类型。请不要使用计算为 null 的表达式。
而应计算为实现 IEnumerable 的类型或声明 GetEnumerator 方法的类型。在后一种情况中，GetEnumerator 应该要么返回实现 IEnumerator 的类型，要么声明 IEnumerator 中定义的所有方法。
statement
要执行的嵌入语句。
事例：
int[] arr = new int[] { 0, 1, 2, 3, 4 };
foreach(int i in arr)
{
Console.Write(i);
}
C#中foreach语法
int[] arr={1,2,3};
foreach(int i in arr)
{
System.Console.WriteLine(i);
}
php中foreach语法
$arr=array(1,2,3,4,'a','b',“c”);
1.foreach($arr as $v)
{
echo $v.“ ”;
}
2.foreach($arr2 as $k=>$v)
{
echo “[$k]=>$v
”;
}
java中foreach语法
格式：
for(元素类型type 元素变量x : 遍历对象obj)
{
引用了x的java语句;
}
Example：
public class Test {
public static void main(String[] args)
{
int[] a = {1,2,3};
for(int i : a)
System.out.print(i + “ ”);
}
}
第二篇：C#总结
引用类型是类型安全的指针，它们的内存是分配在堆（保存指针地址）上的。String、数组、类、接口和委托都是引用类型。
强制类型转换与as类型转换的区别：当类型转换非法时，强制类型转换将抛出一System.InvalidCastException异常，而as不会抛出异常，它返回一个null值。用using创建别名：using console = System.Console;访问限定符：
public 该成员可以被其他任何类访问 protected 该成员只能被其派生类访问
private 该成员只能被本类的其他成员访问 internal 该成员只能在当前编译单元的其他成员访问 带参数列表和返回值的Main方法： class Test {
public static int Main(string[] args)
{
foreach(string arg in args)
{
...}
} } 构造函数（constructor）包括实例构造函数和静态构造函数。构造函数与类名相同，且不能有返回值。例：
class TestClass {
TestClass()//实例构造函数：可以访问静态成员和实例成员，用于初始化实例成员
{
...}
static TestClass()//静态构造函数：只能访问静态成员，用于初始化静态成员
{
...} } 类的静态成员属于类所有，不必生成实例就可以访问，它是在载入包含类的应用程序时创建的，但静态方法不能访问类的实例变量和方法。通常，静态变量是在定义时就赋初始值的。类的实例成员属于类的实例所有，不创建实例对象就无法对其进行访问，实例成员可以访问类的
静态成员和其它实例成员。调用基类的析构函数： class A {
public A()
{
...} } class B {
public B(): base()//调用基类的析构函数
{
...} } 常量：其值是在编译时设定的，必须是数值文字。默认状态下常量是静态的。例： class A {
public const double pi = 3.1415;} 常量是编译时就确定的值，只读字段是在运行才能确定的值。比如运行时才能确定的屏幕分辨率。
只读字段只能在类的析构函数中赋值。静态只读字段： class A {
public static readonly int ScreenWidth;//静态只读字段
static A()
//静态析构函数
{
ScreenWidth = 1024;//在静态析构函数中初始化
} } 在类的继承中，类的析构函数是不会被继承的。一个派生类只能从一个基类继承，不能同时从多个基类继承，但可以通过继承多个接口来达到相同目的。实现多继承的唯一方法就是使用接口。例：
class MyFancyGrid: Control, ISerializable, IDataBound {...} 密封类是不能继承的类，抽象类不能被定义为密封类，且密封类的私有成员不能用protected修饰，只能用private。例： sealed class A {...} 关键字ref和out用于指定用引用方式传递方法的参数。
它们的区别是：ref参数必须初始化，而out参数不需要初始化。所以在方法处理代码依赖参数的初始化值时使用ref，不依赖初始化值时使用out。对out参数即使在传递前对其进行了初始化，其值也不会传递到方法处理函数内部。传递时系统会将其设为未初始化。所以在方法内部必须对out参数进行初始化。
方法重载时，必须参数数目和参数类型其中之一不同，返回值不同不能作为重载。C#不支持方法的默认值，只能通过方法重载来实现。例： class A {
int Method(int a)
{
...}
void Method(int a, int b)//参数数目不同
{
//返回值不同不能作为重载
...} } params参数用于一个不定数目参数的方法，一般后面跟一个数组。例： class A {
public void Method(params int[] i)
{
...} } 方法的覆盖：指派生类覆盖基类的同名方法，有二种方法
1）第一种是在派生类要覆盖的方法前面加new修饰，而基类不需要作任何改动。这种方法的缺点是不能实现多态。例： class A {
public void Method()//无需任何修饰
{
...} } class B: A
//从基类继承
{
new public void Method()//覆盖基类的同名方法
{
...} } class TestClass {
A Instance = new B();
Instance.Method();//这时将调用类A的Method方法，而不是类B的Method方法 } 2）第二种是在派生类要覆盖的方法前面加override修饰，而基类的同名方法前面加virtual修饰。这样就能实现多态，例： class A {
virtual public void Method()
//基类定义虚方法
{
//虚拟方法不能定义为private，因为private成员对派生类是无法访问的...} }
class B: A
//从基类继承 {
override public void Method()
//派生类覆盖基类的同名虚方法
{
...} } class TestClass {
protected void Test()
{
A Instance = new B();
//定义一个实例，类型为基类，从派生类创建
//派生类总是能够向上转换为其基类
Instance.Method();
//将调用派生类B的Method方法，而不是基类的，这就是多态
} } 说明：new修饰的方法覆盖不能实现多态的原因，是因为使用new时编译器只会实现早期绑定（early binding）。即调用的方法在编译时就决定了：编译器看到Instance.Method()而Instance的类是A，就会调用类A的Method()方法。
override修饰的方法覆盖可以实现多态的原因，是因为实现了后期绑定（late binding）。使用override时强制编译器在运行时根据类的真正类型正确调用相应的方法，而不是在编译时。
而基类的同名方法必须加virtual修饰。
类的静态方法可能通过 类名.静态方法名 这种格式来调用，不能使用 实例名.静态方法名 这种方法调用。
因为类的静态方法为类所有（是属于类本身的），而非实例所有（不是属于类的实例的）。类的静态方法可以访问类的任何静态成员，但不能访问类的实例成员。C#中类的变量称为字段。类的public变量称为类的公共字段。
类的属性由一个protected（也可以是private）字段和getter和setter方法构成： class Address {
protected string zipCode;//protected字段，注意大小写
public string ZipCode
{
get
//getter方法
{
return zipCode;
}
set
//setter方法
{
zipCode = value;//被传递的值自动被在这个value变量中
}
};} 只读属性是指省略setter方法的属性，只读属性只能读取，不能设置。
属性也可以用限定符virtual，override和abstract修饰，功能同其他类的方法。
属性有一个用处称为懒惰的初始化（lazy initialization）。即在需要类成员时才对它们进行初始化。如果类中包含了很少被引用的成员，而这些成员的初始化又会花费大量的时候和系统资源的话，懒惰的初始化就很有用了。C#中数组对象共同的基类是System.Array。将数组声明为类的一个成员时，声明数组与实例化数组必须分开，这是因为只能在运行时创建了类的实例对象之后，才能实例化数组元素值。声明：
int[] intArray;//一维数组 int[，] int3Array;//三维数组 初始化：
intArray = new int[3] {1,2,3};int[,] int2Array = new int[2,3] {{1,2,3},{4,5,6}};//声明时可以初始化 遍历：
1）一维数组
for(int i = 0;i < intArray.Length;i++);//Array.Length返回数组所有元素的个数 foreach(int i in intArray);for(int i = 0;i < intArray.GetLength(0);i++);//Array.GetLength(0)返回数组第一维的个数 2）多维数组
for(int i = 0;i < int3Array.GetLength(0);i++)//遍历三维数组
for(int j = 0;j < int3Array.GetLength(1);j++)
for(int k = 0;k < int3Array.GetLength(2);k++)
{
...} 数组的维数就是该数组的秩（Rank）。Array.Rank可以返回数据的秩。锯齿数组（jagged Array）是元素为数组的数组，例：
int[][] jaggedArray = new int[2][];//包含二个元素，每个元素是个数组 jaggedArray[0] = new int[2];//每个元素必须初始化 jaggedArray[1] = new int[3];for(int i = 0;i < jaggedArray.Length;i++)//遍历锯齿数组
for(int j = 0;j < jaggedArray[i].Length;j++)
{
...} 类的属性称为智能字段，类的索引器称为智能数组。由于类本身作数组使用，所以用this作索引器的名称，索引器有索引参数值。例： using System;using System.Collections;class MyListBox {
protected ArrayList data = new ArrayList();
public object this[int idx] //this作索引器名称，idx是索引参数
{
get
{
if(idx >-1 && idx < data.Count)
{
return data[idx];
}
else
{
return null;
}
}
set
{
if(idx >-1 && idx < data.Count)
{
data[idx] = value;
}
else if(idx = data.Count)
{
data.Add(value);
}
else
{
//抛出一个异常
}
}
} } 接口是二段不同代码之间约定，通过约定实现彼此之间的相互访问。C#并不支持多继承，但通过接口可实现相同功能。当在接口中指定了实现这个接口的类时，我们就称这个类“实现了该接口”或“从接口继承”。一个接口基本上就是一个抽象类，这个抽象类中除了声明C#类的其他成员类型——例如属性、事件和索引器之外，只声明了纯虚拟方法。接口中可以包含方法、属性、索引器和事件——其中任何一种都不是在接口自身中来实现的。例：
interface IExampleInterface {
//property declaration
int testProperty { get;}
//event declaration
event testEvevnt Changed;
//mothed declaration
function void testMothed();
//indexer declaration
string this[int index] { get;set;} } 说明：定义接口时，在方法、属性、事件和索引器所有这些接口成员都不能用public之类的访问限定符，因为所有接口成员都是public类型的。因为接口定义了一个约定，任何实现一个接口的类都必须定义那个接口中每一个成员，否则将编译失败。例： using System;public class FancyControl {
protected string data;
public string Data
{
get {return this.data;}
set {data = value;}
} } interface IValidate {
bool Validate();//接口方法
} public class MyControl: FancyControl, IValidate {
public MyControl()
{
data = “my control data”;
}
public bool Validate()//实现接口
{
if(data == “my control data”)
return true;
else
return false;
} } class InterfaceApp {
MyControl myControl = new MyControl();
IValidate val =(IValidate)myControl;//可以将一个实现某接口的类，转换成该接口
bool success = val.Validate();//然后可调用该接口的方法 } 也可以用：bool success = myControl.Validate();这种方法来调用Validate方法，因为Validate在类MyControl中是被定义成public的，如果去除public，Validate方法被隐藏，就不能用这种方法调用了，这样隐藏接口方法称为名字隐藏（name hiding）。可以用：类实例 is 接口名 来判断某个类是否实现了某接口，例： myControl is IValidate //MyControl类的实例myControl是否实现了IValidate接口
当然，也可用as来作转换，根据转换结果是否为null来判断某个类是否实现了某接口，例： IValidate val = myControl as IValidate;if(null == val){...//没有实现IValidate接口 } else {...//实现了IValidate接口
}
如果一个类从多个接口继承，而这些接口中如果定义的同名的方法，则实现接口的方法时，必须加接口名来区别，写成 接口名.方法名。假设Test类从IDataStore和ISerializable二个接口继承，而这二个接口都有SaveData()方法，实现SaveData()方法时必须写成： class Test: ISerializable, IDataStore {
void ISerializable.SaveData()
{
...}
void IDataStore.SaveData()
{
...} } 如果一个类从多个接口继承，为了方便可以定义一个新的接口，这个接口继续多个接口，然后类直接从这个接口继承就可以了，这个叫合并接口。例： interface ISaveData: ISerializable, IDataStore { //不需要定义任何方法或成员，只是用作合并 } class Test: ISaveData //只要继承ISaveData就可以了 {...} C# 操作符优先级（从高到低）
初级操作符()x.y f(x)a[x] x++ x--new typeof sizeof checked unchecked 一元操作符 +位移操作符 << >> 关系操作符 < > <= >= is 等于操作符 == 逻辑与
& 逻辑异或 ^ 逻辑或
| 条件与
&& 条件或
|| 条件操作符 ?: 赋值操作符 = *= /= %= +=-= <<= >>= &= ^= |= 所有的二元操作符除赋值符外都是左联合的，即从左到右计算。
typeof()运算符可以从一个类名得到一个System.Type对象，而从System.Object对象继承来的GetType()方法则可从一个类实例来得到一个System.Type对象。例： Type t1 = typeof(Apple);//Apple是一个类名
Apple apple = new Apple();//apple是Apple类的一个实例 Type t2 = apple.GetType();//t1与t2是相同的 通过反射得到一个类的所有成员和方法： Type t = typeof(Apple);string className = t.ToString();//得到类名
MethodInfo[] methods = t.GetMethods();//得到所有方法 foreach(MethodInfo method in methods){ //用method.ToString()得到方法名 } MemberInfo[] members = t.GetMembers();//得到所有成员 foreach(MemberInfo member in members){ //用member.ToString()得到成员名 } sizeof()操作符用来计算值类型变量在内存中占用的字节数（Bytes），并且它只能在unsafe（非安全）
代码中使用。例：
static unsafe public void ShowSizes(){
int i, j;
j = sizeof(short);
j = sizeof(i);} 尽可能使用复合赋值操作符，它比不用复合赋值操作符的效率高。for语句的语法为：
for(initialization;Boolean-expression;step)
embedded-statement 在initialization和step部份还可以使用逗号操作符，例： for(int i = '0', j = 1;i <= 'xFF';i++, j++)for(int i = 1, j = 1;i < 1000;i += j, j = i!~ ++--true false 二元：+32)/ 9)* 5;
} } 代表的(delegate)目的与C++中的函数指针相同，代表不是在编译时被定义的，而是在运行时被定义的。
代表主要有二个用途：回调(Callback)和事件处理(event)回调通常用于异步处理和自定义处理。例： class DBManager {
static DBConnection[] activeConnections;
//声明回调函数
public void delegate EnumConnectionCallback(DBConnection connection);
public static void EnumConnections(EnumConnectionCallback callback)
{
foreach(DBConnection connection in activeConnections)
{
callback(connection);//执行回调函数
}
} } //调用
class DelegateApp {
public static void ActiveConncetionCallback(DBConnection connection)//处理函数
{
...}
public void main()
{
//创建指向具体处理函数的代表实例（新建一个代表，让它指向具体的处理函数）
DBManager.EmnuConnectionCallback myCallback = new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
DBManager.EnumConnections(myCallback);
} } //使用静态代表，上面的调用改为 class DelegateApp {
//创建一个指向处理函数的静态代表
public static DBManager.EmnuConnectionCallback myCallback
= new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
public static void ActiveConncetionCallback(DBConnection connection)
{...} public void main()
{
DBManager.EnumConnections(myCallback);
} } //在需要时才创建代表，上面的调用改为
class DelegateApp {
//将创建代表放在属性的getter方法中
public static DBManager.EmnuConnectionCallback myCallback
{
get
{
retun new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
}
}
public static void ActiveConncetionCallback(DBConnection connection)
{...} public void main()
{
DelegateApp app = new DelegateApp();//创建应用程序
DBManager.EnumConnections(myCallback);
} } 可以将多个代表整合成单个代表，例： class CompositeDelegateApp {
public static void LogEvent(Part part)
{
...}
public static void EmailPurchasingMgr(Part part)
{
...}
public static void Main()
{
//定义二个代表
InventoryManager.OutOfStockExceptionMethod LogEventCallback
= new InventoryManager.OutOfStockExceptionMethod(LogEvent);
InventoryManager.OutOfStockExceptionMethod EmailPurchasingMgrCallback
= new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);
//整合为一个代表，注意后加的代表先执行（这里是先执行LogEventCallback）
InventoryManager.OutOfStockExceptionMethod onHandExceptionEventsCallback
= EmailPurchasingMgrCallback + LogEventCallback;
//调用代表
InventoryManager mgr = new InventoryManager();
mgr.ProcessInventory(onHandExceptionEventsCallback);
//InventoryManager类的ProcessInventory方法的原型为：
//public void ProcessInventory(OutOfStockExceptionMethod exception);
} } 可以根据需要将多个代表自由地组合成单个代表，例： class CompositeDelegateApp {
//代表指向的处理函数（三个代表三个函数）
public static void LogEvent(Part part)
{
...} public static void EmailPurchasingMgr(Part part){...}
public static void EmailStoreMgr(Part part)
{
...}
public static void Main()
{
//通过数组定义三个代表
InventoryManager.OutOfStockExceptionMethod[] exceptionMethods
= new InventoryManager.OutOfStockExceptionMethod[3];
exceptionMethods[0] = new InventoryManager.OutOfStockExceptionMethod(LogEvent);
exceptionMethods[1] = new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);
exceptionMethods[2] = new InventoryManager.OutOfStockExceptionMethod(EmailStoreMgr);
int location = 1;
//再定义一个代表（用于组合成单代表）
InventoryManager.OutOfStockExceptionMethod compositeDelegate;
//根据需要组合
if(location = 2)
{
compositeDelegate = exceptionMethods[0] + exceptionMethods[1];
}
else
{
compositeDelegate = exceptionMethods[0] + exceptionMethods[2];
}
//调用代表
InventoryManager mgr = new InventoryManager();
mgr.ProcessInventory(compositeDelegate);
} } C#的事件遵循“发布——预订”的设计模式。在这种模式中，一个类公布能够出现的所有事件，然后任何的类都可以预订这些事件。一旦事件产生，运行环境就负责通知每个订户事件已经发生了。
当代表作为事件的处理结果时（或者说定义具有代表的事件），定义的代表必须指向二个参数的方法：一个参数是引发事件的对象（发布者），另一个是事件信息对象（这个对象必须从EventArgs类中派生）。例： using System;
class InventoryChangeEventArgs: EventArgs //事件信息对象，从EventArgs类派生 {...//假设定义二个public属性string Sku和int Change } class InventoryManager
//事件的发布者 {
//声明代表
public delegate void InventoryChangeEventHander(object source, InventoryChangeEventArgs e);
//发布事件，event关键字可将一个代表指向多个处理函数
public event InventoryChangeEventHandler onInventoryChangeHander;
public void UpdateInventory(string sku, int change)
{
if(change == 0)
return;
InventoryChangeEventArgs e = new InventoryChangeEventArgs(sku, change);
//触发事件
if(onInventoryChangeHandler!= null)//如果有预订者就触发
onInventoryChangeHandler(this, e);//执行代表指向的处理函数
} } class InventoryWatcher
//事件的预订者 {
public InventoryWatcher(InventoryManager mgr)//mgr参数用于联结发布者
{
this.inventoryManager = mgr;
//预订事件，用 += 调用多个处理函数
mgr.onInventroyChangeHandler += new InventoryManager.InventoryChangeEventHandler(onInventoryChange);
//事件处理函数
void onInventroyChange(object source, InventroyChangeEventArgs e)
{
...}
InventoryManager inventoryManager;
} } class EventsApp
//主程序 {
public static void Main()
{
InventoryManager inventoryManager = new InventoryManager();
InventoryWatcher inventoryWatcher = new InventoryWatcher(inventoryManager);
inventoryManager.UpdateInventory(“111 006 116”,-2);
inventoryManager.UpdateInventory(“111 006 116”, 5);
} } Microsoft Windows NT和IBM OS/2等操作系统都支持占先型多任务。在占先型多任务执行中，处理器负责
给每个线程分配一定量的运行时间——一个时间片(timeslice)。处理器接着在不同的线程之间进行切换，执行相应的处理。在单处理器的计算机上，并不能真正实现多个线程的同时运行，除非运行在多个处理器 的计算机上。操作系统调度的多线程只是根据分配给每个线程时间片进行切换执行，感觉上就像同时执行。
上下文切换(context switching)是线程运行的一部分，处理器使用一个硬件时间来判断一个指定线程的时间片何时结束。当这个硬件计时器给出中断信号时，处理器把当前运行的线程所用的所有寄存器(registers)数据存储到堆栈中。然后，处理器把堆栈里那些相同的寄存器信息存放到一种被称为“上下文结构”的数据结构中。当处理器要切换回原来执行的线程时，它反向执行这个过程，利用与该线程相关的上下文结构，在寄存器里重新恢复与这一线程相关的信息。这样的一个完整过程称为“上下文切换”。多线程允许应用程序把任务分割为多个线程，它们彼此之间可以独立地工作，最大限度地利用了处理器时间。using System;using System.Threading;class SimpleThreadApp {
public static void WorkerThreadMethod()//线程的执行体
{
...//执行一些操作
}
public static void Main()
{
//创建一个线程代表指向线程的执行体，ThreadStart是创建新线程必须用到的代表
ThreadStart worker = new ThreadStart(WorkerThreadMethod);
Thread t = new Thread(worker);//用线程代表创建线程
t.Start();
//执行线程
} } 可以通过两种方式来得到一个Thread对象：一种是通过创建一个新线程来得到，如上例；另一种在正在执行的线程调用静态的Thread.CurrentThread方法。
静态方法Thread.Sleep(int ms)可以让当前线程（它自动调用Thread.CurrentThread）暂停指定毫秒的时间。
如果使用Thread.Sleep(0)那么当前线程将一直处于等待中，直到另一个线程调用这个线程的实例方法Thread.Interrupt方法，等待才会结束。使用Thread.Suspend方法也能挂起线程，Thread.Suspend方法可以被当前线程或其他线程调用，而Thread.Sleep(0)只能由当前线程在执行体中调用。当线程用Thread.Suspend挂起时，必须用Thread.Resume方法恢复。不论Thread.Suspend方法调用了多少次，只要调用Thread.Resume方法一次就可以线程恢复执行。用Thread.Suspend方法并不会阻塞线程，调用立即返回。而Thread.Sleep(0)则会阻塞线程。所以确切地说Thread.Sleep(0)暂停线程，而不是挂起线程。
使用Thread.Abort方法可以终止正在执行的线程。当Thread.Abort方法被调用时，线程不会立即终止执行。运行环境将会等待，直到线程到达文档中所描述的“安全点”。如果要确保线程已经完全停止，可以使用Thread.Join方法。这是一个同步调用，同步调用意味着直到线程完全停止，调用才会返回。
Thread.Priority属性用于设置的线程的优先级。其值是Thread.ThreadPriority枚举值，可以设为Highest, AboveNormal,Normal, BelowNormal, Lowest。缺省值是Thread.ThreadPriority.Normal。
线程的同步是为了解决多个线程同时使用同一对象产生的一些问题。通过同步，可以指定代码的临界区(critical section)，一次只有一个线程可以进入临界区。使用System.Monitor类（锁定与信号量）进行线程同步： using System;using System.Threading;public void SaveData(string text)//线程执行函数或线程执行函数调用的对象的方法 {
...//执行其他一些不需要同步的处理
Monitor.Enter(this);//获取对象的Monitor锁
...//执行需要同步的处理
Monitor.Exit(this);//释放对象的Monitor锁
...//执行其他一些不需要同步的处理
} 说明：当执行Monitor.Enter方法时。这个方法会试图获取对象上的Monitor锁，如果另一个线程已经拥有了这个锁，这个方法将会阻塞(block)，直到这个锁被释放。
也可用C#的lock语句来获得和释放一个Monitor锁。上面同步写成：public void SaveData(string text)//线程执行函数或线程执行函数调用的对象的方法 {
...//执行其他一些不需要同步的处理
lock(this)//获取对象的Monitor锁，代码块执行完成后释放Monitor锁
{
...//执行需要同步的处理
}
...//执行其他一些不需要同步的处理 } 也可以使用System.Threading名称空间的Mutex类（互斥类）进行线程同步。与Monitor锁一样，一次只有一个线程能获得一个给定的互斥。但Mutex要慢得多，但它增加了灵活性。例：
using System;using System.Threading;class Database {
Mutex mutex = new Mutex(false);//创建一个互斥，但不立即获得它
//注意：创建互斥在需要同步的方法之外，实际上它只要创建一个实例
public void SaveData(string text)//需要同步的方法
{
mutex.WaitOne();//等待获得互斥
...//需要同步的处理
mntex.Close();//释放互斥
} } Mutex类重载了三个构造函数：
Mutex()
//创建并使创建类立即获得互斥
Mutex(bool initiallyOwned)
//创建时可指定是否要立即获得互斥 Mutex(bool initiallyOwned, string muterName)//还可以指定互斥的名称 Mutex.WaitOne方法也重载了三次： Mutex.WaitOne()
//一直等待
Mutex.WaitOne(TimeSpan time, bool exitContext)//等待TimeSpan指定的时间 Mutex.WaitOne(int milliseconds, bool exitContext)//等待指定的毫秒 线程的用法：
1)并发操作：比如一个程序监视多个COM口，当每个COM接到信息时执行一段处理时。2)复杂长时间操作：一个长时间的复杂操作可能会使界面停滞，停止用户响应，如果还允许用户停止它，或者显示进度条、显示操作执行进程信息时。
反射(Reflection)就是能够在运行时查找类型信息，这是因为.NET编译的可执行(PE)文件中包括MSIL和元数据(metadata)。
反射的中心是类System.Type。System.Type是一个抽象类，代表公用类型系统(Common Type System, CTS)中的一种类型。
using System;using System.Reflection;//反射命名空间，必须引用 public static void Main(string[] args){
int i = 6;
Type t = i.GetType();
//根据实例得到类型
t = Type.GetType(“System.Int32”);//根据类型的字符名称得到类型
} 通过Assembly类可以得到已经编译.NET Framework程序的中所有类型，例： using System;using System.Diagnostics;//为了使用Process类 using System.Reflection;//为了使用Assembly类 class GetTypesApp {
protected static string GetAssemblyName(string[] args)
{
string assemblyName;
if(0 == args.Length)//如果参数为空，取当前进程的名称
{
Process p = Process.GetCurrentProcess();
assemblyName = p.ProcessName + “.exe”;
}
else
assemblyName = args[0];//取第一个参数，即当前运行程序名
return assemblyName;
}
public static void Main(string[] args)
{
string assemblyName = GetAssemblyName(args);
Assembly a = Assembly.LoadFrom(assemblyName);//调用编译程序集
Type[] types = a.GetTypes();
//得到多个类型
foreach(Type t in types)
//遍历类型数组
{
...//取得t.FullName,t.BaseType.FullName等类型信息
}
} } 一个应用程序可以包括多个代码模块。若要将一个cs文件编译一个模块，只要执行下面的命令：
csc /target:module 要编译的模块.cs //csc是C Sharp Compiler(C#编译器)然后在应用程序中using编译的模块.cs中的NameSpace即可应用了。要反射应用程序中所有代码模块(Module)，只要：
Assembly a = Assembly.LoadFrom(assemblyName);//应用程序的物理文件名 Module[] modules = a.GetModules();foreach(Module m in modules){...//显示m.Name等
} 后期绑定(latebinding),例：
string[] fileNames = Directory.GetFiles(Environment.CurrentDirectory, “*.dll”);foreach(string fileName in fileNames){
Assembly a = Assembly.LoadFrom(fileName);
Type[] types = a.GetTypes();
foreach(Type t in types)
{
if(t.IsSubclassOf(typeof(CommProtocol)))//判断是否有CommProtocol的派生类
{
object o = Activator.CreateInstance(t);//生成实例
MethodInfo mi = t.GetMethod(“DisplayName”);
mi.Invoke(o, null);
//调用方法
}
} } //带参数的例子
namespace Programming_CSharp {
using System;
using System.Reflection;
public class Tester
{
public static void Main()
{
Type t = Type.GetType(“System.Math”);
Object o = Activator.CreateInstance(t);
// 定义参数类型
Type[] paramTypes = new Type[1];
paramTypes[0]= Type.GetType(“System.Double”);
MethodInfo CosineInfo = t.GetMethod(“Cos”, paramTypes);
//设置参数数据
Object[] parameters = new Object[1];
parameters[0] = 45;
//执行方法
Object returnVal = CosineInfo.Invoke(o, parameters);
Console.WriteLine(“The cosine of a 45 degree angle {0}”, returnVal);
}
} } 动态生成代码和动态调用的完整例子： //动态生成代码的部分 using System;using System.Reflection;using System.Reflection.Emit;//动态生成代码必须引用 namespace ILGenServer {
public class CodeGenerator
{
public CodeGenerator()
{
currentDomain = AppDomain.CurrentDomain;//得到当前域
assemblyName = new AssemblyName();//从域创建一个程序集
assemblyName.Name = “TempAssembly”;
//得到一个动态编译生成器，AssemblyBuilerAccess.Run表示只在内存中运行，不能保存
assemblyBuilder = currentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilerAccess.Run);
//从编译生成器得到一个模块生成器
moduleBuilder = assemblyBuilder.DefineDynamicModule(“TempModule”);
//模块生成器得到类生成器
typeBuilder = moduleBuilder.DefineType(“TempClass”, TypeAttributes.Public);
//为类添加一个方法
methodBuilder = typeBuilder.DefineMethod(“HelloWord”, MethodAttributes.Public, null, null);
//为方法写入代码，生成代码必须使用到IL生成器
msil = methodBuilder.GetILGenerator();
msil.EmitWriteLine(“Hello World”);msil.Emit(OpCodes.Ret);//最后还需要编译(build)一下类 t = typeBuilder.CreateType();
}
AppDomain currentDomain;
AssemblyName assemblyName;
AssemblyBuilder assemblyBuilder;
ModuleBuilder moduleBuilder;
TypeBuilder typeBuilder;
MethodBuilder methodBuilder;
ILGenerator msil;
object o;
Type t;
public Type T
{
get
{
return this.t;
}
}
} } //动态调用的部分
using System;using System.Reflection;using ILGenServer;//引用动态生成代码的类 public class ILGenClientApp {
public static void Main（{
CodeGenerator gen = new CodeGenerator();//创建动态生成类
Type t = gen.T;
if(null!= t)
{
object o = Activator.CreateInstance(t);
MethodInfo helloWorld = t.GetMethod(“HelloWorld”);//为调用方法创建一个MethodInfo
if(null!= helloWorld)
{
helloWorld.Invoke(o, null);//调用方法
}
}
} } 调用DLL using System;using System.Runtime.InteropServices;//为了使用DLLImport特性
class PInvokeApp {
[DllImport(“user32.dll”, CharSet=CharSet.Ansi)] //CharSet.Ansi指定Ansi版本的函数(MessageBoxA),CharSet.Unicode指定Unicode版本的函数(MessageBoxW)
static extern int MessageBox(int hWnd, string msg, string caption, int type);//声明DLL中的函数
//[DllImport(“user32.dll”, EntryPoint=“MessageBoxA”)] //用这种方法使用不同的函数名
//static extern int MsgBox(int hWnd, string msg, string caption, int type);
//[DllImport(“user32.dll”, CharSet=CharSet.Unicode)] //调用Unicode版的DLL函数
//static extern int MessageBox(int hWnd, [MarshalAs(UnmanagedType.LPWStr)]string msg，// [MarshalAs(UnmanagedType.LPWStr)]string caption, int type);//将LPWStr翻译为string型，缺省情况系统只将LPStr翻译成string
public static void Main()
{
MessageBox(0, “Hello, World!”, “CaptionString”, 0);//调用DLL中的函数
} } 例2，使用回调： class CallbackApp {
[DllImport(“user32.dll”)]
static extern int GetWindowText(int hWnd, StringBuilder text, int count);
delegate bool CallbackDef(int hWnd, int lParam);
[DllImport(“user32.dll”)]
static extern int EnumWindows(CallbackDef callback, int lParam);
static bool PrintWindow(int hWnd, int lParam)
{
StringBuilder text = new StringBuilder(255);
GetWindowText(hWnd, text, 255);
Console.WriteLine(“Window Caption: {0}”, text);
return true;
}
static void Main()
{
CallbackDef callback = new CallbackDef(PrintWindow);
EnumWindows(callback, 0);
} } 关键字unsafe指定标记块在非控环境中运行。该关键字可以用于所有的方法，包括构造函数和属性，甚至还有方法中的代码块。关键字fixed负责受控对象的固定(pinning)。Pinning是一种动作，向垃圾收集(Garbage Collector, GC)指定一些不能被移动的对象。为了不在内存中产生碎片，.NET运行环境把对象四处移动，以便于最有效地利用内存。使用fixed后指定对象将不会被移动，所以就可以用指针来访问它。
C#中只能得到值类型、数组和字符串的指针。在数组的情况下，第一个元素必须是值类型，因为C#实际上是返回一个指向数组第一个元素的指针，而不是返回数组自身。& 取一个变量的内存地址（即指向该变量的指针）* 取指针所指变量的值-> 取成员
例：using System;class UnsafeApp {
public static unsafe void GetValues(int* x, int* y)
{
*x = 6;
*y = 42;
}
public static unsafe void Main()
{
int a = 1;
int b = 2;
GetValues(&a, &b);
} } fixed语法为：fixed(type* ptr = expression)statements其中type也可以为非控类型，也可是void；expression是任何产生一个type指针的表达式；statements是应用的代码块。例： fixed(int* f = &foo.x)//foo是Foo类的一个实例，x是Foo类的一个int属性 {
SetFooValue(f);//SetFooValue方法的定义为unsafe static void SetFooValue(int* x)} 传统的COM组件可以通过互操作层(COM Interop)与.NET运行环境交互。互操作层处理在托管运行环境和非托管区域中的COM组件操作之间传递所有的消息。
要使COM组件能在.NET环境中使用,必须为COM组件生成元数据。.NET运行环境用元数据层业判断类型信息。在运行时刻使用类型信息，以便生成RCW(Runtime Callable Wrapper,运行时可调用包装)。当.NET应用程序与COM对象交互时，RCW处理对COM对象的装载和调用。RCW还完成许多其他的工作，如管理对象标识、对象生存周期以及接口缓冲区。对象生存周期管理十分关键，因为.NET GC把对象到处移动，并且当对象不再使用时，自动处理这些对象。RCW服务告诉.NET，应用程序正与托管.NET组件交互，同时又使非托管COM组件“觉得”COM对象是被传统的COM客户端调用的。
为了为COM组件生成元数据包装，必须使用tlbimp.exe(TypeLib Importer)工具： tlbimp some_COM.tlb /out:som_COM.dll
第三篇：绘图总结
绘图总结
一、总结
(1)图形的对称行，绘画中心线，节省大量的时间和图纸干净整洁。(2)图层的线粗分明，查看图纸的时候，比较清晰，尤其对折弯线的辨别。(3)绘画三视图，体现高平齐宽相等。
(4)标注的时候，孔的定位、折弯的定位标注线，分开来标注。总尺寸单独拉开，便于下料查看尺寸。
(5)绘图比例，必须明确规定。
二、看图的顺序
(1)查看图号、名称、材料和厚度。(2)查看展开图的总体尺寸，长和宽。
(3)查看定位孔的尺寸，定位基准长和宽，孔的标注。(4)折弯尺寸。(5)线性角度的标注。(6)折弯图尺寸查看。(7)折弯角度的查看。
三、制图技术要求
（1）制图表面平整、无毛刺、无凹坑。
（2）制件应符合Q/LS-2008-29《钣金件检验规范》
（3）未注公差符合Q/LS027-028
四、图幅规范
A0（841×1189）A1（594×841）A2（420×594）A3（297×420）A4（210×297）
五、线性的分类和规则
细实线 ．应用过渡线、标注线、指引线、剖面线、折弯线。
波浪线 ．断裂处的边界线，视图与剖视图的分界线。双折线 ．断裂处的边界线，视图与剖视图的分界线。粗实线 ．可见轮廓线
粗实现 ． 表格图、流程图中的主要表示线
细虚线 ．不可见轮廓线
细点画线．对称中心线、分度圆、孔系分布的中心线、剖切线
细双点画线．成形前的轮廓线、线、轨迹线、制成品的轮廓线、特定区域线、工艺结构的轮廓线、中断线
六GB/T 4457.4-2002规定
粗细线宽度比率2 ：1 0.13mm、0.18mm、0.25mm、0.35mm、0.5mm、0.7mm、1mm、1.4mm、2mm
第四篇：C#实习总结
现在的社会日新月异，科技飞速发展，但是随之而来的环境问题也日益严重，当然这也有很多其他诸如人口、能源等因素，不过这些让人们越来越重视绿色产业，而软件就是首当其冲的一个。我积极参加了学校组织的软件实习，主要是对.Net方面的实训和实战，一方面想要继续深造之前在大学里面学习的软件方面的知识，另一方面，也是为了自己的职业规划，说直接点，就是以后找份好工作。虽然实训中时间安排有点紧，但很充实，学到了很多之前在大学课堂上没有学到的知识，可以说我从这次实训中的收获很大。
对于计算机编程，我可以说从高中就开始接触，大学从专科开始一直学习的都是软件开发的专业，学过C#、Java，学过开发，也学过测试。但是这次实训让我体会了和之前完全不同的学习感受，不仅是时间安排、或者说效率还是教学授课的方式上，都是和大学课堂完全不同的，不是一节课讲一点，也不是一点一点教给你，这个实训中更多的是培养我们独立动手解决实际问题的能力，分析考虑问题的方法思路，让我们真正成长起来。
学校为我们提供了良好的学习的平台，提供了好工作的面试机会。我们觉得我们更应该充分利用资源，珍惜机会，努力学习，不断地给自己“充电”，这样才能不断的开拓进取，勇于创新，才不至于被社会淘汰。
这次实习中，我们主要有S0、S1、S2三个阶段，S0阶段主要是自学C#基础知识，S1阶段是在老师的指导下学习C#基础编程、C#桌面应用开发、C#数据库应用开发、C#网络应用开发、软件测试和软件工程几个方面的技术方面的课程，S2阶段则是进入项目实战，做实际项目来进行巩固和总结。整个过程中，还有穿插了职业素养课和英语口语课，学技术的同时，我们也注重职业素养的培养和英语口语的锻炼。
到目前为止，我们实习的主要成果有（按时间顺序）：Point24(24点游戏求解小程序)、HandsUp（举手游戏模拟小程序）、SimpleCalculator（简单计算器）、GottaU（捕捉鼠标小游戏）、TypeGame（打字小游戏）、WebBrowser（简易网络浏览器）、Checker（单机对战跳棋小游戏）、MDITextEditor（多文档界面文本编辑器）、FileManager（文件管理器）、SimpleMediaPlayer（简单媒体播放器）等，这些小程序或是项目，虽然和市面的那些软件比起来，在功能强大、界面美观、Bug稀少等方面都有欠缺，但是都是实打实的，我们自己动脑、动手做出来的，当然在做的过程中遇到了不少困难、挫折，但是正因为这些困难和挫折，我们才真正学到了知识和技术。更值得注意的则是，在老师带领我们做项目的过程中，我们从老师的言传身教中学到了很多很多编程思想、解决问题的方法思路等各种“无形”的知识。
众多收获之中，让我感触颇深的，则是老师给我们介绍的“10-90”原则和“Quality-Client-Cost”原则。“10-90”原则的意思是，我们通常都是花10%的代价就可以完成一件事或者一个项目的90%，而剩下的10%，却需要我们花费90%的金钱、精力等各种代价，能不能做到这最后的10%，往往是衡量一个人或者一家公司很重要的一个原则。而且这个原则还是可以嵌套的，最后10%的部分中，也可以再分成90%和10%，同样是开始的90%需要10%的代价，最后的10%需要90%的代价。这个原则不仅适用于做软件、做项目、做公司，其实人生中做人也是如此，很多时候最后的10%是很重要的一把标尺。虽然不能说这个原则放之四海而皆准，但是确实是适用于很多地方、很多方面，让我获益良多。“Quality-Client-Cost”原则讲的则是做软件或是做软件公司的一个原则，就是质量一定要放在第一位，客户在第二位。我自己原本心目中对这三项的排序是Client-Quality-Cost”，但是老师的讲解点醒了我，最具有说服力的例子，就是像微软这样的大公司，都是Quality第一的，他们宁可花费多一些，价格贵一些，但是一定把产品尽善尽美。这个原则同样可以用在人生中，Quality就是人品、品德、素质，Client是朋友、客户、亲人，我们当然应该把个人的品格放在第一位。这些都属于这次实习中，我在技术以外的收获。
另外在实习还有职业素养课中，也学到了很多其他在今后的工作中，要注意的东西，首先要有团队合作精神，现金的大中型软件的编写，分工越来越细，这样在开发、测试的过程中，团队的合作、成员间的交流就变得尤为重要，是决定效率的重要因素；要学会独立解决问题，工作不比在学校学习，遇到的各种实际问题不会有老师专门帮助解决，自己独立分析、解决问题的能力就变得极其重要；要有创新精神，在工作和学习中，如果只是一味的模仿、学习，那就永远不会真正得学得得心应手、融会贯通，必须自己去实践，在实践中创新，这样才能把学来的，变成自己的；要有耐心，学会自我规划和管控，耐心自是不必多说，有耐心才能把事情仔细做好，而公司的管理制度和学校根本上的不同，使得自我规划和管控就成了能否按时圆满完成任务的很重要的条件。
通过这次实习，我在个人素质方面有较大的提高，不仅是在C#的技术方面，还包括面对、分析和处理问题的思路、能力，思维的创造性和全面性，交流和沟通能力，英语口语水平，同时也克服了一些自己的缺点，获得很大进步。
总的来说，这次实习对我有很大意义，不仅巩固和实践了之前在大学课堂上学到的各种知识，扩充了自己对软件技术方面的知识储备，同时也给了我很大的成就感，增强了我的自信。并不是说因为我做成的很难的程序，或者做出来的软件很强很完善，但都是自己认真完成的，过程中有遇到各种困难和挫折，但是经
过网上查资料、小组讨论、向老师请教等几种途径，最终都克服了，当最终自己完成时，总会有一些成就感。
此外，我还人知到在以后的工作和学习中，不仅要努力学习和锻炼专业技能知识，包括C#技术、算法技巧、MVC模式框架的开发、中间技术等等，而且也要注意让自己兴趣广泛起来，拓宽自己的知识面，多积累各种知识，这不仅对以后的软件开发工作有一定好处，对自身的个人修养的提升也是大有裨益。
社会的竞争是激烈的，我想我们应该好好把握住大学学习的时间，充实、完善自我，掌握更多的专业知识，加强实践和设计能力，同时也注意全面发展，这样更有利于将来的发展，在自己的专业领域有所作为。
第五篇：c#基础总结
【1】面向对象程序设计语言的三大特点是什么？答：【23】Main函数特点？答：1）Main方法是C#程序的限定，默认的为private【2】三种命名法则的特点？答：匈牙利命名法：在变限定符，返回类型为void或int类型，Main方法必须是静态方法；3)一个类或结构只能有一个有效的入驼表示法：一个标示符用若干个有意义的英语单词或口点函数；4）main方法必须定义在某一个类中。缩写组成，第一个单词首字母小写，后边的首字母大【24】多态（重写、隐藏）
写；Pascal表示法：与骆驼表示法类似，但是第一个 单词的首字母也需要大写。【3】C#注释的三种形式特点？答1）单行注释：// 2）class A /// {public virtual void F()【4】引用类型和值类型的数据类型？ {Console.WriteLine(“A.F”);}} abstract class B:A（1）int valOne = 0;{public abstract override void F();}int valTwo = valOne;答：abstract override 是不可以一起修饰 int valThree = 333;例：在下面的例子里 valTwo = 333;TestValueRefRef1 = new TestValueRef();class A TestValueRefRef2 = Ref1;{public A(){PrintFields();} Ref2.value = 444;public virtual void PrintFields(){} } Console.WriteLine(“values:{0},{1}”, Ref1.value, class B:A Ref2.value);{int x=1;int y;public B(){y=-1;} Console.WriteLine(“values:{0}, {1},{2}”,valOne, public override void valTwo,valThree);PrintFields(){Console.WriteLine(“x={0},y={1}”,答：输出结果：values:444,444 x,y);} 当使用new B()创建B的实例时，产生什么输出？（2）public class EnumTest答：x=1,y=0 { enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};分析：执行new B()时，由于B继承自A，所以会调用static void Main()A的构造函数，并执行其中的PrintFields()方法，由{int x=(int)Days.Sun;inty=(int)Days.Fri;于该方法为虚方法，在继承类中被重写，所以，将执Console.WriteLine(“Sun = {0}”, x);行B中的PrintFields()方法。此时，将在DOS界面Console.WriteLine(“Fri = {0}”, y);}} 上输出“x=1,y=0”，然后，在运行B的构造函数中的答：输出结果：Sun = 2Fri = 7 y=-1。（建议同学们将此程序放入到代码中，设置断点【5】枚举类型的字段和关联值？枚举类型有三个要看执行过程。）
【25】什么是多态对象？答：用基类类名声明，但是特性 修饰符 enum 枚举名 ： 基础类型 {枚举成员声明，枚举成员声明，„„，枚举成员声明}默认的基础函数来实例化的对象。这类对象的主要用途是引发多类型为int；关联值：如果没有被声明，默认为0。态，为了将它们和一般的对象（声明和创建都使用同【6】强制类型转换（例：若有double f=2.7;int 一个类型名的对象）加以区别、揭示它们的特点和用2）将源类型的对象途，这种形态的对象称为多态对象。转换成为目的类型的对象 【26】接口的特点。答：接口只能包含抽象方法，不【7】运算符&和&&的区别？答：条件“与”运算符(&&)没有访问修饰符，接口成员必须是方法属性事件或者时才计算第二个操作数。而&需要计算所有操作数，索引器不能包含常数字段运算符也不能有静态成员。并且优先级高于&& 【27】委托和事件，【8】装箱和拆箱的概念？答：装箱就是把一个值类型委托的定义修饰符 delegate 返回类型 委托类型名(参数列表)； 【9】for循环和if语句联合使用的程序分析，for(;;)eg: public delegate int DelegateClass(stringinfo);
和continue的区别？答：break跳出循委托的创建(实例化)委托对象 ＝ new 委托名（关联方法）； 【11】命名空间的特点答：它提供一种命名机制，是eg: DelegateClass obj=new DelegateClass(MethodA);
合方式无关，不能表明源文件的存取方式，命名空间DelegateClass obj=MethodA;//隐式创建和初是按层次组织的。始化(不用new)【12】数组元素的的复制和读值 例：分析下列语句： int[3]{5,6,2},new int[5]{6,9,7,8,3},new Hello(string target);} int[2]{3,2}};myArray3[2][2]的值是（D）A)9；B)2；该语句的作用是：在TestCS 命名空间中定义了了一C)6；D)越界 个名为Hello 的委托类型；
【13】类和对象的关系？答：类是对象的抽象，对象【28】Windows窗体中Button按钮触发的事件是什【14】关键字this和base的区别？答：base指代基【29】Windows窗体中控件的标识符如何修改？答：【15】关键字new、using的多种用法？答：new修饰【30】如何修改Windows窗体的启动窗体？答：修改被重写，但new修饰符可终止这一特性；向下传播； 实例化一个对象。Using：导入命名空间；自动释放【31】要使用SQL Server需要使用哪两个命名空间？ Using代码框里的资源。【16】索引器的特点？答：索引器允许重载；字符串Using System.Date.SqlClient： 【32】什么是DataSet、DataAdapter？两者联系？答：过签名标识；通过元素访问来访问；必须为实例成员；索引器的get访问器具有与索引器相同的形参表；除DataAdapter：数据适配器，数据库与DataSet间的桥value参数外，索引器的set访问器还具有与索引器梁，把数据库中数据下载到DataSet或回传回去。相同的形参表。【33】用户登录和密码修改（带数据库）【17】静态数据成员特点？答：为所有类所共享，区用户登录 【18】构造函数的特点？答：（1）构造函数名与类名UserName='“ + txtUsername.Text.Trim().ToLower()+ ”' and UserPwd='“ + txtPassword.Text.Trim()+ 【19】析构函数的特点？答：（1）析构函数名是在类”'“;if(OperateDB.ExecuteReader(sql))型(默认为空)和修饰符；（3）析构函数不能被重载。{username = txtUsername.Text.Trim().ToLower();【20】什么是方法的重载？重载的特点是什么？答： frmMain frm = new frmMain();frm.Show();this.Hide();} 定义一组方法。重载的特点：1）位于同一类中；2）else
方法名相同；3）方法参考列表不同，包括参数个数不{MessageBox.Show(”用户名或密码错误“, ”出错了“, 同和参数类型不同；4）与方法返回值和修饰符没关系。MessageBoxButtons.OK, MessageBoxIcon.Error);} 【21】虚函数的特点？答：1)虚方法前不允许有修改密码： 修饰符；2)虚方法不能是私有的，因此不能使用private修饰符； where UserName='” + frmLogin.username + “' and 【22】抽象类和抽象方法的主要特点？答：抽象类：UserPwd='” + txtOldPwd.Text.Trim()+ “'”;（或者if(OperateDB.ExecuteReader(sqlCheckPwd))说，不能产生对象。但是，它可以有构造函数。（2）{string sql = “update UserInfo set UserPwd='” 设计abstract类的目的是为了被继承。抽象方法：是+ txtNewPwd.Text.Trim()+ “' where UserName='” + 不完整的，不能执行的。frmLogin.username + “'”;
if(OperateDB.ExecuteNonQuery(sql)== 1)
{MessageBox.Show(“密码修改成功！”);}else
{ MessageBox.Show(“密码修改失败！”);}}
else{MessageBox.Show(“旧密码不正确！”);}
【34】抽象类定义和继承使用
特点：1.没有被完整定义，因而它不能用来实例化，或者说，不能产生对象。(但是，它可以有构造函数。)2.设计abstract类的目的是为了被继承。public abstract class Employee{public virtual void Pay(){ }
public abstract void CalculatePay();} public class HourlyEmployee: Employee
{public override void Pay(){CalculatePay();}public override void CalculatePay(){ }} 【35】接口及继承类的使用
特定功能的抽象成员的集合。一个类可以继承多个接口，从而获得多个行为的描述，将它们组合成新的功能并在类中实现。继承类中必须实现接口中的所有抽象成员。
定义接口的格式：修饰符 interface 接口名：基接口列表 {接口体} 其中，接口体的声明可以包括：接口方法声明；接口属性声明；接口事件声明；接口索引器声明
public delegate void
StringListEvent(IStringList sender);public interface IStringList{ void Add(string s);//方法int Count{get;}//属性event StringListEvent Changed;//事件string this[int index]{get;set;}//索引器} 【编程题例题】
定义一MobilePhone类，包括属性成员——网络类型(NetworkType)，字段成员——屏幕尺寸(screenSize)、手机品牌(brand)，手机型号
(brandModel)，公共方法成员——Open、Close。其中screenSize为单位是英寸的双精度数，brand为字符串，NetworkType只能是“GSM”或“CDMA”字符串。要求：（1）在此类中包含构造函数，构造函数用于对数据（屏幕尺寸、手机品牌和手机型号）进行初始化。（2）公共成员方法中输出相应提示信息（参见（3）中的输出结果格式）。（3）写一测试类，在类中实例化一MobilePhone对象，最后能在DOS界面下显示如下结果：诺基亚N81（屏幕尺寸2.0英寸），是一款GSM手机。手机关机了。using System;
public enum NetworkType {GSM,CDMA,}
public class MobilePhone {public double screenSize;public string brand;
public string brandModel;
public NetworkType networkType;public NetworkType NetworkType{get { return networkType;}}
public MobilePhone(double ss, string bra, string bm, NetworkType nt){screenSize = ss;brand = bra;brandModel = bm;networkType = nt;}public void Open()
{Console.WriteLine(“{0}{1}(屏幕尺寸{2}英寸),是一款{3}手机.”,brand,brandModel,screenSize.ToString(“.0”), networkType);}
public void Close()
{Console.WriteLine(“手机关机了。”);} }
public class Test
{public static void Main()
{MobilePhone mp = new MobilePhone(2.0, “诺基亚”, “N81”, NetworkType.GSM);mp.Open();mp.Close();
System.Console.ReadLine();} }
【例】写一名为Desk的类，包含两个字段Length（双精度类型）、Height（双精度类型）。再写一继承类ComputerDesk类。ComputerDesk类除了有Length和Height外，还有KeyboardTray（字符串类型）。Public class desk {double length;double height;}
Public class computerdesk:desk {string keyboardtray}
点击咨询 