Net笔试题1.doc

Net笔试题1

资料仅供参考
.Net笔试题1：说说什么叫字符串不可变？string s="abc";s="123"字符串s不就变了吗？
 答：String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创立一个新的字符串对象，这就需要为该新对象分配新的空间。
String是不可变的。在这段代码中，s原先指向一个String对象，内容是 "abc"，然后我们将s指向"123"，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"123"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
扩展：在需要对字符串执行重复修改的情况下，与创立新的String 对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创立新的对象，则能够使用System.Text.StringBuilder 类。例如，当在一个循环中将许多字符串连接在一起时，使用StringBuilder类能够提升性能。

.net笔试题2：BS与CS的联系与区别？
答：C/S是Client/Server的缩写。客户端需要安装专用的客户端软件。
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器。在这种结构下，用户界面完全经过浏览器实现，一部分事务逻辑在前端实现，可是主要逻辑在服务器端实现。浏览器经过Ｗeb Server 同数据库进行数据交互。
C/S 与 B/S 区别：
１）．硬件环境不同:
　　C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再经过专门服务器提供连接和数据交换服务.
　　B/S 一般建立在广域网之上的,  有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行 。
２)．对安全要求不同
　　C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 能够经过B/S发布部分可公开信息.
　　B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
3)．处理问题不同
　　C/S 程序能够处理用户面固定, 而且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统。C/S的客户端由于是本地程序，因此和本地硬件、程序的交互性很强，比如能够控制本机的其它程序、能够读写本地磁盘文件、能够与硬件交互。
　　B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小，正应为如此B/S很难和本地硬件、程序、文件进行交互，比如很难控制本机的其它程序、很难读写本地磁盘文件、很难与硬件交互，当然能够用ActiveX技术解决。

