新手菜鸟-

VC#复习资料（是轩~）

一、判断题

2、“闪电”图标

3、using命名空间

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式，using 关键字表明程序使用的是给定命名空间中的名称，使用 using 命名空间指令，这样在使用的时候就不用在前面加上命名空间名称。该指令告诉编译器随后的代码使用了指定命名空间中的名称。

//没有使用using
//first_space;second_space我们都没有using;其格式为：命名空间.类
using System;
namespace first_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

//使用using
//就可以省略命名空间的“名字”了，直接调用里面的类
using System;
using first_space;
using second_space;
 
namespace first_space
{
   class abc
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class efg
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

//注意：因为我们using System,所以我们可以只写：
Console.WriteLine ("Hello there");
//我们可以写完全限定名称，如下：
System.Console.WriteLine("Hello there");

综上，我们使用using 命名空间后，可以简写一部分内容

5、Main()方法

需要大写

6、数据类型

值类型直接存储其值，而引用类型存储对其值的引用【类似于指针】

值类型（value type）：byte，short，int，long，float，double，decimal，char，bool 和 struct 统称为值类型。值类型变量声明后，不管是否已经赋值，编译器为其分配内存。

引用类型（reference type）：string 和 class、interface、delegate、object、数组统称为引用类型。当声明一个类时，只在栈中分配一小片内存用于容纳一个地址，而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时，分配堆上的空间，并把堆上空间的地址保存到栈上分配的小片空间中。

（1）值类型变量的操作只影响存储在变量中的值类型实例，就是我们一般的操作

//写一个伪代码
int a=10;
int b=a;
b=5;

最终值为：a=10,b=5;

（2）引用类型变量。就是和指针差不多【类比，但不是】，看如下的操作

我们发现当更改SC2.num的值时，SC1.num也跟着改变了

介绍一下一些数据类型。

decimal（高精度浮点数）、struct（结构体）、byte（无符号的8位整数）

8、int字节

int 4个字节

9、unit关键字

C＃中， uint是一个关键字，用于声明一个变量，该变量可以存储值的整数类型(无符号整数)

10、string

C#中的string是System.String的别名，继承与System.Object。

所以string就是一个引用类型。引用类型一般是类。

12、运算符

^ 异或

C#没有乘方运算符，想要乘方。Math.pow()

& 与

字符连接，直接使用'+'即可

14、非零即真的问题

C#语言的布尔类型变量，其赋值只能是true和false，所以非0即true并不存在于C#中

15、数组

声明数组 int[] x; //声明一个int[]类型的变量（无法指定大小）

定义数组：

数据类型[] 数组名=new 数据类型[数组长度];
数据类型[] 数组名=new 数据类型[数组长度]{元素1,元素2…};
数据类型[] 数组名=new 数据类型[]{元素1,元素2…};
数据类型[] 数组名={元素1,元素2…};

搞清楚什么是声明；什么是定义

16、Length

array.Length是数组的长度，只读的。

17、二维数组

二维数组声明：数据类型[,] 数组名 int[,] array;

二维数组定义：

数据类型[,] 数组名 = new 数据类型[第一维长度,第二维长度]

int[,] arr= new int[50,3];

数据类型[,] 数组名 = new 数据类型[,]{数组值};

int[,] arr= new int[,]{{1,0,1},{3,0,5}};

数据类型[,] 数组名 = {数组值};

int[,] arr= {{1,0,1},{3,0,5}};

所以不合法，行列都要写清楚

18、数组初始化

动态初始化

数据类型[] 数组名=new 数据类型[数组长度];
- 此时数组中每一个元素都是为默认值
  - int的默认值0
  - float的默认值0
  - bool的默认值false
  - char的默认值‘\0’，表示空字符
  - string的默认值""

20、循环5要素

网上有4要素的，有5要素的。这道题也是北大慕课的一道判断题。

5要素为：初始化部分、循环条件部分、循环体部分、迭代部分、结束后处理

21、switch

switch(控制表达式){

case 常量:

语句...;

break;

case 常量:

语句...;

break;

default:

语句;

}

//控制表达式，其结果只能是整型或字符型、字符串型

//case 后的常量必须不同

//常量

常数或常数计算表达式（编译时是知道结果的）

所以case后为变量是错的

switch变量可以是string，只要符合最终控制表达式结果即可

26、类

类里的字段和方法如下

27、this

this代表当前实例，用this.显式调用一个类的方法和成员

namespace Demo
{
  public class Test
  {
    private string scope = "全局变量";
    public string getResult()
    {
      string scope = "局部变量";
　　　　　　　// 在这里，this代表Test的实例，所以this.scope指向的是全局变量，scope所访问的是局部变量
      return this.scope + "-" + scope;
    }
  }

28、构造方法

作用：构造方法用来创建对象，并且在构造方法中对对象进行初始化

返回：构造函数是一种特殊的函数，负责创建该类的实例对象。一般用new + 构造函数。可以认为构造函数的返回值类型就是该类本身。就是没有返回的意思【不是void】

特殊要求：

没有返回值，不需要写类型，连void都不要写。

构造方法的方法名，与类名要相同

//一个类里的构造方法
class Person
{
        //构造方法
        public Person(string name)
        {
            this.Name = name;
            this.Age = age;
            this.Sex = sex;
            this.Chinese = chinese;
            this.Math = math;
            this.English = english;
        }

        //字段
        private string Name;

}

//使用构造方法
class Program
    {
        static void Main(string[] args)
        {
            //创建小明对象
            Person p1 = new Person("小明");
        }
    }

29、访问父类成员（属性、方法、构造方法）：base

构造方法调用

方法调用

// 父类
public class Father
{
    public String name = "小头爸爸";
    public void TellName()
     {
         Console.WriteLine("My name is {0}.",name);
     }
}
// 子类
public class Son:Father
{
    public new String name = "大头儿子";
    public new void TellName()
     {
         Console.Write("Father Told: ");
         base.TellName();
         Console.WriteLine("My Father's name is {0}",base.name);
         Console.WriteLine("My name is {0}.", name);
     }
}

30、object

所有类的最终基类:Object

当一个类没有指明父类时，则相当于继承于object类。也就是说，object类是最有类的最终父类。

所有类的最终基类:Object

31、Tostring()

object.Tostring() 方法

因为所有的类都是基于Object的，都继承了这个方法。

对象，就是创建类的对象。所以所有的对象都有Tostring()方法

32、object命名空间

using System; 主命名空间,包含所有.net基础类型和通用类型,比如Object,比如string等。

根据我们之前说的using 命名空间规则。所以等价

33、重写

如果子类想对父类的方法实现进行修改，可以重写该方法。在重写时，要求父类将此方法声明为 virtual（虚拟方法，表示被重写的)。子类将方法声明为override（表示重写)。

34、强制类型转换

传统的强制类型转换

object objTest = new NewType();
NewType newValue = (NewType)objTest;

但是这样转换，有个严重的问题，就是在把objTest强转换成NewType类型对象的时候，这个过程是不安全的，因此需要用try-catch语句来进行保护。

    object objTest = new NewType();

    NewType newValue = null;

    try

    {

        newValue = (NewType)objTest;

    }

    catch( Exception err )

    {

        MessageBox.Show( err.Message );

    }

但是这样又显得很冗余，由此在C#中比较高效而且安全的写法，应该用as操作符。

as强制类型转换

格式：原类型 as 目标类型

    object objTest = new NewType();

    NewType newValue = objTest as NewType;

as运算符类似于强制转换,只不过不会抛出异常,如果转换不成功会返回null

那么很明显，如上的写法首先看起来很简便，至少代码数量和强转方式一样。至于安全性，对于as操作符来说，它不会做过的转换操作，当需要转换对象的类型属于转换目标类型或者转换目标类型的派生类型的时候，那么此转换操作才能成功，而且并不产生新的对象。因此用as来进行类型转换使安全的。为什么用as操作符进行类型转换的效率要高于老式的类型转换的，因为用as操作符进行转换就如前面所说的，首先判断当前对象的类型，当类型满足要求后才进行转换【不满足返回null】。而传统的类型转换方式，是用当前对象直接去转换，而且为了保护转换成功，要加上try-catch，这就决定了它的效率不会高于as操作符的效率。

例如，如果上述代码转换不成功，newValue=NULL.

36、public、internal、private、protected的访问级别和实例

C#语言关于类的继承和访问中public、internal、private、protected的访问级别和实例_zhengyinyin的博客-CSDN博客_c#继承可访问到private

internal ：默认访问级别，internal修饰的变量只可以在本程序集中使用，包括本程序集的继承类

protected：保护某一个方法或属性，使其不能直接作为属性暴露，但是创建他的子类时可以使用，范围可以是本程序集也可以是另一程序集

protect是起到保护作用，使用此，只供继承的子类使用。所以和继承相关

38、‎static

首先纠正一下答案。此题出现在【C#程序设计(北京大学)中国大学mooc】

静态方法中不能包含非静态成员【所以不能访问其成员，因为该成员可能是非静态成员】和非静态方法，因为静态方法被调用的时候，非静态对象有可能还不存在

（1）首先，什么是类的实例化

就是可以new 一个对象

//创建一个类
class Person
{
        //构造方法
        public Person(string name)
        {
            this.Name = name;
            this.Age = age;
            this.Sex = sex;
            this.Chinese = chinese;
            this.Math = math;
            this.English = english;
        }

        //字段
        private string Name;

}


//在主程序中
class Program
    {
        static void Main(string[] args)
        {
            //创建小明对象
            Person p1 = new Person("小明");  //类的实例化
        }
    }

（2）static类的特点

静态类中只能包含静态成员
静态类不能被实例化
静态类不能被继承

所以我们不能 new一个静态类对象

（3）this 的使用

this指的是类实例化的当前对象，静态方法是通过类调用的，不需要实例化；既然不需要实例化，就没有当前对象；既然没有当前对象，所以不能使用this 关键字。

（4）静态类成员的调用

//这里我们以静态成员变量为例
public class MyBaseC
{
    public static int x = 100;
}

