选择
１、C#语言源代码文件的后缀名为： D
A、.C# B、.CC C、.CSP D、.CS
2、C#中导入某一个命名空间的关键字是：A
A、using B、use C、import D、include
3、方法中的值参数是_________的参数。 A
A、按值传递 B、按引用传递
C、按地址传递 D、不传递任何值
4、以下标识符中，错误的是： C
A、_b39 B、x345 C、6_321 D、nAverage
5、 结构化程序设计的3种结构是： D
A、顺序结构、if结构、for结构
B、if结构、if…else结构、else if结构
C、while结构、do…while结构、foreach结构
D、顺序结构、分支结构、循环结构
6、while语句循环结构和do…while语句循环区别的区别在于：D
A、while语句的执行效率较高
B、do…while语句编写程序较复杂
C、无论条件是否成立，while语句都要执行一次循环体
D、do…while循环是先执行循环体，后判断条件表达式是否成立，而while语句是先判断条件表达式，再决定是否执行循环体
7、下面有关break、continue和goto语句描述正确的是： D
A、break语句和continue语句都是用于中止当前整个循环的
B、使用break语句可以一次跳出多重循环
C、使用goto语句可以方便地跳出多重循环，因而编程时应尽可能多地使用goto语句
D、goto语句必须和标识符配合使用，break和continue语句则不然
１、Microsoft通过___A_______向编程人员提供了功能强大的数据访问能力。
A、ADO.NET B、Windows.Form C、XML D、ASP.NET
2、C#语言的核心是面向对象编程（OOP），所有OOP语言都应至少具有三个特性：A
A、封装、继承和多态 B、类、对象和方法
C、封装、继承和派生 D、封装、继承和接口
3、以下标识符中，正确的是：A
A、_total B 3abc C while D class
4、以下类型中，不属于值类型的是：D
A、整数类型 B、布尔类型 C、字符类型 D、类类型
5、已知a、b、c的值分别是4、5、6，执行下面的程序段后，判断变量n的值为：C
int a,b,c,n;
if (c < b)
n = a + b + c;
else if (a + b < c)
n = c - a - b;
else
n = a + b;
A、3 B、-3 C、9 D、15
6、while语句循环语句结构和do…while语句循环结构的区别在于：C
A、while语句的执行效率比较高
B、do…while语句编写程序较为复杂
C、do…while循环是先执行循环体，后判定条件表达式是否成立，而while语句是先判定条件表达式，再决定是否执行循环体
D、无论条件是否成立，while语句都要执行一次循环体
7、下面是几条动态初始化二维数组的语句，指出其中正确的：D
A、int arr5[][]=new int[4,5];
B、int[][] arr6 = new int[4, 5];
C、int arr7[,]=new int[4,5];
D、int[,] arr8=new int[4,5];
第 2 页
共 6 页
8、下面有关析构函数的说法中，不正确的是：D
A. 析构函数中不可以包含return语句
B. 一个类中只能有一个析构函数
C. 析构函数在对象被撤销时，被自动调用
D. 用户可以定义有参析构函数
9、以下关于类和对象的说法中，不正确的是：D
A、类包含了数据和对数据的操作
B、一个对象一定属于某个类
C、密封类不能被继承
D、可由抽象类生成对象
10、在C#中，高质量编码标准不包括下面哪一项：B
A、好的编码结构 B、不需要注释
C、好的命名规范 D、避免文件过大
11、让控件不可用的属性是以下哪一个? B
A、Cursor B、Enabled
C、Dock D、Visible
12、窗口打开时触发的事件是以下哪一个? C
A、Click B、MenuStart
C、Load D、MouseMove
13、以下哪一个命名空间是在进行Sql Server数据库访问时必须加载的? B
A、System.Data.Odbc B、System.Data.SqlClient
C、System.Data.OleDb D、System.Data.SqlTypes
14、下列说法哪个正确？ B
A、不需要定义类，就能创建对象
B、属性可以定义为抽象的
C、对象中必须有属性和方法
D、常量不能作为类成员
15、下列说法哪个正确？ B
A、允许一个子类有多个父类
B、某个类是一个类的子类，它仍有可能成为另一个类的父类
C、一个父类只能有一个子类
D、继承关系最多不能超过4层
3、以下标识符中，正确的是： A
A、_nName B typeof C 6b Dx5
9、下面有关枚举成员赋值说法正确的是：B
A、在定义枚举类型时，至少要为其中的一个枚举成员赋一个常量值
B、在定义枚举类型时，直接为某个枚举成员赋值，则其他枚举成员依次取值
C、在把一个枚举成员的值赋给另一个枚举成员时，可以不考虑它们在代码中出现的顺序
D、在定义的一个枚举类型中，任何两个枚举成员都不能具有相同的常量值
10、下面有关静态方法的描述中，错误的是：ABD
A、静态方法属于类，不属于实例
B、静态方法可以直接用类名调用
C、静态方法中，可以访问非静态的局部变量
D、静态方法中，可以访问静态的变量
11、在类的外部可以被访问的成员是： A
A、public成员 B、private成员 C、protected成员 D、protected internal成员
12、下面有关析构函数的说法中，不正确的是： C
A、析构函数中不能包含return语句
B、一个类中只能有一个析构函数
C、用户可以定义有参析构函数
D、析构函数在对象被撤销时，被自动调用
13、控件不可用的属性是以下哪一个 B
A、 AllowDrop B、Enabled
C、Bounds D、Visible
14、用于设置时间的控件是以下哪一个? A
A、Timer B、ComboBox
C、DateTime D、DateTimePicker
15、以下哪一个命名空间是在进行Sql Server数据库访问时必须加载的? B
A、System.Data.Odbc B、System.Data.SqlClient
C、System.Data.OleDb D、System.Data.SqlTypes
10、C#实现了完全意义上的面向对象，所以它没有____D____，任何数据域和方法都必须封装在类体中。
A、全局变量 B、全局常数
C、全局方法 D、全局变量、全局常数和全局方法
- 下列说法哪个正确？ B
- 不需要定义类，就能创建对象
- 属性可以定义为抽象的
- 对象中必须有属性和方法
- 常量不能作为类成员
13、数据库连接中的参数设置Connection Timeout=10表示 B
A、设置数据库连接超时为10秒钟
B、设置数据库连接超时为10毫秒
C、设置数据库连接的用户最多为10个
D、设置数据库连接的次数不能超过10次
2、静态构造函数只能对（ a ）数据成员进行初始化。
a) 静态 b) 动态 c)实例 d) 静态和实例
3、关于如下程序结构的描述中，哪一项是正确的？（ b ）
for ( ; ; )
{ 循环体; }
a) 不执行循环体 b) 一直执行循环体,即死循环
c) 执行循环体一次 d) 程序不符合语法要求
5、下列哪一个不是类成员的成员( d ).
a）属性 b) 数组 c) 索引器 d)while循环结构
6、枚举类型是一组命名的常量集合，所有整形都可以作为枚举类型的基本类型，如果类型省略，则定义为（ a ）。
a) int b) sbyte c) uint d) ulong
7、下列关于数组访问的描述中，哪些选项是正确的? ( d )。
a) 数组元素索引是从0开始的 b) 对数组元素的所有访问都要进行边界检查
c)如果使用的索引小于0，或大于数组的大小，编译器将抛出一个IndexOutOfRangeException异常；
d) 数组元素的访问是从1开始，到Length结束；
8、下列结构图对应于哪种结构（A是程序段，P是条件）？（ c ）。
a) while 循环结构 b) do…while 循环结构
c) if…else… 选择结构 d) switch…case…选择结构
9、C#数组主要有三种形式，它们是（ c ）。
a) 一维数组 、二维数组、三维数组 b) 整型数组、浮点型数组、字符型数组
c) 一维数组、多维数组、不规则数组 d) 一维数组、二维数组、多维数组
10、下列标识符命名正确的是（ d ）。
a） X.25 b）4foots c）val(7) d）_Years
11、面向对象编程中的“继承”的概念是指（ b ）
a) 对象之间通过消息进行交互 b）派生自同一个基类的不同类的对象具有一些共同特征
c）对象的内部细节被隐藏 d) 派生类对象可以不受限制地访问所有的基类对象
12、下列语句在控制台上的输出是什么？（ b ）
if(true)
System.Console.WriteLine(“FirstMessage”);
System.Console.WriteLine(“SecondMessage”);
a) 无输出 b)FirstMessage c)SecondMessage d)FirstMessage
SecondMessage
13、在C#的类结构中，class关键字前面的关键字是表示访问级别，下面哪个关键字表示该类只能被这个类的成员或派生类成员访问? ( d )。
a) public b) private c) internal d) protected
14、下列类型中, 哪些不属于引用类型?（ b ）。
a) String b) int c) Class d) Delegate
- 数组pins的定义如下：
int[] pins=new int[4]{9,2,3,1};
则pins[1]=( b )
a) 1 b) 2 c) 3 d) 9
17、调用方法时，如果想给方法传递任意个数的参数时，应选用哪个关键字（ c ）。
a) ref b) out c) params d) 无特殊要求
18、C#中TestClass为一自定义类,其中有以下属性定义
public void Property{…}
使用以下语句创建了该类的对象,并使变量obj引用该对象:
TestClass obj = new TestClass();
那么,可通过什么方式访问类TestClass的Property属性? （ a ）
a) Obj,Property; b) MyClass.Property;
c) obj :: Property; d) obj.Property ();
19. 在C#中，表示一个字符串的变量应使用以下哪条语句定义？（ b ）
a) CString str; b) string str; c) Dim str as string d) char * str;
20、下列关于C#面向对象应用的描述中，哪项是正确的？（ c ）。
a) 派生类是基类的扩展，派生类可以添加新的成员，也可去掉已经继承的成员
b) abstract方法的声明必须同时实现
c) 声明为sealed的类不能被继承
d) 接口像类一样，可以定义并实现方法
21、C#中导入某一命名空间的关键字是（ a ）。
a) using b) use c)import d) include
23、以下程序的输出结果是（ b）。
enum Color
{ Red, Green = 2, Blue }
static void Main(string[] args)
{
Color c = 0;
Color c1 = (Color )2;
Console.WriteLine("{0},{1}", c,c1 );
Console .Read ();
}
a) Green,Red b) Red,Green c) Red,Blue d) Green,Blue
27、C#中MyClass 为一自定义类，其中有以下方法定义public void Hello(){⋯⋯}
使用以下语句创建了该类的对象，并使变量obj 引用该对象：MyClass obj = new MyClass();
那么，可如何访问类MyClass 的Hello 方法？( a )。
a) obj.Hello(); b) obj::Hello(); c) MyClass.Hello(); d)MyClass::Hello();
28、如果左操作数大于右操作数，（ ｄ ）运算符返回false。
a）= b）< c） <= d）以上都是
29、下面哪个关键字不是用来修饰方法的参数？（ d ）。
a) ref b) params c) out d) in
31、有说明语句double[,] tab=new double[2,3];那么下面叙述正确的是（ c ）。
a) tab是一个数组维数不确定的数组，使用时可以任意调整
b) tab是一个有两个元素的一维数组，它的元素初始值分别是2，3
c) tab是一个二维数组，它的元素个数一共有6个
d) tab是一个不规则数组，数组元素的个数可以变化
33、下列关于“方法重载”的描述中，哪些选项是不正确的？（ b ）。
a) 方法重载可以扩充现有类的功能
- 构造函数不可以重载
- 方法ConsoleW(int _value)是方法ConsoleW(string _value)的重载
- 方法重载即“同样的方法名但传递的参数不同”
37、下列标识符命名正确的是（ c ）。
a） exam-1 b）Main c）_months d）X.25
38、下列关于数组的描述中，哪些选项是不正确的？（ d ）。
a) String类中的许多方法都能用在数组中
b) System.Array类是所有数组的基类
c) String类本身可以被看做是一个System.Char对象的数组
d) 数组可以用来处理数据类型不同的批量数据
39、在类的定义中，类的（ b ）描述了该类的对象的行为特征。
a) 类名 b）方法 c）所属的命名空间 d）私有域
40、枚举类型是一组命名的常量集合，所有整形都可以作为枚举类型的基本类型，如果类型省略，则定义为（ d ）。
a) uint b) sbyte c) ulong d) int
41、在定义类时，如果希望类的某个方法能够在派生类中进一步进行改进，以处理不同的派生类的需要，则应将该方法声明成（ c ）。
a) sealed方法 b）public方法 c）vitual方法 d）override方法
42、面向对象三个基本原则是（ c ）。
a) 抽象，继承，派生 b) 类，对象，方法
c)继承，封装，多态 d) 对象，属性，方法
43、分析下列代码段，运行结果是什么？（ d ）。
Static void Main(string [] args)
{
string[] words = new string[] {“a”，“b”,“c”};
foreach (int word in words)
{
word =“abc”;
Console.WriteLine(word);
}
Console.ReadKey ()；
}
a) a b c b) abc abc abc c) bc ac ab d)不能正确编译
44、在数组中对于for 和 foreach 语句，下列那些选项中的说法不正确？（ b ）。
a) foreach语句能使你不用索引就可以遍历整个数组
- foreach语句总是从索引1,遍历到索引Length
- foreach总是遍历整个数组
- 如果需要修改数组元素就必须使用for语句
45、在C#的类结构中，class关键字前面的关键字是表示访问级别，下面哪个关键字的访问级别是表示只有在同一个程序集内，且内部类型或成员才是可访问的? ( d )。
a) public b) private c) protected d) internal
46、c#的引用类型包括类、接口、数组、委托、object和string.其中object（ d ）根类。
a) 只是引用类型的 b) 只是值类型的
c) 只是string 类型的 d) 是所有值类型和引用类型的
47、C#的构造函数分为实例构造函数和静态构造函数，实例构造函数可以对（ b ）进行初始化，静态构造函数只能对静态成员进行初始化。
a) 静态成员 b) 静态成员和非静态成员 c) 非静态成员 d)动态成员
48、在C#中，（ b ）表示 “” 。
a) 空字符 b) 空串 c) 空值 d) 以上都不是
50、在C#中无需编写任何代码就能将int型数值转换为double型数值，称为（ b ）。
a) 显式转换 b）隐式转换 c) 数据类型转换 d) 变换
51、下面属于合法变量名的是（ A ）。
a) P_qr b）123mnp c) char d) x-y
52、表达式12/4-2+5*8/4%5/2的值为（ A ）。
a) 1 b）3 c) 4 d) 10
53、当运行程序时，系统自动执行启动窗体的（ C ）事件。
a) Click b）DoubleClick c) Load d) Activated
54、若要使命令按钮不可操作，要对（ B ）属性进行设置。
a) Visible b）Enabled c) BackColor d) Text
55、若要使TextBox中的文字不能被修改，应对（ d ）属性进行设置。
a) Locked b）Visible c) Enabled d) ReadOnly
56、在设计窗口，可以通过（ A ）属性向列表框控件如ListBox的列表添加项。
a) Items b）Items.Count c) Text d) SelectedIndex
57、在VS集成开发环境中有两类窗口，分别为浮动窗口和固定窗口，下面不属于浮动窗口的是（ D ）
a) 工具箱 b）属性 c) 工具栏 d)窗体
60、下面代码的输出结果是（d）。
int x = 5;
int y = x++;
Console.WriteLine(y);
y = ++x;
Console.WriteLine(y);
a)5 6 b) 6 7 c) 5 6 d) 5 7
61、当month 等于6时，下面代码的输出结果是（c）。
int days = 0;
switch (month)
{
case 2:
days = 28;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
default:
days = 31;
break;
}
a) 0 b）28 c) 30 d)31
62、如果 x=35， y=80，下面代码的输出结果是（b）。
if (x < -10 || x > 30)
{
if (y >= 100)
{
Console.WriteLine("危险 ");
}
else
{
Console.WriteLine("报警 ");
}
}
else
{
Console.WriteLine("安全 ");
}
a) 危险 b）报警 c) 报警 安全 d)危险 安全
63、下面代码运行后，s 的值是（B）。
int s = 0;
for (int i = 1; i < 100;i++)
{
if (s > 10)
{
break;
}
if (i % 2 == 0)
{
s += i;
}
}
a) 20 b）12 c) 10 d)6
64、下面代码实现数组array的冒泡排序，画线处应填入（d）。
int[ ] array = { 20, 56, 38, 45 };
int temp;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < _____; j++)
{
if (a[j] < a[j + 1])
{
temp = a[j];
array[j] = a[j + 1];
array[j + 1] = temp;
}
}
}
a) 4-i b）i c) i+1 d)3-i
65、下面代码的输出结果是（c）。
static void Main(string[ ] args)
{
int radius = 2;
double area = GetArea(radius);
Console.WriteLine(area);
Console.ReadLine();
}
private static double GetArea(int r)
{
return 3.14 * r * r;
}
a)2 b）3.14 c) 12.56 d)6.28
66、下面代码的运行结果是（D）
static void Main(string[ ] args)
{
int num1 = 34;
int num2 = 55;
Increase(ref num1, num2);
Console.WriteLine("{0}和{1}", num1, num2);
Console.ReadLine();
}
private static void Increase (ref int num1, int num2)
{
num1++;
num2++;
}
a)35和56 b）34和55 c) 34和56 d) 35和55
67、窗体中有一个年龄文本框 txtAge，下面（d）代码可以获得文本框中的年龄值。
a)int age = txtAge;
b)int age = txtAge.Text;
c)int age = Convert.ToInt32(txtAge);
d)int age = int.Parse(txtAge.Text);
- 下面（b）代码可以显示一个消息框。
a)Dialog.Show();
b)MessageBox.Show();
c)Form.Show();
d)Form.ShowDialog();
70、在Ｃ#中创建类的实例需要使用的关键字是（C）
A : this B: base C new D : as
71、在下列C# 代码中，（A）是类Teacher 的属性。
Public class Teacher{
int age=13;
private string Name{
get{return name;}
set{name=value;}
}
public void SaySomething(){//…}
}
A Name B name C age D SaySomething
72、在C# 语言中，方法重载的主要方式有两种，包括（ D ）和参数类型不同的重载。
A：参数名称不同的重载 B : 返回类型不同的重载
C： 方法名不同的重载 D ：参数个数不同的重载
73、下列关于继承说法中，哪个选项是正确的（d）
A。派生类可以继承多个基类的方法和属性。
B。派生类必须通过base关键字调用基类的构造函数
C。继承最主要的优点是提高代码性能
D。继承是指派生类可以获取其基类特征的能力。
75、下列选项中，不属于值类型的是（D）
A。struct B.Int32 C.Int D.string
76、声明double a; int b;下列哪个选项中的表达式能够正确的进行类型转换？(B)
A. a=(decimal)b; B。a=b; C. a=(int)b ; D. b=a;
77、下列哪个语句不是C#2005提供的循环语句（a）
A。do…loop while…语句
B。foreach 语句
C。do…while语句
D。while语句
79、在C# 中，使用（ B）访问修饰符修饰的方法被称之为抽象方法。
A： this B ：abstract C ：new D ：virtual
80、在C# 中创造一个对象是，系统最先执行的是（B）中的语句。
A ：main方法 B：构造函数 C ：初始化函数 D ：字符串函数
81、C#代码如下，代码的输出结果是（B）。
class Program{
static void Main(string[] args){
Student s=new Student（）；
s.sayHi();
Console.ReadLine();
}
}
class Person{
public virtual void sayHi(){
Console.WriteLine(“你好”);
}
}
Class Student:Person{
Public override void sayHi(){
Console.WriteLine(“你好，我是一名学生”);
}
}
A ：学生 B：你好，我是一名学生
C：你好！
你好，我是一名学生
D： 空
82、分析一下C#片段中的属性，该属性是（C）属性。
private string name;
Public string Name{
get{return name;}
}
A:可读可写 B：只写 C：只读 D: 静态
83、.NET框架是.NET战略的基础，是一种新的便捷的开发平台，它具有两个主要的组件，分别是（A ）和类库。
A：公共语言运行库 B：Web服务
C：命名空间 D：Main（）函数
84、在以下代码中，（D）是类Teacher的方法。
public class Teacher
{
int age=33;
private string name;
public string Name
{
get{return name;}
set{name=value;}
}
}
public void SaySomething（）{
//…..
}
A Name B name C age D SaySomething
85、构建Windows窗体以及其所使用空间的所有类的命名空间是下列哪个选项（D）
A。System.IO B。System.Data
C。System.Text D。System.Windows.Forms
86、C#程序设计语言属于什么类型的编程语言（B）
A。机器语言 B。高级语言
C。汇编语言 D。自然语言
88、以下选项中，哪个选项中的变量命名是合法的（B）
A。**z B。_ester C。tc@caac D。www.eroman.com
90、下列关于接口的说法，哪项是正确的（A）
A。接口可以被类继承，本身也可以继承其他接口。
B。定义一个接口，接口名必须使用大写字母I开头
C。接口像类一样，可以定义并实现方法
D。类可以继承多个接口，接口只能继承一个接口
92、下列哪个选项能正确的创建数组？（B）
A.int[,] array=int[4,5];
B.int size=int.Parse(Console.ReadLine());
int[] pins=new int [size];
C. string[] str=new string[];
D. int pins[] = new int[2];
93、在C#中，下列数据类型属于引用类型的是（C）。
A．整型（int） B．结构（struct） C．接口（interface） D．枚举（enum）
94、在C#中，下列关于属性的使用正确的是（B）。
- private int num;
public string Num
{
get{return num;}
set{num=value;}
}
- private int num;
public int Num
{
get{return num;}
set{num=value;}
}
- private int num;
public int Num
{
get{ num=value;}
set{ return num;}
}
- private int num;
private int Num
{
get{return num;}
set{num=value;}
}
95、在C#语言中，以下关于继承的说法错误的是（B）。
A.一个子类不能同时继承多个父类 B任何类都是可以被继承的
C.子类继承父类，也可以说父类派生了一个子类 D.Object类是所有类的基类
96、以下关于C#中的构造函数说法正确的是（A）。
A.构造函数可以有参数 B.构造函数有返回值
C.一般情况下，构造函数总是private类型的 D.构造函数可以通过类的实例调用
97、在C#中，如果类C继承自类B，类B继承自类A，则以下描述正确的是（A）。
a) C不仅继承了B中的成员，同样也继承了A中的成员
b） C只继承了B中的成员
c） C只继承了A中的成员
d） C 不能继承了A或B中的成员
98、在C#程序中，定义如下方法，下面选项中（A ）错误的实现对该方法的方法重载。
public string Do(int value,string s){//省略代码}
A.public int Do(int value,string s){//省略代码}
B.public string Do(string s,int value){//省略代码}
C.public void Do(string s,int value) {//省略代码}
D.public void Do(){{//省略代码}}
100、以下关于密封类的说法，正确的是（C）
A．密封类可以用作基类 B. 密封类可以是抽象类
C.密封类永远不会有任何派生类 D.密封类或密封方法可以重写或继承
101、以下关于接口的说法，不正确的是（C）
A.接口不能实例化 B. 接口中声明的所有成员隐式地为public和abstract
C.接口默认的访问修饰符是private D.继承接口的任何非抽象类型都必须实现接口的所有成员。
103、能作为C#程序的基本单位是( B )。
A. 字符 B. 语句 C. 函数 D. 源程序文件
104、可用作C#程序用户标识符的一组标识符是( B )。
A. void define +WORD B. a3_b3 _123 YN
C. for -abc Case D. 2a DO sizeof
105、改变窗体的标题，需修改的窗体属性是( A )。
A. Text B. Name C.Title D. Index
106、在C#中定义接口时，使用的关键字是( A )。
A.interface B. : C.class D.overrides
107、在C#中，定义派生类时，指定其基类应使用的语句是( B )。
A.Inherits B. ： C.Class D.Overrides
108、类的以下特性中，可以用于方便地重用已有的代码和数据的是( C ).
A.多态 B.封装 C.继承 D.抽象
109、将变量从字符串类型转换为整型可以使用的类型转换方法是( D )。
A.Str() B.Cchar C.CStr() D.int.Parse();
110、字符串连接运算符包括&和（ A ）。
A. + B. - C. * D. /
111、先判断条件的当循环语句是( B )。
A. do...while B. while C. while...do D. do ...loop
112、假定一个10行20列的二维整型数组，下列哪个定义语句是正确的（ C ）。
A. int[]arr = new int[10,20]
B. int[]arr = int new[10,20]
C. int[,]arr = new int[10,20]
D. int[,]arr = new int[20;10]
113、以下正确的描述是（ B ）。
A. 函数的定义可以嵌套，函数的调用不可以嵌套
B. 函数的定义不可以嵌套，函数的调用可以嵌套
C. 函数的定义和函数的调用均可以嵌套
D. 函数的定义和函数的调用均不可以嵌套
114、属于C#语言的关键字( A )。
A. abstract B. camel C. Salary D. Employ
115、C#语言中，值类型包括：基本值类型、结构类型和（ D ）。
.小数类型 B.整数类型 C.类类型 D.枚举类型
116、下列关于抽象类的说法错误的是（ A ）。
A. 抽象类可以实例化 B. 抽象类可以包含抽象方法
C. 抽象类可以包含抽象属性 D. 抽象类可以引用派生类的实例
117、下列关于重载的说法，错误的是（ D ）。
A. 方法可以通过指定不同的参数个数重载
B. 方法可以通过指定不同的参数类型重载
C. 方法可以通过指定不同的参数传递方式重载
D. 方法可以通过指定不同的返回值类型重载
118、以下关于继承的说法错误的是（ D ）。
A. .NET框架类库中，object类是所有类的基类
B. 派生类不能直接访问基类的私有成员
C. protected修饰符既有公有成员的特点，又有私有成员的特点
D. 基类对象不能引用派生类对象
119、继承具有（ B ），即当基类本身也是某一类的派生类时，派生类会自动继承间接
类的成员。
A. 规律性 B. 传递性 C. 重复性 D. 多样性
120、下列说法中，正确的是（ A ）。
A. 派生类对象可以强制转换为基类对象
B. 在任何情况下，基类对象都不能转换为派生类对象
C. 接口不可以实例化，也不可以引用实现该接口的类的对象
D. 基类对象可以访问派生类的成员
122、下面关于抽象类的说法正确的是 ：（B）
A. 抽象类可以被实例化 B. 含有抽象方法的类一定是抽象类
C抽象类可以是静态类和密封类 D.抽象类中的抽象方法可以在其它类中重写
124、在C#中，关于接口下面说法错误的是 ：（D）
A. 接口是一组规范和标准 B.接口可以约束类的行为
C. 接口中只能含有未实现的方法
D 接口中的方法可以指定具体实现，也可以不指定具体实现
127、下面关于抽象类的说法正确的是？（C）
A. 抽象类只能做子类 B. 抽象类可以被实例化
C 抽象类不能被实例化 D. 一个抽象类只能有一个子类
128、C#源程序文件的拓展名是（D）
A、vb B、c C、cpp D、cs
129、有两个double类型的变量x和y，分别取值为8.8和4.4，则表达式（int）x-y/y的值是（A）
A、7 B、7.0 C、7.5 D、8.0
130、运行int a=20，b=5，c=10，d=3；
bool s，e=false；
则表达式（s=a<c）&&(e=b-d>0)运算后，e的值是（D）
A、0 B、1 C、true D、false
131、以下程序的输出结果是（D）
string str=”b856ef10”;
string result=””;
for(int i=0;str[i]>=’a’&&str[i]<=’z’;i+=3)
{
result =str[i]+result;
Console.WriteLine(result);
}
A、10fe658b B、feb C、10658 D、b
132、和C#中的所有对象一样，窗体也是对象，是（C）类的实例
A、Label B、Controls C、Form D、System
134、下列语句创建了（D）个string 对象
string [,] strArray = new string[3,4]
A.0 B.3 C.4 D.12
136、在定义类时，如果希望类的某个方法能够在派生类中进一步改进，已处理不同的派生类的需要，则该将方法声明成（C）
A.sealed 方法 B.public 方法 C.virtual 方法 D.override 方法
137、在类的定义中，类的（B）描述了该类的对象的行为特征
A.类名 B.方法 C.所属的命名空间 D.私有域
138、在类作用域中能够通过直接使用该类的（ D ）成员名进行访问。
A. 私有 B. 公用 C. 保护 D. 任何
139、在下面循环语句中循环体执行的次数为（ B ）。
for(int i=0; i<n; i++)
if(i>n/2) break;
A. n/2 B. n/2+1 C. n/2-1 D. n-1
141、在C#程序中，使用(a)关键字来创建数组
a) new b) array c) staic d) this
142、在C#语言的循环结构中，首先执行一次，然后再判断条件的循环结构是( b)
a) while循环 b) do…while循环 c) for循环 d) foreach循环
143、在C#中，下列代码的运行结果是（a）
using System;
class Test{
static void Main(string[] args){
string[] strings={“a”,”b”,”c”};
foreach（string info in strings）
{
Console.Write(info);
}
}
}
a)abc b)a c)b d)C
144、在C#中，下列代码的运行结果是（c）
int[]age=new int[]{16,18,20,14,22};
foreach(int i in age){
if(i>18)
continue;
Console.Write(i.ToString()+” ”);
}
a)16,18,20,14,22 b)16,18,14,22 c)16,18,14 d)16,18
145、以下关于C#代码的说法正确的是(a)
for(int i=l；i<=3；i++)
{
switch(i)
{
case 1：
Console．Write{i.ToString())；
case 2：
Console．Write((i*2)．ToString())；
case 3：
Console．Write((i*3)．ToString())；
}
}
a)有编译错误，提示case标签不能贯穿到另一个标签，不能运行
b) 输出149 c) 输山123246369
d) 正确运行，但没有输出
146、在c#中，下列代码的运行结果是（c）
using System;
class Test{
static Void Main(string [] args){
int a=10,b=20;
int c=a>b?a++:--b;
Console.WriteLine（c）;
}
}
a)10 b)11 c)19 d)20
147、在c#的条件判断语句switch case结构中，（d）子句用于指定在找不到匹配项时执行的动作
a) continue b)goto c)else d)default
148、Console是C#语言中的控制台类，它负责向控制台输出不同格式的字符串，在格式字符串中，可以使用(b)来实现水平制表输出。
a)\r b)\t c)\n d)\d
149、C#程序的（a）方法被成为程序的大门，应用程序从这里开始运行
a) Main() b) Begin() c) Start() d) main()
150、在以下C#类中，（b）是控制台类，利用它我们可以方便的进行控制台的输入输出。
a) Control b) Console c) Cancel d) Write
151、关于C#中的switch case 语句，以下说法正确的是（c）
a)switch判断的表达式可以是整型或者字符型，但不能是字符串型
b)在该语句中最多不能超过5个case子句
c)在该语句中只能有一个default子句
d)在该句中只能有一个break语句
152、以下的C#程序代码，程序运行时在控制台打印输出值为（c）
int count=3;
while(count>1)
{
Console.Write(- -count);
}
a) 32 b) 321 c) 21 d) 2
153、C#语言中的类Console包含两个输出方法：Write()和WriteLine()。它们之间的唯一区别是（a ）。
a) WriteLine()方法输出后换行，Write()方法输出后不换行
b) WriteLine()方法可以格式化输出，Write()方法不可以
c) Write()方法输出后换行，WriteLine()方法输出后不换行
d) Write()方法可以格式化输出，WriteLine()方法不可以
154、在下列C#代码中，程序的命名空间是（a）
using System;
namespace Test{
class Program{
static void Main(string[]args){
Console.Write(“Hello World!”);
}
}
}
a)Test b)Main c)namespace d)Program
155、在C#中，下列代码的运行结果是（b ）
using System;
class Test
{
Public static void Main(string[] args)
{
int a=21,b=22,c=23;
if(a<b)
Console.WriteLine(b);
else
Console.WriteLine(a+b+c);
}
}
a)21 b)22 c)23 d)66
156、C#语言与Java语言一样，也是一种面向对象的语言，C#语言中声明类的关键字是（b）。
a) using b) class c) namespace d) Main
157、C#程序设计语言属于什么类型的编程语言？（ C ）
A 汇编语言 B 机器语言 C 高级语言 D 自然语言
159、设int型变量x的值为9，那么表达式x-- + x-- + x--的值为（A）
A . 27 B. 24 C. 21 D .18
161、以下数组声明中，不正确的有（B）
A int[] a ; B int a[]=new int[2];
C int [] a={1,3} D int [] a=int []{1,3}
162、下列语句执行后y的值为（C）
int x=0,y=0;
while(x<10)
{
y+=(x+=2);
}
A 10 B 20 C 30 D 55
163、C#中每个char类型变量占用（ B ）字节内存
A 1 B 2 C 3 D 4
164、在C#中，表示一个字符串变量应使用下面哪条语句定义（ B）
A、CString str; B、string str;
C、Dim str as string; D、char * str;
165、下列语句在控制台上的输出是什么？（B）
if(true)
System.Console.WriteLine("FirstMessage");
System.Console.WriteLine("SecondMessage");
A、无输出
B、FirstMessage
SecondMessage
C、SecondMessage D、FirstMessage
166、以下数据类型中不可以使用算术运算的是（A）
A. bool B. char C. decimal D. sbyte
167、以下数据类型不能表示负数范围的是（D）
A. sbyte B. decimal C. double D. uint
168、C#中下列变量标识符定义不正确的是（C）
A. m_n B. _a124; C. @3_4; D. udouble
169、以下语句不可以在屏幕上输出Hello,World语句是（C）
A. Console.WriteLine(“Hello”+”,World”);
B. Console.Write(“Hello,{0}”,”World”);
C. Console.WriteLine(“{0},{1}”,”Hello,World”);
D. Console.Write(“Hello,World”);
170、在C#语言中，运算符"＝"和"＝＝"的功能分别是（ B ）
A．关系运算和赋值运算 B．赋值运算和关系运算
C．都是关系运算 D．都是赋值运算
171、两次运行下面的程序，如果从键盘上分别输入6和3，则输出结果是（ C ）。
int x；
x=int.Parse(Console.ReadLine());
if（x++>5）
Console.WriteLine(x)；
else
Console.WriteLine(x - -)；
A. 7和5 B. 6和3 C. 7和4 D. 6和4
173、关于循环语句下列错误的是（A）
A. for语句while语句与do while语句可以相互替换。
B. while(5){Console.WriteLine(“Hello!”);}将无限输出字符串Hello。
C.for(int i=5;i<13;i++){} 这个语句将运行8次
D.while语句中的条件必须是布尔类型的结果
174、下列选项中属于字符串常量的是 （ B ）
A. ABC B. “ABC” C. ‘abs’ D. ‘a’
175、下列代码的运行结果是：( A )
int a = 30;
int b = 20;
b = a;
a = 10;
Console.WriteLine(a);
Console.WriteLine(a/b);
A、10 C、 30
0 0
B、10 D、 10
1 1.5
176、设int a=9, b=6, c 执行语句c=a/b+0. 8 后c 的值是( B )
A. 1 B. 1. 8
C. 2 D. 2. 3
177、已知如下程序，下列选项放在空白处不能输出***的是（D）
void main()
{
int x=6;
do
{
Console.WriteLine(“*”);
x--;
--x;
}while(_____)-----空白处
}
A. x>=1; B. x>=2; C. x>0; D. x>3;
178、在C#编制的财务程序中，需要创建一个存储流动资金金额的临时变量，则应使用下列哪条语句（ A ）
A．decimal EMoney; B．int EMoney;
C．string EMoney; D．Dim EMoney as double;
179、设int x=10, a=0, b=25 则条件表达式x<1?a+10:b 的值是（ D ）
A．0 B．1
C．10 D．25
180、在.NET中，从属性的读写特性上来进行分类，可以划分为以下三种，除了（ D ）。
A.只读属性 B.只写属性 C.读写属性 D.不可读不可写的属性
181、在C#中，一个类（ B ）.
A.可以继承多个类 B.可以实现多个接口
C.在一个程序中只能有一个子类 D.只能实现一个接口
182、以下的C＃代码：
static void Main（string[] args）
{
Console.WriteLine("运行结果: {0}",Console.ReadLine());
Console.ReadLine();
}
代码运行结果为（ D ）。
A.在控制台窗口显示“运行结果：”
B.在控制台窗口显示“运行结果：{0}”
C.在控制台窗口显示“运行结果：，Console．ReadLine”
D.如果用户在控制台输入“ A”，那么程序将在控制台显示“运行结果：A”
183、在C#中定义一个数组，正确的代码为（ B ）。
A.int arraya = new int[5]; B.int[] arraya = new int[5];
C.int arraya = new int[]; D.int[5] arraya = new int;
184、在C＃语言中，下列关于属性的描述正确的是（ B ）．
A.属性系是以public关键字修饰的字段，以public关键字修饰的字段也可称为属性
B.属性是访问字段值的一种灵活机制，属性更好地实现了数据的封装和隐藏
C.要定义只读属性只需在属性名前加上readonly关键字
D.在C#的类中不能自定义属性
186、.NET中，程序中的错误可以划分为以下三类，除了（ D ）。
A.逻辑错误 B.运行时错误 C.语法错误 D.自定义错误
187、在.NET中，一些数据类型为引用类型，当引用类型的值为（ B ）时，表明没有引用任何对象。
A.Empty B.null C.Nothing D.0
189、在C#中，（B ）访问修饰符修饰的变量只能由当前程序集访问。
A.public B.protected C.internal D.private
190、在C#中，关于continue和break，以下说法正确的是（ B ）
A break是中断本次循环 B continue是中断本次循环，进入一下次的循环
C break是中断本次循环，进入一下次的循环 D continue是中断整个循环
191、在C#中，关于while和do…while，以下说法正确的是（ C ）
A while先执行然后判断条件是否成立 B while最少的循环次数是1次
C do…while先执行然后判断条件是否成立 D do…while最少的循环次数是0次
192、在.NET中，程序员在代码中漏写了一个大括号，这属于（ C ）
A 逻辑错误 B 运行时错误 C 语法错误 D 自定义错误
193、以下说法正确的是( B )
A.构造函数名不必和类名相同 B.一个类可以声明多个构造函数
C.构造函数可以有返回值 D.编译器可以提供一个默认的带一个参数的构造函数
194、以下说法不正确的是( B )
A.一个类可以实现多个接口 B.一个派生类可以继承多个基类
C.在C#中实现多态，派生类中重写基类的虚函数必须在前面加override
D.子类能添加新方法
195、C#的数据类型有（ B ）
A 值类型和调用类型 B 值类型和引用类型
C 引用类型和关系类型 D 关系类型和调用类型
196、C#程序中的类myClass中的成员变量var1如下：
public class myClass
{
private int var1;
}
则可以访问var1的是（ AA ）。
a) 在myClass类中 b) myClass的继承类
c) myClass的父类 d) 和myClass在同一命名空间下的类
197、下列关于.net中枚举型的描述正确的是（ b B ）。
a) 枚举型是引用类型
b) 枚举型是值类型，它是一组称为枚举数列表的命名常量组成的独特类型
c) 指定分配给每个枚举数的存储大小的基础类型是可以为int，也可以为char类型，还可以为long类型
d) 枚举型的默认基础类型为int，第一个枚举数的值必须为0，后面每个枚举型的值依次递增1
198、以下（ c C ）是用于声明枚举类型的关键字。
a) static b) struct c) enum d) delegate
199、下列关于异常的描述正确的是（ b B ）
a) 在C#中一个try块只能有一个catch块
b) 一个try块可能产生多个异常
c) 可以使用throws回避方法中的异常
d) finally块是异常处理所必需的
201、public abstract class Animal{
public abstract void Eat();
public void Sleep(){ }
}以下关于C#代码地描述正确的是（ aA ）。
A） 该段代码正确
B） 代码错误，因为类中存在非抽象方法
C） 代码错误，因为类中方法没有实现
D） 通过代码Animal an = new Animal;可以创建一个Animal对象
202、for(int i=1;i<=3;i++){
switch(i){
case 1:Console.write(i.ToString());
case 2:Console.write((i * 2).ToString());
case 1:Console.write((i * 3).ToString());
}
}上述关于C#代码的描述正确的是（ aA ）。
A） 程序将报告编译错误，提示Case标签不能贯穿到 一个标签，不能运行
B） 运行时输出149
C） 运行时输出123246369
D） 运行时在屏幕上没有输出
203、C#程序中,使用关键字（AA）来声明自定义的名称空间。
A）namespace B）new C）import D）try
206、class A{
static void Main(){
int[] b = new int[10];
for(int i=1;i<=10;i++)
_________ //(1)此处填写代码
foreach(int C in b)
Console.writeLine(C);
}
}要在控制台输出1到10的数字，（1）处应该填写的正确的代码为（CC）。
A） b[i] = i+1; B） b[i] = i; C） b[i-1] = i D） b[i+1] = i
207、在C#类中，（BB）允许相同名称、不同参数个数或者参数类型的方法存在。
A）方法重写 B）方法重载 C）方法取消 D）方法覆盖
208、用户单击”消息框”按钮时返回（DD）值。
A）DialogValue B）DialogBox C）DialogCommand D）DialogResult
209、在C#中，某程序在一个类中编写了两个同名的方法，该段代码的运行结果是（CC）。
public class Musician{
public void Song(){
Console.WriteLine(“忘记你我做不到”);
}
public void Song(string musicName){
Console.WriteLine(musicName);
}
static void Main(){
Musician musician = new Musician ();
string musicName = ”还是觉得你最好”;
musician.Song(“分手总要在雨天”);
}
}
A）忘记你我做不到 B）还是觉得你最好 C）分手总要在雨天 D）没有输出
210、请仔细阅读有如下C#代码：
int A = 3;
int B = 4
Console.WriteLine(A + B);
因为第二行代码少写了一个分号，程序运行时将（AA）。
A）产生语法错误 B）产生语义错误 C）中断 D）正常运行
212、在C#的语言特性中，关于抽象类，以下描述正确的是（ DD）。
A）在抽象类包含全部已经实现的方法的时候，抽象类可以实例化
B）子类可以同时实现多个抽象类
C）使用void关键字标注一个抽象类
D）抽象基类可以包含己经实现的方法
213、在C#中,下列代码的运行结果是（BB）。
int a = 30 , b = 20;
b = a;
a = 10;
Console.WriteLine(a);
Console.WriteLine(b);
A） 10 B） 10 C） 30 D） 10
10 30 20 20
215、在C#中，下列代码的运行结果是（A）。
string[] names = {“ACCP”,”BENET”,”BETEST”};
foreach(string name in names)
Console.WriteLine(name);
A） ACCP B） n C） name D） “ACCP”
BENET a name “BENET”
BETEST m name “BETEST”
e
s
216、在C#程序中，使用关键字（D）来定义静态成员。
A）malloc B）class C）private D）static
217、以下都是C#提供的循环结构，除了（C）。
A）while语句 B）for语句 C） if语句 D）foreach语句
218、在C#程序中，一个类（BB）。
A） 可以继承多个类 B） 可以实现多个接口
C） 在一个程序中只能有一个子类 D） 只能实现一个接口
219、在C#程序中，声明一个整数类型变量A，正确的代码为（AA）
A） int A; B） Dim A As Integer; C） new A int ; D） A int;
220、在.NET中，（D）类提供了操作字符串的方法。
A） System.Threading C） System.Collections
B） System.IO D） System.String
221、在C#类中，使用（AA）关键字来设置只读属性。
A） get B） let C） set D） is
222、在C#程序中，如果类B要继承类A，类B正确的定义为（BB）。
A） public class B inherit A C） public class B :: A
B） public class B : A D） public class B from A
223、在C#类中，（A）。
A）允许有多个相同名称的构造函数 C）至少要有一个构造函数
B）允许有多个不相同名称的构造函数 D）只能有一个构造函数
224、C#类中的构造函数的特点是（BB）。
A） 一个类中,只能有一个构造函数 C） 构造函数在对象销毁时自动执行
B） 构造函数的名称与类名称一样 D） 要求构造函数至少有两个参数
225、下面关于C#中值类型和引用类型的描述正确的是（D）。
A） 结构属于引用类型 B） 字符串属于值类型
C） 所有内置的数据类型都是值类型，所有用户定义的数据类型都是引用类型
D） 值类型变量直接存放真正的数据，引用类型变量存放的是指向真正数据的内存地址
226、在C#中，下列代码运行后，变量Max的值是（CC）。（选择一项）
int a = 5,b = 10,c = 15,Max = 0;
Max = a > b ? a : b;
Max = c < Max ? c : Max;
A） 0 B） 5 C） 10 D） 15
227、class Student{
string type = ”学员”;
internal string name = ”李明”;
}
public class Test{
static void Main(){
Student stu = new Student();//1
Console.WriteLine(stu.type);//2
Console.WriteLine(stu.name);//3
}
}在C#中，关于以上C#代码的描述正确的是（BB）。
A）代码1错误 B）代码2错误 C）代码3错误 D） 代码都正确
228、运行如下的C#代码段将（DB）。（选择一项）
int a = 10;
string b = “10”;
Console.WriteLine (a + b);
A）输出：20 B）输出：1010 C）输出：10+10 D） 编译报错，提示数据类型不匹配
| 229、 | 数据类型转换有隐式转换和（C）转换。 | ||
| a)强制 b)自制 c)显式 d)非隐式 | |||
| 230、 | 在C#中，下列代码的运行结果是（B）(单选) | ||
| static void Main(){ | |||
| a)输出name b)输出bird c)输出cccc d)编译出错，存在语法错误 | |||
231、Switch的语法结构不正确的是（B）
a)Switch条件判断接收int,char,string三种类型
b)Switch的case块，必须要加上break;
c)Switch的case块，可以没有break
d)Switch的default块，在条件都不满足的情况下执行
232、下列语句在控制台上的输出是多少？ ( A )
string msg = @”Hello\nWorld!”;
System.Console.WriteLine(msg);
a)Hello\nWorld! b)@”Hello\nWorld!” c)Hello World! d)Hello
World!
233、C#中每个int 类型的变量占用____C___个字节的内存( )
a)1 b)2 c)4 d)8
234、下面代码输出的结果是：( B )
static void TrunCate(int[] nums)
{
nums[1] = 99;
}
static void Main(string[] args)
{
int[] nums = {1, 2, 3, 4};
TrunCate(nums);
Console.WriteLine(nums[1]);
Console.ReadLine();
}
a)2 b)99 c)1 d)编译出现语法错误，不能运行
235、下列代码输出的结果是：( B )
int i = 0;
i = ++i + 8;
Console.WriteLine(i++);
a)8 b)9 c)10 d)编译出现语法错误，不能运行
237、当开发者不希望自己编写的类被继承，或者有的类已经没有再被继承的必要时，我们通常对class使用哪一个关键字？(A)
a.sealed b.virtual c.abstract d.override
238、下列哪种类型是引用类型的数据类型？（d）
a. int b. bool c.double d. array
239、声明方法时，如果有参数，则必须写在方法名后面的小括号内，并且必须指明它的类型和名称，若有多个参数，需要用（A ）隔开。
A. 逗号 B. 分号 C. 冒号 D. 不能定义多个参数
240、小数类型（decimal）和浮点类型都可以表示小数，正确说法：( C )
A. 两者没有任何区别 B. 小数类型比浮点类型取值范围大
C.小数类型比浮点类型精度高 D. 小数类型比浮点类型精度低
241、类的以下特性中，可以用于方便地重用已有的代码和数据的是( C ).
A.多态 B.封装 C.继承 D.抽象
242、将变量从字符串类型转换为数值类型可以使用的类型转换方法是( D )。
A.Str() B.Cchar C.CStr() D.int.Parse();
243、下列关于抽象类的说法错误的是（ A ）。
A. 抽象类可以实例化 B. 抽象类可以包含抽象方法
C. 抽象类可以包含抽象属性 D. 抽象类可以引用派生类的实例
244、以下关于继承的说法错误的是（ D ）。
A. .NET框架类库中，object类是所有类的基类
B. 派生类不能直接访问基类的私有成员
C. protected修饰符既有公有成员的特点，又有私有成员的特点
D. 基类对象不能引用派生类对象
245、继承具有（ B ），即当基类本身也是某一类的派生类时，派生类会自动继承间接基类的成员。
A. 规律性 B. 传递性 C. 重复性 D. 多样性
247、面向对象的语言具有继承性、多态性和__A__性。
A) 封装 B) 拆箱 C) 封闭 D) 逻辑
249、在c#中new关键字的作用是___A__
A)新建对象实例 B)定义命名空间 C)调用类 D)引入命名空间
250、在c#中利用sealed修饰的类__A___。
A）密封，不能继承 B）密封，可以继承 C）表示基类 D）表示抽象类
251、C#中每个 int 类型的变量占用___ C ____个字节的内存｡
A.1 B.2 C.4 D.8
253、分析下列程序:
public class class4
{
private string _sData = "";
public string sData{set{_sData = value;}}
}
在 Main 函数中,在成功创建该类的对象 obj 后,下列哪些语句是合法的? (A)
A.obj.sData = "It is funny!"; B.Console.WriteLine(obj.sData);
C.obj._sData = 100; D.obj.set(obj.sData);
254、在定义类时,如果希望类的某个方法能够在派生类中进一步进行改进,以处理不同的派生类的需要,则应将该方法声明成( C )｡
A.sealed 方法 B.public 方法 C.virtual 方法 D.override 方法
256、列语句创建了多少个 string 对象? (D)
string[,] strArray = new string[3][4];
A.0 B.3 C.4 D.12
257、以下类 MyClass 的属性 count 属于__A___属性. (A)
class MyClass
{
int i;
int count
{ get{ return i;}
}
}
A.只读 B.只写 C.可读写 D.不可读不可写
258、为了将字符串 str=“123,456”转换成整数 123456,应该使用以下哪条语句? (A)
A.int Num = int.Parse(str);
B.int Num = str.Parse(int);
C.int Num = (int)str;
D.int Num = int.Parse(str,Globalization.NumberStyles.AllowThousands);
259、关于 C#程序的书写,下列不正确的说法是__ D __｡
A.区分大小写 B.一行可以写多条语句
C.一条语句可写成多行
D.一个类中只能有一个 Main()方法,因此多个类中可以有多个 Main()方法
260、在 C#语言中,下列能够作为变量名的是___ C _｡
A.if B.3ab C.a_3b D.a-bc
261、以下程序的输出结果是__(C)__｡ Using system;
Class Example1
{
Public Static void main()
{
Int a=5,b=4,c=6,d;
Console.Writeline(“{0}”,d=a>b?(a>c?a:c):b);
}
}
A.5 B.4 C.6 D.不确定
262、if语句后面的表达式应该是__(A)__｡
A.逻辑表达式 B.条件表达式 C.算术表达式 D.任意表达式
263、以下关于 for 循环的说法不正确的是__(A)__｡
A.for 循环只能用于循环次数已经确定的情况
B.for 循环是先判定表达式,后执行循环体语句
C.for 循环中,可以用 break语句跳出循环体
D.for 循环体语句中,可以包含多条语句,但要用花括号括起来
264、枚举型常量的值不可以是__(D)__类型
A.int B.long C.ushort D.doule
265、调用重载方法时,系统根据___(B)_____来选择具体的方法｡
A.方法名 B.参数的个数和类型
C.参数名及参数个数 D.方法的返回值类型
266、下列的____ D ___不是构造函数的特征｡
A.构造函数的函数名和类名相同
B.构造函数可以重载
C.构造函数可以带有参数
269、以下类型中,不属于值类型的是__ D __｡
A.整数类型 B.布尔类型 C.字符类型 D.类类型
270、结构化的程序设计的 3 种基本结构是___ D __｡
A.顺序结构,If结构,for 结构 B.if 结构,if…..else结构 else if结构
C.while结构,do….while结构,foreach结构
D.顺序结构,分支结构,循环结构
271、下列参数类型中_D__是 C#中不允许使用的。
A.值参数 B.引用参数 C.输出参数 D.指针参数
272、关于参数数组,下列说法错误的是__ C _.
A.参数数组必须是函数的最后一个参数｡
B.参数数组必须是一维数组
C.参数数组的声明同普通数组一样
D.参数数组所对应的实参的个数是不固定的
273、在下列程序空格处填入正确的选项__C___,能够实现调用函数 show().
class Class1
{
static void show(ref int i)
{
i*=15;
Console.WriteLine(“i={0}”,i);
}
static void Main(string[] args)
{
int test=10;
Console.WriteLine(“调用函数 show前,test={0}”,test);
show(______);
Console.WriteLine(“调用函数 show后,test={0}”,test);
}
}
A.test B.out test C.ref test D.params test
277、在下面的类定义中，缺省构造函数的作用是（ C ）
Public class MyClass
{
private MyClass() { }
public static int counter;
public static int increnentCounter()
{
return ++counter;
return ++counter;
}
}
- 在创建类的实例时初始化类的域
- 因为是private的，因此不起任何作用
- 防止创建类的实例
278、下列语句是类myclass的一部分，obj是myclass的一个对象。
Void change(int i)
{
i++
}
public void test()
{
int a=100;
Change(a);
Console.Writeline(a);
}
则调用obj.test后，控制台输出（ B ）
A. 0 B. 100 C. 101
279、下列语句是类myclass的一部分，obj是myclass的一个对象。
Void change(int i)
{
i++
}
public void test()
{
int a=100;
Change(ref a);
Console.Writeline(a);
}
则调用obj.test后，控制台输出（ A ）
A. 101 B. 100 C. 0
280、下列类的定义中哪些是合法的抽象类？（ D ）
- sealed abstract class c1{abstract public void test() {}
- abstract sealed public viud test();
- abstract class c1 { abstract void test(); //test()默认为私有，不合法
- abstract class c1 {abstract public void test(); }
282、C#中执行下列语句整形变量x和y的值是多少？（D）
int x=100;
int y=++x;
A. x=100 y=100 B. x=101 y=100 C. x=100 y=101 D. x=101 y=101
285、C#中，回车字符对应的转义字符串为（ C ）
A. \r B. \f C. \n D. \a
288、在C#程序中，显示一个信息为“This is a test!”，标题为“Hello”的消息框，正确的语句是（ B ）
- MessageBox(“this is a test!”,”Hello”);
- MessageBox.Show(“this is a test!”,”Hello”);
- MessageBox(”Hello” , “this is a test!”);
- MessageBox.Show (”Hello” , “this is a test!”);
289、在C#中，引用命名空间System的正确语句是（ A ）
- using System;
- # import <System>;
- uses System;
- # include <System>;
291、下列说法中不正确的是（D）？
A C#中以“；”作为一条语句的结束
B C#中注释是不参与编译的
C C#有三种不同的注释类型
D swith语言中case标签结束可是有跳转语句，也可以没有。
292、判断下列语句中哪个存在语法错误（B）。
bool a=true bool b=false bool c=true int i=0
A if(a||b) B if(i) C if(i!=3) D if((i==3)==false)
293、下列关于switch语句的表述中哪个是正确的（B）？
Ａswitch语句的控制表达式可以是任何数据类型
B switch语句可以出现default标签，也可以不出现default标签
C switch中可以有两个或两个以上的case标签的常量与控制表达式的值相同
D switch语句中case标签结束可以有跳转语句，也可以没有。
295、下列关键字中哪些不能作为修饰类（C）
A：sealed B:abstract C:override D:public
296、下列关于继承机制的描述中不正确的是（D）
A提供继承机制有利于提高软件模块的可重用性及可扩充性。
B继承机制使面向对象的开发语言能够更准确的描述客观世界，使软件开发方式变简单。
C继承机制使得软件开发过程效率更高。
D继承机制使得软件开发的难度相对增加。
297、下列关于继承的理解，错误的是（A）
A子类可以从父类中继承其所有的成员。
B无论是否声明，子类都继承自object(System.object)类。
C假如，类M继承自类N，而类N又继承自类P，则类M也继承自类P。
D子类应是对基类的扩展。子类可以添加新的成员，但不能出去已经继承的成员的定义。
298、开发基于C#的Windows应用程序需要引用哪个名空间（B）？
A System B System.Forms C System.Collections D System.Data
299、消息对话框不是放置到窗体上的，是使用MessageBox .（B）方法显示出来的。
A．Move B．Show C．Control D．Load
300、下列选项中，（ C）是引用类型。
A.enum类型 B.struct类型 C.string类型 D.int类型
填空
1、要使TextBox控件显示给定的文字“Hello”，应在设计状态下设置它的___Text____属性值。
2、要在控制台程序运行时输入信息，可使用Console类的__Readline()或Read（）_____方法。
3、在switch语句中，在分支的最后应有一条___Default___语句。
4、数组定义与赋值语句如下：int [] a={11,22,53,84,95};则a[0]的值是___11_____。
5、定义方法时使用的参数是____形参____，调用方法时使用的参数是____实参____。
第 3 页
共 6 页
6、下列方法的作用是求两个数的较小数，并把较小的数作为返回值，请填空
double min_v(__double a,double b;____)
{
double min;
min=a;
If(min<b) min =b;
_ return min_____;
}
7、已知某类的类名为ClassName，则该类的构造函数名为____public ClassName()____。
8、在声明类时，在类名前__abstract______修饰符，则声明的类只能作为其他类的基类，不能被实例化。
9、表示是否显示控件的属性是___Visible_____。
10、控件取得焦点发生的事件是__GetFocus______。
11、按钮控件的常用事件是_ Click_______。
12、如果TextBox控件中显示的文本发生了变化将会发生____TextChanged____事件。
13、要给属性对应的数据成员赋值，通常要使用set访问器，set访问器始终使用_____value___来设置属性的值。
1、操作符（ && ）被用来说明两个条件同为真的情况。
2、接口只能定义方法，实现要由（ 类 ）完成。
3、任何事物都是（对象），它可以是现实世界中的一个物理对象，可以是抽象的概念或规则。
4、（ += ）运算符将左右操作数相加的结果赋值给左操作数。
5、（ Array ）是所有数组的基类。
6、如果一个属性里既有set访问器又有get访问器，那么该属性为（ 读写 ）属性。
7、如果一个属性里只有set 访问器，那么该属性为（ 只写 ）属性。
8、常量通过关键字（ const ）进行声明。
9、在C#中，进行注释有两种方法：使用//和使用“/* */”符号对，其中（ // ）只能进行单行注释。
10、布尔型的变量可以赋值为关键字（ true ）或（ false ）。
11、System.Array有一个（ Length ）属性，通过它可以获取数组的长度。
12、如果一个类包含一个或多个抽象方法，它是一个（ 抽象 ）类。
14、设x=10; 则表达式 x<10?x=0:x++ 的值为（ 10 ）。
16、已知整型变量a=5,b=4,c=6,则a>b?(a>c?a:c):b的结果为（ 6 ）。
17、在C#语言中，实现循环的主要语句有while, do-while, for和( foreach )语句。
19、在C#语言中，可以用来遍历数组元素的循环语句是（ foreach ）。
20、（ 多态 ）是指同一个消息或操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
22、（ 封装 ）是用一个框架把数据和代码组合在一起，形成一个对象。
23、声明为（ private ）的一个类成员，只有定义这些成员的类的方法能够访问。
24、（ 构造函数 ）提供了对对象进行初始化的方法，而且它在声明时没有任何返回值。
26、在C#中实参与形参有四种传递方式，它们分别是（ 值参数 ）（ 引用参数 ）（ 输出参数 ）和（ 参数数组 ）。
27、数组是一种（ 引用 ）类型。
28、类的数据成员可以分为静态字段和实例字段。（静态字段）是和类相关联的，（实例字段）是和对象相关联的。
33、关键字（ Readonly ）表明对象或者变量在初始化后不可修改。
35、面向对象语言都应至少具有的三个特性是 封装、（ 继承 ）和多态。
36、C#虽然不支持多重继承，但提供了另一种类似的机制是（ 接口 ）。
41、类是引用类型，而结构是（ 值类型 ）。
42、在do-while循环结构中，循环体至少要执行（ 1 ）次。
47、C#语言源代码文件的后缀名是（ .cs ）。
48、在循环结构中，continue语句的作用是（结束本次循环，继续下一次循环）。
51、C#通用类型系统CTS分为（ 值类型 ）和（引用类型）。
55、属性窗口的属性可以按（分类）顺序和按字母顺序排列。
56、当进入VS集成环境，如果没有显示“工具箱”窗口，应选择（视图）菜单的“工具箱”选项，以显示工具箱窗口。
57、每个枚举成员均具有相关联的常量值，默认时，第一个枚举成员的关联值为（0）。
58、结构的默认值是通过将所有值类型字段设置为它们的默认值，并将所有的引用类型字段设置为（null）。
61、当在程序中执行到（continue）语句时，将结束所在循环语句中循环体的一次执行。
62、在switch语句中，每个语句标号所含关键字case后面的表达式必须是（常量表达式）。
63、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成（死循环）
64、C#数组元素的下标从（0）开始
65、若要在文本框中输入密码，常指定（PasswordChar）属性。
68、Console.WriteLine(“RP”);和Console.Write(“RP”);的区别是（第一个输出RP后换行，
第二个不换）。
69、c#中bool类型只有两个值分别是_（true）和(false)。
71、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成( 死循环 )。
72、传入某个属性的SET方法的隐含参数的名称是（value）
75、委托声明的关键字是（delegate）。
76、在实例化类对象时，系统自动调用该类的( 构造函数 )进行初始化。
77、要使Lable控件显示给定的文字“您好”，应在设计状态下设置它的（ Text ）属性值
78、在C#程序中，程序的执行总是从（ Main（） ）方法开始的
80、要在控制台程序运行时输入信息，可使用Console类的（ ReadLine ）方法。
81、在循环执行过程中，希望当某个条件满足时退出循环，使用（ break ）语句。
82、数组定义与赋值语句如下：int []a={1,2,3,4,5};则a[2]的值是（ 3 ）
83、下列程序段执行后，a[4]的值为（ 4 ）。 int []a={1,2,3,4,5};a[4]=a[a[2]];
84、要定义一个3行4列的单精度型二维数组f，使用的定义语句为（float[,] f=new float[3,4]; ）
85、定义方法时使用的参数是（ 形参 ），调用方法时使用的参数是（ 实参 ）。
86、数据类型说明符用来说明方法返回值的类型，如果没有返回值，则其类型说明符应为（ void ）。
87、C#中的字符串有两类，规则字符串和逐字字符串，定义逐字字符串时，应在其前面加上（ @ ）号。
88、在类的成员声明时，若使用了（ protected）修饰符则该成员只能在该类或其派生类中使用。
89、类的静态成员属于（ 类 ）所有，非静态成员属于类的实例所有。
90、要给属性对应的数据成员赋值，通常要使用set访问器，set访问器始终使用（ value ）来设置属性的值。
91、在声明类时，在类名前使用（abstract）修饰符，则声明的类只能作为其他类的基类，不能被实例化。
94、get访问器必须用（return）语句来返回。
95、C#中的属性通过（get）和(set)访问器来对属性的值进行读和写。
96、已知有类MyOwnClass，则其默认的构造函数为（MyOwnClass）。
98、当在程序中执行到 （break）语句时，将结束本层循环类语句或switch语句的执行。
101、通过( interface )关键字定义一个接口，通过( ： )关键字实现接口。
102、设x为int型变量，请写出描述“x是奇数”的C#语言表达式（ x%2==1 ）。
104、在C#中，可以标识不同的对象的属性是（Name）。
106、浮点类型包括（float）、（double）和（decimal）。
107、枚举类型使用（enum）关键字声明。
108、在switch语句中，（default）语句是可选的，且若存在，只能有一个。
109、break语句只能用于循环语句或（switch）语句中。
110、如果 int x的初始值为5，则执行表达式x-=3之后，x的值为（ 2 ）。
111、（*=）运算符将左右操作数相乘的结果赋值给左操作数。
112、存储整数型变量应该使用关键字（int）来声明。
113、在带有（&&）操作符的语句中，如果其中两个条件都为真，则语句为真。
114、（类）是具有相同或相似性质的对象的抽象。
115、（属性）是对现实世界中事物特征进行的抽象。
116、（封装）是指使用抽象数据类型将数据和基于数据的操作包装在一起。
117、类的访问修饰符（public）表示公共的访问级别，对所有其它类可见。
118、只读字段声明为（readonly）关键字。
119、常量被声明为字段，声明时在字段的类型前面使用（const）关键字。
121、有时不能确定一个方法的方法参数到底有几个，可以使用（params）关键字解决这个问题。
122、out和ref关键字类似，不同之处在于（ref）要求变量在作为参数传递之前必须进行初始化，而（out）不需要初始化。
123、（Main（））方法是程序的入口点，程序控制在该方法中开始和结束。
124、方法签名由（方法名称）和参数列表组成。
125、（继承）是指派生类可以获得其基类特征的能力。
128、在C#中创建一个对象，系统最先执行的是（构造函数）中的语句。
129、结构化的程序设计的3种基本结构是（顺序结构），（选择结构）和（循环结构）。
130、8/3的结果是（2）。
131、具有n+1个元素的数组的索引是0－（n）。
134、在C#中每个short类型的变量战胜（4）个字节的内存
136、（CTS或通用类型系统）保证在.NET开发中不同的语言类型之间的相互兼容。
137、在类的定义中，类的（方法）描述了该类的对象的行为特征。
138、使用（sealed）关键字修饰的类，可以避免类被继承。
139、在定义类时，如果希望类的某个方法能够在派生类中进一步进行改进，以处理不同的派生类的需要，则应将该方法声明为（virtual）。
140、在C#中实参与形参有四种传递方式，它们分别是值参数、引用参数、 输出参数和参数数组。
143、C#程序的基本单位是（语句）。
144、类的以下特性中，可以用于方便地重用已有的代码和数据的是（继承）。
145、在Array类中，可以对一维数组中的元素进行排序的方法是（Sort）。
146、C#是一种面向（对象）的语言。
147、在C#中，可以标识不同的对象的属性是（Name）。
148、继承具有（传递性），即当基类本身也是某一类的派生类时，派生类会自动继承间接基类的成员。
149、StreamWriter的（WriteLine）方法，可以向文本文件写入一行带回车和换行的文本的。
154、C#中执行下列语句后，int n=21; n<<=1;n的值为（ 42 ）
155、在Visual Studio.NET窗口，（ 解决方案资源管理器 ）窗口显示了当前Visual Studio解决方案的树型结构。
156、在编写C#程序时，若需要对一个数组中的所有元素进行处理，则使用（ foreach循环）循环体最好。
159、C#中每个char类型量占用（ 2 ）个字节的内容。
161、在C#程序中，显示一个信息为“This is a test!”，标题为“Hello”的消息框，语句是（ MessageBox.Show(“this is a test!”,”Hello”); ）
163、Microsoft ADO.NET框架中的类主要属于（ System.Data ）命名空间？
164、在C#中，引用命名空间System的语句是（ using System; ）
165、float f=-123.567F; int i=(int)f.则i的值现在是（-123）。
166、委托声明的关键字是（delegate）。
167、要想在输出中换行，可以使用（\n）转义字符。
169、优先级最高的运算符是（( )）。
170、类的protected类型成员只允许在（ 当前类）和(其子类）被直接访问。
172、静态属性只能通过（类）调用。
173、类的方法声明中，若没有显式指定方法的访问修饰符，则默认为（private）。
174、在Visual Studio中双击窗体中的某个按钮，则会自动添加该按钮的（Clicked）事件。
176、通过Visual Studio主菜单中“视图 | （属性窗口）”菜单项可以控制“属性”面板的显示或隐藏。
179、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成（死循环）。
180、在c#的条件判断语句switch case结构中，（default）子句用于指定在找不到匹配项时执行的动作。
181、在以下C#类中，（Console）是控制台类，利用它我们可以方便的进行控制台的输入输
出。
182、Console是C#语言中的控制台类，它负责向控制台输出不同格式的字符串，在格式字符串中，可以使用（\t）来实现水平制表输出
184、C#语句末尾必须使用（；或分号）。
185、在类作用域中能够通过直接使用该类的（任何 ）成员名进行访问。
187、C#中，使用（string）关键字来声明一个字符串。
188、String类的（Compare）方法实现的功能是比较两个字符串的值。
189、C#的值类型包括简单类型、结构类型和枚举类型。
192、对于定义为bool基本数据的数组，所有的元素都被默认初始化为（false）。
193、开发C#程序的集成开发环境是（Visual Studio .NET）。
194、在C#中，用（{}）开始和结束方法体。
195、（object）类是所有类的基类。
197、在实例化对象时，系统自动调用该类的（构造函数）进行初始化。
198、在C#中类的实例化需要使用的关键字是（new）。
212、在类的成员声明时，若使用（protected）修饰符，则该成员只能在该类或其派生类中使用。
214、在声明类时，在类名前加（abstract）修饰符，则声明的类只能作为其他类的基类，不能被实例化。
215、在循环执行过程中，希望当某个条件满足时退出循环，使用（break）语句。
216、按钮控件的常用事件是（Click或单击）事件。
219、C#语言规定变量在使用之前必须先（声明）后使用。
220、在C#语言中，系统命名空间使用（using ）关键字导入。
221、C#中的表达式类似于数学运算中的表达式，是由操作符、操作对象和（运算符）等连接而成的式子。
222、表达式“4*10>=65”的值为（false）。
223、计算表达式“10==10&&10>4+3”的结果为（true）。
224、计算表达式“10*10*10>10||2<2+3”结果为（true）。
225、循环语句“for（int i=30;i>=10;i=i-3）”循环次数为（7）次。
226、对于do-while循环结构，当while语句中的条件表达式的值为（false）时结束循环。
227、跳转语句中的（goto）语句可以将程序控制直接转移到标号指定的语句。
228、C#语言中的结构类型采用（struct）来进行声明。它是一系列相关的但类型不一定相同的变量组织在一起构成的。
229、数组内的值都具有相同的（类型）。
231、派生类的对象对它的基类成员中的（ 私有或private ）成员是不可访问的。
233、点击“工具箱”窗口中的“下箭头”按钮后，可以选择的窗口停放样式有（停靠）、（浮动）和（隐藏）。
234、有一个字符串的定义为string s = “hello world!”; 在此字符串中，字符w的索引是（6）。
235、Windows窗体应用程序的编程模型主要由（窗体）、（控件）和（事件）。
237、在类的定义中，类的（ 方法 ）描述了该类的对象的行为特征。
238、如果未显式赋值,则将整型值（ 0 ）赋给枚举中的第一个元素
239、用来定义事件的关键字是（event ）。
240、在.NET中，一些数据类型为引用类型，当引用类型的值为（null）时，表明没有引用任何对象。
241、在C#中,用来表示回车的转义字符是（\n）。
242、在C#中,布尔类型的关键字是（ bool ）。
243、在C#中byte类型所占用的内存空间是（2）个字节。
245、C#中的三元运算符是_ ？_：____。
246、使用Message.Show( )方法可以显示消息框，消息框的返回值是一个 DialogResult 类型。
248、C#中，使用（属性）的功能来读写类中的字段，从而便于为这些字段提供保护。
249、所有的Windows窗体控件都是从System.Windows.Forms. Control_类继承而来，它公开的成员主要包含：____属性____、__事件____、__方法_____。
250、在windows程序中，若想选中复选框，则应将该控件的_____Checked_________属性设置为true。
251、实现密码框功能的方法是将TextBox控件的____PasswordChar___属性赋予屏蔽字符
253、当进入Visual Studio集成环境，如果没有显示“工具箱”窗口，应选择“（_视图_）_”菜单项的“工具箱”选项，以显示“工具箱”窗口。
254、属性窗口的属性可以按（分类 ）顺序和按字母顺序排列。
255、类声明后，可以创建类的实例，创建类的实例要使用（new）关键字，类的实例相当于一个变量，创建类的实例的格式如：（类名 对象名= new 对象名（））
256、C#的类定义中可以包含两种成员：静态成员和非静态成员。使用（static）关键字修饰的是静态成员，反之为非静态成员。
259、声明一个10行20列的二维整形数组的语句为：（int[,] a=new int[10,20]）。
260、构造函数在（创建对象）时被调用。
261、 Random.Next 方法用来产生随机数。
262、 索引函数 能够以数组的方式来控制对多个变量的读写访问。
263、被调用的方法中的 return 语句可以用来向调用方法传递表达式的值。
264、在C＃中，下列for循环的运行结果是（12345）。
for(int i=0;i<5;i++)
{
Console.Write(++i);
}
265、在C＃中，下列代码的运行结果是（654321）。
for(int i=6;i>0;i--)
{
Console.Write(i--);
}
266、在C＃中，下列代码的运行结果是（246）。
int []price = new int[]{1,2,3,4,5,6};
foreach(int p in price)
{
if(p%2==0)
Console.Write(p);
}
267、一般将类的构造方法声明为 public或公有 访问权限。如果声明为private，就不能创建该类的对象。
268、C#数组类型是一种引用类型，所有的数组都是从System命名空间的 object 类继承而来的引用对象。
271、在switch语句中，每个语句标号所含关键字case后面的表达式必须是 常量表达式 。
272、确定两个类继承关系的符号是 : 。
273、不可继承的类，使用 sealed 关键字定义。
274、不指定基础类型的枚举的直接量为 int 类型的值 。
275、专门产生伪随机数的类是 Random 类。
276、专用于数组和集合的循环语句是 foreach 。
277、方法重载是指类的两个或两个以上的方法___同名_____，但形式参数列表不同的情况。
278、下面程序段执行后，sum的值为 11
int i,sum=0;
for(i=0,sum=0;i<=10;i++,sum++);
279、下面循环语句的执行次数为 6 次 。
for(int i=0;i<=10;i+=2){}
281、SubString()函数的功能是 （获取子字符串）。
282、表达式 2+5/10*10 的值为（2）。
284、类是一种数据结构，它使用 class 关键字声明。
285、类声明后，可以创建类的实例，创建类的实例要使用 new 关键字。类的实例相当于一个变量。创建类的实例的格式如：类名 对象名= new 对象名（） 。
287、创建新对象时将调用类的 构造函数 。它主要用来为对象分配存储空间，完成初始化操作。
288、抽象类使用关键字 abstract 来声明。
289、派生类构造函数的执行顺序是从最上面的（基类）开始，直到最后一个（派生类）结束。
292、类的定义使用关键字（class），定义结构使用关键字（struct）。
296、在类的成员声明时，若使用了（ protected ）修饰符则该成员只能在该类或其派生类中使用。
298、类的方法声明中，若没有显式指定方法的访问修饰符，则默认为（private）。
299、静态属性只能通过（类）调用。
300、数据类型转换分为（隐式转换）和（显式转换）两种。
1、C#中可以把任何类型的值赋给的object类型变量，当值类型赋给object类型变量时，系统要进行____装箱____操作；而将object类型变量赋给一个值类型变量，系统要进行____拆箱____操作，并且要求必须加___强制_____类型转换。
2、在C#中，进行注释有两种方法：使用“//”和使用“/* */“符号对，其中__//______只能进行单行注释。
3、在C#中，表达式Math.Pow(2,-2)的值是__0.25______。
4、在C#语言中，实现循环语句主要有__while语句______，__do-while语句______和____for语句____1、C#中可以把任何类型的值赋给的object类型变量，当值类型赋给object类型变量时，系统要进行____装箱____操作；而将object类型变量赋给一个值类型变量，系统要进行____拆箱____操作，并且要求必须加___强制_____类型转换。
2、在C#中，进行注释有两种方法：使用“//”和使用“/* */“符号对，其中__//______只能进行单行注释。
3、在C#中，表达式Math.Pow(2,-2)的值是__0.25______。
4、在C#语言中，实现循环语句主要有__while语句______，__do-while语句______和____for语句____
判断
1、在使用变量之前必须先声明类型。 √
2、if语句后面的表达式可以是任意表达式。 ×
3、switch语句中必须有default标签。 ×
4、基类的派生类中必须为基类中的抽象方法提供实现。√
6、由static修饰的成员必须由类来访问而不能通过对象访问。√
7、在C#中，一个类可以继承于多个类、多个接口。×
8、抽象类中所有的方法必须被声明为abstract ×
9、若方法的名字相同、参数相同，而方法的返回值类型不同，则可以实现方法的重载。×
10、继承能够实现代码的复用。√
11、布尔型变量可以赋值为0或1。 ×
13、在控制台应用程序中，若想从键盘上输入数据，可以使用Console.Read()和Console.ReadLine()方法。√
15、下列语句是否正确：for(int i=0 , i<10 , i++) Console.WriteLine(i); ×
16、Windows应用程序和Web应用程序都是通过事件触发的。 √
17、类的static成员可以通过该类的实例来引用 ×
18、有定义：int [ ] a=new int[5]{2,3,5,7,8}; 则a[5]的值为8。×
19、对象是人们要进行研究的任何事物在面向对象程序设计中的抽象。×
20、结构和类均为引用类型×
21、接口的成员默认为公有的，不允许加上修饰符 √
22、类只能继承一个类，但能继承多个接口。√
23、静态构造函数只能对静态成员初始化，不能对实例成员初始化。√
24、当方法的修饰符设为proteced时，表示该方法可以被处于同一个工程的文件访问。×
25、填充数据集应使用SqlDataAdapter的Update()方法×
26、foreach语句既可以用来遍历数组中的元素，又可以改变数据元素的值。×
27、命令对象的ExecuteScalar()方法是在获取单值的时候使用。√
28、定义类成员时，访问修饰符在默认情况下为public. ×
29、ReadOnly类型的变量只能在定义时初始化。 ×
30、在有继承关系的类中，当创建派生类的对象时，先调用派生类的构造函数，再调用基类构造函数。×
31、被sealed关键字修饰的方法不能被继承。√
32、属性必须同时定义get块和set块。 ×
33、有定义：int [ ] a=new int[5]{1,3,5,7,9}; 则a[3]的值为7。√
34、隐式枚举转换允许将十进制的整数转换为枚举类型的变量。×
35、类是对象的抽象，对象是类的实例。√
36、若想在派生类中重写某一方法，则应将该方法用sealed修饰。×
37、派生类可以同时继承一个基类和多个接口，代码可以如下编写：
public class EditBox: Control ; IControl ; IDataBound
{…} ×
38、“*=”运算符是计算右操作数的平方值，然后将结果存储在左操作数中 ×
39、C#中，在进行隐式转换时，可以将一个整数类型隐式转换为char类型的变量。×
40、类只能继承一个类，但能继承多个接口。 √
41、抽象类中所有的方法必须被声明为abstract ×
42、C#源代码的后缀名为.cs √
43、常量通过关键字const进行声明。 √
44、构造函数和析构函数均可以被显式调用。×
45、修饰方法参数的关键字ref和out的区别在于ref修饰的参数在调用方法之前就需要进行初始化。√
46、一个数组的元素可以是多种类型的数据。 ×
47 z=x>y?x:y的含义是获取x和y中的较大值并且赋给z。√
48、在带有“||”操作符的语句中，如果其中一个或两个条件都为真，则语句为真√
49、若想在标签中显示文字，则需设置标签的name属性。×
50、实例构造函数既可以对静态成员进行初始化，也可对实例成员初始化。√
51、以下的代码执行后，string类型变量a的值仍然是“original value”。×
string a=”original value”;
Private void b(string c)
{
c=”changed”;
}
b(a);
52、抽象方法在抽象类中被定义和实现，当派生类从抽象类中继承一个抽象方法时，派生类必须重写该抽象方法。×
53、C#中使用try-catch-finally异常处理机制捕捉和处理错误。（√）
54、类和对象的区别就是，类是对象的实例，而对象则是类的抽象。（×）
55、面向对象将数据和对数据的操作作为一个相互依赖，不可分割的整体，采用了数据抽象和信息隐蔽技术。√
56、 不能指定接口中方法的修饰符。√
57. DotNet包含两个部分，即公共语言运行库和框架类库。√
58. 在同一行上可以书写多条语句，每条语句间用分号分隔。√
59. 在数据类型转化时，只能通过类型转换关键字或Convert类实现。×
60. 在定义数组时不允许为数组中的元素赋值。×
61. 定义枚举时至少为其中的一个枚举成员赋值。×
62. 接口与类同样是面向对象程序设计的核心，是创建对象的模版。√
62. 委托是将方法作为参数传递给另一方法的一种数据类型。事件与委托没有关系。×
63. 如果要实现重写，在基类的方法中必须使用virtual关键字，在派生类的方法中必须使用overrides关键字。×
64. 静态类和实例类的区别在于：静态类不需要初始化即可直接使用，实例类需要进行实例化，生成对象才可使用。√
65. 用Interval属性设置Timer控件Tick事件发生的时间间隔单位为秒。×
66可以重写私有的虚方法。×
67. 在C#中，所有类都是直接或间接地继承System.Object类而得来的。√
68.在C#中，子类不能继承父类中用private修饰的成员变量和成员方法。
69、c#面向对象的程序语言特点：代码好维护，安全，隐藏信息 √
70、类和对象的区别在于万物都是对象，是个实体，而概念是个类上的描述 ×
71、c#面向对象的程序语言有继承性和多态性还有封装性 √
72、接口不能通过方法来实现 √
73、C#中的数据类型分为简单类型和引用类型 √
74、C#是一种安全的、稳定的、简单的、优雅的，面向对象的编程语言。√
75、C#不是由C和C++衍生出来的面向对象的编程语言。 ×
76、C#源程序文件一般用.cs作为扩展名 √
77、C#中所有的类型实质上都是从（object）类派生而来的。 √
78、结构是值类型，而类是引用类型。 √
79、静态方法访问类的attribute时，可以访问类的所有属性。×
80、静态方法不能被派生类重载。√
81、camel命名法是首字符大写，后续的每个词首字符大写，而其他字符则小写 ×
82、在c#中，变量被声明时并同时被自动赋予初始值，在访问变量前，必须明确的为其赋值 ×
83、c#是大小写不敏感的语言 ×
84、为了明确告诉c#编译器我们愿意接受精度损失，必须进行显示转换，把表达式值转换为括号里的目标类型 √
85、方法头包括方法名称、可选的传入形式参数和方法的返回类型 √
86、较好的编程习惯是在一个方法体中包含多个return语句 ×
87、Pascal命名方法是名称的第一个字母大写，后面的每个单词首字母大写，其他字母小写
√
88、所有类和方法名都是用pascal命名方法 √
89、接口实现类必须提供接口所申明的所有方法 √
90、抽象类要比具体类更接近于抽象类型 √
91、通过提供对抽象类申明的所有抽象方法的非抽象实现，就能从抽象类派生出新类 √
92、结对关系的概念只适用于关联，不适用于链接。√
93、实现接口是一种“要么全要，要么不要”的事情。√
94、Camel命名法是用于公共attribute的名称。 ×
95、参数是一个本地变量，在方法头中申明，当方法开始执行时出现。√
96、聚合是一种特殊形式的关联。√
97、继承是一种强大的机制，他通过指出新旧类之间的不同之处，在旧类的基础上定义一个新类 √
98、和用点符号向对象传递消息一样，我们也可以用点符号存取一个对象的attribute。 √
99、在类间或对象间存在不同的结构关系 √
100、在所有情况下，存取作用范围，返回值和方法签名必须保持一致，这样覆盖才会起作用。√
101、用foreach遍历群集时能够用break跳出循环。×
102、关于对象的访问，对象A向对象B传递消息的唯一途径是A能访问B的句柄。√
103、构造器的名称，可以与所属类的名称不一样。×
104、C#支持多重继承。×
105、一切类的基类是object类，并且可以直接继承它。√
106、C#中已经不包含指针。√
107、抽象类里的方法一定不能含有实现。×
108、精度最高的预定义类型是浮点类型。×
109、Object类的Equals方法可以用来判断两个整型值时候相等。×
110、一旦进入一个foreach代码块，就不能试图修改foreach引用变量的值。√
111、C#群集，除Array外，都被设计成能持有一般对象。√
112、ArrayList能够包含任何类型的元素，但不能混合放置不同类型的对象。×
113、C#中一个类可以实现多个接口。
114、接口的实现类必须提供接口所有声明的所有方法的具体版本，这样才能满足编译器的要求。√
115、当一个类实现一个接口时，实现该接口的类通过覆载的手段实现接口。×
116、从抽象类派生的类不一定要覆载所有的抽象方法、提供具体版本；如果一个或多个抽象单发没有被覆载，则该派生类也是一个抽象类。（√
117、如果一个类实现的两个或多个接口中的方法拥有同样的方法签名，则在实现列中只需要实现其中一个。√
118、接口中可以定义方法，还可以定义属性。√
119、静态方法不能被声明为抽象方法。√
120、在C# 编程环境中，常量的值可以在代码中被修改。×
121、C#程序的执行是从第一个方法开始，到Main方法结束。×
122、Main方法的返回值类型必须是void 的类型。×
123、else语句总是与离他最近的一个if语句相匹配。×
124、C# 程序中使用0表示逻辑非 ×
125、C# 关于switch 小括号中表达式可以是字符串类型 ×
126、在一个类中，可以有多于一个的构造函数。√
127、在一个类中，静态构造函数在运行时仅能被引用一次。√
128、一个类不能有多于一个的派生类。×
129、继承通过添加另外的特征给派生类，从而增加了基类的功能。×
130、不能指定接口中方法的修饰符。 √
131、DotNet包含两个部分，即公共语言运行时和框架类库。 √
132、在定义数组时不允许为数组中的元素赋值。 ×
133、定义枚举时至少为其中的一个枚举成员赋值。 ×
134、如果要实现重写，在基类的方法中必须使用virtual关键字，在派生类的方法中必须使用overrides关键字。 ×
135、静态类和实例类的区别在于：静态类不需要初始化即可直接使用，实例类需要进行实例化，生成对象才可使用。 √
136、可以重写私有的虚方法。 ×
137、在C#中，所有类都是直接或间接地继承System.Object类而得来的。 √
138、在C#中，子类不能继承父类中用private修饰的成员变量和成员方法。 √
139、可以阻止某一个类被其他类继承。 √
140、一个类可以有多个基类和多个基接口。 ×
141、在接口的成员中，可以包含常量。×
142、构造函数名必须和类名相同。√
143、构造函数可以声明返回值类型。×
144、构造函数不能带参数。√
145、构造函数不可以重载×
146、方法重载可以扩充现有类的功能√
147、方法ConsoleW(int _value)是方法ConsoleW(string _value)的重载√
148、方法重载即“同样的方法名但传递的参数不同” √
149、try、catch、finally三个字句必须同时出现，才能正确处理异常×
150、catch字句能且只能出现一次×
151、try字句中所抛出的异常一定能被catch字句捕获×
152、无论异常是否抛出，finally子句中的内容都会被执行。√
153、子类可以从父类中继承其所有的成员。×
154、无论是否声明，子类都继承自object(System.object)类√
155、假如，类M继承自类N，而类N又继承自类P，则类M也继承自类P。√
156子类应是对基类的扩展。子类可以添加新的成员，但不能出去已经继承的成员的定义√
157、switch语句可以出现default标签，也可以不出现default标签√
158、switch语句的控制表达式可以是任何数据类型×
159、switch语句中case标签结束可以有跳转语句，也可以没有。×
160、switch中可以有两个或两个以上的case标签的常量与控制表达式的值相同×
161、for 循环只能用于循环次数已经确定的情况×
162、for 循环是先判定表达式,后执行循环体语句√
163、for 循环中,可以用 break语句跳出循环体√
164、for 循环体语句中,可以包含多条语句,但要用花括号括起来√
165、结构属于引用类型，字符串属于值类型×
166、所有内置的数据类型都是值类型，所有用户定义的数据类型都是引用类型×
167、值类型变量直接存放真正的数据，引用类型变量存放的是指向真正数据的内存地址√
168、允许有多个不相同名称的构造函数×
169、允许有多个相同名称的构造函数√
170、在C#类中至少要有一个构造函数×
171、 要求构造函数至少有两个参数×
172、构造函数的名称与类名称一样√
173、构造函数在对象销毁时自动执行×
174、一个类中,只能有一个构造函数×
175、foreach语句能使你不用索引就可以遍历整个数组√
176、foreach语句总是从索引1遍历到索引Length×
177、foreach总是遍历整个数组√
178、如果需要修改数组元素就必须使用for语句√
179、枚举型是值类型，它是一组称为枚举数列表的命名常量组成的独特类型√
180、枚举型的默认基础类型为int，第一个枚举数的值必须为0，后面每个枚举型的值依次递增1×
181、重写虚方法时可以为虚方法指定别称×
182、虚方法是实现多态的唯一手段×
183、多态性是指以相似的手段来处理各不相同的派生类。√
184、定义一个接口，接口名必须使用大写字母I开头√
185、接口可以被类继承，本身也可以继承其他接口。√
186、接口像类一样，可以定义并实现方法×
187、类可以继承多个接口，接口只能继承一个接口×
188、派生类可以继承多个基类的方法和属性。×
189、参数数组所对应的实参的个数是不固定的√
190、参数数组的声明同普通数组一样×
191、参数数组必须是一维数组√
192、参数数组必须是函数的最后一个参数｡√
193、对象之间通过消息进行信息传递√
194、面向对象方法的核心是继承
195、构造函数不可以用private修饰×
196、构造函数可以设置缺省参数√
197、派生类对象可以不受限制地访问所有的基类对象 ×
198、异常类对象均为System.Exception类或其子类的对象 √
199、实现接口的类必须实现接口中定义的所有方法。 √
200、返回值类型、参数个数和类型都相同的函数也可以重载。×
201、使用关键字sealed声明的类不能是基类。Sealed是密封类，不能改写还有继承 √
202、在抽象类中不能包含非抽象成员。 ×
203、具有抽象方法的类必须声明为abstract。 √
204、类的静态数据成员需要在定义每个类的对象时进行初始化。×
205、基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能被其它的函数访问。×
206、类的保护成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。 ×
207、不同的命名空间中不能有同名的方法。 ×
208、在C#中，int[][]是定义一个int型的二维数组. ×
209、C#中标识符内的大小写字母是没有区别的。（×）
210、在C#中可使用 new 修饰符显式隐藏从基类继承的成员。√
211、Office2007属于系统软件（×）
212、Vista是系统软件（√）
213、计算机软件系统一般包括管理软件和应用软件（×）
214、Web购物系统属于系统软件（×）
215、派生类重写基类的虚方法时，可改变方法的参数个数。 ×
216、抽象类不能实例化且不能用sealed关键字修饰。 √
217、类的static成员可以通过该类的实例来引用。 ×
218、类的属性成员必须是可读写。 ×
219、抽象类和接口都不能被实例化（√）
220、基类的构造函数不能被派生类继承（√）
221、构造函数可以声明为虚函数。（×）
222、计算机软件是指令、数据和代码的集合（√）
223、当程序中只需要进行两个选择，一般采用if…else…语句。（√）
224、当程序中有两个以上的选择要选时，可以采用switch…case…语句。（√）
225、在程序中switch…case…语句可以代替if…else…语句。（×）
226、“解决方案管理器”窗口可以用来浏览当前项目中所有的文件、名字空间和类。（×）
227、C#中声明变量规则不能用“@#!$%”等除了“_”以外的符号作为变量名。（√）
228、“>>”运算符是位移操作符。（√）
229、在C#中,声明一个变量 int abc，不给abc付值直接使用abc，它将获得默认值1。（×）
230、const字段的值是在编译时确定的（√）
231、const字段的值是在运行时才确定的（×）
232、static字段的值是在运行时才确定的（√）
233、面向对象中类的定义是具有相同或相似性质的对象的抽象（√）
234、readonly字段只能在初始化期间或是在构造函数中赋值（√）
235、面向对象的程序设计是以要解决的问题中所涉及的各种对象为主要矛盾的（√）
236、C、C++、C#这三个语言都是面向对象的程序设计语言（×）
237、计算机编程中主要有两种抽象型式：过程抽象和数据抽象，面对对象的编程主要采用过程抽象的方法。（×）
238、派生类可以同时继承一个基类和多个接口，代码可以如下编写：
public class EditBox: Control ; IControl ; IDataBound
{…}（×）
239、基类的派生类中必须为基类中的抽象方法提供实现。（√）
240、abstract方法的声明必须同时实现（×）
241、接口像类一样，可以定义并实现方法（×）
242、派生类是基类的扩展，派生类可以添加新的成员，也可去掉已经继承的成员（×）
243、继承是指派生类可以获取其基类特征的能力（√）
244、在派生类中重写基类方法必须使用 override 关键字（√）
245、抽象类可以作为基类，所以不能直接实例化，也不可以被密封（√）
246、C#的异常处理机制中try块和catch块都是必不可少的，finally块是可以省略的。×
247、在派生于System.Exception异常类层次结构中, 用来派生出自己定义的异常类是ApplicatonException。（√）
248、在派生于System.Exception异常类层次结构中, 用来派生出自己定义的异常类是System.SystemException。（×）
249、数组在创建实例时已经被编译器初始化了默认值，因此可以直接访问；（×）
250、可以不使用new关键字来对数组进行初始化（√）
251、允许创建大小为0的数组（√）
252、数组在访问之前必须初始化。（√）
253、数组元素的访问是从1开始，到Length结束；（×）
254、如果使用的整数索引小于0，或者大于数组的大小，编译器将抛出一个IndexOutOfRangeException异常；（√）
255、对数组元素的所有访问都要进行边界检查（√）
256、开发人员不需要创建MessageBox类的实例，只需调用Show()方法既可显示消息框√
258、如果实现重写，在基类的方法中必须使用virtual关键字，在派生类的方法中必须使用overrides关键字。（×）
259、用Interval属性设置Timer控件Tick事件发生的时间间隔单位为秒。（×）
261、在C#中，装箱操作是将引用类型转化成值类型。（×）
262、.NET包含两个部分：公共语言运行库和类库。（√）
263、在定义数组时不允许为数组中的元素赋值。（×）
264、定义枚举时至少为其中的一个枚举成员赋值（×）。
265、接口和类相同是面向对象程序设计的核心，是创建对象的模板。（√）
266、委托是将方法作为参数传递给另一方法的一种数据类型，事件与委托没有联系。（×）
267、如果不带修饰符，C#中类成员被默认声明成public。（×）
268、构造函数和方法都可以进行重载。√
269、任何运算符都可以进行重载 （×）
270、重载是继承的形式之一（×）
271、在面向对象编程的思想中，类是相同或者相似对象的抽象。√
272、静态类和实例类的区别在于：静态类不需要初始化即可直接使用，实例类需要进行实例化，生成对象才可使用。√
273、菜单项标题中有含有带下划线的字符，这是快捷键。（×）
274、在C#中，子类不能继承父类中用private修饰的成员变量和成员方法。√
275、.在C#中，所有类都是直接或间接地继承System.Object类而得来的。√
276、函数是C#程序的基本单位。（×）
277、在类作用域中能够通过直接使用该类的任何成员名进行访问。√
278、C#语言中，值类型包括：基本值类型、结构类型和枚举类型。√
280、salary属于C#语言的关键字。（×）
281、在C#中，接口可以被多重继承而类不能。√
282、接口中的成员不可以有访问域修饰符，但可以有其它修饰符。×
283、在C#中，装箱操作是将值类型转化成引用类型√
284、任何事物都是对象。√
285、析构函数是自动调用的，它也可以被显式调用。×
286、用ref修饰符声明的形参是引用形参。√
287、用out修饰符声明的形参是输出形参。√
288、从用户的角度看，变量是存储信息的基本单元，在变量中可以存储各种类型事物信息√
289、如果在try块之后没有任何catch块，那么finally块也是可选的。×
290、当创建派生类对象时，先执行基类的构造函数，后执行派生类的构造函数。√
291、如果基类没有默认的构造函数，那么其派生类构造函数必须通过base关键字来调用基类的构造函数。√
292、对象与对象之间的关系可以分为三类：包含、继承和关联。√
293、在C# 2005编程环境中，int32型变量可以直接隐式的转换成char型变量。×
294、“+，-，*，/，%”均属于三元运算符。×
295、属性就是实体特征的抽象，比如，对象猫可以有重量，身长等属性。√
296、在同一行代码或同一段语句中，等于运算符的优先级别高于关系运算符。√
297、.NET Framework运行环境除了支持VB.net和C#两种编程语言，还支持Perl、C++.NET、J#、Jscript.NET、ActionScript。×
298、在C#中可以使用String作为变量名，但不能使用string作为变量名。√
299、在C#中，每个方法都必须定义为类或结构的成员。√
300、在一个程序内，不可以包含2个及以上的Main方法。√