.net笔试题3：下面的程序执行结果是什么？
 (class Person
{
     public int Age { get; set; }
}
int a = 20;
int b = a;
a++;
Console.WriteLine(b);     //结果是20

Person p1 = new Person();
p1.Age = 20;
Person p2 = p1;
p1.Age++;
Console.WriteLine(p2.Age); //结果是21

.net笔试题4：填空
Http默认的端口号是80、
Ftp默认的端口号是21、
SQLServer的默认端口号是1433

.net笔试题5：如果不用VisualStudio，用哪个命令行编译C#程序？
答：csc.exe。

.net笔试题6：.Net Framework中的类是专门供C#调用的是吗？
 答：错。VB.Net等语言都能够调用.Net Framework中的类。

.net笔试题7：.Net、ASP.Net、C#、VisualStudio之间的关系是什么？
答：Net一般指的是.Net Framework，提供了基础的.Net类，这些类能够被任何一种.Net编程语言调用，.Net Framework还提供了CLR、JIT、GC等基础功能。
ASP.Net是.Net中用来进行Web开发的一种技术，ASP.Net的页面部分写在aspx 文件中，逻辑代码一般经过Code-behind的方式用C#、VB.Net等支持.Net的语言编写。
C#是使用最广泛的支持.Net的编程语言。除了C#还有VB.Net、IronPython等。
VisualStudio是微软提供的用来进行.Net开发的集成开发环境（IDE），使用VisualStudio能够简化很多工作，不用程序员直接调用csc.exe等命令行进行程序的编译，而且VisualStudio提供了代码自动完成、代码高亮等功能方便开发。除了VisualStudio，还有SharpDevelop、MonoDevelop等免费、开源的IDE，VisualStudio Express版这个免费版本。

.net笔试题8：能说出尽可能多的数据库管理系统？
 答：MSSQLServer、Oracle、Access、DB2、Sybase

.net笔试题9：在C＃中，string str = null 与 string str = ""的区别
答：string str = null 是不给她分配内存空间,而string str = "" 给它分配长度为空字符串的内存空间

.net笔试题10：请详述在dotnet中类(class)与结构(struct)的异同？
 答：Class能够被实例化,属于引用类型,是分配在内存的堆上的。类是引用传递的。
Struct属于值类型,是分配在内存的栈上的。结构体是复制传递的

.net笔试题11：DataReader和DataSet的异同？
答：DataReader和DataSet最大的区别在于,DataReader使用时始终占用SqlConnection,在线操作数据库..任何对SqlConnection的操作都会引发DataReader的异常..因为DataReader每次只在内存中加载一条数据,因此占用的内存是很小的..因为DataReader的特殊性和高性能.因此DataReader是只进的..你读了第一条后就不能再去读取第一条了..
DataSet则是将数据一次性加载在内存中.抛弃数据库连接..读取完毕即放弃数据库连接..因为DataSet将数据全部加载在内存中.因此比较消耗内存...可是确比DataReader要灵活。

.net笔试题12：C#中的委托是什么？事件是不是一种委托？事件和委托的关系？
答：委托是一种安全的函数指针，事件是一种消息机制
委托能够把一个方法作为参数代入另一个方法。
委托能够理解为指向一个函数的指针。
委托和事件没有可比性，因为委托是类型，事件是对象，下面说的是委托的对象（用委托方式实现的事件）和（标准的event方式实现）事件的区别。事件的内部是用委托实现的。因为对于事件来讲，外部只能“注册自己+=、注销自己-=”，外界不能够注销其它的注册者，外界不能够主动触发事件，因此如果用Delegate就没法进行上面的控制，因此诞生了事件这种语法。事件是用来阉割委托实例的，类比用一个自定义类阉割List。事件只能add、remove自己，不能赋值。事件只能+=、-=，不能= 。

.net笔试题13：进程和线程的区别
答：进程是系统进行资源分配和调度的单位；线程是CPU调度和分派的单位，一个进程能够有多个线程，这些线程共享这个进程的资源。

.net笔试题14：在.Net中，类System.Web.UI.Page 能够被继承么？
 答：能够

.net笔试题15：概述反射和序列化
反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您能够使用反射动态地创立类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，能够调用类型的方法或访问其字段和属性

序列化:序列化是将对象转换为容易传输的格式的过程。例如，能够序列化一个对象，然后使用 HTTP 经过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。

.net笔试题16：用sealed修饰的类有什么特点
答：sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其它类的基类，则会发生编译时错误。

.net笔试题17：UDP连接和TCP连接的异同
答：前者只管传,不论数据到不到,无须建立连接.后者保证传输的数据准确,须要连结

.net笔试题18：属性和public字段的区别是什么？
答：调用set方法为一个属性设值，然后用get方法读取出来的值一定是set进去的值吗？
属性能够对设值、取值的过程进行非法值控制，比如年龄禁止设值负数，而字段则不能进行这样的设置。虽然一般情况下get读取的值就是set设置的值，可是能够让get读取的值不是set设置的值的。 

.net笔试题19：里面包含20个选择题
1、  不能重载索引器（B）
a)对                       b)错
2、  能够为索引器指定（B）索引参数（选择一项）
a)       只能一个  b)一个或多个c)只能两个或多于两个d)以上说法都不对
3、  以下说法正确的是：A
a)一个委托在某一时刻能够指向多个方法。
b)一个委托在某一时刻不能够指向多个方法。
c)一个委托在某一时刻只能指向多个方法。
d)一个委托在某一时刻能够指向多个事件。
4、将事件通知其它对象的对象称为：A
   a)发布方b)订户c)通知方d)接受方
5、建议不要使用只写属性（A）
   a) 对     b)错
6、下列说法不正确的有（选择三项）ABD
   a)属性经过使用访问器来读写数据库中的数据，从而为保护数据库中字段提供了可能
b)属性经过使用访问器来读写类中的数据，从而为保护数据库中字段提供了可能
c)属性经过使用访问器来读写类中的字段，从而为保护类中字段提供了可能
d)属性经过使用访问器来读写数据库中的数据，从而为保护类中字段提供了可能
7、下列关于索引器说法正确的有（三项）ABD
   a)索引器不指向内存位置     b)索引器能够有非整数下标
c)索引器不指向get 和set访问器    d)索引器能够重载
8、下列关于索引器说法正确的有（三项）BCD
   a)不必指定决定索引器可见性的访问修饰符  b)必须说明索引器返回类型
c)必须指定this关键字                    d)必须指定索引的数据类型
9、下列说法正确的有：（三项）ABC
   a)必须声明索引的变量名       b)索引器能够建立两个或多个参数的索引