若要引用 static 成员 x，除非可从相同范围访问该成员，否则请使用完全限定的名称 MyBaseC.MyStruct.x：

39、readonly

（1）先介绍readonly

使用了readonly的属性，只能在定义时，或者构造函数中初始化，其他的地方都不能再修改其值

class Age
    {
        //年纪添加了 readonly修饰符
        //1.可以在定义时对其赋值
        readonly int year=20;
        //2.在构造函数中赋值
        Age(int year)
        {
            this.year = year;
        }
        //3.但是不能在其他地方赋值
        void ChangeYear()
        {
            year = 1967; // 如果这里赋值了，会出现编译错误
        }
    }

（2）Const 与 readonly区别

静态常量（Const）是指编译器在编译时候会对常量进行解析，并将常量的值替换成初始化的那个值。

动态常量（Readonly）的值则是在运行的那一刻才获得的，编译器编译期间将其标示为只读常量，而不用常量的值代替，这样动态常量不必在声明的时候就初始化，而可以延迟到构造函数中初始化。

Const修饰的常量在声明的时候必须初始化；Readonly修饰的常量则可以延迟到构造函数初始化

//动态常量    
public class Student
    {
        public readonly int Age; //在定义时不用先赋值

        public Student(int age)
        {
            this.Age = age;    //可以推到构造函数赋值
        }
    }

//静态常量
    public static class MyClass
    {
        public const int Count = 10; //在定义时直接赋值
    }

40、Const

const是常量，只能用于修饰基本类型和string类型

41、抽象类

以abstract修饰的类，称为抽象类。

抽象方法必须要放在抽象类里面

抽象方法没有方法体： [访问修饰符] abstruct 返回值类型方法名(形参列表);

抽象方法的访问修饰符不能是private

抽象类即可以放抽象方法，也可以放普通方法

抽象方法必须在子类中全部实现

也就是说，在抽象类里定义方法，子类里实现方法的具体内容

以下定义了一个抽象类，名为 FutureVehicle，里面定义了2个抽象方法。示例如下。

综上，抽象类无法实例化【需要让子类继承，去实例化那个子类】，抽象类主要是为了被继承。

　尽管抽象类不能直接进行实例化，但是继承类会调用该抽象类的构造函数。如果没有手动定义一个构造函数，编译器会自动为其创建一个无参，访问等级为protected的构造函数。

43、接口

先看一下它是如何使用的

接口的作用：

1.接口用于描述一组类的公共方法/公共属性【这些属性就是特征的意思】. 它不实现任何的方法或属性，只是告诉继承它的类至少要实现哪些功能,继承它的类可以增加自己的方法.

2.使用接口可以使继承它的类: 命名统一/规范,易于维护.比如: 两个类 "狗"和"猫",如果它们都继承了接口"动物",其中动物里面有个方法Behavior(),那么狗和猫必须得实现Behavior()方法，并且都命名为Behavior这样就不会出现命名太杂乱的现象.如果命名不是Behavior()，接口会约束即不按接口约束命名编译不会通过.

3.提供永远的接口。当类增加时，现有接口方法能够满足继承类中的大多数方法，没必要重新给新类设计一组方法，也节省了代码，提高了开发效率.

具体可看：C# 浅谈接口(Interface)的作用

45、enum

枚举【enum】是一组命名整型常量。枚举类型是使用 enum 关键字声明的。

C# 枚举是值类型。就是值的整数。

46、catch多重异常

catch多重异常时，子异常类必须在它们任何父类之前。因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。这样，如果子类在父类后面，子类将永远不会到达。你想写也不行，系统会报编译错误。

就是父类在子类前面会捕获所有子类涉及到的异常，无法给出对应的响应。【每个子类对应一种异常，并给出相应的响应】

47、自定义异常

自定义异常类必须要继承Exception类。

//格式
class 异常类名:Exception
{
    
}

class InvalidStudentNameException : Exception
{
    public InvalidStudentNameException(string name)
        : base(String.Format("Invalid Student Name: {0}", name))
    {

    }
  
}

48、特性【Attribute】

特性是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的

    [Route("api/[controller]/[action]")]
    [ApiController]
    public class TestController:ControllerBase
    {
        [HttpGet]
        [Obsolete]
        public void Test()
        {
            Console.WriteLine("如果想知道特性更详细的使用，自行搜索");
        }
    }

50、C# 2

这个是委托的调用，至于为什么C# 2版本可以这么写我就不知道了。我就介绍一下委托吧。

//直接上代码

//首先我们定义一个类,类里有一个方法
//其中，delegate声明它是个委托类型，DogFunction是类型的名字
public delegate void DogFunction(string name); //定义一个委托类型
class example
{
    public delegate void Method(string name)
    {
        Console.write(name);
    }
}



//在主程序里


example ex=new example(); //实例化类
DogFunction my=new DogFunction(ex.Method); //实例化委托
my("世轩");

//输出：世轩
//my("世轩")  等价于 ex.Method("世轩")

51、记着吧。看这个看的眼花。。。

52、委托-多播

多播委托就是指引用多个方法委托，它也是一个委托，当调用委托时，它连续调用每个方法，只要这些方法的签名与委托的定义相同。

为了把委托的单个实例合并为一个多播委托，委托必须是同类型的，返回类型必须是void

1.委托声明包含的方法返回值必须为void，否则会抛出run-time exception。
2.使用“+”、“+=”添加方法，“-”、“-=”删除方法。
3.声明和实例化都和其他委托没有什么不同。

多播委托的实例：

using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApp1
{
    //声明一个委托
    public delegate void msg();

    //编写一个类
    class messges
    {
        //messges类下的一个成员方法m1
        public static void m1()
        { Console.WriteLine("方法一被huashanlin调用"); }

        //messges类下的一个成员方法m2
        public static void m2()
        { Console.WriteLine("方法二被huashanlin调用"); }

        //messges类下的一个成员方法m3
        public static void m3()
        { Console.WriteLine("方法三被huashanlin调用"); }
    }

    //另一个类
    class Program
    {
       
        //该类下包含的主函数
        static void Main(string[] args)
        {
            //实例化一个委托，并封装messges类中的一个方法m2
            msg ms = new msg(messges.m2);

            //在原有的封装了一个m2方法的委托实例中再封装进一个新的方法m1
            ms = ms + messges.m1;
            //也可以这么写ms += messges.m1;

            //以下为该委托实例封装第三个方法
            ms += messges.m3;

            //调用该委托实例，那么由于多播委托之后调用该委托就要执行完此封装进去的三个方法
            ms();
        }
    }
}

//输出
方法二被huashanlin调用
方法一被huashanlin调用
方法三被huashanlin调用

53、前面有解释

54、Lambda

Lambda就是匿名函数

使用lambda声明运算符 => 的表达式就是Lambda表达式

创建Lambda表达式，需要在 Lambda 运算符左侧指定输入参数（如果有），然后在另一侧输入表达式或语句块。
即是说我们使用形如（）=> { } 这样的格式就可以创建Lambda表达式

（1）Lambda表示式的两种方式

表达式 lambda，表达式为其主体

(input-parameters) => expression
//如：
 x => x * 4

语句 lambda，语句块作为其主体

(input-parameters) => {  }
//如：
(int x) => { return x * 2; };

    public class LambdaTest
    {
        public void Test()
        {
            //表达式lambda 只有一个表达式，表示这里面只允许有一行代码
            //这个func是一个委托
            Func func = x => x * 4;
            //接收表达式Lambda返回的值
            int result1 = func(5);

            //在表达式lambda中调用方法
            func = x => x * Add(3, 2);
            int result2 = func(5);
        }
        public int Add(int x,int y)
        {
            return x + y;
        }
    }


任何 Lambda 表达式都可以转换为委托类型。
 Lambda 表达式可以转换的委托类型由其参数和返回值的类型定义。
 如果 lambda 表达式不返回值，则可以将其转换为 Action 委托类型之一；
否则，可将其转换为 Func 委托类型之一

（2）lambda 表达式的输入参数

将 lambda 表达式的输入参数括在括号中。使用空括号指定零个输入参数

Action line = () => Console.WriteLine();

所以‌匿名函数可以不带参数【55题】

有时，编译器无法推断输入参数的类型。可以显式指定类型

Func isTooLong = (int x, string s) => s.Length > x;

一般我们是不指定参数类型的

Func cube = x => x * x * x;

所以Lambda表达式的函数参数型是可以省略的【54题】

56、throw

throw 语句用于发出在程序执行期间出现反常情况（异常）的信号。
通常，throw 语句与 try-catch 或 try-finally 语句一起使用

try
{

}
catch（exception ex）
{
    throw ex；//该异常发生后，执行[throw]自定义的事件[ex]
}

57、Lambda表达式是可以作为函数的参数的

//创建一个类
using System;
using System.Collections.Generic;
using System.Text;

namespace test
{
    class E1
    {
        public void Example(int a)
        {
            Console.WriteLine(a.ToString());
        }
    }
}

//主程序
using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace test
{
    class Program
    {
        static void Main(string[] args)
        {
            E1 ex = new E1();
            Func a = x => x * x; //将匿名函数委托
            ex.Example(a(2));//作为参数
        }
    }
}


//输出4

58、event

在C#中，所谓event事件，就是一种特殊的委托。如果要声明event事件，首先就要声明一个相对应的委托类型。

        //1.先声明委托类型
        public delegate void MethodDel(string param);
        //2.再次声明事件
        public event MethodDel DoEvent;

下面一个例子
//定义一个类
public class SampleEventArgs
{
    //构造函数
    public SampleEventArgs(string text) { Text = text; }
    //定义的属性Text 自动属性
    public string Text { get;set; } 
}

public class Publisher
{
    //声明委托  参数是：基类、SampleEventArgs类
    public delegate void SampleEventHandler(object sender, SampleEventArgs e);
    //event事件
    public event SampleEventHandler SampleEvent;

    protected virtual void RaiseSampleEvent()
    {
        SampleEvent(this, new SampleEventArgs("Hello"));
    }
}

//event事件SampleEvent执行。新建SampleEventArgs对象，触发构造函数，使得Txet=text;
//之后触发自动属性，最终SampleEventArgs类中属性Text值为"Hello"

