要想的面试题

double i = 5;
            double j = 5;
            string a = "1";
            string b = "1";
            if (Object.ReferenceEquals(i, j))
                Console.WriteLine("Equal");
            else
                Console.WriteLine("Not Equal");
            if (Object.Equals(i, j))
                Console.WriteLine("Equal");
            else
                Console.WriteLine("Not Equal");


            if (Object.ReferenceEquals(a, b))
                Console.WriteLine("Equal");
            else
                Console.WriteLine("Not Equal");
            if (Object.Equals(a, b))
                Console.WriteLine("Equal");
            else
                Console.WriteLine("Not Equal");

大概描述一下ASP.NET服务器控件的生命周期
初始化 -> 加载视图状态 -> 处理回发数据 -> 加载 -> 发送回发更改通知 -> 处理回发事件 -> 预呈现 -> 保存状态 -> 呈现 -> 处置 -> 卸载

HashMap和Hashtable的区别

HashMap是Hashtable的轻量级实现(非线程安全的实现)，他们都完成了Map接口，主要区别在于HashMap允许空(null)键值(key),由于非线程安全，效率上可能高于Hashtable.

14.<%# %> 和 <% %>有什么区别?
<%# %>表示绑定的数据源; <% %>是服务器端代码块

15.GC是什么? 为什么要有GC?

GC是垃圾收集的意思(Gabage Collection)，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

class ConfigInfo 
{ 
        public int state; 
        public string api; 
        public ConfigInfo vc= null; 
        public ConfigInfo ac= null; 
public ConfigInfo 
{ 
  vc = new ConfigInfo(); 
  ac = new ConfigInfo();这样会 
} 
} 

ConfigInfo config= new ConfigInfo()  ----这样有问题吗？ 

你怎么去解决这个问题？

答案
public ConfigInfo 
{ 
  vc = new ConfigInfo(); 
  ac = new ConfigInfo();这样会 
} 
这都是错的,更不用说后面了,改为下面就会造成死循环,内存溢出，报 
public ConfigInfo() 
{ 
  vc = new ConfigInfo(); 
  ac = new ConfigInfo();这样会 
} 
报StackOverflowException异常了 

 IEnumerable 、 GetEnumerator (对foreach机制的理解)

(1) 以下叙述正确的是： bc

      A. 接口中可以有虚方法。     B. 一个类可以实现多个接口。
      C. 接口不能被实例化。       D. 接口中可以包含已实现的方法。

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

class Class1 {
       private string str = "Class1.str";
       private int i = 0;
       static void StringConvert(string str) {
           str = "string being converted.";
       }
       static void StringConvert(Class1 c) {
           c.str = "string being converted.";
       }
       static void Add(int i) {
           i++;
       }
       static void AddWithRef(ref int i) { 


           i++;
       }
       static void Main() {
           int i1 = 10;
           int i2 = 20;
           string str = "str";
           Class1 c = new Class1();
           Add(i1);
           AddWithRef(ref i2);
           Add(c.i);
           StringConvert(str);         
           StringConvert(c);
           Console.WriteLine(i1);
           Console.WriteLine(i2);
           Console.WriteLine(c.i);
           Console.WriteLine(str);
           Console.WriteLine(c.str);
       } 
    } 
答案
10
21
0
str
string being conveted.

注意 因为string是具有值类型特点的引用类型。
所以第四个为str， 和int一样的性质

public abstract class A 
{
        public A() 
       {
            Console.WriteLine('A');
        }
        public virtual void Fun() 
       {
            Console.WriteLine("A.Fun()");
        }
} 



public class B: A 
{
        public B() 
      {
            Console.WriteLine('B');
        } 



        public new void Fun() 
       {
            Console.WriteLine("B.Fun()");
        } 


        public static void Main() 
       {
           A a = new B();
           a.Fun();
        }
} 

A
B
A.Fun()
(考查在继承类中构造函数, 以及new 方法, ) 

 

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

public class MainClass
    {
        public static void Main()   
        {
            Console.WriteLine(Foo(30));
        }
        public static int Foo(int i)
        {
            if (i <= 0)
                return 0;
            else if(i > 0 && i <= 2)
                return 1; 
            else return Foo(i -1) + Foo(i - 2);
        }
    }

public class A 
{
        public virtual void Fun1(int i) 
       {
            Console.WriteLine(i);
        } 

        public void Fun2(A a)   
       {
            a.Fun1(1);
            Fun1(5);
        }
} 

public class B : A 
{
        public override void Fun1(int i)    
       {
            base.Fun1 (i + 1);
        } 



        public static void Main()   
       {
            B b = new B();
            A a = new A();
            a.Fun2(b);
            b.Fun2(a);          
        }
} 

2
5
1
6
最后一个Fun1(5);因为在父类中直接调用func1方法，而fun1方法已经被子类重写，因此调用子类重写的fun1方法。和a.fun1不同。
a.fun1!=this.fun1