c#基础概念二十五问.txt

适合与初级C#程序员使用

            return string.Format("Don't have this.: {0} MSEL", Environment.TickCount - vTickCount); 
        } 
    } 
    class UnitTransClass 
    { 
        public static double C2F(Class1 value) 
        { 
            //摄氏到华氏的转换公式 
            return 1.8 * value.C + 32; 
        } 
    } 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            Class1 tmpObj = new Class1(37.5); 
  
            Console.WriteLine(tmpObj); 
  
            Console.WriteLine(tmpObj.Test1()); 
            Console.WriteLine(tmpObj.Test2()); 
  
            Console.ReadLine(); 
        } 
    } 
} 
结果： 
37.5 Celsius = 99.5 Fahrenheit 
Have this.: 4375 MSEL 
Don't have this.: 4406 MSEL  


11.可以使用抽象函数重写基类中的虚函数吗？ 

答： 

可以，但需使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现 

示例: 

    class BaseClass 
    { 
        public virtual void F() 
        { 
            Console.WriteLine("BaseClass.F"); 
        } 
    } 
    abstract class  DeriveClass : BaseClass 
    { 
        public new abstract void F(); 
    } 

12.密封类可以有虚函数吗？ 

答： 

可以，基类中的虚函数将隐式的转化为非虚函数，但密封类本身不能再增加新的虚函数 

示例： 

    class BaseClass 
    { 
        public virtual void F() 
        { 
            Console.WriteLine("BaseClass.F"); 
        } 
    } 
    sealed class DeriveClass : BaseClass 
    { 
        //基类中的虚函数F被隐式的转化为非虚函数 
  
        //密封类中不能再声明新的虚函数G 
        //public virtual void G() 
        //{ 
        //    Console.WriteLine("DeriveClass.G"); 
        //} 
    } 

13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有 get 和 set 两个呢？ 

答： 

如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后也应只有一个。如果基类中有 get 和 set 两个属性访问器，
那么继承类中可以只有一个也可以同时有两个属性访问器 


14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？ 

答： 

abstract 修饰符不可以和 static、virtual 和 override 修饰符一起使用 


15.接口可以包含哪些成员？ 

答： 

接口可以包含属性、方法、索引指示器和事件，但不能包含常量、域、操作符、构造函数和析构函数，而且也不能包含任何静态成员 

  

16.类和结构的区别？ 

答： 
类： 

类是引用类型在堆上分配，类的实例进行赋值只是复制了引用，都指向同一段实际对象分配的内存 

类有构造和析构函数 

类可以继承和被继承 

结构： 

结构是值类型在栈上分配（虽然栈的访问速度比较堆要快，但栈的资源有限放），结构的赋值将分配产生一个新的对象。 

结构没有构造函数，但可以添加。结构没有析构函数 

结构不可以继承自另一个结构或被继承，但和类一样可以继承自接口 

  

示例： 

根据以上比较，我们可以得出一些轻量级的对象最好使用结构，但数据量大或有复杂处理逻辑对象最好使用类。 

如：Geoemtry（GIS 里的一个概论，在 OGC 标准里有定义） 最好使用类，而 Geometry 中点的成员最好使用结构 

using System; 
using System.Collections.Generic; 
using System.Text; 
  
namespace Example16 
{ 
    interface IPoint 
    { 
        double X 
        { 
            get; 
            set; 
        } 
        double Y 
        { 
            get; 
            set; 
        } 
        double Z 
        { 
            get; 
            set; 
        } 
    } 
    //结构也可以从接口继承 
    struct Point: IPoint 
    { 
        private double x, y, z; 
        //结构也可以增加构造函数 
        public Point(double X, double Y, double Z) 
        { 
            this.x = X; 
            this.y = Y; 
            this.z = Z; 
        } 
        public double X 
        { 
            get { return x; } 
            set { x = value; } 
        } 
        public double Y 
        { 
            get { return x; } 
            set { x = value; } 
        } 
        public double Z 
        { 
            get { return x; } 
            set { x = value; } 
        } 
    } 
    //在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作 
    class PointGeometry 
    { 
        private Point value; 
         
        public PointGeometry(double X, double Y, double Z) 
        { 
            value = new Point(X, Y, Z); 
        } 
        public PointGeometry(Point value) 
        { 
            //结构的赋值将分配新的内存 
            this.value = value; 
        } 
        public double X 
        { 
            get { return value.X; } 
            set { this.value.X = value; } 
        } 
        public double Y 
        { 
            get { return value.Y; } 
            set { this.value.Y = value; } 
        } 
        public double Z 
       { 
            get { return value.Z; } 
            set { this.value.Z = value; } 
        } 
        public static PointGeometry operator +(PointGeometry Left, PointGeometry Rigth) 
        { 
            return new PointGeometry(Left.X + Rigth.X, Left.Y + Rigth.Y, Left.Z + Rigth.Z); 
        } 
        public override string ToString() 
        { 
            return string.Format("X: {0}, Y: {1}, Z: {2}", value.X, value.Y, value.Z); 
        } 
    } 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            Point tmpPoint = new Point(1, 2, 3); 
  
            PointGeometry tmpPG1 = new PointGeometry(tmpPoint); 
            PointGeometry tmpPG2 = new PointGeometry(tmpPoint); 
            tmpPG2.X = 4; 
            tmpPG2.Y = 5; 
            tmpPG2.Z = 6; 
  
            //由于结构是值类型，tmpPG1 和 tmpPG2 的坐标并不一样 
            Console.WriteLine(tmpPG1); 
            Console.WriteLine(tmpPG2); 
  
            //由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3 
            PointGeometry tmpPG3 = tmpPG1; 
            tmpPG1.X = 7; 
            tmpPG1.Y = 8; 
            tmpPG1.Z = 9; 
            Console.WriteLine(tmpPG1); 
            Console.WriteLine(tmpPG3); 
  
            Console.ReadLine(); 
        } 
    } 
} 
结果： 
X: 1, Y: 2, Z: 3 
X: 4, Y: 5, Z: 6 
X: 7, Y: 8, Z: 9 
X: 7, Y: 8, Z: 9  


17.接口的多继承会带来哪些问题？ 

答： 

C# 中的接口与类不同，可以使用多继承，即一个子接口可以有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性（这也正是 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  


18.抽象类和接口的区别？ 

答： 

抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义 

抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性 

分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么” 

为外部提供调用或功能需要扩充时优先使用接口 


19.别名指示符是什么？ 

答： 

通过别名指示符我们可以为某个类型起一个别名 

主要用于解决两个命名空间内有同名类型的冲突或避免使用冗余的命名空间 

别名指示符只在一个单元文件内起作用 

示例： 

Class1.cs: 

using System; 
using System.Collections.Generic; 
using System.Text; 
  
namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01 
{ 
    class Class1 
    { 
        public override string ToString() 
        { 
            return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01's Class1"; 
        } 
    } 
} 
Class2.cs 

using System; 
using System.Collections.Generic; 
using System.Text; 
  
namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02 
{ 
    class Class1 
    { 
        public override string ToString() 
        { 
            return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02's Class1"; 
        } 
    } 
} 
主单元（Program.cs）： 

using System; 
using System.Collections.Generic; 
using System.Text; 
  
//使用别名指示符解决同名类型的冲突 
using Lib01Class1 = com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01.Class1; 
using Lib02Class2 = com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02.Class1;