59、事件 += -=

（1）先说一下什么是事件

我们上面介绍到的event就是事件，一个特殊的委托

（2）再介绍一下+=、-=

事件使用这个操作。

删除事件添加事件作用

//创建一个类
    public delegate void msg();
    //编写一个类
    class messges
    {
        
        public event msg Ev;
        //messges类下的一个成员方法m1
        public void m1()
        { Console.WriteLine("方法一被huashanlin调用"); }

        //messges类下的一个成员方法m2
        public void m2()
        { Console.WriteLine("方法二被huashanlin调用"); }

        //messges类下的一个成员方法m3
        public void m3()
        { Console.WriteLine("方法三被huashanlin调用"); }

        //调用事件
        public void OK()
        {
            Ev();
        }

    }


//主程序里
    class Program
    {
        static void Main(string[] args)
        {
            messges me = new messges();
            //事件里添加方法
            me.Ev += new msg(me.m1);
            me.OK();
        }
    }

输出：方法一被huashanlin调用
     方法二被huashanlin调用

我不知道它这个类外指的是什么【是哪个类的外面】，所以【59、60】就先记着吧，我不理解它的题意

61、请看47

62、Convert.ToDateTime()

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine(Convert.ToDateTime("2002 8 29"));
        }
    }
}

输出：2002-08-29 0:00:00

63、Math

.Math.Exp(n); e的n次方

65、string.trim

删除字符串头部和尾部的空格,删除的过程是从外到内,直到碰到一个非空格的字符为止,前后有多少空格都会不删掉,但是字符串中间的空格是不能被删去的

66、很简单，自己搜

和python的for循环差不多

67、Dictionary

68、算法是指令的有限序列

它是指令的有限序列：比如说，你要炒菜，首先要买菜，然后择菜，洗菜，切菜，炒菜！这个序列是不能变的！也就是他们之间有先后顺序！而有限就是你做这件事情时，步骤是有限的！！

71、遍历【试】、迭代、递归

遍历：就是走一遍
迭代：走n遍，反反复复

递归：就是在运行的过程中调用自己【汉诺塔是最典型的例子】

72、文本文件

使用程序打开文本文件时，要考虑它的编码类型，不然会报错

73、FileInfo

FileSystemInfo为FileInfo和DirectoryInfo对象提供基类

74、DirectoryInfo

DirectoryInfo 类继承自 FileSystemInfo

75、【反】序列化

序列化(Serialize)、反序列化(Deserialize)

序列化是把对象转变成流。相反的过程就是反序列化。

哪些场合用到这项技术呢？

1. 把对象保存到本地，下次运行程序时恢复这个对象。

2. 把对象传送到网络的另一台终端上，然后在此终端还原这个对象。

3. 复制系统的粘帖板中，然后用快捷键Ctrl+V恢复这个对象。

具体怎么用，可以自己看，我是看的头晕。。

76、可序列化

类型前面添加了[serializable]特性的类就是可序列化类型

77、控件

控件的基类【控件Control类】用于Windows窗体应用的控件都派生自Control类

78、控件/组件

什么是控件：

控件就是组件，控件通常是指设计时所见即所得、运行时处理图形显示和接受用户交互输入的那些组件。

什么是组件：

组件是指可重复使用并且可以和其他对象进行交互的对象。组件(component)是靠类实现的

二者的关系：

控件是能够提供用户界面接口(UI)功能的组件。所有控件肯定都是组件，但并不是每个组件都一定是控件。所以并不是所有的组件都能显示在界面上

79、Keypress

KeyDown：用户摁下摁键时发生
KeyPress：用户摁下摁键，并且产生一个字符时发生
KeyUp：用户释放某一个摁键时触发

完整的 keypress 过程分为两个部分：1. 按键被按下；2. 按键被松开。

当按钮被按下时，发生 keydown 事件

按键被松开，发生KeyUp事件

80、日期时间框

81、富文本框

private void richTextBox3_TextChanged(object sender, EventArgs e)
        {
            for (int i = 0; i < richTextBox3.Lines.Length; i++)
            {
                string[] lineArr = richTextBox3.Lines[i].Split(new string[] { " --" }, StringSplitOptions.None);
                if (lineArr.Count() > 1)
                {
                    //获取每一行第一个字符的索引位置
                    int lineFirstCharIndex = richTextBox3.GetFirstCharIndexFromLine(i);
                    //选中需要变色的内容的起点索引位置以及需要变色的内容长度（就是需要变色的文本的自身长度）
                    richTextBox3.Select(lineFirstCharIndex, lineArr[0].Length);
                    //对其进行变色，当然也可以加上其他属性，比如字体样式改变等等，因为我这里只需要变色即可
                    richTextBox3.SelectionColor = Color.Green;
                }
 
            }
        }

这个需要在代码里自己改。

82、WebBrowser

就是没有ShowPage方法方法

83、用户控件

在C#中，有时为方便控件的数据绑定，在C#自带控件的基础上进行进一步封装，即创建用户自定义控件。这篇文章介绍如何创建。

至于是否一定有多个子控件，我个人认为不一定，或许是一对一的情况呢

基于C#的自定义用户控件（WinForm窗体）_Leon良木的博客-CSDN博客_c# 用户控件

84、Enabled

85、ProgressBar

86、Main()返回值

Main方法可以是void类型 Main方法可以返回int类型

如果不需要使用 Main 的返回值，则返回 void 可以使代码变得略微简单。但是，返回整数可使程序将状态信息与调用该可执行文件的其他程序或脚本相关

87、String不变性

首先我们要搞清楚String的不变，指的是什么不变。

（1）这里有一个字符数组、一个字符串。我们更改它们的首字符，发现字符数组可以更改，但是string型却报错了。

这就是字符串的不变性，string只是可读，但不可写，字符串对象不可以改变。但字符数组可读可写。

（2）这里有人提出，str=“abc”；str+=“d”，Console.WriteLine(str);出现abcd；这不是表明字符传可以更改吗？可写吗？

（3）string str=“abc”；string str1=“abc”两者指的是同一个对象。

（4）总结：改变的不是原来的字符串的内容，改变的是引用。【abc】并没有改变，改变的是引用

88、正则表达式

正则表达式,又称正规表达式、常规表达式,使用字符串来描述、匹配一系列符合某个规则的字符串

89、正则表达式语法【部分】

所以说【0-9】可以使用\d表示【89题】

92、$替换

"$"是在C#6.0出现的一个新特性，其作用相当于对String.format()的简化。string.format()需要自己在字符串中写占位符，在后面跟上参数。如果要格式化的参数比较多，写起来就比较恶心。而用$符号，写法就简洁多了，我们可以直接在字符串的相应位置协商自己想要替换的参数就好了

举个例子：

string sqlOne = string.Format(@" select * from MD_Person  where Code='{0}' AND Role=N'{1}' AND Type=N'{2}'", code, role, type);

使用$后

string sqTwo = $"select * from MD_Person where Code='{code}' AND Role='{role}' AND Type='{type}'";

93、Regex

我不晓得是不是题出错了，这个( )里是什么？那我就介绍下相关的

(1)Match()方法

Match()方法总是获取满足条件的第一个匹配，而不关心满足条件的匹配有多少个。

Match()方法都回一个Match对象，其中包含了匹配的各种细节。

一般，当我们确定只有一个符合条件的匹配或只需要第一个符合条件的匹配时，可以使用Match()。

// 要匹配的字符串内容
string content="(dfs45545)][(dkjsdjf63)";
// 正则表达式
string RegexStr = @"\(.*?\)";
// 使用Match()匹配
Match m=Regex.Match(content, RegexStr);
// 结果：(dfs45545)

(2)Matches()方法

// 要匹配的字符串内容
string content="(dfs45545)][(dkjsdjf63)";
// 正则表达式
string RegexStr = @"\(.*?\)";
// 使用Matches()匹配
MatchCollection mc = Regex.Matches(content, RegexStr);
foreach (Match m in mc)
{
    Console.WriteLine(m.Value);
}
// 结果：将输出(dfs45545)和(dkjsdjf63)两个结果

二、选择题

1、变量命名

只能由字母、数字、@和下划线(_)这些组成
数字不能开头，⌨ 1a❌、3f❌、xiaoming1✅
@符号，要么不用，要用必须放在首位，@zhansan✅,zhang@san❌
不能与系统的关键词同名，int，long，sbyte❌
变量名不能重复
中文变量名语法上是可以的，但极为不推荐

不能使用关键字作为变量名

B是关键字，所以错误

2、Main()方法

A 、略

B 、Main()函数返回值只能为void(无类型)或int(整数类型)

C 、Main()方法的参数只有两种形式：无参数和string 数组表示的命令行参数，即static void Main()或static void Main(string［］args) ，后者接受命令行参数。

D、一个C#程序中只能有一个Main()函数入口点。

3、C#代码的变量赋值

B、前后类型不一致，“1”为字符串型

C、没有指明类型

D、不能连等

补充下额外知识：

变量可以不赋初值（在特殊情况下必须要赋初值）

不赋初值时，当前变量的值是默认值

int/float 默认值是0

char 默认值’\0’（表示空字符）

4、变量a和b值

和C语言语法一样，不难

int a = 1;
int b = a++;     //b=1,a=2
b = (++a) + b;   //(++a)=3;a变成了3  相当于b=3+1

最后a=3;b=4

5、流程图

7、int类型的变量a，并赋值为5。不能正确输出“5*5=25”

A Console.WriteLine(a+"*"+a+"="+(a*a)) //涉及到隐式转换
B Console.WriteLine("a*a=(a*a)")       //输出：a*a=(a*a)
C Console.WriteLine("{0}*{0}={1}",a,a*a) 
D Console.WriteLine("{0}*{1}={2}",a,a,a*a)

隐式转换：【int 和 string】

将int型的变量转换成string类型，再和string变量进行字符串的+操作，即拼接两个string变量，最后结果当然也就是string类型的了

string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + widgetsSold + " widgets.");

输出：Bob sold 7 widgets.

