【收藏】C#面试题整理笔试篇（最全1000+道带答案）300道填空 + 300道选择 + 300道判断 + 70道读程序写结果和看程序填空 + 100道简答题_c#题目1000题

作者：盐析白兔 | 2024-07-29 00:47:30

踩

c#题目1000题

在这里插入图片描述
《程序员》曾陪伴了无数开发者成长。《新程序员》全新归来，推荐给大家！
《新程序员》
一、填空：

1、操作符（ && ）被用来说明两个条件同为真的情况。
2、接口只能定义方法，实现要由（类）完成。
3、任何事物都是（对象），它可以是现实世界中的一个物理对象，可以是抽象的概念或规则。
4、（ += ）运算符将左右操作数相加的结果赋值给左操作数。
5、（ Array ）是所有数组的基类。
6、如果一个属性里既有set访问器又有get访问器，那么该属性为（读写）属性。
7、如果一个属性里只有set 访问器，那么该属性为（　只写　）属性。
8、常量通过关键字（ const ）进行声明。
9、在C#中，进行注释有两种方法：使用//和使用“/* /”符号对，其中（ // ）只能进行单行注释。
10、布尔型的变量可以赋值为关键字（ true ）或（ false ）。
11、System.Array有一个（ Length ）属性，通过它可以获取数组的长度。
12、如果一个类包含一个或多个抽象方法，它是一个（抽象）类。
13、SQL语句中删除一个表中记录，使用的关键字是（ delete ）。
14、设x=10; 则表达式 x<10?x=0:x++ 的值为（ 10 ）。
15、接口的实现指出接口成员所在的接口，称为显式接口成员，它只能通过（接口）来调用。
16、已知整型变量a=5,b=4,c=6,则a>b?(a>c?a:c):b的结果为（ 6 ）。
17、在C#语言中，实现循环的主要语句有while, do-while, for和( foreach )语句。
18、封装的对象之间进行通信的一种机制叫做（　消息传递　）。
19、在C#语言中，可以用来遍历数组元素的循环语句是（ foreach ）。
20、（多态）是指同一个消息或操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
21、Stack类表示对象的先（出）后（进）集合。
22、（封装）是用一个框架把数据和代码组合在一起，形成一个对象。
23、声明为（ private ）的一个类成员，只有定义这些成员的类的方法能够访问。
24、（构造函数）提供了对对象进行初始化的方法，而且它在声明时没有任何返回值。
25、在异常处理结构中，抛出的异常要用（ catch ）语句捕捉。
26、在C#中实参与形参有四种传递方式，它们分别是（值参数）（引用参数）（输出参数）和（参数数组）。
27、数组是一种（引用）类型。
28、类的数据成员可以分为静态字段和实例字段。（静态字段）是和类相关联的，（实例字段）适合对象相关联的。
29、在异常处理结构中，对异常处理的代码应放在（ catch ）块中。
30、在类的方法前加上关键字（　virtual ），则该方法被称为虚方法。
31、Timer控件的（Interval）属性，用来指定时钟空间触发时间的时间间隔，单位毫秒。
32、使用关键字（ abstract ）声明抽象类。
33、关键字（ Readonly ）表明对象或者变量在初始化后不可修改。
34、在windows程序中，若想选中复选框，则应将该控件的（Checked）属性设置为true。
35、面向对象语言都应至少具有的三个特性是封装、（继承）和多态。
36、C#虽然不支持多重继承，但提供了另一种类似的机制是（接口）。
37、数据库表中的每一行称为一条（记录）。
38、要关闭已打开的数据库连接，应使用连接对象的（ close 　）方法。
39、关闭数据库的连接，应使用连接对象的（close）方法。
40、数值转换是指在整数类型、（字符类型）和字符类型之间的转换。
41、类是引用类型，而结构是（值类型）。
42、在do-while循环结构中，循环体至少要执行（ 1 ）次。
43、（不规则数组）是数组的数组，它内部每个数组的长度可以不同，就像一个锯齿形状。
44、一个Web页面的扩展名为（ .aspx ）。
45、Web程序中的GridView控件和Windows程序的（DataGrid/DataGridView）控件类似。
46、SQL语句中的选择语句，使用的关键字是（ SELECT ）。
47、C#语言源代码文件的后缀名是（ .cs ）。
48、在循环结构中，continue语句的作用是（结束本次循环，继续下一次循环）。
49、集合类是由命名空间（ System.Collections ）提供。
50、在C#中，可以通过（ throw ）语句无条件抛出异常。
51、C#通用类型系统CTS分为（值类型）和（引用类型）。
52、C#通过（装箱）和（拆箱）机制，可以实现值类型和引用类型之间的转换。
53、（ListBox1.Items.Count）属性用于获取ListBox1控件中项的数目。
54、ComboBox控件的SelectedIndex属性返回对应于组合框中选定项的索引整数值，其中，第1项为（0），未选中为（-1）。
55、属性窗口的属性可以按（分类）顺序和按字母顺序排列。
56、当进入VS集成环境，如果没有显示“工具箱”窗口，应选择（视图）菜单的“工具箱”选项，以显示工具箱窗口。
57、每个枚举成员均具有相关联的常量值，默认时，第一个枚举成员的关联值为（0）。
58、结构的默认值是通过将所有值类型字段设置为它们的默认值，并将所有的引用类型字段设置为（null）。
59、所有的枚举默认都继承于（System.Enum）。
60、类是存储在（堆）上的引用类型，而结构是存储在（堆栈）上的值类型。
61、当在程序中执行到（continue）语句时，将结束所在循环语句中循环体的一次执行。
62、在switch语句中，每个语句标号所含关键字case后面的表达式必须是（常量表达式）。
63、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成（死循环）
64、C#数组元素的下标从（0）开始
65、若要在文本框中输入密码，常指定（PasswrodChar）属性。
66、c#支持的循环有(for)、(while)、(do while)和(foreach)循环。
67、一个类不可以多重继承几个父类但是可以多重继承（接口）。
68、Console.WriteLine(“RP”);和Console.Write(“RP”);的区别是（第一个输出RP后换行，
第二个不换）。
69、c#中bool类型只有两个值分别是_（true）和(false)。
70、（多态）是指两个或多个属性不同类的对象，对同一个消息做出不同响应的能力。
71、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成( 死循环 )。
72、传入某个属性的SET方法的隐含参数的名称是（value）
73、C#数组元素的下标从 (0)开始。
74、对于方法，参数传递分为值传递和 (引用传递)两种。
75、委托声明的关键字是（delegate）。
76、在实例化类对象时，系统自动调用该类的( 构造函数 )进行初始化。
77、要使Lable控件显示给定的文字“您好”，应在设计状态下设置它的（ Text ）属性值
78、在C#程序中，程序的执行总是从（ Main ）方法开始的
79、在C#中，进行注释有两种方法：使用“//”和使用“/ /“符号对，其中（ // ）只能进行单行注释。
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）修饰符，则声明的类只能作为其他类的基类，不能被实例化。
92、（ try ）块封装了可能引发异常的代码。
93、Exception类中有两个重要的属性：（ Message ）属性包含对异常原因的描述信息
94、get访问器必须用（return）语句来返回。
95、C#中的属性通过（get）和(set)访问器来对属性的值进行读和写。
96、已知有类MyOwnClass，则其默认的构造函数为（MyOwnClass）。
97、元素类型为double的2行5列的二维数组共占用（80）字节的存储空间
98、当在程序中执行到（break）语句时，将结束本层循环类语句或switch语句的执行。
99、元素类型为int的10个元素的数组共占用（40）个字节的存储空间。
100、要使Lable控件显示给定的文字“您好”，应在设计状态下设置它的（ Text ）属性值。
101、通过( interface )关键字定义一个接口，通过( ： )关键字实现接口。
102、设x为int型变量，请写出描述“x是奇数”的C#语言表达式（ x%2==1 ）。
103、C#中的字符串有两类，规则字符串和逐字字符串，定义逐字字符串时，应在其前面加上（ @ ）号。
104、在C#中，可以标识不同的对象的属性是（Name）。
105、在C#中，用来创建主菜单的对象是（MenuStrip）。
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）关键字。
120、（索引器）是一类特殊的属性，通过它们可以像引用数组一样引用自己的类。
121、有时不能确定一个方法的方法参数到底有几个，可以使用（params）关键字解决这个问题。
122、out和ref关键字类似，不同之处在于（ref）要求变量在作为参数传递之前必须进行初始化，而（out）不需要初始化。
123、（Main）方法是程序的入口点，程序控制在该方法中开始和结束。
124、方法签名由（方法名称）和参数列表组成。
125、（继承）是指派生类可以获得其基类特征的能力。
126、要在控制台程序运行时输入信息，可使用Console类的（ReadLine）方法。
127、在C#中类的默认访问修饰符是（internal）。
128、在C#中创建一个对象是，系统最先执行的是（构造函数）中的语句。
129、结构化的程序设计的3种基本结构是（顺序结构），（选择结构）和（循环结构）。
130、8/3的结果是（2）。
131、具有n+1个元素的数组的索引是0－（n）。
132、使用SqlDataReader一次可以读取（1）条记录。
133、使用（throw）关键字可以再次引发捕获到的异常。
134、在C#中每个short类型的变量战胜（4）个字节的内存
135、用鼠标右击一个控件时出现的菜单一般称为（快捷菜单）。
136、（CTS或通用类型系统）保证在.NET开发中不同的语言类型之间的相互兼容。
137、在类的定义中，类的（方法）描述了该类的对象的行为特征。
138、使用（sealed）关键字修饰的类，可以避免类被继承。
139、在定义类时，如果希望类的某个方法能够在派生类中进一步进行改进，以处理不同的派生类的需要，则应将该方法声明为（virtual）。
140、在C#中实参与形参有四种传递方式，它们分别是值参数、引用参数、输出参数和（参数数组）。
141、在C#中实参与形参有四种传递方式，它们分别是值参数、引用参数、（输出参数）和参数数组。
142、在C#中实参与形参有四种传递方式，它们分别是（值参数）、引用参数、输出参数和（参数数组）。
143、C#程序的基本单位是（语句）。
144、类的以下特性中，可以用于方便地重用已有的代码和数据的是（继承）。
145、在Array类中，可以对一维数组中的元素进行排序的方法是（Sort）。
146、C#是一种面向（对象）的语言。
147、在C#中，可以标识不同的对象的属性是（Name）。
148、继承具有（传递性），即当基类本身也是某一类的派生类时，派生类会自动继承间接基类的成员。
149、StreamWriter的（WriteLine）方法，可以向文本文件写入一行带回车和换行的文本的。
150、（MSIL）是独立于CPU 的指令集，它可以被高效地转换为特定于某种CPU 的代码。
151、C#程序中，可使用try…catch 机制来处理程序出现的（运行）错误。
152、在Queue类中，Enqueue方法的作用是（在队列末端加入新的元素）。
153、在ADO.NET中，表示程序到数据的连接的对象为（ Connection对象）。
154、C#中执行下列语句后，int n=21; n<<=1;n的值为（ 42 ）
155、在Visual Studio.NET窗口，（解决方案资源管理器）窗口显示了当前Visual Studio解决方案的树型结构。
156、在编写C#程序时，若需要对一个数组中的所有元素进行处理，则使用（ foreach循环）循环体最好。
157、在Queue类中，移除并返回队列前端对象的方法是（ Dequeue ）。
158、在ADO.NET中，可以在DataSet中维护（ DataRelation）对象的集合来管理表间的导航关系。
159、C#中每个char类型量占用（ 2 ）个字节的内容。
160、在DataSet对象中，可通过（ Tables ）集合遍历DataSet对象中所有的数据表对象。
161、在C#程序中，显示一个信息为“This is a test!”，标题为“Hello”的消息框，语句是（ MessageBox.Show(“this is a test!”,”Hello”); ）
162、在ADO.NET中，通过执行Command对象的ExecuteReader方法返回的DataReader对象是一种（只向前的只读的结果集）。
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）转义字符。
168、当整数a赋值给一个obiect对象时，整数a将会被（装箱）。
169、优先级最高的运算符是（( )）。
170、类的protected类型成员只允许在（当前类）和(其子类）被直接访问。
171、C#中的域如果没有被显式地初始化，其初值为（该类型的默认值）
172、静态属性只能通过（类）类调用
173、类的方法声明中，若没有显式指定方法的访问修饰符，则默认为（private）。
174、在Visual Studio中双击窗体中的某个按钮，则会自动添加该按钮的（Clicked）事件。
175、CheckBox与RadioButton控件的区别在于（后者只能单选）
176、通过Visual Studio主菜单中“视图 | （属性窗口）”菜单项可以控制“属性”面板的显示或隐藏。
177、C#中使用（struct）关键字表示泛型的值类型约束。
178、元素类型为int的2行5列的二维数组共占用( 40 )字节的存储空间。
179、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成（死循环）。
180、在c#的条件判断语句switch case结构中，（default）子句用于指定在找不到匹配项时执行的动作。
181、在以下C#类中，（Console）是控制台类，利用它我们可以方便的进行控制台的输入输
出。
182、Console是C#语言中的控制台类，它负责向控制台输出不同格式的字符串，在格式字符串中，可以使用（\t）来实现水平制表输出
183、在异常处理中，无论异常是否抛出，（finally）子句中的内容都会被执行。
184、C#语句末尾必须使用（；或分号）。
185、在类作用域中能够通过直接使用该类的（任何）成员名进行访问。
186、C#程序设计语言属于（高级）编程语言。
187、C#中，使用（string）关键字来声明一个字符串。
188、String类的（Compare）方法实现的功能是比较两个字符串的值。
189、C#的值类型包括（简单类型）、结构类型和枚举类型。
190、C#的值类型包括简单类型、（结构类型）和枚举类型。
191、C#的值类型包括简单类型、结构类型和（枚举类型）。
192、对于定义为bool基本数据的数组，所有的元素都被默认初始化为（false）。
193、开发C#程序的集成开发环境是（Visual Studio .NET）。
194、在C#中，用（{}）开始和结束方法体。
195、（object）类是所有类的基类。
196、要使Lable控件显示给定的文字“你好”，应在设计状态下设置它的（Text）属性值。
197、在实例化对象时，系统自动调用该类的（构造函数）进行初始化。
198、在C#中类的实例化需要使用的关键字是（new）。
199、结构化异常处理用try…catch…finally语句，则可能出现异常的语句放在(try)块。
200、ADO.NET对象模型包含（.NET数据提供程序）和（DataSet）两部分
201、在设置连接字符串时，参数Initial Catalog代表的含义是（数据库的名称）。
202、成功向数据库表中插入5条记录，当调用ExecuteNonQuery方法后，返回值为（5）。
203、属于DDL 语句（数据定义语句）（ Create ）、（Drop）和（Alter）。
204、若想从数据库中查询到student表和course表中的所有信息并显示出来，则应该调用
命令对象的（ExecuteReader）方法
205、在ADO.NET中，为访问DataTable对象从数据源提取的数据行，可使用DataTable
对象的（Rows）属性
206、若想在数据表中创建一个计算列，应设置数据列的（Expression）属性。
207、DataAdapter 对象使用与（UpdateCommand）属性关联的Command 对象将DataSet 修改的数据保存入数据源。
208、数据适配器对象使用与（InsertCommand）属性相关联的Command对象将DataSet插入的数据更新入数据源。
209、填充数据集应调用数据适配器的（Fill）方法。
210、更新数据集应调用数据适配器的（Update）方法。
211、C#中的字符串有两类，规则字符串和逐字字符串，定义逐字字符串时，应该在其前面加上（@）号。
212、在类的成员声明时，若使用（protected）修饰符，则该成员只能在该类或其派生类中使用。
213、类的静态成员属于（类）所有，非静态成员属于类的实例所有。
214、在声明类时，在类名前加（abstract）修饰符，则声明的类只能作为其他类的基类，不能被实例化。
215、在循环执行过程中，希望当某个条件满足时退出循环，使用（break）语句。
216、按钮控件的常用事件是（Click或单击）事件。
217、定义方法时使用的参数是（形参），调用方法时使用的参数是（实参）。
218、数据类型说明符用来说明方法返回值的类型，如果没有返回值，则其类型说明符应为（void）。
219、C#语言规定变量在使用之前必须先（声明）后使用。
220、在C#语言中，系统命名空间使用（using ）关键字导入。
221、C#中的表达式类似于数学数学运算中的表达式，是由操作符、操作对象和（运算符）等连接而成的式子。
222、表达式“410>=65”的值为（false）。
223、计算表达式“10==10&&10>4+3”的结果为（true）。
224、计算表达式“101010>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、数组内的值都具有相同的（类型）。
230、选定或取消选定RadioButton时，都会触发（CheckedChanged）事件。
231、派生类的对象对它的基类成员中的（　私有或private　）成员是不可访问的。
232、C#程序中,可使用try…catch 机制来处理程序出现的（运行）错误。
233、点击“工具箱”窗口中的“下箭头”按钮后，可以选择的窗口停放样式有（停靠）、（浮动）和（隐藏）。
234、有一个字符串的定义为string s = “hello world!”; 在此字符串中，字符w的索引是（6）。
235、Windows窗体应用程序的编程模型主要由（窗体）、（控件）和（事件）。
236、在方法定义中，virtual含义是（被virtual修饰的方法可以被子类重写）。
237、在类的定义中，类的（方法）描述了该类的对象的行为特征。
238、如果未显式赋值,则将整型值（ 0 ）赋给枚举中的第一个元素
239、用来定义事件的关键字是（event ）。
240、在.NET中，一些数据类型为引用类型，当引用类型的值为（null）时，表明没有引用任何对象。
241、在C#中,用来表示回车的转义字符是（\n）。
242、在C#中,布尔类型的关键字是（ bool ）。
243、在C#中byte类型所占用的内存空间是（2）个字节。
244、对类不指定访问修饰符，则类的默认访问修饰符为____internal___,但是类成员的默认访问级别为___private______
245、C#中的三元运算符是_ ？：。
246、使用Message.Show( )方法可以显示消息框，消息框的返回值是一个 DialogResult 类型。
247、当整数a赋值给一个object对象时，整数a将会被（装箱），
248、C#中，使用（属性）的功能来读写类中的字段，从而便于为这些字段提供保护。
249、所有的Windows窗体控件都是从System.Windows.Forms. Control_类继承而来，它公开的成员主要包含：属性、事件、方法___。
250、在windows程序中，若想选中复选框，则应将该控件的_____Checked_________属性设置为true。
251、实现密码框功能的方法是将TextBox控件的____PasswordChar___属性赋予屏蔽字符
252、__Count____属性用于获取ListBox中项的数目。
253、当进入Visual Studio集成环境，如果没有显示“工具箱”窗口，应选择“（视图）”菜单项的“工具箱”选项，以显示“工具箱”窗口。
254、属性窗口的属性可以按（分类）顺序和按字母顺序排列。
255、类声明后，可以创建类的实例，创建类的实例要使用（new）关键字，类的实例相当于一个变量，创建类的实例的格式如：（类名对象名= new 对象名（））
256、C#的类定义中可以包含两种成员：静态成员和非静态成员。使用（static）关键字修饰的是静态成员，反之为非静态成员。
257、让控件不可用的属性是（enabled）。
258、让控件不可见的属性是（visible）。
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§;
}
267、一般将类的构造方法声明为 public或公有访问权限。如果声明为private，就不能创建该类的对象。
268、C#数组类型是一种引用类型，所有的数组都是从System命名空间的 object 类继承而来的引用对象。
269、C#数组元素的下标从 0 开始。
270、在while循环语句中，一定要有修改循环条件的语句，否则，可能造成死循环 .。
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){}
280、使用MessageBox显示消息时，第（2）个参数为标题参数。
281、SubString()函数的功能是（获取子字符串）。
282、表达式 2+5/1010 的值为（2）。
283、C#程序的入口是（Main）方法。
284、类是一种数据结构，它使用 class 关键字声明。
285、类声明后，可以创建类的实例，创建类的实例要使用 new 关键字。类的实例相当于一个变量。创建类的实例的格式如：类名对象名= new 对象名（）。
286、C#的类定义中可以包含两种成员：静态成员和非静态成员。使用了 static 关键字修饰的就是静态成员，反之就是非静态成员。
287、创建新对象时将调用类的构造函数。它主要用来为对象分配存储空间，完成初始化操作。
288、抽象类使用关键字 obstract 来声明。
289、派生类构造函数的执行顺序是从最上面的（基类）开始，直到最后一个（派生类）结束。
290、在C#中调用基类的方法使用关键字（base）。
291、引入命名空间的关键字是（using）。
292、类的定义使用关键字（class），定义结构使用关键字（struct）。
293、在catch语句中列出异常类型时FormatException异常应列在Exception异常的（前面）。
294、Exception类中有两个重要的属性：（ Message ）属性包含对异常原因的描述信息。
295、在声明类时，在类名前（abstract）修饰符，则声明的类只能作为其他类的基类，不能被实例化。
296、在类的成员声明时，若使用了（ protected ）修饰符则该成员只能在该类或其派生类中使用。
297、在方法的参数列表中定义的参数称为（形参）。
298、类的方法声明中，若没有显式指定方法的访问修饰符，则默认为（private）。
299、静态属性只能通过（类）调用。
300、数据类型转换分为（隐式转换）和（显式转换）两种。
二、选择：
1、装箱是把值类型转换到（ b ）类型。
a)数组 b)引用 c)char d)string
2、静态构造函数只能对（ a ）数据成员进行初始化。
a) 静态 b) 动态 c)实例 d) 静态和实例
3、关于如下程序结构的描述中，哪一项是正确的？（ b ）
for ( ; ; )
{ 循环体; }
a) 不执行循环体 b) 一直执行循环体,即死循环
c) 执行循环体一次 d) 程序不符合语法要求
4、下列哪个类型的对象是ADO.NET在非连接模式下处理数据内容的主要对象？（ d ）
a) Command b) Connection c) DataAdapter d) DataSet
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
15、数组pins的定义如下：
int[] pins=new int[4]{9,2,3,1};
则pins[1]=( b )
a) 1 b) 2 c) 3 d) 9
16、创建数据库连接使用的对象是（ a ）。
a) Connection b) Command c) DataReader d) DataSet
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
22、一般情况下，异常类存放在什么命名空间中？（ b ）。
a) 生成异常类所在的命名空间 b) System.Exception命名空间
c) System.Diagnostics命名空间 d) System命名空间
23、以下程序的输出结果是（ d ）。
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
24、若将数据库中的数据填充到数据集，应调用SqlDataAdapter的（ c ）方法。
a) Open b) Close c) Fill d) Update
25、下列标识符命名正确的是（ a ）。
a） X_25 b）4foots c）&Years d）val(7)
26、若将数据集中所作更改更新回数据库，应调用SqlAdapter的（ a ）方法。
a) Update b) Close c) Fill d) Open
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
30、在使用FileStream 打开一个文件时，通过使用FileMode 枚举类型的( a )成员，
来指定操作系统打开一个现有文件并把文件读写指针定位在文件尾部。
a) Append b) Create c) CreateNew d) Truncate
31、有说明语句double[,] tab=new double[2,3];那么下面叙述正确的是（ c ）。
a) tab是一个数组维数不确定的数组，使用时可以任意调整
b) tab是一个有两个元素的一维数组，它的元素初始值分别是2，3
c) tab是一个二维数组，它的元素个数一共有6个
d) tab是一个不规则数组，数组元素的个数可以变化
32、在菜单项File中，为将F设为助记符，应将该菜单项的Text属性设置为（ b ）。
a) @File b)&File c)%File d)File
33、下列关于“方法重载”的描述中，哪些选项是不正确的？（ b ）。
a) 方法重载可以扩充现有类的功能
b)构造函数不可以重载
c) 方法ConsoleW(int value)是方法ConsoleW(string value)的重载
d)方法重载即“同样的方法名但传递的参数不同”
34、以下程序的输出结果是（ b ）。
class Program
{ static void Main(string[] args)
{
MyStruct s1 = new MyStruct(1, 2);
s1.x = 2;
s1.Sum();
Console.ReadLine();
}
}
struct MyStruct
{
public int x;
public int y;
public MyStruct(int i, int j)
{
x = i;
y = j;
}
public void Sum()
{
int sum = x + y;
Console.WriteLine(“the sum is {0}”,sum );
}
}
a) the sum is 4 b) the sum is 3 c) the sum is 2 d) the sum is 0
35、指定操作系统读取文件方式中的FileMode .Create的含义是（ d ）。
a) 打开现有文件
b) 指定操作系统应创建文件，如果文件存在，将出现异常
c) 打开现有文件，若文件不存在，出现异常
d) 指定操作系统应创建文件，如果文件存在，将被改写
36、以下说法正确的是（ b ）。
a) 虚方法必须在派生类中重写，抽象方法不需要重写
b) 虚方法可以在派生类中重写，抽象方法必须重写
c) 虚方法必须在派生类中重写，抽象方法必须重写
d) 虚方法可以在派生类中重写，抽象方法也不需要重写
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语句能使你不用索引就可以遍历整个数组
b)foreach语句总是从索引1遍历到索引Length
c)foreach总是遍历整个数组
d)如果需要修改数组元素就必须使用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) 以上都不是
49、当（ d ）时，条件“expression1 XOR expression2”的值为真。
a) expression1为真而expression2为假 b) expression1为假而expression2为真
c) expression1和 expression2均为真 d) a和b都对
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+58、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中的文字不能被修改，应对（ B ）属性进行设置。
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)窗体
58、引用ListBox(列表框)最后一个数据项应使用（ C ）语句
a) ListBox1.Items[ListBox1.Items.Count]
b）ListBox1.Items[ListBox1.SelectedIndex]
c) ListBox1.Items[ListBox1.Items.Count-1]
d) ListBox1.Items[ListBox1.SelectedIndex-1]
59、引用ListBox(列表框)当前被选中的数据项应使用（ B ）语句
a) ListBox1.Items[ListBox1.Items.Count]
b）ListBox1.Items[ListBox1.SelectedIndex]
c) ListBox1.Items[ListBox1.Items.Count-1]
d) ListBox1.Items[ListBox1.SelectedIndex-1]
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);
68、下面（b）代码可以显示一个消息框。
a)Dialog.Show();
b)MessageBox.Show();
c)Form.Show();
d)Form.ShowDialog();
69、在C# 编程中，访问修饰符控制程序对类中成员的访问，如果不写访问修饰符，类的默认访问类型是（b）。
A public B private C internal D protected
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： A：参数名称不同的重载 B : 返回类型不同的重载
C：方法名不同的重载 D ：参数个数不同的重载
73、下列关于继承说法中，哪个选项是正确的（d）
A。派生类可以继承多个基类的方法和属性。
B。派生类必须通过base关键字调用基类的构造函数
C。继承最主要的优点是提高代码性能
D。继承是指派生类可以获取其基类特征的能力。
74、当你需要使用一种数据类型表达同一类事物的不同状态，比如：男人、女人、小孩、老人或者春夏秋冬时，C#中最可靠和直观的解决方案是什么？(B)
A。使用struct结构
B。使用enum枚举
C。使用int类型，用不同的数值{0，1，2……}表示
D。C#中无法通过一种数据类型实现同一事务的不同状态。
75、下列选项中，不属于值类型的是（A）
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语句
78、在C# 中，可以避免使用枚举变量来避免不合理的赋值，一下枚举定义中正确的是（A）
A ： public enum Sex{
male,femal
}
B ：public enum Sex{
male,femal;
}
C ：public Sex enum {
male,femal;
}
D ：public Sex enum {
male,femal
}
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。自然语言
87、请问经过表达式a = 3 + 1 >5 ? 0 : 1的运算，变量a的最终值是什么？（D）
A。4 B。0 C。1 D。3
88、以下选项中，哪个选项中的变量命名是合法的（B）
A。**z B。_ester C。tc@caac D。www.eroman.com
89、下列关于多态的说法中，哪个选项是正确的（D）
A。重写虚方法时可以为虚方法指定别称
B。抽象类中不可以包含虚方法
C。虚方法是实现多态的唯一手段
D。多态性是指以相似的手段来处理各不相同的派生类。
90、下列关于接口的说法，哪项是正确的（A）
A。接口可以被类继承，本身也可以继承其他接口。
B。定义一个接口，接口名必须使用大写字母I开头
C。接口像类一样，可以定义并实现方法
D。类可以继承多个接口，接口只能继承一个接口
91、程序运行可能会出现两种错误：可预料的错误和不可预料的错误，对于不可预料的错误，可以通过C#语言提供的哪个方法来处理这种情形（D）
A。中断调试 B。逻辑判断 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）。
A．private int num;
public string Num
{
get{retuen num;}
set{num=value;}
}
B．private int num;
public int Num
{
get{retuen num;}
set{num=value;}
}
C．private int num;
public int Num
{
get{ num=value;}
set{ retuen num;}
}
D．private int num;
private int Num
{
get{retuen 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(){{//省略代码}}
99、以下关于结构的说法，正确的是（B）
A.结构不可以通过ref或out形参以引用方式传递给函数成员
B.结构是值类型，类是引用类型
C.结构和类一样，均支持继承
D．结构允许声明无形参的实例构造函数
100、以下关于密封类的说法，正确的是（C）
A．密封类可以用作基类 B. 密封类可以是抽象类
C.密封类永远不会有任何派生类 D.密封类或密封方法可以重写或继承
101、以下关于接口的说法，不正确的是（C）
A.接口不能实例化 B. 接口中声明的所有成员隐式地为public和abstract
C.接口默认的访问修饰符是private D.继承接口的任何非抽象类型都必须实现接口的所有成员。
102、派生类访问基类的成员，可使用（A）关键字
A.base B.this C.out D. external
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. 基类对象可以访问派生类的成员
121、关于base关键字，下列使用方法错误的是：（C）
A. 在子类中，base可以调用父类的构造函数
B、在子类中，base关键字可以访问父类的公共属性
C、在子类中，base关键字不可以调用父类的protected成员
D、在子类中，base关键字不可以调用父类的private成员
122、下面关于抽象类的说法正确的是：（B）
A. 抽象类可以被实例化 B. 含有抽象方法的类一定是抽象类
C抽象类可以是静态类和密封类 D.抽象类中的抽象方法可以在其它类中重写
123、下面关于虚方法说法错误的是：（B）
A 使用virtual关键字修饰虚方法 B. 虚方法必须被其子类重写
C虚方法可以有自己的方法体 D.虚方法和抽象方法都可以实现多态性
124、在C#中，关于接口下面说法错误的是：（D）
A. 接口是一组规范和标准 B.接口可以约束类的行为
C. 接口中只能含有未实现的方法
D 接口中的方法可以指定具体实现，也可以不指定具体实现
125、使用（C）关键字可以再次引发捕获到的异常？
A. New B. this C . throw D. Exception
126、异常捕获发生在（B）块中？
A. try B.catch C. finally D. throw
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
133、（A）控件组合了TextBox控件和ListBox控件的功能。
A、ComboBox B、Label C、ListView D、DomainUpDown
134、下列语句创建了（D）个string 对象
string [,] strArray = new string[3,4]
A.0 B.3 C.4 D.12
135、c#程序中，可使用try···catch 机制来处理程序出现的（B）错误
A. 语法 B. 运行 C. 逻辑 D. 拼写
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
140、27.在C#语言中，下列异常处理结构中有错误的是（a）
a）catch{}finally{} b) try{}finally{} c) try{}catch{}finally{}
d) try{}catch{}
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((i2)．ToString())；
case 3：
Console．Write((i3)．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 自然语言
158、请问经过表达式 a=3+1>5?0:1 的运算，变量a的最终值是什么? ( D )
A 3 B 1 C 0 D 4
159、设int型变量x的值为9，那么表达式x-- + x-- + x–的值为（A）
A . 27 B. 24 C. 21 D .18
160、下列属于合法C#变量名的有（）
A、x_123 B if C 1_x D 3x
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
172、为了避免嵌套的条件分支语句if-else的二义性，C语言规定：C程序中的else总是与（C ）组成配对关系。
A. 缩排位置相同的if B. 在其之前未配对的if
C. 在其之前未配对的最近的if D. 同一行上的if
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、44. 下列选项中属于字符串常量的是（ 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#的类中不能自定义属性
185、程序运行过程中发生的错误，叫作（ C ）．
A.版本 B.断点 C.异常 D.属性
186、.NET中，程序中的错误可以划分为以下三类，除了（ D ）。
A.逻辑错误 B.运行时错误 C.语法错误 D.自定义错误
187、在.NET中，一些数据类型为引用类型，当引用类型的值为（ B ）时，表明没有引用任何对象。
A.Empty B.null C.Nothing D.0
188、WinForms程序中，如果复选框控件的 Checked属性值设置为 True，表示（ A ）。
A.该复选框被选中 B.该复选框不被选中
C.不显示该复选框的文本信息 D.显示该复选框的文本信息
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块是异常处理所必需的
200、在C#中，下列代码的运行结果是（ dD ）。
int []age1 = new int[]{10,20};
int []age2 = age1;
age2[1] = 30;
Console.WriteLine(age1[1]);
A） 0 B） 10 C） 20 D） 30
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
204、在C#程序中，下列用来处理异常的结构，错误的是（AA ）。
A）catch{ }finally{ } C）try{ }catch{ }finally{ }
B）try{ }finally{ } D）try{ }catch{ }
205、在C# 中，程序使用（BB）语句抛出系统异常或自定义异常。
A）run B）throw C）catch D）finally
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©;
}
}要在控制台输出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）正常运行
211、在Visusl Studio.Net 开发环境中，在代码编辑器内输入对象的名称后将自动显示出对应的属性、方法、时间列表，以方便选择和避免书写错误，这种技术被称之为（ DD ）。
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
214、Visual Studio.Net开发平台是（BB）公司提供的.NET应用程序集成开发工具。
A） Borland B） Microsoft C） Intel D） IBM
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(){
string name=”bird”;
foreach(char c in name){
Console.Write©;
}
}
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)编译出现语法错误，不能运行
236、C#程序中,可使用try…catch 机制来处理程序出现的___B___错误
a) 语法 b) 运行 c) 逻辑 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. 多样性
246、在C#.Net中，用来创建主菜单的对象是( C )。
A. Menu B.MenuItem C.MenuStrip D.Item
247、面向对象的语言具有继承性、多态性和__A__性。
A) 封装 B) 拆箱 C) 封闭 D) 逻辑
248、当整数a赋值给一个object对象时，整数a将会被__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
252、在 C#编制的财务程序中,需要创建一个存储流动资金金额的临时变量,则应使用下列哪条语句? (A)
A.decimal theMoney; B.int theMoney;
C.string theMoney; D.Dim theMoney as double
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 方法
255、C#中,在方法 MyFunc 内部的 try…catch 语句中,如果在 try 代码块中发生异常,并且在当前的所有 catch 块中都没有找到合适的 catch 块,则(D)
A.NET 运行时忽略该异常 B.NET 运行时马上强制退出该程序
C.NET 运行时继续在 MyFunc 的调用堆栈中查找提供该异常处理的过程
D.NET 抛出一个新的“异常处理未找到”的异常
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、以下程序的输出结果是©｡ 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.构造函数可以带有参数
D.可以指定构造函数的返回值
267、为了能够在程序中捕获所有的异常,在 catch语句的括号中使用的类名为 A ___
A.Exception B.DivideByZeroException
C.FormatException D.以上三个均可
268、在设计菜单时,若希望某个菜单项前面有一个“√”号,应把该菜单项的____A__ 属性设置为 true｡
A.Checked B.RadioCheck C.ShowShortcut D.Enabled
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、103.在下列程序空格处填入正确的选项__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
274、下面对异常说法不正确的是___(D)
A.try/catch块为基本引发异常的组合 B.在捕获异常时,可以有多个 catch块
C.无论异常是否发生,finally块总会执行 D.try块和 finally 不能连用
275、在Visual Studio.NET窗口，（ B ）窗口显示了当前Visual Studio解决方案的树型结构。
A．类视图 B. 解决方案资源管理器 C. 资源视图 D. 属性
276、在C#中设计类时，如何将一个可读可写的公有属性Name修改为只读属性？（ A ）
A．将Name的set块删除 B.将Name的set块置空
C. 将Name的set块前加修饰符private D. 将Name添加readonly修饰符
277、在下面的类定义中，缺省构造函数的作用是（ C ）
Public class MyClass
{
private MyClass() { }
public static int counter;
public static int increnentCounter()
{
return ++counter;
return ++counter;
}
}
A．在创建类的实例时初始化类的域
B．因为是private的，因此不起任何作用
C．防止创建类的实例
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 ）
A.sealed abstract class c1{abstract public void test() {}
B.abstract sealed public viud test();
C.abstract class c1 { abstract void test(); //test()默认为私有，不合法
D.abstract class c1 {abstract public void test(); }√
281、在C#中，将路径名”C:\Documents\”存入字符串变量path中的正确语句是（ A ）
A. path=’C:\Documents\’’; √ B. path=”C://Documents//”;
C. path=”C:\Documents\”; D. path=”C:/Documents/”;
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√
283、通过继承（ C ）类，用户可以创建自己的异常类。
A. System.Exception B. System.SystemException
C. System.ApplicationException√ D. System.UserException
284、C#类MyClass下列函数重载是否合法？（B）
Public void showInfo(int i)
{…}
public bool showInfo(int i) {…} //重载必须是参数不同
A．合法 B. 不合法√
285、C#中，回车字符对应的转义字符串为（ C ）
A. \r B. \f C. \n √ D. \a
286、设置openfiledialog1引用一个openfiledialog对象，则打开该对话框的正确代码是（ B ）
A. openfiledialog1.show(); B. openfiledialog1.showdialog();√
C. openfiledialog1.open(); D. openfiledialog1.openandshow();
287、创建菜单后，为了实现菜单项的命令功能，应为菜单项添加（ C ）事件处理方法。
A. DrawItem B. Popup C. Click√ D. Select
288、在C#程序中，显示一个信息为“This is a test!”，标题为“Hello”的消息框，正确的语句是（ B ）
A.MessageBox(“this is a test!”,”Hello”);
B.MessageBox.Show(“this is a test!”,”Hello”); √
C.MessageBox(”Hello” , “this is a test!”);
D.MessageBox.Show (”Hello” , “this is a test!”);
289、在C#中，引用命名空间System的正确语句是（ A ）
A.using System;
B.# import ;
C.uses System;
D.# include ;
290、显示消息时，MessageBoxTcon枚举中的Error成员可以消息框中添加一个图标，该图标的形状是（ D ）
A. 问号 B. i C. 感叹号 D. 叉号
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标签结束可以有跳转语句，也可以没有。
294、下列关于异常处理的表述中哪些是正确的（D）？
A try、catch、finally三个字句必须同时出现，才能正确处理异常
B catch字句能且只能出现一次
C try字句中所抛出的异常一定能被catch字句捕获
D无论异常是否抛出，finally子句中的内容都会被执行。
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、在使用变量之前必须先声明类型。 √
2、if语句后面的表达式可以是任意表达式。 ×
3、switch语句中必须有default标签。 ×
4、基类的派生类中必须为基类中的抽象方法提供实现。√
5、在结构化异常处理语句try catch finally中，finally块的内容可以执行也可以不执行。×
6、由static修饰的成员必须由类来访问而不能通过对象访问。√
7、在C#中，一个类可以继承于多个类、多个接口。×
8、抽象类中所有的方法必须被声明为abstract ×
9、若方法的名字相同、参数相同，而方法的返回值类型不同，则可以实现方法的重载。×
10、继承能够实现代码的复用。√
11、布尔型变量可以赋值为0或1。 ×
12、当有多个异常要捕获时，应先捕获特殊（具体）异常，再捕获普通（一般）异常。√
13、在控制台应用程序中，若想从键盘上输入数据，可以使用Console.Read()和Console.ReadLine()方法。√
14、显式接口成员只能通过接口来调用√
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()方法既可显示消息框√
257、ListBox控件用于显示一个选项列表，用户每次只能从中间选择一项（×）
258、如果实现重写，在基类的方法中必须使用virtual关键字，在派生类的方法中必须使用overrides关键字。（×）
259、用Interval属性设置Timer控件Tick事件发生的时间间隔单位为秒。（×）
260、一个窗体可以有多个弹出式菜单。（√）
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#语言中，值类型包括：基本值类型、结构类型和枚举类型。√
279、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方法。√
四、读程序写结果和看程序填空
1、 class Program
{
static void Main(string[] args)
{
Tiger t = new Tiger();
Console.Read();
}
}
class Animal
{
public Animal()
{ Console.Write (“基类”); }
}
class Tiger : Animal
{
public Tiger()
{ Console.Write (“派生类”);}
}
程序的运行结果是_____基类派生类_____________
2、 class Program
{
static void Main(string[] args)
{
Elephant e = new Elephant(“abc”);
Console.ReadLine();
}
}
public class Animal
{
public Animal()
{
Console.Write (“基类默认构造函数！”);
}
public Animal(string s)
{
Console.Write (“非默认构造函数”);
}
}
public class Elephant : Animal
{
public Elephant()
{
Console.Write (“派生类构造函数！”);
}
public Elephant(string str)
: base(str)
{
Console.Write (str);
}
}
程序的运行结果是______非默认构造函数abc __________
3.在Main方法中需要调用Display方法，按照要求填空
class Program
{
static void Main(string[] args)
{
A1 a = new A1(); //创建A1类的对象a
Console.WriteLine(a.Display());
Console.ReadLine();
}
}
class A1
{
public string Display()
{
return “hello everyone!”;
}
}

4、下列程序完成了调用静态方法和实例方法，补充空白处并写出运行结果
class Program
{
static void Main(string[] args)
{
Example e1 = new Example();
e1.meth1();
Example.meth2(); //调用meth2()
Console.WriteLine(“a={0},b={1}”,e1 .a ,Example .b);
Console.ReadLine();
}
}
class Example
{
public int a;
static public int b;
public void meth1()
{
a = 10;
b = 20;
}
public static void meth2()
{
b = 30;
}
程序的输出结果是_________a=10,b=30_______________
5、 class Program
{
static void Main(string[] args)
{
s s1 = new s();
s t1 = new s();
Console.ReadLine();
}
}
public class s
{
public s()
{Console.Write (“构造函数！”);}
static s()
{Console .Write (“静态构造函数！”);}
}
程序的运行结果是_____静态构造函数！构造函数！构造函数！__________________
6、 class Program
{
static void Main(string[] args)
{
Person p = new Person();
p.N = “www”;
Console.WriteLine(p.N );
Console.ReadLine();
}
}
public class Person
{
private string p_name=“abc”;
public string N
{
get { return p_name; }
set { p_name = value; }
}
}
程序最终的输出结果是_www__
7、class Program
{
static void Main(string[] args)
{
B b = new B();
A a = b;
a.G();
b.G();
Console.Read();
}
}
class A
{
public virtual void G()
{
Console.Write (“A.G!”);
}
}
class B : A
{
public override void G()
{
Console.Write (“B.G!”);
}
}
程序的输出结果是___ B.G!B.G!__________________________
8、下列程序完成了输出数组中的最大值和最小值，请补充程序中的空白处
class Program
{
static void Main(string[] args)
{
MyClass m = new MyClass();
int[] s ={ 1, 6, 4, 7, 3, 87, 5 };
int smax, smin;
m.MaxMin(s, out smax, out smin);
Console.WriteLine(“smax={0},smin={1}”,smax ,smin );
Console.ReadLine();
}
}
class MyClass
{
public void MaxMin(int[] a, out int max, out int min)
{
max = min = a[0];
for (int i = 1; i < a.Length; i++)
{
if (a[i] > max) max = a[i];
if (a[i] < min) min = a[i];
}
}
}
9、下列程序完成了调用静态方法和实例方法，补充空白处并写出运行结果
class Program
{
static void Main(string[] args)
{
Example e1 = new Example();
e1.meth1();
Example.meth2();
Console.WriteLine(“a={0},b={1}”,e1 .a ,Example .b);
Console.ReadLine();
}
}
class Example
{
public int a;
static public int b;
public void meth1()
{
a = 10;
b = 20;
}
public static void meth2()
{
b = 30;
}
程序的输出结果是____ a=10,b=30_________________
10、class Program
{
static void Main(string[] args)
{
Triangle t = new Triangle(3, 4);
double s = t.area();
Console.WriteLine(“area is {0}”,s);
Console.ReadLine();
}
}
class Shape
{
protected double width;
protected double height;
public Shape()
{
width = height = 0;
}
public Shape(double w, double h)
{
width = w;
height = h;
}
public virtual double area()
{
return width * height;
}
}
class Triangle : Shape
{
public Triangle(double x, double y)
: base(x, y)
{ }
public override double area()
{
return width * height / 2;
}
}
程序的输出结果是____area is 6____________________
11、class Program
{
static void Main(string[] args)
{
Point p1 = new Point();
Point p2 = new Point(3, 4);
Console.WriteLine(“p1.x={0},p1.y={1}”, p1.x, p1.y);
Console.WriteLine(“p2.x={0:f},p2.y={1}”, p2.x, p2.y);
Console.ReadLine();
}
}
class Point
{
public double x = 0, y = 0;
public Point()
{
x = 1; y = 1;
}
public Point(double a, double b)
{
x = a;
y = b;
}
}
程序最终的输出结果是___ p1.x=1,p1.y=1
p2.x=3,p2.y=4 __
12、class Program
{
static void Main(string[] args)
{
Triangle t = new Triangle(3, 4);
double s = t.area();
Console.WriteLine(“area is {0}”,s);
Console.ReadLine();
}
}
class Shape
{
protected double width;
protected double height;
public Shape()
{
width = height = 0;
}
public Shape(double w, double h)
{
width = w;
height = h;
}
public virtual double area()
{
return width * height;
}
}
class Triangle : Shape
{
public Triangle(double x, double y)
: base(x, y)
{ }
public override double area()
{
return width * height / 2;
}
}
程序最终的输出结果是_ area is 6__
13、class Program
{
static void Main(string[] args)
{
MyClass m = new MyClass();
int a, b, c;
a = 0; b =20; c = 10;
m.sort(ref a, ref b, ref c);
Console.WriteLine(“a={0},b={1},c={2}”,a,b,c);
Console.ReadLine();
}

      }
class MyClass
{
    public void sort(ref int x, ref int y, ref int t)
    {
        int tmp;
        if (x > y) { tmp = x; x = y; ;y = tmp; }
        if (x > t) { tmp = x; x = t; t = tmp; }
        if (y > t) { tmp = y; y = t; t = tmp; }
        Console.WriteLine("{0},{1},{2}", x, y, t);
    }
  }
程序的输出结果是_____ a=0,b=10,c=20 ______________________
1
2
3
4
5
6
7
8
9
10
11
12
13

14、 class Program
{
static void Main(string[] args)
{
MyClass m = new MyClass();
int[] s ={ 34, 23, 65, 67, 54, 98, 6, 56 };
m.Array(s);
for(int i=0;i<s.Length ;i++)
{
Console .Write("{0}",s [i]);
}
Console .ReadLine ();
}
}
class MyClass
{
public void Array(int[] a)
{
for (int i = 0; i < a.Length; i++)
{
a[i] = i;
}
}
}
程序最终的输出结果是01234567 _
15、class Program
{
enum Season : int
{
Spring,
Summer ,
Autumn,
Winter
}
static void Main(string[] args)
{
Season s = (Season)2;
Console.WriteLine(s);
Console.Read();
}
}
程序的输出结果是________ Autumn ________________
16、class Program
{
static void Main(string[] args)
{
int i = 0, sum = 0;
do
{
sum++;
}
while (i > 0);
Console.WriteLine(“sum = {0}”, sum);
}
}
程序的运行结果是_________ sum = 1________________
17、static void Main(string[] args)
{
int x = 123;
object obj1=x;
x = x+100;
Console.WriteLine (" obj1= {0}" , obj1 );

}
程序的输出结果是_________ obj1=123___________
1
2

18、下面程序的功能是：输出100以内能被3整除且个位数为6的所有整数，请填空。
static void Main(string[] args)
{
int j;
for (int i = 0; i <= 9; i++)
{
j = i * 10 + 6;
if (i % 10 !=6&&j%3!=0)
Continue;
Console.Write("\t{0}",j);
}
Console.Read();
}

19、using System;
class Program
{
static void Main(string[] args)
{
int m, n, i, j, max = 0;
Console.WriteLine(“请输入m,n的值”);
m = Convert.ToInt32(Console.ReadLine ());
n = int.Parse(Console.ReadLine());
if (m < n)
i = m;
else
i = n;
for (j = i; j > 0; j–)
if (m % j == 0 && n % j == 0)
{
max = j;
break;
}
Console.WriteLine(“max={0}”, max);
Console.ReadLine();
}
}
若分别从键盘输入8和6，则程序的运行结果是__ max=2___________________
20、static void Main(string[] args)
{
int Sum = 0;
for (int i = 1； i <= 10； i++)
{
if (i % 2 == 0)
Sum += i;
}
Console.WriteLine(Sum);
}
程序的输出结果是____30______
21、 static void Main(string[] args)
{
int m, n,i;
int[] a = new int[6]{1,2,5,3,9,7};
m = n = a[0];
for (i = 1; i < 6; i++)
{
if (a[i] > max) m = a[i];
if (a[i] < min) n = a[i];
}
Console.WriteLine("{0}, {1}",m,n );
Console.ReadLine();
}
程序最终的输出结果是________9,1___________
22、class Program
{
static void Main(string[] args)
{
for (int i = 1; i <= 10; i++)
{
Console.Write(i);
if (i % 5 == 0)
Console.WriteLine();
else
Console.Write(’\t’);
}
}
}
程序的运行结果是_______1 2 3 4 5
6 7 8 9 10__________________
23、static void Main(string[] args)
{
int Sum = 0;
for (int i = 1； i <= 10； i++)
{
if (i % 2 == 1)
Sum += i;
}
Console.WriteLine(Sum);
}
程序的输出结果是_______25___________
24、 static void Main(string[] args)
{
int a=2, b=7, c=5;
switch (a > 0)
{
case true :
switch (b < 10)
{
case true: Console.Write("^"); break;
case false: Console.Write("!"); break;
}
break;
case false :
switch (c == 5)
{
case false: Console.Write("*"); break;
case true: Console.Write("#"); break;
}
break;
}
Console.Read();
}
程序最终的输出结果是___ ^___
25、 static void Main(string[] args)
{
try
{
int x = Convert.ToInt32(Console.ReadLine());
int y = Convert.ToInt32(Console.ReadLine());
int z = x / y;
}
catch (FormatException)
{
Console.WriteLine(“格式不符”);
}
catch (DivideByZeroException)
{
Console.WriteLine(“除数不能是0”);
}
catch (Exception)
{
Console.WriteLine(“Exception!”);
}
finally
{
Console.WriteLine(“thank you for using the program!”);
}
Console.ReadLine();
}
若分别从键盘上输入5和x，则程序的最终执行结果是格式不符
thank you for using the program!
26、 class Program
{
static void Main(string[] args)
{
Taxi t = new Taxi();
Console.WriteLine(t.isInitialized );
Console.ReadLine();
}
}
public class Taxi
{
public bool isInitialized = false;
public Taxi()
{
isInitialized = true;
}
}
程序最终的输出结果是___ True __
27、 class Program
{static void Main(string[] args)
{
Mouse m = new Mouse();
m.Eat();
m.Sleep();
}
}
public abstract class Animal
{ public abstract void Sleep();
public virtual void Eat()
{ Console.Write (“eat something”); }
}
public class Mouse : Animal
{ public override void Sleep()
{Console.Write (“mouse sleeping!”);}
public override void Eat()
{Console.Write (“eat cheese!”);}
}

程序的输出结果是_______ eat cheese! mouse sleeping! _____________________
28、 class Program
{
static void Main(string[] args)
{
SharedClass sc = new SharedClass();
sc.SetDataA(“interface IpartA”);
Console.ReadLine();
}
}
public interface IpartA
{
void SetDataA(string dataA);
}
public class SharedClass : IpartA
{
private string DataA;
private string DataB;
public void SetDataA(string dataA)
{
DataA = dataA;
Console.WriteLine("{0}", DataA);
}
}
程序最终的输出结果是interface IpartA _
29、 static void Main(string[] args)
{
int m, n, i, j, s= 0;
Console.WriteLine(“请输入m,n的值”);
m = Convert.ToInt32(Console.ReadLine ());
n = int.Parse(Console.ReadLine());
if (m < n)
i = m;
else
i = n;
for (j = i; j > 0; j++)
if (j % m == 0 && j % n == 0)
{
s = j;
break;
}
Console.WriteLine("{0}", s);
}
若从键盘上分别输入4和6，则程序最终的输出结果是______12________
30、static void Main(string[] args)
{
int[] pins = { 9, 3, 7, 2 };
for (int index = 0; index != pins.Length; index++)
{
int pin = pins[index];
System.Console.Write (pin);
}
foreach (int i in pins)
{
Console.Write (i);
}
}
程序的输出结果是________93729372____________________
31、分析一下C#代码，根据面向对象的多态性，代码的运行结果是__B___________
class A{
public void F(){
Console.Write(“A”);
}
Public void F(string chr)
{
Console .Write(“B”);
}
}
class B:A
{
Public void F(){
Console.write(“B”);
}
Static void Main()
{
B objB=new B();
objB.F();
}
}
32、分析如下C# 代码，根据类的继承关系，运行后的输出结果是___不得入内未成年人___
public class Person
{
private int age=0;
public int Age
{
get{return age;}
set
{
If(value>=18)
Console.WriteLine(“成年人”);
Else
Console.WrteLine(“未成年人”);
}
}
}
public class People:Person
{
public People()
{
Console.Write（“不得入内”）；
}
}
class Test
{
static void Main (string[]args)
{
people shang=new People();
shang.Age=17
}
}
33、阅读下面程序，请确定枚举成员的关联值。
enum Color:uint
{
Red,
Green=3,
Blue,
Max=Blue
}
（1）枚举成员Red的关联值为（0）
（2）枚举成员Green的关联值为（3）
（3）枚举成员Blue的关联值为（4）
（4）枚举成员Max的关联值为（4）。
34、写出以下程序的运行结果。57
using System;
class Test
{
public static void Main()
{
int x = 5;
int y = x++;
Console.Write (y);
y=++x;
Console.Write (y);
}
}
35、写出下列函数的功能。若A>B则返回1,若AB则返回0,若A<B则返回-1
static int SA(int a,int b)
{
if (a>b)
return 1;
else if (ab)
return 0;
else
return -1;
}
36、写出以下程序运行结果。9 12 15
using System;
class Test
{
static int[] a = { 1, 2, 3, 4, 5, 6, 7, 8 };
public static void Main()
{
int s0, s1, s2;
s0 = s1 = s2 = 0;
for (int i = 0; i < 8; i++)
{
switch (a[i] % 3)
{
case 0: s0 += Test.a[i]; break;
case 1: s1 += Test.a[i]; break;
case 2: s2 += Test.a[i]; break;
}
}
Console.WriteLine(s0 + " " + s1 + " " + s2);
}
}
37、写出以下程序的运行结果。
2 4 6
8 10 12
14 16 18
using System;
class Test
{
public static void Main ()
{
int[ ] a ={2,4,6,8,10,12,14,16,18};
for (int i=0; i<9; i++) {
Console.Write(“ ”+a[i]);
if ((i+1)%30) Console.WriteLine();
} }
}
38、写出以下程序运行结果。i,s=15,56
using System;
class Test
{
public static void Main ()
{
int s=0,i;
for (i=1; ; i++) {
if (s>50) break;
if (i%20) s+=i;
}
Console.WriteLine (“i, s=” + i + “,” + s);
} }
39、写出下列程序的运行结果。
static void Main(string [ ] args)
{
string[] words = new string[ ] { “a”,”b”,”c”};
foreach ( string word in words)
{
Console.WriteLine(word);
}
}
答： a
b
c______
40、完善如下程序：键入10个整数，统计其中正数(neg)、负数(pos)和零（zero）的个数并将三者输出。
int i;
int num;
int zeroNum = 0;
int ZengNum=0;______
int FuNum = 0;
for (i = 1; i <= 10; i++)
{
Console.WriteLine(“请输入第{0}个整数”,i);
string strTemp = Console.ReadLine();
num = Convert.ToInt32(strTemp);____
if (num > 0)
{
ZengNum++;
}
else if (num == 0)
{
zeroNum++;
}
else
{
FuNum++;_
}
}//for_end
Console.WriteLine(“正数:{0}、负数: {1}、零:{2}”, ZengNum, FuNum, zeroNum);
41、下列代码的功能是要遍历整个数组并将其显示出来，但是有一行代码是错误的。请检查下列代码，并在错误代码行后填入该行完整的正确代码：
1)． static void Main(string [] args)
2). {
3). string [ ] myArray = new string[ ] { “C#”, “C++”, “VB”, “java” };
4). for(int i = 1; i<myArray.Length -1; i++)
5). {
6). Console.WriteLine(myArray[i]);
7). }
8). }

