C# .Net笔试题 期末试题 含答案
-
C#中File类的（ ）方法可以检查指定文件是否存在。A
A:Exists( )
B:Copy( )
C:Move( )
D:Delete( ) -
在.NET中，下面关于.NET Framework描述错误的是（ ）。D
A:.NET框架可以安装在Windows操作系统上
B:.NET框架是运行在操作系统之上的
C:.NET框架支持C#、VB.NET、C++等开发语言
D:.NET应用程序不能运行在Linux上 -
在C#中，下面关于静态方法和实例方法描述错误的是（ ）。C
A:静态方法需要使用static关键字修饰
B:静态方法不可以直接访问实例成员
C:实例方法不可以直接访问静态成员
D:实例方法要使用实例对象调用 -
在C#中，如果要实现父类的成员在父类及其子类中可以访问，而其他类中无法访问，应使用（ ）修饰符修饰该成员。D
A:public
B:private
C:base
D:protected -
关于C#中的继承，以下说法错误的是（ ）。A
A:在子类中不能访问父类的protected成员
B:通过类的继承，既可以扩展类的功能，又可以复用类的功能
C:public class Student : Person表明Student的父类可能是Person
D:继承要符合is-a的关系 -
在C#中，下面有关继承的说法错误的是（ ）。C
A:子类可以再派生子类
B:子类就是父类的派生类
C:子类可以继承和访问父类的私有成员
D:一个子类不可以继承多个父类 -
在C#中，以下（ ）集合是通过键和值来组织的。BD
A:ArrayList
B:Hashtable
C:List
D:Dictionary -
在C#中，以下Teacher类的构造函数的写法正确的是（ ）。AC
A:
public Teacher (){ }
B:
private void Teacher (){ }
C:
private Teacher (int id,string name) { }
D:
public int Teacher (int id,string name) { }
-
在C#中，以下关于装箱和拆箱的说法正确的是（ ）。A
A:将值类型转换为引用类型的过程称为装箱，反之，成为拆箱
B:将值类型转换为引用类型的过程称为拆箱，反之，成为装箱
C:使用装箱和拆箱，可以提高程序性能
D:值类型的数据被装箱之后，不能被修改 -
运行以下C#代码，则输出（ ）。C
class Student
{
public static int id = 1;
public static void Alter()
{
id++;
}
}
class Program
{
static void Main(string[] args)
{
Student stu = new Student();
Student.id++;
Student.Alter();
Console.WriteLine(Student.id);
}
}
A:1
B:2
C:3
D:程序运行出错，不输出任何结果
-
在C#中，Student类继承自Person类，其中stuObj为Student对象，perObj为Person对象，下列代码中属于类型转换的是（ ）。AD
A:perObj as Student
B:perObj is Student
C:stuObj is Person
D:(Student) perObj -
关于C#的base关键字，说法错误的是（ ）。A
A:在父类中用base关键字修饰的成员，子类都可以用base来访问
B:base关键字可以调用父类的属性
C:base关键字可以调用父类的方法
D:base关键字可以调用父类的构造函数 -
运行以下C#代码，程序将输出（ ）。B
int num1 = 10;
Object obj = num1;
num1++;
Console.WriteLine("obj={0},num1={1}", (int)obj, num1);
A:obj=11,num1=10
B:obj=10,num1=11
C:obj=10,num1=10
D:obj=11,num1=11
-
以下C#代码中，Book为图书类，通过Book类构造函数可初始化其Name属性，则下面代码的输出结果为（ ）。A
Dictionary
books.Add(“1001”, new Book(“C#OOP”));
Console.WriteLine(books[“1001”].Name);
A:C#OOP
B:Book
C:1001
D:程序运行错误 -
运行下面的C#代码，以下说法正确的是（ ）。B
public class Student
{
public int age;
}
public class Program
{
static void Alter(Student stu)
{
stu.age++;
}
static void Main()
{
Student stu = new Student();
stu.age = 30;
Alter(stu);
Console.WriteLine("age={0} ",stu.age);
}
}
A:程序正常运行，输出：age=30
B:程序正常运行，输出：age=31
C:程序出错，输出：age=31
D:程序出错，什么也不输出
- 在控制台应用程序中，以下C#代码的输出结果是（ ）。B
static void Main(string[] args)
{
int num1 = 10, num2 = 20;
fun(num1, ref num2);
Console.WriteLine("num1:" + num1 + ",num2:" + num2);
}
static void fun(int num1,ref int num2)
{
num1 += num2;
num2 += num1;
Console.WriteLine("num1:"+num1+",num2:"+num2);
}
A:
num1:30,num2:50
num1:30,num2:50
B:
num1:30,num2:50
num1:10,num2:50
C:
num1:30,num2:50
num1:10,num2:20
D:
num1:10,num2:20
num1:10,num2:20
- 在C#中，下面代码的运行结果是（ ）。A
public class Fruit
{
public virtual void Show()
{
Console.WriteLine("水果的味道不同!");
}
}
public class Lemon: Fruit
{
public override void Show(){
Console.WriteLine("柠檬是酸的!");
}
}
class Program
{
static void Main(string[] args)
{
Fruit lemon = new Fruit ();
lemon. Show();
}
}
A:输出“水果的味道不同！”
B:输出“柠檬是酸的！”
C:程序不出错，但什么也不输出
D:程序出错，提示对象类型不一致
- 关于以下C#代码，说法正确的是（ ）。D
public struct Student
{
public int id;
public int age;
public void Say()
{
Console.WriteLine("hello！");
}
}
class Program
{
static void Main(string[] args)
{
Student stu;
stu.id = 1;
stu.age = 20;
stu.Say();
}
}
A:结构中不能定义方法，所以在结构Student中定义Say()方法是错误的
B:Student stu;这句代码错误，因为必须用new关键字实例化结构对象
C:代码无错误，但运行程序不会输出任何结果
D:代码无错误，程序可以正常执行，将输出“hello！”
- 以下C#代码的运行结果是（ ）。D
public abstract class FaClass
{
public void FaClass()
{
Console.Write("1");
}
abstract public void ABSMethod();
}
public class SonClass : FaClass
{
public SonClass()
{
Console.Write("2");
}
public override void ABSMethod()
{
Console.Write("3");
}
static void Main()
{
SonClass objB = new SonClass();
objB.ABSMethod();
}
}
A:12
B:21
C:13
D:23
- 以下C#代码的输出结果是（ ）。B
public class Person
{
public Person()
{
Console.WriteLine("无名英雄");
}
public Person(string name)
{
Console.WriteLine("我叫" + name);
}
}
public class Student : Person
{
public Student(string name)
{
Console.WriteLine("我是" + name + "同学");
}
static void Main(string[] args)
{
Student student = new Student("孙悟空");
Console.ReadLine();
}
}
A:我是孙悟空同学
B:无名英雄
我是孙悟空同学
C:我叫孙悟空
我是孙悟空同学
D:无名英雄
我叫孙悟空
我是孙悟空同学
-
下列关于C#的抽象方法说法正确的是（ ）。B
A:使用virtual修饰
B:抽象方法无方法体
C:抽象类中必须有抽象方法
D:非抽象类中的抽象方法可以有方法体 -
在.NET框架结构中，公共语言运行时（CLR），由（ ）两个组成部分。BD
A:MSIL
B:CLS
C:FCL
D:CTS -
在C#里，下面（ ）不是File类的方法。C
A:Move()方法
B:Exists()方法
C:Update()方法
D:Delete()方法 -
执行如下C#代码，输出结果是（ ）。D
List<string> list = new List<string>();
list.Add("张三");
list.Add("李四");
list.Remove("张三");
Console.WriteLine(list[0]);
A:null
B:0
C:张三
D:李四
-
在C#程序中，可以使用（ ）获取XML文件当前节点的值。D
A:XmlNode的Text属性
B:XmlNode的ChildNodes属性
C:XmlNode的Name属性
D:XmlNode的InnerText属性 -
以下C#代码中，执行装箱的次数为（ ）。B
static void Main(string[] args)
{
int i = 321;
object o = i;
float j = (float)o;
Console.WriteLine(j);
}
A:0
B:1
C:2
D:3
- 在C#中，如下代码对控件tvMenu(TreeView控件)进行操作，下列选项描述错误的是（ ）。C
this.tvMenu.Nodes.Add("节点"); //代码1
this.tvMenu.SelectedNode.Remove();//代码2
this.tvMenu. SelectedNode.Nodes.Clear();//代码3
this.tvMenu.Nodes.Clear();//代码4
A:执行“代码1”为tvMenu添加一个节点
B:执行“代码2”删除tvMenu当前选中节点
C:执行“代码3”清空tvMenu当前选中的节点以及其子节点
D:执行“代码4”清空tvMenu所有子节点
-
在.NET框架类库中，下列（ ）命名空间用于访问ADO.NET。B
A:System
B:System.Data
C:System.Net
D:System.Collections.Generic -
关于以下C#代码，说法不正确的是（ ）。C
Dictionary<string, Student> student = new Dictionary<string, Student>();
student.Add("s001",new Student("Mike"));
student.Add("s002",new Student("张三"));
student.Remove(0);
Console.WriteLine(student.Values.Count);
A:集合student以键值对的方式存储数据
B:集合student中存储了两个学生对象，键分别是“s001”、 “s002”
C:程序无错误，输出结果为2
D:student.Remove(0);此行代码有错误
- 以下C#代码，如需要在Hero类中重写Person类的ToLive()方法，则横线处应依次填入（ ）。D
public class Person
{
public ________ void ToLive()
{ Console.WriteLine("生下来，活下去");}
}
public class Hero : Person
{
public ________ void ToLive()
{Console.WriteLine("生当作人杰，死亦为鬼雄");}
}
A:不填 不填
B:override virtual
C:不填 override
D:virtual override
- 阅读以下C#代码，选项中说法正确的是（ ）。D
public class A
{
public int sign1;
}
public class B
{
public int sign2;
}
public class C : A,B
{
public int sign3;
static void Main(string[] args)
{
C objC = new C();
objC.sign1 = 1;
objC.sign2 = 2;
objC.sign3 = 3;
Console.WriteLine(objC.sign1+","+objC.sign2+","+objC.sign3);
}
}
A:运行程序将输出：1，2，3
B:C类是A类和B类的子类，所以C类继承了A类和B类中的所有成员
C:C类只能继承A类的成员，不能继承B类的成员
D:程序编译错误，提示C不能具有多个基类A和B
- 以下C#代码，选项中的子类构造函数调用父类构造函数正确的是（ ）。D
public class Person
{
public string name;
public Person(string name)
{ this.name = name; }
}
public class Hero : Person
{ //需要显式调用父类Person(string name)构造函数 }
A:
public Hero(string name)
{ Person(name); }
B:
public Hero(string name)
{ base (name); }
C:
public Hero(string name): Person(name){ }
D:`
public Hero(string name): base(name){ }`
-
在C#中，关于文件操作相关的类说法正确的是（ ）。AB
A:FileInfo类提供了用于操作文件的实例方法
B:File类提供了用于操作文件的静态方法
C:Directory类提供了操作目录的实例方法
D:DirectoryInfo类提供了操作目录的静态方法 -
在C#中，下列File类的方法中（ ）可以实现将指定文件移动到一个新的路径。D
A:
Delete(string filename1,string filename2)
B:
Copy(string filename1,string filename2)
C:
Exists(string filename1,string filename2)
D:
Move(string filename1,string filename2)
-
在C#中，使用下列（ ）关键字来定义结构。B
A:static
B:struct
C:abstract
D:enum -
能与以下C#方法形成方法重载的是（ ）。CD
public int Fun(int p)
{…}
A:
public int Fun(int p2)
{…}
B:pu
blic int Fun2(int p)
{…}
C:
public string Fun(string p)
{…}
D:
public bool Fun(bool p)
{…}
-
以下关于解析XML的说法正确的是（ ）。B
A:XML被称为可扩展标记语言，语法和HTML完全一致
B:XmlNode表示一个XML中的节点
C:XmlDocument对象可以表示整个XML文档，用Save()方法将指定的XML文件读入XmlDocument对象
D:XmlNode对象的属性ChildNode表示当前节点的所有子节点 -
在C#中，下列关于泛型集合Dictionary
A:Dictionary
B:添加/读取值类型元素需要拆箱、装箱
C:可以通过Key获取Value
D:Dictionary -
在C#中，以下关于base关键字的说法正确的是（ ）。BD
A:base关键字和this关键字的用法完全一样
B:在子类中，可以使用base关键字访问父类的公有属性。语法为：base.父类的属性
C:在子类中，可以使用base关键字调用父类的构造函数，实现继承属性的初始化。语法为：base.父类构造函数( )
D:在子类中，使用base关键字不能访问父类的private字段 -
在C#中，以下关于结构的说法错误的是（ ）。AB
A:结构是引用类型
B:和类一样，定义结构的对象时必须用new关键字
C:定义结构使用struct关键字
D:结构中可以有字段，也可以有方法 -
.NET框架的核心组件包括（ ）。BD
A:CTS
B:CLR
C:CLS
D:FCL -
在C# 中，以下关于XML的说法不正确的是（ ）。A
A:XML被称为可扩展标记语言，语法和HTML完全一致
B:XmlNode表示一个XML中的节点
C:XmlDocument对象可以表示整个XML文档，用Load()方法将指定的XML文件读入XmlDocument对象
D:XmlNode对象的属性ChildNodes表示当前节点的所有子节点 -
运行以下C#代码，则可能出错的代码行是（ ）。C
class Student
{
public static int id =1; //1
int age=20;
public static void Alter()
{
id++; //2
age++; //3
}
}
class Program
{
static void Main(string[] args)
{
Student stu = new Student();
stu.Alter(); //4
}
}
A:1
B:1、2
C:3、4
D:1、2、3、4
-
在C#中，关于继承和方法重写，以下说法正确的是（ ）。D
A:父类的虚方法不能被子类的子类重写
B:父类的方法被子类重写后就不能被父类对象调用了
C:只有使用virtual关键字修饰的方法才可以被重写
D:使用override关键字实现方法重写 -
在C#中，关于装箱拆箱的说法正确的是（ ）。AD
A:将值类型转换为引用类型的过程称为装箱，反之，称为拆箱
B:拆箱是隐式进行的，不需要显示转换
C:在实际开发中，装箱和拆箱操作会提高程序的性能
D:读取泛型集合元素时无须拆箱、装箱 -
执行下面的C#代码，输出的结果是（ ）。B
public class Number
{
public int num;
}
public class Program
{
static void Change(Number n)
{
n. num = 17;
}
static void Main()
{
Number n = new Number();
n. num = 7;
Change(n);
Console.WriteLine(n. num);
}
}
A:7
B:17
C:717
D:程序编译出错
- 在C#中，如下代码的运行结果是（ ）。B
class Temp
{
int _iCnt;
public Temp(int iName)
{
_iCnt = iName;
}
public Temp()
{
_iCnt = 9;
}
public void Sum(int iName)
{
_iCnt += iName;
}
public void Output()
{
Console.WriteLine(_iCnt);
Console.ReadLine();
}
}
class Program
{
static void Main(string[] args)
{
Temp temp = new Temp(5);
temp = new Temp();
temp.Sum(4);
temp.Output();
}
}
A:18
B:13
C:9
D:编译错误
- 在.NET中，以下关于装箱和拆箱的描述，正确的是（A）。
A:int i=32;
object o =(object)i;
这是装箱操作
B:double num1=11.49;
int num2 =(int) num1;
这是拆箱操作
C:拆箱是将值类型转换成引用类型
D:装箱和拆箱操作对程序性能没有影响 - 在C#中，关于以下代码的说法错误的是（B）。
try
{
}
catch (SqlException ex)
{
throw ex;
}
catch (IOException ex)
{
return null;
}
finally
{
}
A:两个catch块可以颠倒顺序，不会影响异常的处理
B:以上代码可以捕获try块中的任何异常
C:如果出现IO异常，以上代码不能正常反馈错误
D:finally块最终一定会执行
50. 在.NET平台中，以下（C）不属于.NET程序集的组成部分。
A:程序集清单
B:类型元数据
C:数据配置文件
D:MSIL代码
51. 在C#中，关于方法重写，以下说法正确的是（BD）。
A:方法重写就是方法重载，二者是一回事，只不过是两种叫法
B:方法重写是子类重写父类的方法
C:使用virtual关键字修饰的方法不可以被重写
D:使用override关键字实现方法重写
52. 在C#中，有如下SetData方法，则以下选项中（AC）不是SetData方法的重载方法。
public int SetData (int iCnt,double dBnt){……//省略具体处理方法}
A:
public double SetData (int iCnt,double iBnt){……}
B:
public int SetData (int iCnt, double dBnt,int iZnt){……}
C:
private int SetData (int iCnt,double dBnt){……}
D:
public int SetData (double dBnt, int iCnt){……}