在这种情况下，C# 编译器了解我们想使用 + 符号来连接两个操作数。它推断出此情况，因为 + 符号由 string 和 int 数据类型的操作数包围。因此，它会尝试将 int 变量 widgetsSold 暂时转换为 string 以便将其与字符串的其余部分连接。

8、运算优先级

比较好记得顺序：单元运算符>算术运算符>关系运算符【大于小于等于】>逻辑运算符【与或】>赋值运算符

9、规定是这样，记着吧

12、变量名

A、关键字

B、首位是数字【×】

D、有其他符号【减号 “-”】

13、数据类型

值类型：

引用类型：

对象（Object）、动态（Dynamic）、字符串（String）、指针类型（Pointer types）

C、布尔错了，应该是bool

15、基本单位

语句是构成C#程序的基本单位。语句可以声明局部变量、常数、调用方法、创建对像、将值赋给变量、属性或字段，语句通常以分好终止。

16、Main()方法的说法

C、Main()方法必须为静态方法(static)，所以加上static

Main()方法为什么使用static修饰：Main()方法必须是一个静态方法，所以是用static修饰。这样在调用它时就不必实例化对象，可直接类名.静态方法名，底层调用它时更快捷。Main()方法在启动程序时由公共语言运行时 (CLR) 调用

17、题面不全

18、变量声明和赋值

A、short范围【-32768-32767】

B、

小数常量，默认为double型。

所以给float型赋值时，末尾加上f。 float a=10.5f

以此类推

如果是float a =10; 也是可以的，整型可以隐式转换为浮点型。

C、前后类型不一致。“a”为字符串型

D、布尔型。只能赋予true false

19、除法运算

和C语言一样

"/"号做什么运算与除数和被除数的类型有关

整形运算是取整（不进行四舍五入只取整数部分）

            int a = 4;
            int b = 5;
            float c = a / b;

浮点运算时为除法运算

            float a = 4;
            float b = 5;
            float c = a / b;

20、自增和自减运算符

和C一样，不解释

21、常量const

关键字是const

22、表达式的结果

"abcde"== “abcde” + “2006”;

//根据运算符优先级，先计算右边加法，组成“abcde2006”，然后判断和"abcde"是否相等

24、下列代码片段的执行结果

int a=1; 
int b=a++; //b=1,a=2
b+=2; //b=3
Console.WriteLine(b);

25、Write()方法和WriteLine()方法

Console.WriteLine()方法是将要输出的字符串与换行控制字符一起输出,当次语句执行完毕时,光标会移到目前输出字符串的下一行.
至于Console.Write()方法,光标会停在输出字符串的最后一个字符后,不会移动到下一行。

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {
        static void Main(string[] args)
        {
            //WriteLine输出后鼠标显示在下一行开头
            //Write输出后不开始一个新行
            System.Console.WriteLine("First WriteLine Line");
            System.Console.WriteLine("Second WriteLine Line");

            System.Console.Write("First Write Line");//First Write Line后面不开始新的一行，直接紧跟着输出Second Write Line
            System.Console.Write("Second Write Line");

        }
    }
}

A、B 正确

C、不需要

D、没有参数，啥也不会输出

26、表达式

(3>=7)&&(5<8)

//先执行括号里的。 根据短路规则，只执行的左边 ,返回false

再注意下短路规则

a++ > 0是没有执行的

28、哪种数据类型的变量

A、C是整型，所以不可以

float的精度为6~7位有效数字

double更多

33、哪一个选项中y的值最小

A int y = 10 % 3  //1
B int y = 3 % 10  //3
C int y = 10 % 11 //10
D int y = 10 % 10;//0

36、下列选项中，正确的是

A C#是一种面向对象的开发语言，而Java不是 //都是
B C#项目编译后的可执行文件扩展名为.exe
C C#中Main()方法中的M首字母不一定要大写  //一定要大写
D Console.WriteLine()输出不换行 //换行

37、在C#语言中，下列运算符优先级最高的是

A % 算数运算符

B ++ 单目运算符

C /= 赋值运算符

D > 关系运算符

B>A>D>C

38、下列变量的命名正确的是

A void define +word //关键字

B a3_b3 _123 YN

C for –abc Case //关键字其他符号'-'

D 2a DO sizeof //数字开头关键字

39、这些输出语句中 (C) 会报错

A double d = 2.3

B double d = 3;

C int i = 2.3 浮点型不会隐式转换为整型

D int i =3;

43、下列关于变量说法不正确的是（D）

int a=10;
int b;
b=a+200;

44、分析下列代码片段的执行结果

int x=5,y=10; 
Console.WriteLine(“{0}+{1}={2}”,y,x,y+x);
//一个格式化输出，10+5=15

45、下列属于C#中的注释的有（B）

A /

B //

C /** /

D ~~ / */~~

注释分为：单行注释多行注释文本注释。

单行注释：//开头单行注释只能注释单行内容

多行注释：/* 开头 */结尾

文本注释：///

C没看出来哪有问题。。是因为它是这么写的吗？ /** 开头 /结尾

48.以下选项中那些是C#中的关键字（ABD）

A static

B string

C main

D using

值得一提的是，Main不是关键字

49.常量和变量说法错误的是（BC）

A 常量声明时必须使用const关键字

B 变量赋值后程序运行中不能改变

C 声明常量代码const float PI;正确 //const 数据类型名称=值;

D 常量赋值后程序运行中不能改变

50.以下代码能够在控制台中输出"Hello C#!"并换行的有（A D）

A Console.WriteLine("Hello C#!") 自带换行

B Console.Write("Hello C#!")

C Console.Write("Hello C#!\t")

D Console.Write("Hello C#!\n") 有换行符

三、问答题

1. .NET和C#有什么区别

.NET一般指 .NET FrameWork框架，它是一种平台，一种技术。

解释：C#是一个语言，.net是一个平台，上面支持用C#或者VB .Net写代码。另外，C#不但可以开发基于.net的应用程序，也可以开发基于WinForm的程序，这就是区别。

C#本身是一种语言；.NET Framework是一个平台即一个环境。只是C#编译器专门用于.net，所以C#代码总是使用.net运行。

2. 一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少，用递归算法实现。

递归：函数不断循环调用

//表示求第num位数
//递归需要有出口，出口就定义为最初始的时候。例如当求第一位、第二位时直接返回1.
public static int Add(int num)
{
    if (num == 1 || num == 2)
    {
        return 1;
    }
    else if (num > 1)
    {
        return Add(num - 1) + Add(num - 2);    第30位=Add(29)+Add(28)
    }
    else
    {
        return 0;
    }
}

3. C#中的委托是什么？事件是不是一种委托？

（1）委托可以把一个方法作为参数代入另一个方法。委托可以理解为指向一个函数的引用。
（2）是，是一种特殊的委托

       //第1步：声明一个委托
        public delegate void CalculateDelegate(int x, int y);

        //第2步：创建与委托关联的方法，二者具有相同的返回值类型和参数列表
        public void Add(int i, int j)
        {
            MessageBox.Show((i+j).ToString());
        }

        //第3步：定义委托类型变量
        private CalculateDelegate myDelegate;

        public void GetDelegateEx()
        {
            //第4步：进行委托绑定
            myDelegate = new CalculateDelegate(Add);

            //第5步：回调Add方法
            myDelegate(1, 2);
        }

相当于委托myDelegate指向了Add

using System;

namespace 测试
{
    class Demo
    {
        static void Main(string[] args){
            PublisherDemo e = new PublisherDemo(); /* 实例发布器类*/
            SubscriberDemo v = new SubscriberDemo(); /* 实例订阅器类 */
            //添加事件，这个就和委托一样。可以看看之前那一个，委托是怎么定义的
            e.MyEvent += new PublisherDemo.MyEntrust( v.printf );

            
            e.SetValue("C语言中文网");
        }
    }
    /***********发布器类***********/
    public class PublisherDemo{
        //在类的内部声明事件，首先必须声明该事件的委托类型
        public delegate void MyEntrust(string str);
        //声明事件，事件名为MyEvent
        public event MyEntrust MyEvent;

        public void SetValue( string s ){
            MyEvent(s);     // 触发事件
        }
    }

    /***********订阅器类***********/
    public class SubscriberDemo{
        public void printf(string str){
            Console.WriteLine(str);
        }
    }
}

4. 简述 private、 protected、 public、internal 修饰符的访问权限

private : 私有成员, 在类的内部才可以访问。

protected: 保护成员，该类内部和继承类中可以访问。

public: 公共成员，完全公开，没有访问限制。

internal:在同一命名空间内可以访问。

C#语言关于类的继承和访问中public、internal、private、protected的访问级别和实例_zhengyinyin的博客-CSDN博客_c# public void如何访问

5. override与重载的区别

override 与重载的区别。重载是方法的名称相同。参数或参数类型不同，进行多次重载以适应不同的需要

Override是进行基类中函数的重写。为了适应需要。

重载：

Override：重新定义函数的内容

6. 如果在一个B/S结构的系统中需要传递变量值，但是又不能使用Session、Cookie、Application，您有几种方法进行处理？

this.Server.Transfer

记着吧，没看懂

7. 请编程遍历页面上所有TextBox控件并给它赋值为string.Empty

//this表示这个页面【相当于一个类】，把这个类上所有的控件遍历完
foreach (System.Windows.Forms.Control control in this.Controls)
{
    //判断控件是否属于TextBox的控件
    if (control is System.Windows.Forms.TextBox)
    {
        //为这个控件创建一个对象
        System.Windows.Forms.TextBox tb = (System.Windows.Forms.TextBox)control;
        //使用这个对象改变其Text属性为空
        tb.Text = String.Empty;
    }
}

8. 请编程实现一个冒泡排序算法

此图转载自：排序算法之冒泡排序（图解）_Sueko的博客-CSDN博客，侵删。

