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<K,V>
在C#中，以下Teacher类的构造函数的写法正确的是（）。AC
A:

public Teacher (){
    
      }

private void Teacher (){
    
      }

private Teacher (int id,string name) {
    
      }

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<string, Book> books = new Dictionary<string, Book>();
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);
}

num1:30,num2:50
num1:30,num2:50

num1:30,num2:50
num1:10,num2:50

num1:30,num2:50
num1:10,num2:20

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)构造函数 }

public Hero(string name)
{
    
     Person(name); }

public Hero(string name)
{
    
     base (name); }

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)

Copy(string filename1,string filename2)

Exists(string filename1,string filename2)

Move(string filename1,string filename2)

在C#中，使用下列（）关键字来定义结构。B
A:static
B:struct
C:abstract
D:enum
能与以下C#方法形成方法重载的是（）。CD

public int Fun(int p)
{
    
    …}

public int Fun(int p2)
{
    
    …}

B:pu

blic int Fun2(int p)
{
    
    …}

public string Fun(string p)
{
    
    …}

public bool Fun(bool p)
{
    
    …}

以下关于解析XML的说法正确的是（）。B
A:XML被称为可扩展标记语言，语法和HTML完全一致
B:XmlNode表示一个XML中的节点
C:XmlDocument对象可以表示整个XML文档，用Save()方法将指定的XML文件读入XmlDocument对象
D:XmlNode对象的属性ChildNode表示当前节点的所有子节点
在C#中，下列关于泛型集合Dictionary<K,V>说法错误的是（）。B
A:Dictionary<K,V>访问元素无须类型转换
B:添加/读取值类型元素需要拆箱、装箱
C:可以通过Key获取Value
D:Dictionary<K,V>是通过键/值对保存元素的
在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){
    
    ……//省略具体处理方法}

public double SetData (int iCnt,double iBnt){
    
    ……}

public int SetData (int iCnt, double dBnt,int iZnt){
    
    ……}

private int SetData (int iCnt,double dBnt){
    
    ……}

public int SetData (double dBnt, int iCnt){
    
    ……}

C# .Net笔试题 期末试题 含答案

猜你喜欢

C# .Net笔试题期末试题含答案