1
《
.
N
E
T
/
C
#
⾯
试
⼿
册
》
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
基
础
语
法
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
⾯
向
对
象
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
集
合
、
异
常
、
泛
型
、
L
I
N
Q
、
委
托
、
E
F
!
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
多
线
程
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
A
S
P
.
N
E
T
M
V
C
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
A
S
P
.
N
E
T
C
o
r
e
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
A
D
O
.
N
E
T
、
X
M
L
、
H
T
T
P
、
A
J
A
X
、
W
e
b
S
e
r
v
i
c
e
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
常
⻅
的
算
法
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
数
据
库
概
念
知
识
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
数
据
库
S
Q
L
查
询
(
附
建
表
语
句
)
2
.
N
E
T
/
C
#
⾯
试
题
汇
总
系
列
:
基
础
语
法
s
t
r
i
n
g
.
E
m
p
t
y
相
当
于
“
”
,
E
m
p
t
y
是
⼀
个
静
态
只
读
的
字
段
。
s
t
r
i
n
g
s
t
r
=
"
"
,
初
始
化
对
象
,
并
分
配
⼀
个
空
字
符
串
的
内
存
空
间
s
t
r
i
n
g
s
t
r
=
n
u
l
l
,
初
始
化
对
象
,
不
会
分
配
内
存
空
间
本
题
考
查
的
是
数
据
类
型
能
承
载
数
据
的
⼤
⼩
。
1
b
y
t
e
=
8
b
i
t
,
1
个
汉
字
=
2
个
b
y
t
e
,
1
个
英
⽂
=
1
个
b
y
t
e
=
8
b
i
t
所
以
b
c
是
对
的
,
d
e
g
是
错
的
。
'
a
'
是
c
h
a
r
类
型
,
a
错
误
j
a
v
a
b
y
t
e
取
值
范
围
是
-
1
2
8
~
1
2
7
,
⽽
C
#
⾥
⼀
个
b
y
t
e
是
0
~
2
5
5
都
是
引
⽤
类
型
,
分
配
再
堆
上
S
t
r
i
n
g
B
u
i
l
d
e
r
默
认
容
量
是
1
6
,
可
以
允
许
扩
充
它
所
封
装
的
字
符
串
中
字
符
的
数
量
.
每
个
S
t
r
i
n
g
B
u
f
f
e
r
对
象
都
有
⼀
定
的
缓
冲
区
容
量
,
当
字
符
串
⼤
⼩
没
有
超
过
容
量
时
,
不
会
分
配
新
的
容
量
,
当
字
符
串
⼤
⼩
超
过
容
量
时
,
会
⾃
动
增
加
容
量
。
对
于
简
单
的
字
符
串
连
接
操
作
,
在
性
能
上
s
t
r
i
n
g
b
u
i
l
d
e
r
不
⼀
定
总
是
优
于
s
t
r
i
n
因
为
s
t
r
i
n
g
b
u
l
i
d
e
r
对
象
的
创
建
也
消
耗
⼤
量
的
性
能
,
在
字
符
串
连
接
⽐
较
少
的
情
况
下
,
过
度
滥
⽤
s
t
r
i
n
g
b
u
i
l
d
e
r
会
导
致
性
能
的
浪
费
⽽
⾮
节
约
,
只
有
⼤
量
⽆
法
预
知
次
数
的
字
符
串
操
作
才
考
虑
s
t
r
i
n
g
b
u
i
l
d
e
r
的
使
⽤
。
从
最
后
分
析
可
以
看
出
如
果
是
相
对
较
少
的
字
符
串
拼
接
根
本
看
不
出
太
⼤
差
别
。
S
t
r
i
n
g
b
u
l
i
d
e
r
的
使
⽤
,
最
好
制
定
合
适
的
容
量
值
,
否
则
优
于
默
认
值
容
量
不
⾜
⽽
频
繁
的
进
⾏
内
存
分
配
操
作
,
是
不
妥
的
实
现
⽅
法
。
参
考
链
接
:
h
t
t
p
s
:
/
/
w
w
w
.
c
n
b
l
o
g
s
.
c
o
m
/
h
a
o
f
u
q
i
/
p
/
4
8
2
6
2
6
2
.
h
t
m
l
⼀
句
话
解
释
,
扩
展
⽅
法
使
你
能
够
向
现
有
类
型
“
添
加
”
⽅
法
,
⽆
需
修
改
类
型
1
.
字
符
串
中
s
t
r
i
n
g
s
t
r
=
n
u
l
l
和
s
t
r
i
n
g
s
t
r
=
"
"
和
s
t
r
i
n
g
s
t
r
=
s
t
r
i
n
g
.
E
m
p
t
y
的
区
别
?
2
.
b
y
t
e
b
=
'
a
'
;
b
y
t
e
c
=
1
;
b
y
t
e
d
=
'
a
b
'
;
b
y
t
e
e
=
'
啊
'
;
b
y
t
e
g
=
2
5
6
;
这
些
变
量
有
些
错
误
是
错
再
哪
⾥
?
3
.
s
t
r
i
n
g
和
S
t
r
i
n
g
B
u
i
l
d
e
r
的
区
别
,
两
者
性
能
的
⽐
较
4
.
什
么
是
扩
展
⽅
法
?
1 int i=0;
2 Syste.Object obj=i;
1 int i=0;
2 System.Object obj=i;
3 int j=(int)obj;
obj
3
条
件
:
按
扩
展
⽅
法
必
须
满
⾜
的
条
件
,
1
.
必
须
要
静
态
类
中
的
静
态
⽅
法
2
.
第
⼀
个
参
数
的
类
型
是
要
扩
展
的
类
型
,
并
且
需
要
添
加
t
h
i
s
关
键
字
以
标
识
其
为
扩
展
⽅
法
建
议
:
通
常
,
只
在
不
得
已
的
情
况
下
才
实
现
扩
展
⽅
法
,
并
谨
慎
的
实
现
使
⽤
:
不
能
通
过
类
名
调
⽤
,
直
接
使
⽤
类
型
来
调
⽤
b
y
t
e
的
取
值
范
围
是
-
2
的
8
次
⽅
⾄
2
的
8
次
⽅
-
1
,
-
2
5
6
⾄
2
5
8
,
a
+
=
1
时
,
a
的
值
时
0
,
a
+
=
5
时
,
a
的
值
是
0
,
所
以
a
+
=
5
时
,
值
是
4
装
箱
就
是
隐
式
地
将
⼀
个
值
类
型
转
换
成
引
⽤
类
型
,
如
:
拆
箱
就
是
将
引
⽤
类
型
转
换
成
值
类
型
,
如
:
值
类
型
变
量
是
直
接
包
含
值
。
将
⼀
个
值
类
型
变
量
赋
给
另
⼀
个
值
类
型
变
量
,
是
复
制
包
含
的
值
,
默
认
值
是
0
。
引
⽤
类
型
变
量
的
赋
值
只
复
制
对
对
象
的
引
⽤
,
⽽
不
复
制
对
象
本
身
,
默
认
值
是
n
u
l
l
值
类
型
有
整
形
、
浮
点
型
、
b
o
o
l
、
枚
举
。
引
⽤
类
型
有
c
l
a
s
s
、
d
e
l
e
g
a
t
e
、
O
b
j
e
c
t
、
s
t
r
i
n
g
5
.
b
y
t
e
a
=
2
5
5
;
a
+
=
5
;
a
的
值
是
多
少
?
6
.
什
么
是
装
箱
和
拆
箱
?
(
将
拆
箱
)
7
.
值
类
型
和
引
⽤
类
型
的
区
别
1 public class ItemFactory where T : IComparable, new()
2 {
3 }
4
值
类
型
存
储
在
栈
中
,
引
⽤
类
型
存
储
在
堆
中
运
算
符
:
创
建
对
象
实
例
修
饰
符
:
在
派
⽣
类
定
义
⼀
个
重
名
的
⽅
法
,
隐
藏
掉
基
类
⽅
法
约
束
:
泛
型
约
束
定
义
,
约
束
可
使
⽤
的
泛
型
类
型
,
如
:
i
n
t
?
为
可
空
类
型
,
默
认
值
可
以
是
n
u
l
l
i
n
t
默
认
值
是
0
i
n
t
?
是
通
过
i
n
t
装
箱
为
引
⽤
类
型
实
现
⼀
句
话
解
释
就
是
:
将
⽅
法
当
作
参
数
传
⼊
另
⼀
个
⽅
法
的
参
数
。
.
n
e
t
中
有
很
多
常
⻅
的
委
托
如
:
F
u
n
c
、
A
c
t
i
o
n
作
⽤
:
提
⾼
⽅
法
的
扩
展
性
位
运
算
是
最
快
,
使
⽤
的
是
位
运
算
逻
辑
左
位
移
<
<
。
⽅
法
是
2
<
<
3
相
当
于
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
(
2
的
1
6
位
i
n
t
⼆
进
制
)
左
移
三
位
就
是
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
(
1
6
的
⼆
进
制
)
都
可
以
标
识
⼀
个
常
量
。
主
要
有
以
下
区
别
:
8
.
n
e
w
关
键
字
的
作
⽤
?
9
.
i
n
t
?
和
i
n
t
有
什
么
区
别
?
1
0
.
C
#
中
的
委
托
是
什
么
?
1
1
.
⽤
最
有
效
的
⽅
法
算
出
2
乘
以
8
等
于
⼏
?
1
2
.
c
o
n
s
t
和
r
e
a
d
o
n
l
y
有
什
么
区
别
?
1 private static byte get(int n)
2 {
3 byte number = 1;
4 while (n/2!=1)
5 {
6 n = n / 2;
7 number += 1;
8 }
9 return number;
10 }
5
1
、
初
始
化
位
置
不
同
。
c
o
n
s
t
必
须
在
声
明
的
同
时
赋
值
;
r
e
a
d
o
n
l
y
即
可
以
在
声
明
处
赋
值
,
也
可
以
在
静
态
构
造
⽅
法
(
必
须
是
静
态
构
造
⽅
法
,
普
通
构
造
⽅
法
不
⾏
)
⾥
赋
值
。
2
、
修
饰
对
象
不
同
。
c
o
n
s
t
即
可
以
修
饰
类
的
字
段
,
也
可
以
修
饰
局
部
变
量
;
r
e
a
d
o
n
l
y
只
能
修
饰
类
的
字
段
3
、
c
o
n
s
t
是
编
译
时
常
量
,
在
编
译
时
确
定
该
值
;
r
e
a
d
o
n
l
y
是
运
⾏
时
常
量
,
在
运
⾏
时
确
定
该
值
。
4
、
c
o
n
s
t
默
认
是
静
态
的
;
⽽
r
e
a
d
o
n
l
y
如
果
设
置
成
静
态
需
要
显
示
声
明
5
、
修
饰
引
⽤
类
型
时
不
同
,
c
o
n
s
t
只
能
修
饰
s
t
r
i
n
g
或
值
为
n
u
l
l
的
其
他
引
⽤
类
型
;
r
e
a
d
o
n
l
y
可
以
是
任
何
类
型
。
4
(
1
0
0
)
、
5
(
1
0
1
)
、
8
(
1
0
0
0
)
、
1
6
(
1
0
0
0
0
)
取
模
运
算
:
⽤
n
u
m
b
e
r
%
2
=
=
0
可
以
判
断
,
但
是
这
个
有
点
低
级
位
运
算
:
(
使
⽤
位
运
算
逻
辑
并
,
两
个
位
上
的
都
为
1
才
是
1
,
其
余
都
是
0
,
判
断
是
否
等
于
0
)
4
&
3
相
当
于
1
0
0
&
0
1
1
,
结
果
是
0
0
0
等
于
0
,
所
以
4
是
2
的
n
次
⽅
5
&
4
相
当
于
1
0
1
&
1
0
0
,
结
果
是
1
0
0
不
等
于
0
,
所
以
5
不
是
2
的
n
次
⽅
如
果
要
问
如
果
是
2
的
N
次
⽅
,
这
个
N
是
多
少
?
这
该
怎
么
算
?
1
3
.
现
有
⼀
个
整
数
n
u
m
b
e
r
,
请
写
⼀
个
⽅
法
判
断
这
个
整
数
是
否
是
2
的
N
次
⽅
1 string strTmp = "a1
2 int a = System.Text.Encoding.Default.GetBytes(strTmp).Length;
3 int b = strTmp.Length;
";
6
C
T
S
:
通
⽤
语
⾔
系
统
。
C
L
S
:
通
⽤
语
⾔
规
范
。
C
L
R
:
公
共
语
⾔
运
⾏
库
。
C
T
S
:
C
o
m
m
o
n
T
y
p
e
S
y
s
t
e
m
通
⽤
类
型
系
统
。
I
n
t
3
2
、
I
n
t
1
6
→
i
n
t
、
S
t
r
i
n
g
→
s
t
r
i
n
g
、
B
o
o
l
e
a
n
→
b
o
o
l
。
每
种
语
⾔
都
定
义
了
⾃
⼰
的
类
型
,
.
N
e
t
通
过
C
T
S
提
供
了
公
共
的
类
型
,
然
后
翻
译
⽣
成
对
应
的
.
N
e
t
类
型
。
C
L
S
:
C
o
m
m
o
n
L
a
n
g
u
a
g
e
S
p
e
c
i
f
i
c
a
t
i
o
n
通
⽤
语
⾔
规
范
。
不
同
语
⾔
语
法
的
不
同
。
每
种
语
⾔
都
有
⾃
⼰
的
语
法
,
.
N
e
t
通
过
C
L
S
提
供
了
公
共
的
语
法
,
然
后
不
同
语
⾔
翻
译
⽣
成
对
应
的
.
N
e
t
语
法
。
C
L
R
:
C
o
m
m
o
n
L
a
n
g
u
a
g
e
R
u
n
t
i
m
e
公
共
语
⾔
运
⾏
时
,
就
是
G
C
、
J
I
T
等
这
些
。
有
不
同
的
C
L
R
,
⽐
如
服
务
器
C
L
R
、
L
i
n
u
x
C
L
R
(
M
o
n
o
)
、
S
i
l
v
e
r
l
i
g
h
t
C
L
R
(
C
o
r
e
C
L
R
)
。
相
当
于
⼀
个
发
动
机
,
负
责
执
⾏
I
L
。
程
序
集
。
(
中
间
语
⾔
,
源
数
据
,
资
源
,
装
配
清
单
)
分
析
:
⼀
个
字
⺟
、
数
字
占
⼀
个
b
y
t
e
,
⼀
个
中
⽂
占
占
两
个
b
y
t
e
,
所
以
a
=
8
,
b
=
5
两
个
对
象
,
⼀
个
是
“
x
y
z
”
,
⼀
个
是
指
向
“
x
y
z
”
的
引
⽤
对
象
s
。
1
.
静
态
成
员
⽤
s
t
a
t
i
s
修
饰
符
声
明
,
在
类
被
实
例
化
时
创
建
,
通
过
类
进
⾏
访
问
2
.
不
带
s
t
a
t
i
s
的
变
量
时
⾮
静
态
变
量
,
在
对
象
被
实
例
化
时
创
建
,
通
过
对
象
进
⾏
访
问
,
1
4
.
C
T
S
、
C
L
S
、
C
L
R
分
别
作
何
解
释
1
5
.
在
.
n
e
t
中
,
配
件
的
意
思
是
?
1
6
.
分
析
下
⾯
代
码
,
a
、
b
的
值
是
多
少
?
某
某
某
1
7
.
S
t
r
i
n
g
s
=
n
e
w
S
t
r
i
n
g
(
“
x
y
z
”
)
;
创
建
了
⼏
个
S
t
r
i
n
g
O
b
j
e
c
t
?
1
8
.
静
态
成
员
和
⾮
静
态
成
员
的
区
别
7
3
.
静
态
⽅
法
⾥
不
能
使
⽤
⾮
静
态
成
员
,
⾮
静
态
⽅
法
可
以
使
⽤
静
态
成
员
4
.
静
态
成
员
属
于
类
,
⽽
不
属
于
对
象
C
#
在
u
n
s
a
f
e
模
式
下
可
以
使
⽤
指
针
对
内
存
进
⾏
操
作
,
但
在
托
管
模
式
下
不
可
以
使
⽤
指
针
,
C
#
N
E
T
默
认
不
运
⾏
带
指
针
的
,
需
要
设
置
下
,
选
择
项
⽬
右
键
-
>
属
性
-
>
选
择
⽣
成
-
>
“
允
许
不
安
全
代
码
”
打
勾
-
>
保
存
s
1
+
1
不
能
显
式
转
换
成
s
h
o
r
t
类
型
,
可
以
修
改
为
s
1
=
(
s
h
o
r
t
)
(
s
1
+
1
)
。
s
h
o
r
t
s
1
=
1
;
s
1
+
=
1
正
确
强
类
型
是
在
编
译
的
时
候
就
确
定
类
型
的
数
据
,
在
执
⾏
时
类
型
不
能
更
改
,
⽽
弱
类
型
在
执
⾏
的
时
候
才
会
确
定
类
型
。
没
有
好
不
好
,
⼆
者
各
有
好
处
,
强
类
型
安
全
,
因
为
它
事
先
已
经
确
定
好
了
,
⽽
且
效
率
⾼
。
⼀
般
⽤
于
编
译
型
编
程
语
⾔
,
如
c
+
+
,
j
a
v
a
,
c
#
,
p
a
s
c
a
l
等
,
弱
类
型
相
⽐
⽽
⾔
不
安
全
,
在
运
⾏
的
时
候
容
易
出
现
错
误
,
但
它
灵
活
,
多
⽤
于
解
释
型
编
程
语
⾔
,
如
j
a
v
a
s
c
r
i
p
t
,
v
b
,
p
h
p
等
1
.
引
⽤
命
名
空
间
,
也
可
u
s
i
n
g
别
名
2
.
释
放
资
源
,
实
现
了
I
D
i
s
p
o
s
i
a
b
l
e
的
类
在
u
s
i
n
g
中
创
建
,
u
s
i
n
g
结
束
后
会
⾃
定
调
⽤
该
对
象
的
D
i
s
p
o
s
e
⽅
法
,
释
放
资
源
。
1
.
都
是
按
引
⽤
类
型
进
⾏
传
递
2
.
属
性
不
是
变
量
不
能
作
为
o
u
t
、
r
e
f
参
数
传
递
3
.
r
e
f
参
数
必
须
初
始
化
。
o
u
t
不
需
要
初
始
化
4
.
作
⽤
,
当
⽅
法
有
多
个
返
回
值
时
,
o
u
t
⾮
常
有
⽤
1
9
.
c
#
可
否
对
内
存
直
接
操
作
2
0
.
s
h
o
r
t
s
1
=
1
;
s
1
=
s
1
+
1
;
有
什
么
错
?
s
h
o
r
t
s
1
=
1
;
s
1
+
=
1
;
有
什
么
错
?
2
1
.
什
么
是
强
类
型
,
什
么
是
弱
类
型
?
哪
种
更
好
些
?
为
什
么
?
2
2
.
u
s
i
n
g
关
键
字
的
作
⽤
2
3
.
r
e
f
和
o
u
t
有
什
么
区
别
1 class Class1
2 {
3 internal static int count = 0;
4 static Class1()
5 {
6 count++;
7 }
8 public Class1()
9 {
10 count++;
11 }
12 }
13 Class1 o1 = new Class1();
14 Class1 o2 = new Class1();
8
不
⼀
样
,
a
=
=
b
仅
仅
表
示
a
和
b
值
相
等
,
a
.
E
q
u
a
l
s
(
b
)
表
示
a
与
b
⼀
致
o
1
.
c
o
u
n
t
的
值
是
多
少
?
答
案
:
3
,
静
态
构
造
⽅
法
计
算
⼀
次
,
两
个
实
例
化
对
象
计
算
两
次
。
a
)
构
造
函
数
可
以
声
明
返
回
类
型
。
b
)
构
造
函
数
不
可
以
⽤
p
r
i
v
a
t
e
修
饰
c
)
构
造
函
数
必
须
与
类
名
相
同
d
)
构
造
函
数
不
能
带
参
数
2
4
.
a
.
E
q
u
a
l
s
(
b
)
和
a
=
=
b
⼀
样
吗
?
2
5
.
下
⾯
这
段
代
码
求
值
2
6
.
关
于
构
造
函
数
说
法
正
确
的
是
哪
个
?