老师给的代码有点难理解，这个比较清楚。

            //定义一个数组
            int[] num = new int[5]{ 3, 6, 1, 4, 9 };
            //排length-1次就可以了
            for(int i = 0; i < num.Length-1; i++)
            {
                for(int j = 0; j < num.Length-i-1; j++)
                {
                    //从小到大排序
                    if (num[j] > num[j+1])
                    {
                        int temp = num[j];
                        num[j] = num[j+1];
                        num[j+1] = temp;
                    }
                }
            }

            for (int i= 0; i < num.Length; i++)
            {
                Console.WriteLine(num[i]);
            }

视频讲解：冒泡排序法_哔哩哔哩_bilibili

但是他会出填空，不让你写整个代码，所以得按他给的来。在理解了上述代码后，再看看这个

            int[] array = new int[5] { 3,7,1,4,5};
            int temp = 0;
            for (int i = 0; i < array.Length - 1; i++)
            {
                //他这个是把较小的数一个一个冒泡到前面
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[j] < array[i])
                    {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            }
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }

9. 描述一下C#中索引器的实现过程，是否只能根据数字进行索引

不是。可以用任意类型。

实现过程：

所谓索引器就是一类特殊的属性，通过他们你就像引用数组一样引用自己的类。类里定义的每一个索引器必须拥有唯一的标签或参数列表；索引器必须是实例成员；为索引器定义的访问函数可以访问传递给索引器的参数【在其他地方找的答案】

索引器的定义。

[修饰符] 数据类型 this[索引类型 index]

{

get{//获得属性的代码}

set{ //设置属性的代码}

}

索引器的使用。

通过索引器可以存取类的实例的数组成员，操作方法和数组相似，一般形式如下：

对象名[索引]，其中索引的数据类型必须与索引器的索引类型相同。

//可容纳100个整数的整数集
private long[] arr = new long[100];
//声明索引器
public long this[int index]
{
    get
    { //检查索引范围
        if (index < 0 || index <= 100)
        {
            return 0;
        }
        else
        {
            return arr[index];//注意这里，使用数字索引
        }
    }
    set
    {
        if (!(index < 0 || index <= 0))
        {
            arr[index] = value;
        }
    }
}






//声明索引器
public 数据类型 this[string index]    //这里使用string来索引
{
    get
    { 

    }
    set
    {

    }
}

10. 求以下表达式的值，写出您想到的一种或几种实现方法：1-2+3-4+……+m

老师给的代码应该没问题，但有点乱

            int m = 10;
            int sum = 0;
            int item = 1;//负责变号
            for(int i = 1; i <= m; i++)
            {
                sum += i*item;
                item = -item;
            }
            Console.WriteLine(sum);

但我有突然想起来，代码题他只会出填空，所以得按他给的来

            int Num = int.Parse(Console.ReadLine());
            int Sum = 0;//和
            for (int i = 0; i < Num + 1; i++)
            {
                if ((i % 2) == 1) //偶数加
                {
                    Sum += i;
                }
                else //奇数减
                {
                    Sum = Sum - i;
                }
            }
            Console.WriteLine(Sum);

11、在下面的例子里

using System;
class A
{
    public A()
    {
        PrintFields();
    }
    public virtual void PrintFields() { } //virtual表示此父类方法可以重写
} 
class B : A     //父亲A，儿子B
{
    int x = 1;
    int y;
    public B()
    {
        y = -1;
    }
    public override void PrintFields()   //重写父类方法
    {
        Console.WriteLine("x={0},y={1}", x, y);
    }
}

先调用父类构造函数，所以x=1,y默认为0,然后根据子类重载的输出
之后调用子类构造函数，x=1,y=-1。

当使用new B()创建B的实例时，产生什么输出？

x=1,y=0

如果子类父类都有无参构造函数，它们的调用顺序如何

public class Person
{
    public Person()
    {
      Console.WriteLine("我是人");
    }
}
public class Student : Person
{
    public Student()
    {
      Console.WriteLine("我是学生");
    }
}


class Program
{
    static void Main(string[] args)
    {
      Student student = new Student();
      Console.ReadKey();
    }
}


输出：
我是人
我是学生

如果子类父类都是有参构造函数，它们的调用顺序如何

public class Person
{
    public Person()
    {
      Console.WriteLine("我是人");
    }
    public Person(string name)
    {
      Console.WriteLine("我是人，我的名字叫{0}", name);
    }
}
public class Student : Person
{
    public Student()
    {
      Console.WriteLine("我是学生");
    }
    public Student(string name)
    {
      Console.WriteLine("我是学生，我的名字叫{0}", name);
    }
}

Student student = new Student("小明");
Console.ReadKey();

输出：
我是人
我是学生，我的名字叫小明

12. CTS、CLS、CLR分别作何解释？

CTS：通用语言系统。CLS：通用语言规范。CLR：公共语言运行库。

CTS通用类型系统 (common type system)

一种确定公共语言运行库如何定义、使用和管理类型的规范。

CLR公共语言运行库(common language runtime)

.NET Framework 提供了一个称为公共语言运行库的运行时环境，它运行代码并提供使开发过程更轻松的服务。

CLS公共语言规范(common language system)

要和其他对象完全交互，而不管这些对象是以何种语言实现的，对象必须只向调用方公开那些它们必须与之互用的所有语言的通用功能。为此定义了公共语言规范 (CLS)，它是许多应用程序所需的一套基本语言功能。

13. 什么是装箱和拆箱？

从值类型接口转换到引用类型装箱。从引用类型转换到值类型拆箱。

装箱就是隐式的将一个值型转换为引用型对象。
int i=0;
Syste.Object obj=i;

这个过程就是装箱！就是将i装箱！

拆箱就是将一个引用型对象转换成任意值型！
int i=0;
System.Object obj=i;
int j=(int)obj;


这个过程前2句是将i装箱，后一句是将obj拆箱！

14. 什么是受管制的代码？

我咋感觉老师给的答案是回答非受管制的代码呢，你们看看。

unsafe：非托管代码。不经过CLR运行。

正确答案：托管代码就是把有关内存管理（内存分配、内存释放、垃圾回收之类）都是由.net的CLR来管理的程序代码，也就是说使用托管代码把底层的一些操作都封装起来了，不能直接进行内存读取之类的和硬件相关的操作

15.什么是强类型系统？

RTTI：类型识别系统。

所谓的强类型，指的是类型是明确的！
为了保证类型的明确性，强类型的语言的成员、变量必须声明明确的类型，而且要先声明后使用。像c#,c++等是强制类型定义的语言，所有变量先定义再使用，数据类型不可变等。

16.net中读写数据库需要用到那些类？他们的作用？

DataSet:数据存储器。

DataCommand:执行语句命令。

DataAdapter:数据的集合，用语填充。

17.列举ASP.NET页面之间传递值的几种方式

(1)使用QueryString, 如 response. Redirect()
2).使用Session变量
3).使用Server.Transfer

ASP.NET页面之间传递值的几种方式_ba_wang_mao的博客-CSDN博客_asp.net页面之间传递值的几种方式

18.什么是Code-Behind技术？

代码后置。将ASP.NET程序需要呈现的一个网页分为*.aspx和*.cs这两个文件，即代码分离技术，实现了HTML代码和服务器逻辑代码的分离，这样更方便于代码编写、整理及调试。

19.在.net中，配件的意思是？

程序集。（中间语言，源数据，资源，装配清单）

20.常用的调用WebService的方法有哪些？

1.使用WSDL.exe命令行工具。

2.使用VS.NET中的Add Web Reference菜单选项

在VS内添加Web Reference - ю意思я - 博客园

没看懂，就介绍介绍都是些啥意思吧。

WebService是什么。WebService是一种跨编程语言和跨操作系统平台的远程调用技术。

跨编程语言和跨操作平台，就是说服务端程序采用java编写，客户端程序则可以采用其他编程语言编写，反之亦然！跨操作系统平台则是指服务端程序和客户端程序可以在不同的操作系统上运行。

远程调用，就是一台计算机a上的一个程序可以调用到另外一台计算机b上的一个对象的方法

WebService就是一个应用程序向外界暴露出一个能通过Web进行调用的API，也就是说能用编程的方法通过Web来调用这个应用程序。我们把调用这个WebService的应用程序叫做客户端，而把提供这个WebService的应用程序叫做服务端。

WSDL是什么。 .wsdl 文件是一个使用称作 Web 服务描述语言 (WSDL) 的 XML 语法编写的 XML 文档。此文件定义 XML Web services 的行为方式并指示客户端如何与该服务交互

21. .netRemoting 的工作原理是什么？

服务器端向客户端发送一个进程编号，一个程序域编号，以确定对象的位置

.NetRemoting是.NET平台里面一个专门用来处理远程调用的框架，是已经为我们做好的、现成的框架，我们可以利用他来进行远程调用。

不理解。感觉他就是从网上找的一题库来考【面试题大全】。

22. 在C＃中，string str = null 与 string str = “”

string str = null 是不给他分配内存空间,而string str = "" 给它分配长度为空字符串的内存空间。

23.请详述在dotnet中类(class)与结构(struct)的异同？

这个我们之前说过这两个数据类型分别属于哪一个。

Class可以被实例化,属于引用类型,是分配在内存的堆上的,Struct属于值类型,是分配在内存的栈上的

24.分析以下代码，完成填空

string strTmp = "abcdefg某某某";
//将字符串转换为byte数组，并求其数组长度。
int i= System.Text.Encoding.Default.GetBytes(strTmp).Length;
int j= strTmp.Length; //求得长度

以上代码执行完后，i= j=

答：i=13,j=10

我运行完是16、10。但是在网上搜的都是13,10。有问题

25.数据库的操作

SQLSERVER服务器中，给定表table1 中有两个字段 ID、LastUpdateDate，ID表示更新的事务号，LastUpdateDate表示更新时的服务器时间，请使用一句SQL语句获得最后更新的事务号

Select ID FROM table1 Where LastUpdateDate = (Select MAX(LastUpdateDate) FROM table1)

因为时间越新，其值越大，所以取Max

Select 后面是要选择的列，from表示从哪个表选择，where后面是条件【满足的条件是，选择最新的时间的那个数据ID】

26. 简要谈一下您对微软.NET构架下remoting和webservice两项技术的理解以及实际中的应用。

直接背的了，我也看不懂，老师给的答案比网上的要简单

