初探c#--8,9,10

韩冰

1。8 类（Classes）
: v1 T' V9 h; l类用于定义一个新的引用类型。c#不支持多重继承，但支持一个类多重界面（“interfaces”）。
# o: j0 L& j4 w9 b* a, w类的成员包括常量、位域、方法、属性、索引（indexers）、事件、操作符、构造器、析构器和嵌套
类型声明。（一口气说这么多，呼——）
对类中得所有成员有五种访问权限：
+ O) M5 x; Z* X2 U·  “public” 可以被所有代码访问；
' z1 z9 G, \" Y. H·  “protected” 只可以被继承类访问；
8 r; [' h5 o- C4 Y·  “internal” 只可以被同一个项目的代码访问;
·  “protected internal”只可以被同一个项目的代码或继承类访问；
) \* M* F" E$ Z- I  |! |·  “private” 只可以被本类中的代码访问。
缺省状态是“private”。
1 W, x$ E: ^" G2 ^6 R% l: \# T
6 \: c9 v' ~( P" s, P4 _1。9 结构（Structs）
结构和类又非常多的相似之处，如结构可以实现界面，和可以拥有和类一样的成员。结构与类也有一些重要的区
别：结构是值类型，而不是引用类型，所以不支持继承！结构被存在堆栈中或者是内联。结构在精心下可以提高
4 C5 O. o+ i, v' S存储效能。例如，定义一个与类有着相同信息的结构可以大大地减少存储空间。在下例中，程序创建并初始化100
个points。在类“Point”中需要分配101个独立的对象（object）。*/
9 b  Q0 q' \: g" j/ S( F
class Point
{
0 o0 }* B  G/ O. f3 t. N- J. Y; rpublic int x, y;
public Point() {
x = 0;
y = 0;
}
, j# |/ h0 X. @( ~7 v6 ppublic Point(int x, int y) {
this.x = x;
this.y = y;
( W! }) K0 V3 ]9 A. C) ]4 k}
' C" g& r$ G3 f( `4 ^. Y}
class Test
8 s9 t9 e* `7 Z7 v) j{
static void Main() {
Point[] points = new Point[100];
for (int i = 0; i < 100; i++)
  n4 N6 \' U  e' U9 }& Dpoints = new Point(i, i*i);
}
8 V& s( d3 n% x1 E2 _}
/*
如果“Point”被作为一个结构，就可以这样啦：*/
struct Point
{
public int x, y;
public Point(int x, int y) {
) [! j( m( s5 Kthis.x = x;
8 a* [( i, X# }: K. D+ L1 m/ X. Bthis.y = y;
. Z" Y  j/ r! R: F* O0 Y( Q, A5 Q}
}
& |  }) K5 S8 j6 H+ V, o9 y/*
因为Point在内联中实例化，所以得到了优化。当然，错误运用的只会适得其反。比如，当我们传递结构的
时候就会比传递类要慢。因为结构的传递是拷贝值，类是引用值的地址。数据量越大差距就越明显。
( Z" Z5 u8 n' @$ d- _所以“There is no substitute for careful data structure and algorithm design.”（实在是不想译
- F& B9 O% R$ M' t; G  o+ X9 F了 ^_^ ）。

5 I' _. A, y# _  K1。10 界面（Interfaces）
# V9 k0 E' z# J  S& y' k/ q3 ]界面用来定义一种程序的契约。有了这个契约，就可以跑开编程语言的限制了（理论上）。而实现界面的
类或者结构要与界面的定义严格一致。界面可以包含以下成员：方法、属性、索引和事件。例子：*/

: L5 k7 g2 M6 L+ d; L* `interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
) Q0 v) {$ v, I' \) ~  \' T}
+ T* a1 H; ^0 Y2 upublic delegate void EventHandler(object sender, Event e);
' f7 c  [/ @' E7 u9 P# w2 y/*
/ N6 ]% o4 I: ]6 j例子中的界面包含一个索引、一个事件E、一个方法F和一个属性P。
界面可以支持多重继承。就像在下例中，界面“IComboBox”同时从“ITextBox”和“IListBox”继承。
4 J# q% t1 J7 L7 u# ~*/
interface IControl
0 @% ]7 U3 L9 |{
void Paint();
% ^. Z! b" B$ |% x# a}
# l# I2 i" [  b2 uinterface ITextBox: IControl
{
! l" c7 |% H* P  n, D1 N  @. _void SetText(string text);
' ?& G6 Z1 K1 j) J; R: v1 o# r7 m* d$ M7 ~}
/ m+ m$ r  j8 u- |8 \# Pinterface IListBox: IControl
- d! m5 C. f2 L{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}
/*
类和结构可以多重实例化界面。 就像在下例中，类“EditBox”继承了类“Control”，同时从“IDataBound”
和“IControl”继承。
: g5 a+ D- k/ y( a' V; L*/
interface IDataBound
3 O; O# ^; y; e* Q/ u+ b+ e6 s% x{
void Bind(Binder b);
}
% Y+ `( U- y% c7 Npublic class EditBox: Control, IControl, IDataBound
# N1 e& f% i2 r{
public void Paint();
9 w5 I% _( {- M1 k* z) \& {public void Bind(Binder b) {...}
% g9 N  }1 F! O# e4 X6 V; I$ y& y}
/*
- F$ E7 `+ ^' M* v在上面的代码中，“Paint”方法从“IControl”界面而来；“Bind”方法从“IDataBound”界面而来，都
6 o( `( y" |  b6 }以“public”的身份在“EditBox”类中实现。