c)定义索引器时必须指定至少一个索引器参数   d)使用索引器时能够不为其参数赋值
10、属性的类型有：（选择三项）ABD
   a) 读\写属性      b)只读属性
c)只读\只写属性   d)只写属性
11、下列说法正确的有（选二项）AD
   a) 只有 get访问器的属性称为只读属性   b)只有get访问器的属性称为只写属性
c)只有set访问器的属性称为只读属性     d)只有set访问器的属性称为只写属性
12、下列说明不正确的有（选择二项）AC
   a)属性是物理字段    b)属性是字段的扩展
c)属性直接对应于存储位置   d)属性是逻辑字段
13、使用委托涉及的步骤有：a，实例化委托  b。定义委托  c.使用委托，请选择正确的步骤：B
   a) a-b-c    b)b-a-c    c)c-a-b    d)c-b-a
14、下列说法正确的有（选择三项）ACD
   a)必须指定用于设置委托可见性的访问修饰符   b)必须指定关键字distance
c)必须指定委托的返回类型                   d)必须指定委托名，然后是分号

15.可用于设置委托可见性的访问修饰符有：（选择三项）BC(有问题)
   A .NEW   B. PUBLIC   C. INTERNAL   D. OVERRIDE
16.C#中处理事件的步骤有：A.将事件通知订户   B.定义事件   C.给对象预定事件C
请选择正确的步骤：A.  A-B-C    B.  C-B-A     C.  B-C-A     D.  B-A-C
17.在C#中属性常见的访问修饰符是（C）：（选择一项）
   A. NEW   B. STATIC   C. PUBLIC   D.VIRTUAL
18.下面说明正确的有（选择二项）AC
   A.GET访问器，必须返回属性类型的值。
   B.GET访问器，使用VALUE隐式参数。
   C.对属性赋值时调用SET访问器。
   D.SET相当于读取字段的值。
19.下列说法不正确的有(选择二项)AC
   A.只带有GET访问器的属性成为只读属性。
   B.只写属性能够赋值，能够对其进行引用。
   C.无法对只读属性赋值。
   D.同时带动GET和SET访问器的属性为只读只写属性。
20.C#使用（C）的功能来读写类中的字段，从而便于为这些字段提供保护。
   A.索引器   B.委托   C.属性   D.事件

.net笔试题20：什么是内存泄漏，怎样最简单的方法判断被存泄漏 ?
内存被分配，但没有被释放，就是内存泄露。在任务管理器里面看到程序占用内存越来越多，却没有减少的迹象，很可能就发生了内存泄露。