WS主要是可利用HTTP，穿透防火墙。而Remoting可以利用TCP/IP，二进制传送提高效率。

27.

公司要求开发一个继承System.Windows.Forms.ListView类的组件，要求达到以下的特殊功能：点击ListView各列列头时，能按照点击列的每行值进行重排视图中的所有行 (排序的方式如DataGrid相似)。根据您的知识，请简要谈一下您的思路。

根据点击的列头,把该列的ID取出,按照该ID排序后,在给绑定到ListView中。

28.写出一条Sql语句：取出表A中第31到第40记录（SQLServer,以自动增长的ID作为主键,注意：ID可能不是连续的。

解1: select top 10 * from A where id not in (select top 30 id from A)

解2: select top 10 * from A where id >(select max(id) from (select top 30 id from A ) as A)

第一个思路：查询A表中的前10条数据。条件是ID不属于前30条的，这样就把第1-30记录剔除了，此时的前十条，就是31-40

第二个思路：条件是，先取前30条的ID，你的ID要大于第30个，所以也只能去30以后的数据了

29.面向对象的语言具有封装性、继承性、多态性

30.能用foreach遍历访问的对象需要实现IEnumerable接口或声明GetEnumerator方法的类型。

IEnumerable作用：就是使实现这个接口的对象成为可枚举类型。

IEnumerable接口包含一个GetEnumerator方法

31、GC是什么? 为什么要有GC?

gc是垃圾回收器；程序员不必担心内存管理，因为GC会自动进行内存管理；可以通过System.gc()和Runtime.GetRuntime().gc()来调用

32、Strings = new String("xyz");创建了几个String Object?

两个。一个是直接量的xyz对象;另一个是通过new Sting()构造器创建出来的String对象

33.启动一个线程是用run()还是start()?

总结：启动使用start()；停止使用run()

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

进程：是指⼀个内存中运⾏的应⽤程序，每个进程都有⼀个独⽴的内存空间，⼀个应⽤程序可以同时运⾏多个进程；进程也是程序的⼀次执⾏过程，是系统运⾏程序的基本单位系统运⾏⼀个程序即是⼀个进程从创建、运⾏到消亡的过程。

线程：线程是进程中的⼀个执⾏单元，负责当前进程中程序的执⾏，⼀个进程中⾄少有⼀个线程。⼀个进程中是可以有多个线程的，这个应⽤程序也可以称之为多线程程序。

⼀个程序运⾏后⾄少有⼀个进程，⼀个进程中可以包含多个线程

34.接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口可以继承接口。

抽象类可以实现(implements)接口。

抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

C#语言的规定，没什么可解释的。

35.构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载。

重写(override)，是子类重写父类的方法，你这个都不能继承，没有子类，所以无法重写。

构造器

构造器是一个特殊的方法。他没有返回值，不能通过实例调用。必须通过new来调用。

声明构造器的语法为：定义一个没有返回值的方法，方法名和类名一致。
即便构造器大多数都是给别人使用的。但他的默认访问权限仍然是private的。

感觉和构造方法差不多。。。

36.是否可以继承String类?

String类是final类故不可以继承。

String类是sealed类故不可以继承。

两个答案都可以。

（1）被final修饰的类不可以被继承

（2）当对一个类应用 sealed 修饰符时，此修饰符会阻止其他类从该类继承。

通过看源码。被 sealed修饰。

37.try{}里有一个return语句，那么紧跟在这个try后的finally {}里的代码会不会被执行，什么时候被执行，在return前还是后?

try

{

//执行的代码，其中可能有异常。一旦发现异常，则立即跳到catch执行。否则不会执行catch里面的内容

} 

catch

{

//除非try里面执行代码发生了异常，否则这里的代码不会执行

} 

finally

{

//不管什么情况都会执行，包括try catch 里面用了return ,可以理解为只要执行了try或者catch，就一定会执行 finally  

}

38.两个对象值相同(x.equals(y)== true)，但却可有不同的hash code，这句话对不对?

不对，有相同的hash code

hashCode主要用在hashtable类的。是为了快速的验证两个对象是否相等。如果两个对象的hashcode不等，这两个对象就不等

C# 中==是用来判断变量的值是否相等,相等返回true,不相等返回false.Equals是用来判断两个对象(除string类型外)是否相等，相等返回true；相等的条件是--值,地址,引用全相等。

39.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和case语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

switch原则上只能作用于int型上，但是,char、char等可以隐式的转换为int 型，而long, string 不可以，所以呢，switch 不可以作用于Long, string 类型的变量上。

40.当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

不能，一个对象的一个synchronized方法只能由一个线程访问。

synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突

省流版：synchronized方法保证每个线程挨个访问对象成员，避免了多个线程同时访问该成员而造成冲突。

41.abstract的method【抽象类的方法】是否可同时是static,是否可同时是native，是否可同时是synchronized?

都不能

我不懂。。。

42.List,Set, Map是否继承自Collection接口?

List，Set是Map不是

Set【类似哈希表】

List【类似数组】

Map【类似字典】

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

43.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()?它们有何区别?

Set 里的元素是不能重复的，元素重复与否是使用 equals()方法进行判断的。
equals()和==方法决定引用值是否指向同一对象。equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

equals()在类中被覆盖：当子类从父类继承下来的方法不再适合子类的需要的时候,要在子类中对该方法重新定义,这种形式称为方法的覆盖(Override)。子类重新定义equals（）方法。

==：

　　基本类型：比较的是值是否相同

　　引用类型：比较的是地址值是否相同

equals（）：

　　引用类型：默认情况下，比较的是地址值，可进行重写，比较的是对象的成员变量值是否相同

对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等【内存地址】，这时候就需要用==操作符进行比较。

equals 方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。

Set是引用类型，你就想，里面的每个元素相当于成员变量，故使用equals（）方法。

44.数组有没有length()这个方法? String有没有length()这个方法？

数组没有length()这个方法，有length的属性。String有length()这个方法。

都是求长度的

45.sleep()和 wait() 有什么区别?

sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行

wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

另一个答案：

46.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

(1)低级类型可直接隐式转换成高级类型。
(2)高级到低级需要强制类型转换

short s1 = 1; s1 = s1 + 1是错的，1是int 型，无法隐式转换为short型

short s1 = 1； s1 += 1 .正确执行s1+=1;其实执行的是s1 = (short) (s1 + 1); 其中会有一个强制转换的过程

47.谈谈final,finally, finalize的区别。

省流版【final,finally之前有讲过】

final：修饰符，一个类被它修饰，就不能继承，没有子类

finally：try-catch-finally，异常处理机制

finalize：内存清理

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为 final的方法也同样只能使用，不能重载

finally—再异常处理时提供finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

48.如何处理几十万条并发数据？

用存储过程或事务。取得最大标识的时候同时更新。注意主键不是自增量方式这种方法并发的时候是不会有重复主键的。取得最大标识要有一个存储过程来获取.

数据库的知识。存储过程或事务，你们就当成，每进行相关的操作【这个操作是存储过程定义的】，就会触发一个函数，进行处理。

49.Session有什么重大BUG，微软提出了什么方法加以解决？

是iis中由于有进程回收机制，系统繁忙的话Session会丢失，可以用Sate server或SQL Server数据库的方式存储Session不过这种方式比较慢，而且无法捕获Session的END事件。

不懂，背吧

50.进程和线程的区别？

之前有讲过

进程是系统进行资源分配和调度的单位；线程是CPU调度和分派的单位，一个进程可以有多个线程，这些线程共享这个进程的资源。

51.堆和栈的区别

栈：由编译器自动分配、释放。在函数体中定义的变量通常在栈上。
堆：一般由程序员分配释放。用new、malloc等分配内存函数分配得到的就是在堆上

也可以不恰当地理解为栈上是值类型，堆上存的是引用类型

52.成员变量和成员函数前加static的作用？

它们被称为常成员变量和常成员函数，又称为类成员变量和类成员函数。分别用来反映类的状态。比如类成员变量可以用来统计类实例的数量，类成员函数负责这种统计的动作。

什么是类成员XX

例如定义一个Text类【其中有temp属性】。如果你想访问temp属性，你就必须先创建一个Text的对象，才能访问：Text b = new Text（）；b.temp;这就是实例成员变量。

你想访问number的话，不用创建Text的实例就可以访问，就像这样：Text.number.这就是类成员变量。

主要区别就是访问是需不需要创建对象，而对于类成员变量，所有对象是共享一个变量的。

至于为什么能统计统计类实例的数量，我不知道。。。

53. ASP.NET与ASP相比，主要有哪些进步？

asp解释形,aspx编译型,性能提高,有利于保护源码

ASPX文件是包含VBScript或C#代码的文件,是一个服务器生成的网页,其中包含脚本,这些脚本在Web服务器上处理,生成的HTML将发送到用户的Web浏览器,专为Microsoft ASP.NET框架而设计

ASP是解释型的编程框架，因没有事先编译，而是一边解释一边执行，故而页面的执行效率相对比较仍。ASP.NET是编译型的编程框架，服务器上远行的是已经编译好的代码．因此可以利用早期绑定来实时编译，进而提高执行效率。

54.请说明在.net中常用的几种页面间传递参数的方法，并说出他们的优缺点。

1.QueryString 传递一个或多个安全性要求不高或是结构简单的数值。但是对于传递数组或对象的话，就不能用这个方法了
2.session(viewstate) 简单，但易丢失
3.application 对象的作用范围是整个全局，也就是说对所有用户都有效。
4.cookie 简单，但可能不支持，可能被伪造
5.input ttype="hidden" 简单，可能被伪造
6.url参数简单，显示于地址栏，长度有限

55.请指出GAC的含义？

全局程序集缓存

可以存放一些有很多程序都要用到的公共assembly，例如system.data、system.windows.forms 等等。这样，很多程序就可以从gac里面取得assembly，而不需要再把所有要用到的assembly都拷贝到应用程序的执行目录下面

56.向服务器发送请求有几种方式？

get一般为链接方式，post一般为按钮方式。

GET是从服务器上获取数据,POST是向服务器传送数据。