答：第__4__行错误。
应改为___ for(int i = 0; i<myArray.Length ; i++) ____________

42、完善如下程序：求5的阶乘并输出
int mul= 1 ;
for(int i=1;i<=5;i++)
{
mul*=i;
}
Console.WriteLine(mul_______);
43、说明本程序的功能。求数组中的最大值_____________
int[] nums = new int[3];
int max = int.MinValue;
for (int i = 0; i < 3; i++)
{
string strTemp = Console.ReadLine();
nums[i] = int.Parse(strTemp);
}
for (int i = 0; i < 3; i++)
{
if (nums[i]>max)
{
max=nums[i];
}
}
Console.WriteLine(max);
44、void main()
{
int k=2,i=2,m;
m=(k+=i*=k);
Console.WriteLine(“{0},{1}”,m,i);
}
输出结果______6，4___________。
45、 void main()
{
char grade=‘C’;
switch(grade)
{
case ‘A’:
Console.WriteLine(">=85.");
break;
case ‘B’:
Console.WriteLine(">=70.");
break;
case ‘C’:
Console.WriteLine(">=60.");
break;
case ‘D’:
Console.WriteLine("<60.");
break;
default:
Console.WriteLine(“error.”);
break;
}
}
输出结果_______>=60.。
46、说明本程序的功能。
int num;
int sum=0;
int avg=0;
for(int i=1;i<=10;i++){
{ Console.WriteLine(“请输入第{0}个整数”,i);
string strTemp=Console.ReadLine();
num=int.Parse(strTemp);
sum=sum+num;
}
avg = sum / 10;
Console.WriteLine(“平均数值={0}”,avg);
答： 求从键盘输入的10个整数的平均值_________
47、完善如下程序：打印输出平方值小于20000的最大整数。
int i=0;
while(i*i<20000)
{
i++;
}
Console.WriteLine(i___);
48、下列程序的作用是求出所有的水仙花数。（所谓水仙花数是指这样的数：该数是三位数，其各位数字的立方和等于该数）
using system;
class Example1
{
static void Main(string[] args)
{
int a, i, b, c, t;
for (i = 100; i <= 999; i++)
{
t = i;
a = t % 10; t = t / 10; b = t % 10; c = t / 10;
if (i == a * a * a + b * b * b + c * c * c)
Console.WriteLine(“i={0}”, i);
}
Console.ReadLine();
}}
49、public class TEApp{
public static void ThrowException(){
throw new Exception();
}
public static void Main(){
try{
Console.WriteLine(“try”);
ThrowException();
}
catch(Exception e){
Console.WriteLine(“catch”);
}
finally{
Console.WriteLine(“finally”);
}
}
}上述C#代码运行结果是（try
catch
finallyA）
50、分析如上的C#代码段，运行后将输出老师的名字叫小明
学生的名字叫小明
public class Teacher{
public Teacher (string name){
Console.WriteLine(“老师的名字叫”+ name);
}
}
public class Test:Teacher{
public Test(string name){
Console.WriteLine(“学生的名字叫”+ name);
}
}
static void Main(string[] args)
{ Test t=new Test(“小明”);}
51、class Test{
static void Main(){
try{
int a = 10;
int b = 0;
int c = a / b;
Console.WriteLine©;
}
catch{
Console.WriteLine(“出现错误”);
}
finally{
Console.WriteLine(“运行结束”);
}
}
}在C#中，上述代码的运行结果是出现错误
运行结束
52、下列程序是输出100以内所有能被7整除的数，请将程序补充完整。
using System;
class Output
{ static void Main()
{for (int k=1;k<=100;k++ )
{if (k%7!=0) ;
continue;____
Console.Write(k_);}} }
53、写出下列函数的功能。求出从键盘上输入的一批常数的平均值，以-1作为结束输入的标志。
static float FH() {
float y=0,n=0;
int x = Convert.ToInt32(Console.ReadLine()); //从键盘读入整型数据赋给x
while (x!=-1) {
n++; y+=x;
x = Convert.ToInt32(Console.ReadLine());
}
if (n==0)
return y;
else
return y/n;
}
54、写出以下程序运行结果。 25 10
25 10
using System;
class Test
{
static void LE(ref int a, ref int b) {
int x = a;
a = b; b = x;
Console.writeLine (a + “ “ +b);
}
public static void Main ()
{
int x=10, y=25;
LE(ref x, ref y);
Console.writeLine (x + “ “ +y);
}
}
55、阅读以下的C＃代码：下述代码运行后，将在控制台窗口输出 A
B
class A
{
public A( )
{ Console.WriteLine(“A”); }
}
class B:A
{
public B()
{ Console.WriteLine(“B”); }
}
class Program
{
public static void Main()
{
B b = new B();
Console.ReadLine();
}
}
56、class Program
{
static void Main(string[] args)
{
Person p = new Person();
p.N = “www”;
Console.WriteLine(p.N );
Console.ReadLine();
}
}
public class Person
{
private string p_name=“abc”;
public string N
{
get { return p_name; }
set { p_name = value; }
}
}
程序最终的输出结果是_________www____________________
57、static void Main(string[] args)
{
try
{
int x = Convert.ToInt32(Console.ReadLine());
int y = Convert.ToInt32(Console.ReadLine());
int z = x / y;
}
catch (FormatException)
{Console.WriteLine(“格式不符”);}
catch (DivideByZeroException)
{ Console.WriteLine(“除数不能是0”);}
catch (Exception)
{Console.WriteLine(“Exception!”);}
finally
{
Console.WriteLine(“thank you for using the program!”);
}
Console.ReadLine();
}
若分别从键盘上输入5和x，则程序的最终执行结果是

58、程序执行后，m的值是 0
public int which(int k)
{
int x=0;
Switch(k){
case 1: x=10;break;
case 2: x=15;break;
}
return x;
}
……
int m=which(5);
59、在C＃中，下列代码的运行结果是（022）。
public class Student
{
public static int Add(int a,int b)
{
a++;
b++;
return a+b;
}
static void Main()
{
int a=0;
int b=2;
int c = Add(a,b);
Console.Write(a);
Console.Write(b);
Console.Write©;
}
60、在C＃中，下列代码的运行结果是（-5 ）。
public class Test
{
static void Main()
{
int i= showInfo(5,10,"-");
Console.WriteLine(i);
}
static int showInfo(int a,int b,string op)
{
if(op=="+")
return a+b;
if(op=="-")
return a-b;
return a*b;
}
61、分析下列程序的功能，并指出运行结果。
using System;
public class array1
{
public static void Main( )
{
int [ ] a={34,91,83,56,29,93,56,12,88,72};
int i,t=0,temp=100;
for(i=0;i<10;i++)
if(a[i]<temp)
{
temp=a[i]; t=i;
}
Console.WriteLine(“{0} {1}”,temp,t);
}
}
运行结果： 12 7 .
62、写岀下面程序的运行结果 050055
class Program
{
static void Main(string[] args)
{
Class1 c1 = new Class1();
Class1.y = 5;
c1.output();
Class1 c2 = new Class1();
c2.output();
Console.ReadLine();
}
}
public class Class1
{
private static int x = 0;
public static int y = x;
public int z = y;
public void output()
{
Console.Write (Class1.x);
Console.Write (Class1.y);
Console.Write (z);
}
}
63、运行结果： .
static void Main(string[] args)
{
int x = 9;
Console.WriteLine((x–) + (x–) + (x–));
Console.WriteLine(x);
int y = (–x) + (–x) + (–x);
Console.WriteLine(y);
Console.WriteLine(x);
Console.ReadLine();
}
64、程序的最终运行结果是110 150 199 30 18
static void Main(string[] args)
{
int[] myArray = { 110, 150, 199, 30, 18};
for (int i = 0; i != myArray.Length - 1;i++ )
{
AddArray(myArray[i]);
}
foreach (int i in myArray)
{
Console.WriteLine(i);
}
}
public static void AddArray(int num)
{ num += 1; }
65、下面代码是要显示My string, 请分析下列代码段并在空白行补全Ｃ＃代码：
static void Main(string[] args)
{
string myString = “My string”;
char[] myChars = myString.ToCharArray();
foreach (char character in myChars______)
{
Console.WriteLine("{0}",character);
}
Console.ReadKey();
}
66、请写出该段代码的运行结果：____ False
2____
abstract class BaseClass
{
public virtual bool MethodA()
{
return true;
}
public virtual string MethodB()
{
return “0”;
}
}
class Class1:BaseClass
{
public override bool MethodA()
{
return false;
}
public override string MethodB()
{
return “1”;
}
}
class Class2:Class1
{
new public string MethodB()
{
return “2”;
}
}
class MainClass
{
public static void Main(string[] args)
{
Class2 o = new Class2();
Class2 q = new Class2();
Console.WriteLine(o.MethodA());
Console.WriteLine(q.MethodB());
}
}
67、程序运行的最终结果是Microsoft Studio Visual
using System;
class Program
{
private class IntIndexer
{
private string[] myData;
public IntIndexer(int index)
{
myData = new string[index];
for (int i = 0; i < index; i++)
myData[i] = “Microsoft”;
}
public string this[int pos]
{
get
{
return myData[pos];
}
set
{
myData[pos] = value;
}
}
}
static void Main(string[] args)
{
int size = 3;
IntIndexer myIndex = new IntIndexer(size);
myIndex[2] = “Visual”;
myIndex[1] = “Studio”;
for (int i = 0; i < size; i++)
Console.Write(myIndex[i] + " ");
}
}
68、下面的程序是实现一个方法可以接受n个不相等的参数。在空白行补全。
using System;
class Program
{
private static void Test( params string[] strArray)
{
for (int i = 0; i < strArray.Length; i++)
{
Console.Write(strArray[i] + " ");
}
Console.WriteLine();
}
static void Main(string[] args)
{
Test(“One”, “Two”, “Three”);
Test(“Monday”,“Tuesday”,“Wednesday”,“Thursday”,“Friday”);
}
}
69、分析下列程序段: 程序运行的输出结果是sum = 1
using System;
class Program
{
static void Main(string[] args)
{
int i = 0, sum = 0;
do
{
sum++;
}
while (i > 0);
Console.WriteLine(“sum = {0}”, sum);
}
}
70、下面的程序完成的是：从输入串中找出所有的字母，并把这些字母转换成大写，然后输出到终端。请分析下列代码段, 并在空白行补全Visual C#代码。
using System;
class Program
{
static void Main(string[] args)
{
string inputString = string.Empty;
string result = string.Empty;
inputString = Console.ReadLine();
for (int i = 0; i < inputString.Length; i++)
{
if (inputString[i] >= ‘a’ && inputString[i] <= ‘z’)
result += inputString[i].ToString().ToUpper();
if (inputString[i] >= ‘A’ && inputString[i] <= ‘Z’)
________ result += inputString[i]_________________;
}
Console.WriteLine("字母有: " + result);
}
}
五、简答题
1.一个完整的C#控制台程序包括哪些必要的组成部分？
Properties：属性。在AssemblyInfo中可以设置应用程序的版本号、作者等信息。
引用：默认情况下项目引用了System、System.Data和System.XML3个命名空间，这3个命名空间包括了最常见的类和函数。
Program.cs：项目默认建立的，是项目的运行入口。
2.有哪些主要的数据类型？它们之间是怎样进行相互转换的？
值类型包括整数类型、字符类型、浮点类型、布尔类型、结构类型和枚举类型。引用类型包括类、接口、委托、数组、字符串等。
C#中提供了隐式类型转换和显式类型转换。
3.类和对象的区别和关系是什么？
类是对象的抽象，它为属于该类的全部对象提供了统一的抽象描述。它是对象的模板，对象是类的实例。
4.静态字段与非静态字段有什么区别？
加static修饰字段时，则该字段为静态字段，静态字段不属于某个实例对象，只与类相关联，因此，对静态字段的访问只与类关联，访问时使用类名.字段，实例字段的访问与实例对象关联，访问时使用对象名.字段。
5.接口声明主要由几部分组成，各部分的作用是什么？
接口声明形式：访问修饰符 interface 接口名
其中：接口的访问修饰符有new、public、protected、internal和private，各个修饰符都代表不同的访问权限。new修饰符仅允许在类中定义的接口内使用，它指定接口隐藏同名的继承成员。public、protected、private和internal修饰符用于控制接口的可访问性，与前面所介绍的意义相同。接口名称通常以I开头。要实现该接口，必须有类继承该接口。
6.在某些场合中，使用接口继承而不是类继承，为什么？
程序需要许多彼此无关的对象类型来提供特定功能，此时更适合使用接口
接口可以在基类不同的类之间实现多态性
接口比基类更加灵活，因为可以定义实现多个接口的单个实现
若不需要从基类继承实现，则接口是更好的选择
若不能使用类继承，则可以使用接口
7.什么是异常？异常有什么作用？
异常是错误的一种，它的结果是导致程序不能正确运行，如系统崩溃、程序非正常退出、死循环等。当抛出异常后，程序将不正常终止。但是，如果能很好的在程序中俘获异常并处理异常，可以增强程序的健壮性。
8.C#中处理异常采用的结构化异常处理语句有哪些？并简要说明。
C#中共包含3种结构化异常处理语句：try…catch语句，try…finally语句和try…catch…finally语句。其中：try块语句中用来指明有可能出现异常的代码；catch块内指明对所出现的异常的处理，若没有异常，则catch块不执行；finally块是无论是否发生异常均要执行的代码，主要用来清理资源或执行要在try块末尾执行的其它操作，或不需要清理代码，则可以不使用该块。
9.类的声明的一般形式是什么？
类的声明形式：[类的访问修饰符] class 类名[：基类]{ 类成员 }
最简单的声明类的语法为： class 类名 {类成员}
10.什么是继承？
继承是这样的一种能力，它可以使用现有类的所有功能，并且在无须重新编写原来的类的情况下对这些功能进行扩展。使用继承而产生的类被称为派生类或子类，被继承的类称为基类或父类。
11.什么是多态性？
继承使得在原有的类基础之上，对原有的程序进行扩展，从而提高程序开发的速度，实现代码的复用。同一种方法作用于不同对象可以产生不同的结果，这就是多态性。C#中的多态包括两类：编译时多态性和运行时的多态性。
12.C#定义了哪几种类的访问修饰符？
public 可以被任意存取
protected只可以被本类和其继承子类存取
internal只可以被本组合体（Assembly）内所有的类存取，组合体是C#语言中类被组合后的逻辑单位和物理单位，其编译后的文件扩展名往往是“.DLL”或“.EXE”。
protected internal唯一的一种组合限制修饰符，它只可以被本组合体内所有的类和这些类的继承子类所存取。
private只可以被本类所存取。
13.override与重载的区别
重载是方法的名称相同。参数或参数类型不同，进行多次重载以适应不同的需要；
override 是进行基类中函数的重写。为了适应需要。
14.什么是装箱和拆箱？
从值类型接口转换到引用类型装箱。从引用类型转换到值类型拆箱。
15.面向对象的思想的三个基本特征？
封装：用抽象的数据类型将数据和基于数据的操作封装在一起，数据被保护在抽象数据类型内部。
继承：子类拥有父类的所有数据和操作。
多态：一个程序中同名的不同方法共存的情况。。
16.sealed 修饰符有什么特点
sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。当应用于方法或属性时，sealed 修饰符必须始终与 override一起使用。
17.根据get和set访问器是否存在，属性可以分成哪几种类型？
对于属性，如果只设置get访问器，则为只读属性，若只设置set访问器，则为可写属性，两个访问器均存在时，为既可读又可写属性。
18.属性主要用于哪些情况？
C#中提供了属性来实现安全性。C#通过属性特性读取和写入字段，而不直接进行字段的读取和写入，以此来保护类中的字段。属性是类内部封装性的体现。
19.类所包含的成员种类有哪几种？
类的成员包括常量、字段、方法、构造函数、属性、事件、索引等。
20.C#方法有哪4种类型的参数？
（1）普通参数是指在声明方法时，形参前不加任何修饰的参数。若传递的是值类型的参数，则进行值传递，若是引用类型，则进行引用传递。
（2）引用类型参数（ref）。在值类型参数前加上关键字ref，表明实参与形参的传递方式是引用的，对形参的修改会影响实参的值。
（3）输出型参数（out）。与ref相似，该参数为引用类型参数。不同之处在于ref要求变量在作为参数传递之前必须要进行初始化，而out无需进行初始化。当希望方法返回多个值时，声明out方法是很有用。
（4）数组型参数（params）。有时希望能够传递任意个数的参数，使程序更加灵活，比如求2个数的和、3个数的和以及求一个数组各个元素的和，计算方法类似，可以通过一个方法实现，在方法中传递不同个数的参数即可。C#提供了params参数来实现这个功能。params可以使用个数不定的参数调用方法。
21.如何区别重载方法？
不同的参数类型;不同的参数个数;不同的参数顺序.
22.索引器与属性的主要差别是什么？
索引器与属性类似，可以使用get和set块定义索引元素的读写权限，与属性不同的是，索引器有索引参数。
23.构造函数有哪些特征？
（1）函数名与类名相同；（2）没有返回值类型；（3）系统自动调用
24.什么是装箱和拆箱？
从值类型接口转换到引用类型装箱。从引用类型转换到值类型拆箱。
25.结构化异常处理捕获异常的原则是什么？
先捕获特殊异常，再捕获普通异常。
26.简述变量的命名规则？
由数字、字母和下划线组成，不能以数字开头，不能是关键字。
27.简述C#中编译时的多态性和运行时多态性的区别。
编译时的多态性是通过我们前面所介绍的方法重载来实现的。运行时的多态是指直到系统运行时，才根据实际情况决定要实现何种操作。C#中运行时的多态性是通过虚方法来实现的。
28.什么是构造函数的重载？
构造函数中可以没有参数，也可以有一个或多个参数，多个参数之间用“，”隔开。一个类中可以有一个或多个构造函数，这表明在类中可以有多个函数名相同、但参数类型不同或者参数个数不同的构造函数，这叫构造函数重载。
29.简述类和结构的区别。
类的声明和结构的声明非常类似，只是限定符后面是 struct 还是 class 的区别，而且使用时，定义新的结构和定义新的类的方法也非常类似。类和结构的具体区别为：（1）结构是值类型，类是引用类型。（2）结构不能从另外一个结构或者类继承，本身也不能被继承，而类是完全可扩展的，自身也能被继承。（3）结构没有默认的构造函数，但是可以添加构造函数，没有析构函数；类有默认的构造函数，也有析构函数。
30.什么是抽象类和密封类？
抽象类用abstract修饰，能够包含抽象成员。抽象类不能直接实例化，也不能被密封，只能作为其它类的基类。密封类用sealed修饰，不能用作基类。因此，它也不能是抽象类。密封类主要用于防止派生。
31.如何声明基类虚方法，并在派生类中重载基类虚方法？
定义虚方法要用到virtual关键字。如果在派生类中要重写基类的方法，需要用override关键字。
32.什么是委托？委托与C/C++的函数指针有何不同？
函数指针用指针获取一个函数的入口地址，实现对函数的操作。委托与函数指针不同，委托是引用类型，是面向对象的，在使用时要先定义后实例化，然后再调用。委托可以在运行时间接调用一个或多个方法。
33.什么是多播委托？
一个委托只与一个方法关联，称为单路广播委托，也可以将一个委托与多个方法关联，称为多路广播委托，简称多播委托。多播委托通过使用“+”把方法加入执行队列。只调用一个委托就可以完成对多个方法的调用，并且传递给委托的参数会传递到委托所包含的每一个方法。
34.什么是事件？
事件作为C#的一种类型，主要为类和类的实例定义发出通知的能力，从而将事件和可执行代码捆绑在一起。事件最常见于窗体编程，如点击按钮事件、鼠标移动事件等等。
35.如何在程序中定义和使用自定义事件？
（1）首先，必须在类中声明事件并确定将要使用的委托和参数。
（2）其次，必须定义在触发事件时要调用的委托。
（3）最后，必须设计事件参数类，该参数类的实例会将信息传递给被调用的方法。如果使用内置的EventArgs对象和EventHandler委托，则可以不执行该步骤。
36.面向对象程序设计的特征是什么？
面向对象程序设计（OOP）通过类、对象、继承、多态等机制形成一个完善的编程体系。OOP将程序设计中的数据与对数据的操作作为一个不可分割的整体，通过由类生成的对象来组织程序。
37.对象的方法与对象的事件方法有何异同？
两者都是用一段代码完成特定的功能。事件方法代码是由用户添加的，事件方法由事件的发生而被自动调用；对象的方法代码是系统预定义的，对用户是隐藏的，不可见的，而且对象的方法必须在代码中调用。
38.C#集成开发环境中主要有哪些窗体？
C#集成开发环境中主要有起始页、设计器视图与代码视图、解决方案资源管理器与类视图、工具箱与服务器资源管理器、属性与动态帮助等。
39.简述按钮、标签和文本框控件的作用。
按钮控件通常用来接收用户的操作信息，激发相应的事件，按钮是用户与程序交互的最简便的方法。标签控件的主要功能是输出信息，可以用来标识其他无法显示标题的控件。文本框控件用于数据的输入与输出，文本框中的文本在程序运行时，可以被用户编辑。
40.命名空间有什么作用？
命名空间既是Visual Studio.NET提供系统资源的分层组织方式，也是分层组织程序的方式。命名空间有两种：一种是系统命名空间，一种是用户自定义命名空间。
41.C#有几种表达式？根据什么确定表达式的类型？
在C#中，基本表达式有5种：算术表达式、关系表达式、逻辑表达式、条件表达式和赋值表达式.表达式的类型由运算符的类型决定。
42.switch语句控制表达式可以是哪几种数据类型？
Switch语句控制表达式所允许的数据类型为：整数类型、字符类型、字符串类型或者枚举类型，可以能够隐式转换成上述类型的其他类型。
43.单选按钮与复选框控件各有什么作用？
RadioButton控件即单选按钮，提供由两个或两个以上互斥选项组成的选项集。它支持勾选和不勾选两种状态，在文字前用一个可以勾选的圆点来表示，用户只能在一组选项中选择一项。CheckBox控件即复选框控件，通常用来设置选项，用户可以一次选择任意数量的复选框。
44.简述值类型与引用类型的区别。
值类型变量直接包含其本身的数据，因此每个值类型变量本身就包含有赋给它的值。引用类型变量本身不包含数据，只是存储对数据的引用，数据保存在内存的其他位置。
45.基类中的字段通常使用什么类型的访问修饰符，为什么？
在类的继承中，作为基类的数据成员通常使用protected修饰符，而不使用private修饰符。因为如果在基类中使用private修饰符声明数据成员，则其成员将不允许派生类成员访问，而使用protected修饰符，既能保证数据成员不被直接访问，又允许其派生类成员访问。
46.什么是数组？数组最适合在哪种情况下使用？
在C#中，把一组具有同一名字、不同下标的下标变量成为数组。实际应用中，往往会遇到具有相同属性的一批数据，此时，应该考虑使用数组来管理或处理这些有规律的数据。数组是引用类型。
47.自定义的数据类型包括哪些？它们有什么作用？
自定义数据类型包括结构和枚举，结构和枚举都属于值类型。结构类型可以用来处理一组类型不同、内容相关的数据。枚举类型是由用户定义的一组整型符号常量，使用枚举可以将一组相关的有限常量组织在一起，保证变量只能具有预订的值。
48.实际应用中，菜单分为哪两种形式？C#中设计主菜单使用哪种控件？
实际应用中，菜单分为主菜单和弹出式菜单（上下文菜单）。通常使用MenuStrip控件实现主菜单设计。
49.简述文本文件与二进制文件的区别。
文本文件中字节单元的内容为字符的代码，在二进制文件中，文件内容是数据的内部表示，是从内存中直接复制过来的。两者对于字符信息无差别，而对于数值信息，数据的内部表示和字符代码截然不同。二进制文件中的数据不需要进行转换，文本文件中的数据需要进行转换。
50.简述已连接环境与非连接环境的区别与优缺点。
已连接环境是指应用程序和数据库之间保持连续的通信，优点是能及时刷新数据库，安全性较高，缺点是需要固定的数据库连接，不宜多个用户共同使用同一个数据库，扩展性差。非连接环境是指应用程序能够在与数据库断开的情况下进行操作，优点是应用程序可以随时连接到数据库获取相应的信息，缺点是获得的数据可能不是最新的，并且对数据更改时可能引发冲突，因为在某一时刻可能有多个用户同时对统一数据操作。
51.何谓数据绑定技术？
所谓数据绑定技术就是把已经打开的数据集中某个或者字段绑定到组件的某些属性上的一种技术，就是把已经打开的数据的某个或者某些字段绑定到TextBox、ListBox、ComboBox等组件能够显示数据的属性上，当对组件完场数据绑定后，其显示字段的内容将随着数据记录指针的变化而变化。
52.事件是一种委托吗？为什么？
事件不是委托，不过由于事件的性质决定了处理它的程序逻辑能访问的参数，因此，在C#中处理事件的逻辑都包装为委托。
53.列举ADO.NET中的五个主要对象，并简单描述
Connection连接对象，Command执行命令和存储过程，DataReader向前只读的数据流，DataAdapter适配器，支持增删查询，DataSet数据级对象，相当于内存里的一张或多张表。
54.new关键字用法
(1)new运算符用于创建对象和调用构造函数。

(2)new修饰符用于向基类成员隐藏继承成员。
(3)new约束用于在泛型声明中约束可能用作类型参数的参数的类型。
55.C#中，string str = null与string str =""，请尽量用文字说明区别。
string str =""初始化对象分配空间，而string str=null初始化对象
56.C#中的接口和类有什么异同。
异：不能直接实例化接口。接口不包含方法的实现。接口、类和结构可从多个接口继承。但是C#只支持单继承：类只能从一个基类继承实现。类定义可在不同的源文件之间进行拆分。
同：接口、类和结构可从多个接口继承。接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。接口可以包含事件、索引器、方法和属性。一个类可以实现多个接口。
57.接口是否可以继承接口？抽象类是否可以实现接口？抽象类是否可以继承实体类？
接口是可以继承接口的，抽象类是可以实现接口的，抽象类可以继承实体类，但是有个条件，条件是，实体类必须要有明确的构造函数。
58.用最有效的方法算出2乘以8等于几？
2<<3.
59.数组有没有Length()这和方法？string有没有这个方法？
数组中没有这个方法，但有这个属性，string中有这个方法。
60.Override, Overload,的区别？
Override是重写的意思，它表示重写基类的方法，而且方法的名称，返回类型，参数类型，参数个数要与基类相同。Overload是重载是意思，它也表示重写基类的方法，但是只要方法名相同，别的可以不同。
61.C#种索引器实现过程，是否只能根据数字索引？
不是的，可以是任意类型。
62.Const和ReadOnly？
Const用来声明编程时常量，ReadOnly用来声明运行时常量。
63.在.NET中所有类的基类是？
Object
64…NET中读写数据库需要用到那些类？他们的作用？
DataSet:数据存储器；DataCommand:执行语句命令；DataAdapter:数据的集合，用于填充。
65.成员变量和成员函数前加static的作用？
它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。分别用来反映类的状态。比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。
66.什么是ASP.net中的用户控件？
用户控件一般用在内容多为静态,或者少许会改变的情况下…用的比较大…类似ASP中的include…但是功能要强大的多。
67…NET的错误处理机制是什么？
.net错误处理机制采用try->catch->finally结构，发生错误时，层层上抛，直到找到匹配的Catch为止。
68.ADO.NET相对于ADO等主要有什么改进？
1:ado.net不依赖于ole db提供程序,而是使用.net托管提供的程序,2:不使用com3:不在支持动态游标和服务器端游 4:,可以断开connection而保留当前数据集可用 5:强类型转换 6:xml支持
69.&和&&的区别。
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）.
70.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
71…<%# %> 和 <% %> 有什么区别？
<%# %>表示绑定的数据源;<% %>是服务器端代码块.
72.如何理解.net中的垃圾回收机制?
.NET中的垃圾回收机制是引用程序对内存的回收和释放。当每次用new关键字创建一个对象时，运行库都要从托管堆中为其分配内存，因为空间是有限的，最终垃圾回收机制是要回收不用的内存的。已释放内存，重新使用。
73.Heap与stack的差别?
Heap是堆，空间是由手动操作分配和释放的，它的存储区很大的自由存储区。
Stack是栈，是由是操作系统自动分配和释放的，栈上的空间是有限的。程序在编译期间变量和函数分配内存都是在栈上进行的，且在运行时函数调用时的参数的传递也是在栈上进行的。
74.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。
75.如何处理几十万条并发数据？
用存储过程或事务。取得最大标识的时候同时更新…注意主键不是自增量方式这种方法并发的时候是不会有重复主键的…取得最大标识要有一个存储过程来获取.
76.ASP.NET与ASP相比，主要有哪些进步？
答：asp解释形，aspx编译型，性能提高，有利于保护源码。
77.DataReader和DataSet的异同
DataReader使用时始终占用SqlConnection,在线操作数据库…任何对SqlConnection的操作都会引发DataReader的异常…因为DataReader每次只在内存中加载一条数据,所以占用的内存是很小的…因为DataReader的特殊性和高性能.所以DataReader是只进的…你读了第一条后就不能再去读取第一条了…
DataSet则是将数据一次性加载在内存中.抛弃数据库连接…读取完毕即放弃数据库连接…因为DataSet将数据全部加载在内存中.所以比较消耗内存…但是确比DataReader要灵活…可以动态的添加行,列,数据.对数据库进行回传更新操作.
78.存储过程和sql语句的优缺点
优点：1）提高性能，减少网络传输，节约时间。2）减少网络流量。存储过程位于服务器上，调用的时候只须传递存储过程的名称以及参数，不用每次访问都传递很长的sql语句。3）安全性。减少sql注入式攻击。4）可维护性高。更新存储过程通常比更改、测试以及重新部署程序集需要较少的时间和精力。
缺点：1.交互性差。2.可移植性差
79.怎样实现多态？
1.通过对象直接调用成员函数时，始终默认使用该对象的类的成员函数（除非用::显示指定类名）。
2.通过指向对象的指针或引用调用成员函数时：如果该函数是实函数，则调用该指针或引用的类的成员函数；如果该函
3.数是虚函数，则调用该指针或引用指向的对象的类的成员函数。
80.何时必须声明一个类为抽象类？
当这个类中包含抽象方法时，或是该类并没有完全实现父类的抽象方法时。
81.为什么不能指定接口中方法的修饰符？
接口中的方法用来定义对象之间通信的契约，指定接口中的方法为私有或保护没有意义。他们默认为公有方法。
82.虚函数的用法
1)virtual指明一成员函数为虚函数,而virtual仅用于类的定义里,在类外可不加此关键字
2)一个类的成员函数被定义为虚函数时,子类该函数仍保持虚函数特征.
3)子类覆盖此函数时,定义里可不加virtual关键字,但函数声明要和基类的完全一致!且此声明是必须的.
4)不是纯虚函数时,父类的虚函数必须要实现; 而若将父类的虚函数设定为纯虚函数时,子类必需要覆盖之而且必须要实现之!
83.解释virtual、sealed、override和abstract的区别
virtual声明虚方法的关键字，说明该方法可以被重写； sealed说明该类不可被继承；override重写基类的方法；abstract声明抽象类和抽象方法的关键字，抽象方法不提供实现，由子类实现，抽象类不可实例化。
84.能够将非静态的方法覆写成静态方法吗？
不能，覆写方法的签名必须与被覆写方法的签名保持一致，除了将virtual改为override。
85.ref与out区别？
1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。
86.如何在C#中实现继承？C#支持多重继承吗？
在类名后加上一个冒号，再加上基类的名称。不支持。可以用接口来实现。
87.私有成员会被继承吗？
会，但是不能被访问。所以看上去他们似乎是不能被继承的，但实际上确实被继承了。
88.在C＃中，string str = null 与 string str = “” 的区别。
string str = null 是不给他分配内存空间,而string str = “” 给它分配长度为空字符串的内存空间。
89.delegate是引用类型还是值类型？enum、int[]和string呢？
delegate引用类型，enum值类型，int[]引用类型，string引用类型。
90.请指出C#中是否有下列关键字？virtual、sealed、abstract、import、as、in、goto、final、Const、signed、String
没有的关键字：import、final、Const、signed、String
91.object是C#的关键字吗？请指出C#中有哪些类型关键字，如int、float。（提示，写得越多越好）。
是，object、int、uint、long、ulong、short、ushort、byte、sbyte、char、float、double、decimal、bool，如回答：enum、struct、class、delegate也算对。
92.62-63=1 等式不成立，请移动一个数字（不可以移动减号和等于号），使得等式成立，如何移动？
62移动成2的6次方
93.String s = new String(“xyz”);创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象。
94.命名空间System.Data的作用？　　　
主要包括了组成ADO.NET体系结构的类
95.什么叫泛型 (generics)？
使用泛型，可以定义使用类型参数定义的类和/或方法。当客户端代码实例化类型时，会指定一个特定的类型作为参数。
96.extern是什么意思？
extern 修饰符用于声明由程序集外部实现的成员函数经常用于系统API函数的调用（通过 DllImport ）。注意，和DllImport一起使用时要加上 static 修饰符也可以用于对于同一程序集不同版本组件的调用（用 extern 声明别名）不能与 abstract 修饰符同时使用。
97.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？
abstract 修饰符不可以和 static、virtual 和 override 修饰符一起使用
98.params 有什么用？
params 关键字在方法成员的参数列表中使用，为该方法提供了参数个数可变的能力它在只能出现一次并且不能在其后再有参数定义，之前可以
99.C#是否可以对内存直接进行操作？
C#是可以对内存进行直接操作的，虽然很少用到指针，但是C#是可以使用指针的，在用的时候需要在前边加unsafe,，在.net中使用了垃圾回收机制（GC）功能，它替代了程序员，不过在 C#中不可以直接使用finalize方法，而是在析构函数中调用基类的finalize()方法。
100.怎么理解封装性？举例说明。
封装是指用一个框架将数据和代码组合在一起，形成一个对象。一般情况下，数据都是被封装起来的，不能直接被外部访问。C#中，类是支持对象封装的工具，对象则是封装的基本单元。举例略。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/896452