.net笔试题21：什么是TCP/IP/UDP）(TCP/UDP之间的区别是什么？
TCP是基于连接的协议一次请求一次回应(打电话)TRANSFER CONTROL PROTOCOL/INTERNET PROTOCOL,
UDP USER DATA是非连接的只管发送(发邮件)
TcP是传输控制协议,IP是网际协议,UDP是用户数据包协议

.net笔试题22：静态成员和非静态成员的区别？
  静态变量使用 static 修饰符进行声明，在类被实例化时创立，经过类进行访问不带有 static 修饰符声明的变量称做非静态变量，在对象被实例化时创立，经过对象进行访问一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量能够是不同的值静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等

.net笔试题23：const 和 static readonly 区别？
答：const
用 const 修饰符声明的成员叫常量，是在编译期初始化并嵌入到客户端程序
static readonly
用 static readonly 修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法：经过类进行访问、初始化后不能够修改。但与常量不同的是这种变量是在运行期初始化

.net笔试题24：extern 是什么意思？
extern 是什么意思？
答：extern 修饰符用于声明由程序集外部实现的成员函数经常见于系统API函数的调用（经过 DllImport ）。注意，和DllImport一起使用时要加上 static 修饰符也能够用于对于同一程序集不同版本组件的调用（用 extern 声明别名）不能与 abstract 修饰符同时使用
示例：
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace Example03
{
class Program
{
//注意DllImport是一个Attribute Property，在System.Runtime.InteropServices命名空间中定义
//extern与DllImport一起使用时必须再加上一个static修饰符
[DllImport("User32.dll")]

public static extern int MessageBox(int Handle, string Message, 
string Caption, int Type);

static int Main()
{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox(0, myString, "My Message Box", 0);
}
}
}

.net笔试题25：什么是索引指示器？
 答：实现索引指示器（indexer）的类能够象数组那样使用其实例后的对象，但与数组不同的是索引指示器的参数类型不但限于int..
简单来说，其本质就是一个含参数属性
示例：
using System;
using System.Collections.Generic;
using System.Text;

namespace Example08
{
    public class Point
    {
        private double x, y;
        public Point(double X, double Y)
        {
            x = X;
            y = Y;
        }
        //重写ToString方法方便输出
        public override string ToString()
        {
            return String.Format("X: {0} , Y: {1}", x, y);
        }
    }
    public class Points
    {
        Point[] points;
        public Points(Point[] Points)
        {
            points = Points;
        }
        public int PointNumber
        {
            get
            {
                return points.Length;
            }
        }   
        //实现索引访问器
        public Point this[int Index]
        {
            get
            {
                return points[Index];
            }
        }
    }

    //感谢watson hua()的指点
    //索引指示器的实质是含参属性，参数并不只限于int
    class WeatherOfWeek
    {
        public string this[int Index]
        {
            get
            {
                //注意case段使用return直接返回因此不需要break
                switch (Index)
                {
                    case 0:
                        {
                            return "Today is cloudy!";
                        }
                    case 5:
                        {
                            return "Today is thundershower!";
                        }
                    default:
                        {
                            return "Today is fine!";
                        }
                }
            }
        }
        public string this[string Day]
        {
            get
            {
                string TodayWeather = null;
                //switch的标准写法
                switch (Day)
                {
                    case "Sunday":
                        {
                            TodayWeather = "Today is cloudy!";
                            break;
                        }
                    case "Friday":
                        {
                            TodayWeather = "Today is thundershower!";
                            break;
                        }
                    default:
                        {
                            TodayWeather = "Today is fine!";
                            break;
                        }
                }
                return TodayWeather;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Point[] tmpPoints = new Point[10];
            for (int i = 0; i < tmpPoints.Length; i++)
            {
                tmpPoints[i] = new Point(i, Math.Sin(i));
            }

            Points tmpObj = new Points(tmpPoints);
            for (int i = 0; i < tmpObj.PointNumber; i++)
            {
                Console.WriteLine(tmpObj[i]);
            }

            string[] Week = new string[] { "Sunday", "Monday", "Tuesday",
"Wednesday", "Thursday", "Friday", "Staurday"};
            WeatherOfWeek tmpWeatherOfWeek = new WeatherOfWeek();
            for (int i = 0; i < 6; i++)
            {
                Console.WriteLine(tmpWeatherOfWeek[i]);
            }
            foreach (string tmpDay in Week)
            {
                Console.WriteLine(tmpWeatherOfWeek[tmpDay]);
            }

            Console.ReadLine();
        }
    }
}
结果：
X: 0 , Y: 0
X: 1 , Y: 0.8497
X: 2 , Y: 0.682
X: 3 , Y: 0.1411 8059867
X: 4 , Y: -0.928
X: 5 , Y: -0.138
X: 6 , Y: -0.2794
X: 7 , Y: 0.789
X: 8 , Y: 0.382
X: 9 , Y: 0.4121
Today is cloudy!
Today is fine!
Today is fine!
Today is fine!
Today is fine!
Today is thundershower!
Today is cloudy!
Today is fine!
Today is fine!
Today is fine!
Today is fine!
Today is thundershower!
Today is fine!

.net笔试题26：new 修饰符是起什么作用？
 答：new 修饰符与 new 操作符是两个概念
new 修饰符用于声明类或类的成员，表示隐藏了基类中同名的成员。而new 操作符用于实例化一个类型
new 修饰符只能用于继承类，一般用于弥补基类设计的不足
new 修饰符和 override 修饰符不可同时用在一个成员上，因为这两个修饰符在含义上互相排斥
示例：
using System;
using System.Collections.Generic;
using System.Text;

namespace Example09
{
class BaseClass
{
//基类设计者声明了一个PI的公共变量，方便进行运算
public static double PI = 3.1415;
}
class DervieClass : BaseClass
{
//继承类发现该变量的值不能满足运算精度，于是能够经过new修饰符显式隐藏基类中的声明
public new static double PI = 3.1415926;
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine(BaseClass.PI);
Console.WriteLine(DervieClass.PI);

Console.ReadLine();
}
}
}
结果：
3.1415
3.1415926

.net笔试题27：this 关键字的含义？
答：this 是一个保留字，仅限于构造函数和方法成员中使用
在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用。

.net笔试题28：new 修饰符是起什么作用？
答：new 修饰符与 new 操作符是两个概念
new 修饰符用于声明类或类的成员，表示隐藏了基类中同名的成员。而new 操作符用于实例化一个类型
new 修饰符只能用于继承类，一般用于弥补基类设计的不足
new 修饰符和 override 修饰符不可同时用在一个成员上，因为这两个修饰符在含义上互相排斥
示例：
using System;
using System.Collections.Generic;
using System.Text;

namespace Example09
{
class BaseClass
{
//基类设计者声明了一个PI的公共变量，方便进行运算
public static double PI = 3.1415;
}
class DervieClass : BaseClass
{
//继承类发现该变量的值不能满足运算精度，于是能够经过new修饰符显式隐藏基类中的声明
public new static double PI = 3.1415926;
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine(BaseClass.PI);
Console.WriteLine(DervieClass.PI);

Console.ReadLine();
}
}
}
结果：
3.1415
3.1415926