你就这么想，我们输出网址链接获取相关内容【或者输入账号密码得到自己的数据】，就是get。

当我们在网上考试做完卷子时，我们需要点击提交按钮，这样我们的卷子数据就传过去了。

57.DataReader与Dataset有什么区别？

一个是只能向前的只读游标，一个是内存中虚拟的数据库。

58.软件开发过程一般有几个阶段？每个阶段的作用？

需求分析，架构设计，代码编写，QA（测试），部署

需求分析。在确定软件开发可行性的情况下，对软件需要实现的各个功能进行详细需求分析。

架构设计。此阶段中偶要根据需求分析的结果，对整个软件系统进行设计，如系统框架设计、数据库设计等。

代码编写。此阶段是将软件设计的结果转化为计算机可运行的程序代码。在程序编码中必定要制定统一、符合标准的编写规范。

测试。在软件设计完成之后要进行严密的测试，一发现软件在整个软件设计过程中存在的问题并加以纠正。

部署。把开发好的软件应用给到用户正常使用的过程

59.在c#中using和new这两个关键字有什么意义，请写出你所知道的意义？using指令和语句 new 创建实例 new 隐藏基类中方法。

using：引入名称空间或者使用非托管资源

new：新建实例或者隐藏父类方法

60.需要实现对一个字符串的处理,首先将该字符串首尾的空格去掉,如果字符串中间还有连续空格的话,仅保留一个空格,即允许字符串中间有多个空格,但连续的空格数不可超过一个.

string inputStr=" xx xx ";

inputStr=Regex.Replace(inputStr.Trim()," *"," ");//注意这*前面有一个空格，不过无伤大雅，老师也看不出来。

（1）先介绍Regex.Replace()方法

在指定的输入字符串内，使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。

public static string Replace (string input, string pattern, string replacement);

input

要搜索匹配项的字符串。

pattern

要匹配的正则表达式模式。

replacement

替换字符串。

（2）正则表达式中的 *

*是一个限定符，用来修饰前一个字符或分组，限定匹配重复的数量为任意数量。

正则表达式      a*  可以匹配 a   aa   aaa  aaaa aaaaaaa等等
正则表达式   (ab)*   可以匹配  ab  abababab   ababababababab等等

（3）

inputStr=Regex.Replace(inputStr.Trim()," *"," ");

所以我们先是把前后空格去掉，并让中间多个连续空格替换成—个空格

这是一个测试用例，正则表达式/ */表示匹配多个空格。然后多个空格替换成一个空格就行

61.什么叫做SQL注入，如何防止？请举例说明

利用sql关键字对网站进行攻击。过滤关键字等

sql注入是常见的利用程序漏洞进行攻击的方法.导致sql注入攻击并非系统造成的,主要是程序中忽略了安全因素,利用sql语言漏洞获得合法身份登陆系统

62.什么是反射？

动态获取程序集信息

.Net中获取运行时类型信息的方式

反射就是我们在只知道一个对象的外部而不了解内部结构的情况下，可以知道这个对象的内部实现

63.用Singleton如何写设计模式

static属性里面new ,构造函数private

单例模式【Singleton】即所谓的一个类只能有一个实例, 也就是类只能在内部实例一次,然后提供这一实例，外部无法对此类实例化。

知道是个啥就行了。。。


    public class Singleton
    { 
        private static Singleton singleton;  //static属性

        private Singleton() { } //构造函数private

        public static Singleton GetSingleton()
        {
            if (singleton == null)
                singleton = new Singleton();  //在类内部自己实例化  //static属性里面new
            return singleton;
        } 
    }

64.什么是ApplicationPool？

Web应用，类似Thread Pool，提高并发性能。

线程池（Thread Pool）就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

就是事先准备好一些，用的时候直接拿过来使用，不用每次创建，节省更多时间

65.什么是虚函数？什么是抽象函数？

虚函数：没有实现的，可由子类继承并重写的函数。

抽象函数：规定其非虚子类必须实现的函数，必须被重写。

如下图，抽象类里定义了抽象函数，但是没有实现，子类必须实现抽象类的抽象函数

虚函数就是virtual，咱们之前讲过的。子类只能重写父类里的虚函数

两个区别就是，一个必须，一个非必须

66.什么是XML？

XML即可扩展标记语言。XML记是指计算机所能理解的信息符号，通过此种标记，计算机之间可以处理包含各种信息的文章等。如何定义这些标记，既可以选择国际通用的标记语言，比如HTML，也可以使用像XML这样由相关人士自由决定的标记语言，这就是语言的可扩展性。XML是从SGML中简化修改出来的。它主要用到的有XML、XSL和XPath等。

类似HTML，标记语言。有标签啥的，用这个存储数据。

67.什么是WebService？UDDI？

Web Service便是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。

UDDI的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为WebService提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

Web Service从名字上看就是基于Web服务的，它是一种跨平台，跨语言的服务。例如，当我们想查看某地区的天气，我们在某个网站上看到了，我们会以为是这个网站提供了此项服务。其实不然，它只是调用了服务器端的代码，调用了别人家共享的资源。Web service 可以将你的服务【资源】发布到互联网上让别人去调用，也可以调用别人发布的web service

UDII，一个发布或查找相关Web Service服务的地方。通过UDDI，企业可以根据自己的需要动态查找并使用Web服务，也可以将自己的Web服务动态地发布到UDDI注册中心，供其他用户使用

68.什么是ASP.net中的用户控件？

用户控件一般用在内容多为静态,或者少许会改变的情况下用的比较多，类似ASP中的include，但是功能要强大的多。

和winform控件差不多，这次是在web上放控件。用户控件是能够在其放置标记和web服务器控件的容器

ASP中的include：“#include #include 命令指示 Web 服务器将文件内容插入到 HTML 页中。就是添加内容文本的

69.列举一下你所了解的XML技术及其应用

xml用于配置,用于保存静态数据类型，接触XML最多的是web Services和config

config是Web配置命令。【起到web页面初始化的作用】

web浏览器在初始化时使用一个config对象向JSP页面传递信息，此配置信息包括初始化参数（在当前Web应用的应用部署描述文件web.xml中定义）以及表示Servlet或JSP页面所属Web应用的ServletContext对象。

70.ADO.net中常用的对象有哪些？分别描述一下。

Connection 数据库连接对象【获取数据库连接权限】

Command 数据库命令【操作数据库的指令，增删查改】

DataReader 数据读取器【表示从数据库中读取的当前记录】

DataSet 数据集

71、略

72.什么是SOAP,有哪些应用。

【simple object access protocal】简单对象接受协议.以xml为基本编码结构,建立在已有通信协议上

就是一个在web上传递信息的方法。【例如传文本、传数据啥的】

73.C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？

attribute--特性，之前介绍过【判断题48】

一个是属性，用于存取类的字段，一个是特性，用来标识类，方法等的附加性质。

【直接按他给的回答吧，网上搜的，都没有明确说明这种机制的好处在哪里】

74.XML与 HTML 的主要区别

两个都是标记语言

XML是区分大小写字母的，HTML不区分。

在HTML中，如果上下文清楚地显示出段落或者列表键在何处结尾，那么你可以省略
或者
之类的结束标记。在XML中，绝对不能省略掉结束标记。
在XML中，拥有单个标记而没有匹配的结束标记的元素必须用一个 / 字符作为结尾。这样分析器就知道不用查找结束标记了。

在XML中，属性值必须分装在引号中。在HTML中，引号是可用可不用的。

在HTML中，可以拥有不带值的属性名。在XML中，所有的属性都必须带有相应的值。

75.c#中的三元运算符是？

Condition ? Expression1 : Expression2;

其中表达式中Condition为真，则结果返回Expresson1；如果表达式中Condition为假，则结果返回Expresson2。

? :

76.当整数a赋值给一个object对象时，整数a将会被？

装箱

77.类成员有_2种可访问形式？

（1）如果是在类内访问类成员，使用this.成员变量

（2）如果是在类外，就要new一个对象A，A.成员变量

this.

new Class().Method

78.public static const int A=1;这段代码有错误么？是什么？

static 表示静态的
const 表示静态的常数

所以你不可以说 static const,因为const已经是static了,就像你不能用俩static修饰同一个变量一样

有错，const不能用static修饰

79.float f=-123.567F; int i=(int)f ；i的值现在是_____?

浮点型强制转换为整型，小数点后都不要，也不会四舍五入

-123

80、略

81、略

82、在Asp.net中所有的自定义用户控件都必须继承自Control

.NET 分成两个方面：WinForm和WebForm，ASP.NET就是属于WebForm，也就是平时说的B/S模式的开发。而WinForm就是属于C/S模式。都是控件【按钮列表啥的，只不过应用不一样】

控件的基类——Control 控件的基类用于Windows窗体应用的控件都派生自Control类

所以都继承自Control类

83、略

84、就想着，GC是处理内存的

85、私有实例构造函数

当类T只声明了私有实例构造函数时，则在T的程序文本外部，___不可以___（可以 or 不可以）从T派生出新的类，__不可以__（可以 or 不可以）直接创建T的任何实例。

派生类就是继承。

public class Counter
{
    private Counter() { }
    public static int currentCount;
    public static int IncrementCount() //私有构造函数
    {
        return ++currentCount;
    }
}

带私有构造函数的类不能被继承

带私有构造函数的类不能被实例化

86.下面这段代码有错误么？

switch(i)
{
    case():答：//case()条件不能为空
    case 0:
        CaseZero();
        break;
    case 1:
        CaseOne();
        break;
    case 2:
        dufault;答：//wrong，格式不正确。default拼错了，应该是这个错误吧，大伙看看
        CaseTwo();
    break;
}

87.在.Net中，类System.Web.UI.Page 可以被继承么？

可以

用于webForm的创建

88、略

89、利用operator声明且仅声明了==，有什么错误么?

重载“==”时，==必须和!=成对出现

==的逻辑需要保持和bool Equals(object obj)的一致。，所以重写Equals方法来实现两个对象的比较

因为在进行比较的时候，首先时比较其HashCode是否一致，不一致的话直接就不相等，不需要向下进行比较了，所以重写GetHash()

要同时修改Equale和GetHash() ? 重载了"==" 就必须重载 "!="

90.在.net（C# or vb.net）中如何取消一个窗体的关闭。

老师说他不会出程序题写整个代码，会出成填空

private void Form1_Closing(object sender,System.ComponentModel.CancelEventArgs e)
{
    e.Cancel=true;
}

什么是取消窗体关闭：比如用户点击窗口右上角想关闭，但代码里弹出确认框让用户确认是否真的想退出，如果用户选择了否，则e.cancel = true即可；

91、略

92、这是益智题吗？

某一密码仅使用K、L、M、N、O共5个字母，密码中的单词从左向右排列，密

码单词必须遵循如下规则：

（1）密码单词的最小长度是两个字母，可以相同，也可以不同

（2） K不可能是单词的第一个字母

（3）如果L出现，则出现次数不止一次

（4） M不能使最后一个也不能是倒数第二个字母

（5） K出现，则N就一定出现

（6） O如果是最后一个字母，则L一定出现

问题一：下列哪一个字母可以放在LO中的O后面，形成一个3个字母的密码单词？

L次数>=1，所以最后一个是L

问题二：如果能得到的字母是K、L、M，那么能够形成的两个字母长的密码单词的总数是多少？

只有两个字母，M不可能

K也不可能，因为没有N

所以就只有一个LL

问题三：下列哪一个是单词密码？

(A)KLLN //K不能是第一个

(B) LOML //M不能是倒数第二个

(C) MLLO //

(D)NMKO //O是最后一个，但没有L

93、略

96.abstract class和interface有什么区别?

（1）声明方法的存在而不去实现它的类被叫做抽像类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该方法。

（2）不能创建abstract 类的实例【不能new一个抽象类对象，抽象类无法实例化】。

（3）可以创建一个变量，其类型是一个抽像类，并让它指向具体子类的一个实例【我不懂啥意思，小zhang、huang、kang快想想，想好告诉我】

（4）不能有抽像构造函数或抽像静态方法【不能使用virtual、static、private修饰符】

（5）Abstract 类的子类为它们父类中的所有抽像方法提供实现，否则它们也是抽像类【子类实现抽象类里定义的抽象方法，否则它就是抽象子类】取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法【其他类可以仿照实现】

来个简约版的

抽象类不能直接实例化。
抽象类可以包含抽象方法，但是非抽象类不可以。
不能用sealed关键字修改抽象类，如果使用了sealed关键字意味着该类不能被继承。
从抽象类派生【继承的意思】的非抽象类必须重写所有抽象方法

在抽象方法【普通方法和构造方法】声明中使用static或virtual修饰符是错误的

抽象类
 public abstract class FlowBase
 {
    // 成员变量
    public string Name { get; set; }
   	// 成员变量 - 其它类型
    public GrabParam GrabData { get; set; }
	
	// 抽象类函数 -- 普通
    public abstract void StartRun();
    
    // 抽象事件 
    public abstract event Action InitFinish;    
    
    // 抽象类函数 带参数;
    public abstract void ShowNum(ref Label lbkNum);
    
    // 普通函数
    public void SaveImage(HImage hImage, string strType)
    {
    	// 实现
    }
}


子类
public class SingleFlow : FlowBase
{
	// 抽象类函数 -- 普通
    public override void StartRun()
    {
    	// 实现
    }    
    // 抽象事件 
    public override event Action InitFinish;    
    
    // 抽象类函数 带参数;
    public override void ShowNum(ref Label lbkNum)
    {
    	// 实现
    }
}

答案写的冗长而拗口

（1）接口（interface）是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体【方法都被public、abstract修饰，具有多继承性】

（2）接口只可以定义static final成员变量。【接口中基本数据类型为static】

（3）接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法【一个类继承了接口，实现接口里的方法，之后这个类被实例化为对象，该对象可以调用类里实现的方法】

（4）由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。【没懂】

	抽象类	接口
关键字	abstract	Interface
实例化	不能	不能
数据成员【类里的字段】	可以有自己的	必须是static final修饰
方法	可以有抽象/非抽象方法	只有抽象方法
变量	可有私有的，其值可以在子类中重新定义重新赋值	不可以私有，被public static final修饰，且必须赋初值，子类中不能被重新定义，不能改变这个值
多继承性	无	有

多继承即一个子类可以有多个父类,它继承了多个父类的特性。

97.<%# %> 和 <% %> 有什么区别？

<%# %>表示绑定的数据源

<%%>是服务器端代码块：可以执行服务器代码,通俗讲就是可以写像后台一样的代码

1 <%
2         int a = 2;
3         int b = 3;
4         int c = a + b;
5         Response.Write(c);
6 %>

98.重载与覆盖的区别？

这个去体会

1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个

类中方法之间的关系，是水平关系

2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之

间的关系。

//一个类里重载了好多构造方法
Class Student
{
    public string name;
    public int id;

    public Student()
    {

    }
    public Student(string n)
    {
        this.name=n;
    }
    public Student(int num)
    {
        this.id=num;
    }

}

//创建Student时，我们可以选择不同的构造方法
Student s1=new Student();
Student s2=new Student("小明");
Student s3=new Student(1);

//在C#中，首先父类的方法必须virtual，子类覆盖时候方法必须写上ovriride
using System;
using System.Collections.Generic;
using System.Text;
 
namespace dynamicCreateClass
{
    class PostTask
    {
        public virtual void step1(){}
        public virtual void step2(){}
        public virtual void step3(){}
    }
}


//子类
using System;
using System.Collections.Generic;
using System.Text;
 
namespace dynamicCreateClass
{
    class Site1PostTask:PostTask
    {
        public override void step1() { Console.WriteLine(1); }
        public override void step2() { Console.WriteLine(2); }
        
    }
}

99.Overloaded【重载】的方法是否可以改变返回值的类型?

重写：当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法重写了父类中的方法。

重载：一个类中的方法与另一个方法同名，但是参数列不同，这种方法称之为重载方法。

100.C#可否对内存进行直接的操作？

在.net下，.net引用了垃圾回收（GC）功能，它替代了程序员。不过在C#中，c#中是有指针的,虽然很少用到,使用时要加上"unsafe"

四、填空

14、设x=10; 则表达式 x<10?x=0:x++ 的值为(10 )

三目运算符。输出x++，x++值为10

16、已知整型变量a=5,b=4,c=6,则a>b?(a>c?a:c):b的结果为(6 )

先执行括号里面，结果为a>b?c:b

之后再执行，结果为c

21、Stack类表示对象的先(出)后(进)集合

栈：先进后出。也就是后进先出

五、编程题

老师说会出成填空的形式，所以咱们就按老师给的代码来复习

1.判断n是奇是偶

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine()); //输入是字符串型，int.Parse就把字符串转整型
            if (n % 2 == 1) Console.WriteLine("{0}为奇数", n);
            else Console.WriteLine("{0}为偶数", n);
            Console.ReadKey();//就是避免运行完的黑框一闪而过
        }
    }
}

2.判断字符中有几个大写，小写字母，数字，其他字符

不做解释

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            int da = 0, xiao = 0, shuzi = 0, qita = 0;
            for (int i = 0; i < s.Length; i++)
            {
                if (s[i] >= 'A' && s[i] <= 'Z') da++;
                else if (s[i] >= 'a' && s[i] <= 'z') xiao++;
                else if (s[i] >= '0' && s[i] <= '9') shuzi++;
                else qita++;
            }
            Console.WriteLine("大写字母{0}个，小写字母{1}个，数字{2}个，其他{3}个。", da, xiao, shuzi, qita);
            Console.ReadKey();

        }
    }
}

3.定义两个方法：一个用来求圆的面积，一个用来求矩形的面积

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {
        public static double solve(int x)
        {
            return Math.PI * x * x;
        }
        public static int fun(int x, int y)
        {
            return x * y;
        }

        static void Main(string[] args)
        {
            int r = int.Parse(Console.ReadLine());
            double sum = solve(r);
            Console.WriteLine("圆的面积为{0}", sum);
            int a = int.Parse(Console.ReadLine()); //转换
            int b = int.Parse(Console.ReadLine()); 
            int ans = fun(a, b); //由于是静态方法，所以直接使用方法名即可。   如果不是静态方法，需要Program.fun(a,b)
            Console.WriteLine("矩形的面积为{0}", ans);
            Console.ReadKey();


        }
    }
}

4.输入若干个成绩，输出平均分

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine()); //有多少个成绩
            int sum = 0;
            for (int i = 1; i <= n; i++)
            {
                int x = int.Parse(Console.ReadLine()); //输入分数
                sum += x; 
            }
            Console.WriteLine(sum / n);
            Console.ReadKey();
        }
    }
}

5.求1-n之中的完数个数。（一个数如果恰好等于它的因子之和，这个数就称为“完数”）

因子就是所有可以整除这个数的数,不包括这个数自身. 包括1 不包括自身

1不是完数，完数的定义决定了。定义：某自然数除它本身以外的所有因子之和等于该数，则该数被称为完数。

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine()); //输入最后的那个值 因为要1-n遍历一遍嘛
            int sum = 0;
            //因为1不是完数，所以从2开始
            for (int i = 2; i <= n; i++)
            {
                int flag = 0;//统计因子的和
                for (int j = 1; j < i; j++)
                {
                    if (i % j == 0) flag += j;
                }
                //如果是完数，就输出这个数
                if (flag == i) 
                {
                    Console.WriteLine(i);
                    sum++; //个数+1
                }
            }
            Console.WriteLine(sum);//输出1-n一共有几个完数
            Console.ReadKey();
        }
    }
}

6.求一个表达式的和：1！+2！+3！+4！+。。。n！=？

using Microsoft.VisualBasic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Test;

namespace test
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int sum = 0;//求和
            int flag = 1;
            int ans = 1;//表示n!
            while (flag <= n)
            {
                ans *= flag;
                sum += ans;
                flag++;
            }
            Console.WriteLine(sum);
            Console.ReadKey();

        }
    }
}