.net笔试题29：能够使用抽象函数重写基类中的虚函数吗？
答：能够
需使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现
或增加 override 修饰符，表示抽象重写了基类中该函数的实现
示例:
    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class  DeriveClass1 : BaseClass
    {
        public abstract new void F();
    }

    //感谢watson hua()的指点
    //是她提醒了我还能够用这种方法抽象重写基类的虚方法
    abstract class DeriveClass2 : BaseClass
    {
        public abstract override void F();
    }

.net笔试题30：什么是属性访问器？
答：属性访问器（Property Accessor），包括 get 访问器和 set 访问器分别用于字段的读写操作
其设计目的主要是为了实现面向对象（OO）中的封装思想。根据该思想，字段最好设为private，一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问
另外要注意属性本身并不一定和字段相联系

.net笔试题31：接口能够包含哪些成员？
答：接口能够包含属性、方法、索引指示器和事件，
但不能包含常量、域、操作符、构造函数和析构函数，而且也不能包含任何静态成员

.net笔试题32：接口的多继承会带来哪些问题？
 答：C# 中的接口与类不同，能够使用多继承，即一个子接口能够有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性，这时在实现时最好使用显式的声明
示例：
using System;
using System.Collections.Generic;
using System.Text;

namespace Example17
{
class Program
{
//一个完整的接口声明示例
interface IExample
{
//属性
string P
{
get;
set;
}
//方法
string F(int Value);
//事件
event EventHandler E;
//索引指示器
string this[int Index]
{
get;
set;
}
}
interface IA
{
int Count { get; set;}
}
interface IB
{
int Count();
}
//IC接口从IA和IB多重继承
interface IC : IA, IB
{
}
class C : IC
{
private int count = 100;
//显式声明实现IA接口中的Count属性
int IA.Count
{
get { return 100; }
set { count = value; }
}
//显式声明实现IB接口中的Count方法
int IB.Count()
{
return count * count;
}
}
static void Main(string[] args)
{
C tmpObj = new C();

//调用时也要显式转换
Console.WriteLine("Count property: {0}", ((IA)tmpObj).Count);
Console.WriteLine("Count function: {0}", ((IB)tmpObj).Count());

Console.ReadLine();
}
}
}
结果：
Count property: 100
Count function: 10000

.net笔试题33：抽象类和接口的区别？
答：抽象类（abstract class）能够包含功能定义和实现，接口（interface）只能包含功能定义
抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性
分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”
为外部提供调用或功能需要扩充时优先使用接口

.net笔试题34：StringBuilder 和 String 的区别？
答：String 在进行运算时（如赋值、拼接等）会产生一个新的实例，而 StringBuilder 则不会。因此在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String
另外，对于 String 我们不得不多说几句：
1.它是引用类型，在堆上分配内存
2.运算时会产生一个新的实例
3.String 对象一旦生成不可改变（Immutable）
4.定义相等运算符（== 和 !=）是为了比较 String 对象