关闭

C#基础概念二十五问

1740人阅读 评论(0) 收藏 举报

注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除!

    当初学 C# 时是找个人大概问了一下数据类型和分支语句就开始做项目了。这两天又全面的看了一下相关的基础知识(学而时习之嘛),总结了25个问题:

1.静态成员和非静态成员的区别?
2.const 和 static readonly 区别?
3.extern 是什么意思?
4.abstract 是什么意思?
5.internal 修饰符起什么作用?
6.sealed 修饰符是干什么的?
7.override 和 overload 的区别?
8.什么是索引指示器?
9.new 修饰符是起什么作用?
10.this 关键字的含义?
11.可以使用抽象函数重写基类中的虚函数吗?
12.密封类可以有虚函数吗?
13.什么是属性访问器?
14.abstract 可以和 virtual 一起使用吗?可以和 override 一起使用吗?
15.接口可以包含哪些成员?
16.类和结构的区别?
17.接口的多继承会带来哪些问题?
18.抽象类和接口的区别?
19.别名指示符是什么?
20.如何手工释放资源?
21.P/Invoke是什么?
22.StringBuilder 和 String 的区别?
23.explicit 和 implicit 的含义?
24.params 有什么用?
25.什么是反射?

以下是我做的一份参考答案(C# 语言范畴之内),如果有不准确、不全面的,欢迎各位朋友指正!


1.静态成员和非静态成员的区别?

答:

静态变量使用 static 修饰符进行声明,在类被实例化时创建,通过类进行访问

不带有 static 修饰符声明的变量称做非静态变量,在对象被实例化时创建,通过对象进行访问

一个类的所有实例的同一静态变量都是同一个值,同一个类的不同实例的同一非静态变量可以是不同的值

静态函数的实现里不能使用非静态成员,如非静态变量、非静态函数等

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example01
{
    class Program
    {
        class Class1
        {
            public static String staticStr = "Class";
            public String notstaticStr = "Obj";
        }
        static void Main(string[] args)
        {
            //静态变量通过类进行访问,该类所有实例的同一静态变量都是同一个值
            Console.WriteLine("Class1's staticStr: {0}", Class1.staticStr);
 
            Class1 tmpObj1 = new Class1();
            tmpObj1.notstaticStr = "tmpObj1";
            Class1 tmpObj2 = new Class1();
            tmpObj2.notstaticStr = "tmpObj2";
 
            //非静态变量通过对象进行访问,不同对象的同一非静态变量可以有不同的值
            Console.WriteLine("tmpObj1's notstaticStr: {0}", tmpObj1.notstaticStr);
            Console.WriteLine("tmpObj2's notstaticStr: {0}", tmpObj2.notstaticStr);
 
            Console.ReadLine();
        }
    }
}

结果:
Class1's staticStr: Class
tmpObj1's notstaticStr: tmpObj1
tmpObj2's notstaticStr: tmpObj2


2.const 和 static readonly 区别?

答:

const

用 const 修饰符声明的成员叫常量,是在编译期初始化并嵌入到客户端程序

static readonly

用 static readonly 修饰符声明的成员依然是变量,只不过具有和常量类似的使用方法:通过类进行访问、初始化后不可以修改。但与常量不同的是这种变量是在运行期初始化

示例:

测试类:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example02Lib
{
    public class Class1
    {
        public const String strConst = "Const";
        public static readonly String strStaticReadonly = "StaticReadonly";
        //public const String strConst = "Const Changed";
        //public static readonly String strStaticReadonly = "StaticReadonly Changed";
    }
}
 
客户端代码:
using System;
using System.Collections.Generic;
using System.Text;
using Example02Lib;
 
namespace Example02
{
    class Program
    {
        static void Main(string[] args)
        {
            //修改Example02中Class1的strConst初始值后,只编译Example02Lib项目
            //然后到资源管理器里把新编译的Example02Lib.dll拷贝Example02.exe所在的目录,执行Example02.exe
            //切不可在IDE里直接调试运行因为这会重新编译整个解决方案!!
 
            //可以看到strConst的输出没有改变,而strStaticReadonly的输出已经改变
            //表明Const变量是在编译期初始化并嵌入到客户端程序,而StaticReadonly是在运行时初始化的
            Console.WriteLine("strConst : {0}", Class1.strConst);
            Console.WriteLine("strStaticReadonly : {0}", Class1.strStaticReadonly);
 
            Console.ReadLine();
        }
    }
}

结果:
strConst : Const
strStaticReadonly : StaticReadonly

修改后的示例:

测试类:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example02Lib
{
    public class Class1
    {
        //public const String strConst = "Const";
        //public static readonly String strStaticReadonly = "StaticReadonly";
        public const String strConst = "Const Changed";
        public static readonly String strStaticReadonly = "StaticReadonly Changed";
    }
}

结果

strConst : Const
strStaticReadonly : StaticReadonly Changed


3.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);
        }
    }
}

结果:


4.abstract 是什么意思?

答:

abstract 修饰符可以用于类、方法、属性、事件和索引指示器(indexer),表示其为抽象成员

abstract 不可以和 static 、virtual 一起使用

声明为 abstract 成员可以不包括实现代码,但只要类中还有未实现的抽象成员(即抽象类),那么它的对象就不能被实例化,通常用于强制继承类必须实现某一成员

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example04
{
    #region 基类,抽象类
    public abstract class BaseClass
    {
        //抽象属性,同时具有get和set访问器表示继承类必须将该属性实现为可读写
        public abstract String Attribute
        {
            get;
            set;
        }
 
        //抽象方法,传入一个字符串参数无返回值
        public abstract void Function(String value);
 
        //抽象事件,类型为系统预定义的代理(delegate):EventHandler
        public abstract event EventHandler Event;
 
        //抽象索引指示器,只具有get访问器表示继承类必须将该索引指示器实现为只读
        public abstract Char this[int Index]
        {
            get;
        }
    }
    #endregion
 
    #region 继承类
    public class DeriveClass : BaseClass
    {
        private String attribute;
 
        public override String Attribute
        {
            get
            {
                return attribute;
            }
            set
            {
                attribute = value;
            }
        }
        public override void Function(String value)
        {
            attribute = value;
            if (Event != null)
            {
                Event(this, new EventArgs());
            }
        }
        public override event EventHandler Event;
        public override Char this[int Index]
        {
            get
            {
                return attribute[Index];
            }
        }
    }
    #endregion
 
    class Program
    {
        static void OnFunction(object sender, EventArgs e)
        {
            for (int i = 0; i < ((DeriveClass)sender).Attribute.Length; i++)
            {
                Console.WriteLine(((DeriveClass)sender)[i]);
            }
        }
        static void Main(string[] args)
        {
            DeriveClass tmpObj = new DeriveClass();
 
            tmpObj.Attribute = "1234567";
            Console.WriteLine(tmpObj.Attribute);
 
            //将静态函数OnFunction与tmpObj对象的Event事件进行关联
            tmpObj.Event += new EventHandler(OnFunction);
 
            tmpObj.Function("7654321");
 
            Console.ReadLine();
        }
    }
}

结果:
1234567
7
6
5
4
3
2
1


5.internal 修饰符起什么作用?

答:

internal 修饰符可以用于类型或成员,使用该修饰符声明的类型或成员只能在同一程集内访问

接口的成员不能使用 internal 修饰符

值得注意的是,如果为 internal 成员加上了 protected 修饰符,这时的访问级别为 internal 或 protected。只是看字面意思容易弄错,许多人认为 internal protected 应该是“只有同一个程序集中的子类可以访问”,但其实它表示“同一个程序集中的所有类,以及所有程序集中的子类都可以访问”

示例

Example05Lib 项目的 Class1

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example05Lib
{
    public class Class1
    {
        internal String strInternal = null;
        public String strPublic;
        internal protected String strInternalProtected = null;
    }
}

结果
Example05Lib 项目的 Class2 类可以访问到 Class1 的 strInternal 成员,当然也可以访问到 strInternalProtected 成员,因为他们在同一个程序集里


Example05 项目里的 Class3 类无法访问到 Class1 的 strInternal 成员,因为它们不在同一个程序集里。但却可以访问到 strInternalProtected 成员,因为 Class3 是 Class1 的继承类


Example05 项目的 Program 类既无法访问到 Class1 的 strInternal 成员,也无法访问到 strInternalProtected 成员,因为它们既不在同一个程序集里也不存在继承关系


6.sealed 修饰符是干什么的?

答:

sealed 修饰符表示密封

用于类时,表示该类不能再被继承,不能和 abstract 同时使用,因为这两个修饰符在含义上互相排斥

用于方法和属性时,表示该方法或属性不能再被重写,必须和 override 关键字一起使用,因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员

通常用于实现第三方类库时不想被客户端继承,或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱

恰当的利用 sealed 修饰符也可以提高一定的运行效率,因为不用考虑继承类会重写该成员

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example06
{
    class Program
    {
        class A
        {
            public virtual void F()
            {
                Console.WriteLine("A.F");
            }
            public virtual void G()
            {
                Console.WriteLine("A.G");
            }
        }
        class B : A
        {
            public sealed override void F()
            {
                Console.WriteLine("B.F");
            }
            public override void G()
            {
                Console.WriteLine("B.G");
            }
        }
        class C : B
        {
            public override void G()
            {
                Console.WriteLine("C.G");
            }
        }
        static void Main(string[] args)
        {
            new A().F();
            new A().G();
            new B().F();
            new B().G();
            new C().F();
            new C().G();
 
            Console.ReadLine();
        }
    }
}

结果:
类 B 在继承类 A 时可以重写两个虚函数,如图所示:

由于类 B 中对 F 方法进行了密封, 类 C 在继承类 B 时只能重写一个函数,如图所示:

控制台输出结果,类 C 的方法 F 只能是输出 类B 中对该方法的实现:

A.F
A.G
B.F
B.G
B.F
C.G


7.override 和 overload 的区别?

答:

override 表示重写,用于继承类对基类中虚成员的实现

overload 表示重载,用于同一个类中同名方法不同参数(包括类型不同或个数不同)的实现

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example07
{
    class Program
    {
        class BaseClass
        {
            public virtual void F()
            {
                Console.WriteLine("BaseClass.F");
            }
        }
        class DeriveClass : BaseClass
        {
            public override void F()
            {
                base.F();
                Console.WriteLine("DeriveClass.F");
            }
            public void Add(int Left, int Right)
            {
                Console.WriteLine("Add for Int: {0}", Left + Right);
            }
            public void Add(double Left, double Right)
            {
                Console.WriteLine("Add for int: {0}", Left + Right);
            }
        }
        static void Main(string[] args)
        {
            DeriveClass tmpObj = new DeriveClass();
            tmpObj.F();
            tmpObj.Add(1, 2);
            tmpObj.Add(1.1, 2.2);
 
            Console.ReadLine();
        }
    }
}

结果:
BaseClass.F
DeriveClass.F
Add for Int: 3
Add for int: 3.3


8.什么是索引指示器?

答:

实现索引指示器(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(http://huazhihao.cnblogs.com/)的指点
    //索引指示器的实质是含参属性,参数并不只限于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.841470984807897
X: 2 , Y: 0.909297426825682
X: 3 , Y: 0.141120008059867
X: 4 , Y: -0.756802495307928
X: 5 , Y: -0.958924274663138
X: 6 , Y: -0.279415498198926
X: 7 , Y: 0.656986598718789
X: 8 , Y: 0.989358246623382
X: 9 , Y: 0.412118485241757
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!


9.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


10.this 关键字的含义?

答:

this 是一个保留字,仅限于构造函数和方法成员中使用

在类的构造函数中出现表示对正在构造的对象本身的引用,在类的方法中出现表示对调用该方法的对象的引用,在结构的构造上函数中出现表示对正在构造的结构的引用,在结构的方法中出现表示对调用该方法的结果的引用

this 保留字不能用于静态成员的实现里,因为这时对象或结构并未实例化

在 C# 系统中,this 实际上是一个常量,所以不能使用 this++ 这样的运算

this 保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example10
{
    class Class1
    {
        private double c;
        private string value;
 
        public double C
        {
            get
            {
                return c;
            }
        }
        public Class1(double c)
        {
            //限定同名的隐藏成员
            this.c = c;
        }
        public Class1(Class1 value)
        {
            //用对象本身实例化自己没有意义
            if (this != value)
            {
                c = value.C;
            }
        }
        public override string ToString()
        {
            //将对象本身做为参数
            return string.Format("{0} Celsius = {1} Fahrenheit", c, UnitTransClass.C2F(this));
        }
 
        //由于好奇,在这做了一个效率测试,想看看到底哪种方式访问成员变量更快,结论:区别不大。。。
        public string Test1()
        {
            long vTickCount = Environment.TickCount;
            for (int i = 0; i < 10000000; i++)
                this.value = i.ToString();
            return string.Format("Have this.: {0} MSEL", Environment.TickCount - vTickCount);
        }
        public string Test2()
        {
            long vTickCount = Environment.TickCount;
            for (int i = 0; i < 10000000; i++)
                value = i.ToString();
            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 修饰符显式声明,表示隐藏了基类中该函数的实现

或增加 override 修饰符,表示抽象重写了基类中该函数的实现

示例:

    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class  DeriveClass1 : BaseClass
    {
        public abstract new void F();
    }
 
    //感谢watson hua(http://huazhihao.cnblogs.com/)的指点
    //是他提醒了我还可以用这种方法抽象重写基类的虚方法
    abstract class DeriveClass2 : BaseClass
    {
        public abstract override 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.什么是属性访问器?

答:

属性访问器(Property Accessor),包括 get 访问器和 set 访问器分别用于字段的读写操作

其设计目的主要是为了实现面向对象(OO)中的封装思想。根据该思想,字段最好设为private,一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问

另外要注意属性本身并不一定和字段相联系


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

答:

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

abstract 修饰符可以和 override 一起使用,参见第11点

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example14
{
    class BaseClass
    {
        public virtual void F()
        {
            Console.WriteLine("BaseClass.F");
        }
    }
    abstract class DeriveClass1 : BaseClass
    {
        //在这里, abstract是可以和override一起使用的
        public abstract override void F();
    }
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}


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.CSharp25QExample.Example19.Lib01
{
    class Class1
    {
        public override string ToString()
        {
            return "com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1";
        }
    }
}

Class2.cs:

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

主单元(Program.cs):

using System;
using System.Collections.Generic;
using System.Text;
 
//使用别名指示符解决同名类型的冲突
//在所有命名空间最外层定义,作用域为整个单元文件
using Lib01Class1 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
using Lib02Class2 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02.Class1;
 
namespace Example19
{
    namespace Test1
    {
        //Test1Class1在Test1命名空间内定义,作用域仅在Test1之内
        using Test1Class1 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
 
        class Class1
        {
            //Lib01Class1和Lib02Class2在这可以正常使用
            Lib01Class1 tmpObj1 = new Lib01Class1();
            Lib02Class2 tmpObj2 = new Lib02Class2();
            //TestClass1在这可以正常使用
            Test1Class1 tmpObj3 = new Test1Class1();
        }
    }
    namespace Test2
    {
        using Test1Class2 = com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01.Class1;
 
        class Program
        {
            static void Main(string[] args)
            {
                //Lib01Class1和Lib02Class2在这可以正常使用
                Lib01Class1 tmpObj1 = new Lib01Class1();
                Lib02Class2 tmpObj2 = new Lib02Class2();
 
                //注意这里,TestClass1在这不可以正常使用。
                //因为,在Test2命名空间内不能使用Test1命名空间定义的别名
                //Test1Class1 tmpObj3 = new Test1Class1();
                
                //TestClass2在这可以正常使用
                Test1Class2 tmpObj3 = new Test1Class2();
 
                Console.WriteLine(tmpObj1);
                Console.WriteLine(tmpObj2);
                Console.WriteLine(tmpObj3);
 
                Console.ReadLine();
            }
        }
    }
}

结果:

com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib02's Class1
com.nblogs.reonlyrun.CSharp25QExample.Example19.Lib01's Class1

20.如何手工释放资源?

答:

.NET 平台在内存管理方面提供了GC(Garbage Collection),负责自动释放托管资源和内存回收的工作。但在以下两种情况需要我们手工进行资源释放:一、由于它无法对非托管资源进行释放,所以我们必须自己提供方法来释放对象内分配的非托管资源,比如你在对象的实现代码中使用了一个COM对象;二、你的类在运行是会产生大量实例(象 GIS 中的Geometry),必须自己手工释放这些资源以提高程序的运行效率

最理想的办法是通过实现一个接口显式的提供给客户调用端手工释放对象,System 命名空间内有一个 IDisposable 接口,拿来做这事非常合适,省得我们自己再声明一个接口了

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example20
{
    class Program
    {
        class Class1 : IDisposable
        {
            //析构函数,编译后变成 protected void Finalize(),GC会在回收对象前会调用调用该方法
            ~Class1()
            {
                Dispose(false);
            }
 
            //通过实现该接口,客户可以显式地释放对象,而不需要等待GC来释放资源,据说那样会降低效率
            void IDisposable.Dispose()
            {
                Dispose(true);
            }
 
            //将释放非托管资源设计成一个虚函数,提供在继承类中释放基类的资源的能力
            protected virtual void ReleaseUnmanageResources()
            {
                //Do something...
            }
 
            //私有函数用以释放非托管资源
            private void Dispose(bool disposing)
            {
                ReleaseUnmanageResources();
 
                //为true时表示是客户显式调用了释放函数,需通知GC不要再调用对象的Finalize方法
                //为false时肯定是GC调用了对象的Finalize方法,所以没有必要再告诉GC你不要调用我的Finalize方法啦
                if (disposing)
                {
                    GC.SuppressFinalize(this);
                }
            } 
        }
        static void Main(string[] args)
        {
            //tmpObj1没有手工释放资源,就等着GC来慢慢的释放它吧
            Class1 tmpObj1 = new Class1();
 
            //tmpObj2调用了Dispose方法,传说比等着GC来释放它效率要调一些
            //个人认为是因为要逐个对象的查看其元数据,以确认是否实现了Dispose方法吧
            //当然最重要的是我们可以自己确定释放的时间以节省内存,优化程序运行效率
            Class1 tmpObj2 = new Class1();
            ((IDisposable)tmpObj2).Dispose();
        }
    }
}


21.P/Invoke是什么?

答:

在受控代码与非受控代码进行交互时会产生一个事务(transition) ,这通常发生在使用平台调用服务(Platform Invocation Services),即P/Invoke

如调用系统的 API 或与 COM 对象打交道,通过 System.Runtime.InteropServices 命名空间

虽然使用 Interop 非常方便,但据估计每次调用事务都要执行 10 到 40 条指令,算起来开销也不少,所以我们要尽量少调用事务

如果非用不可,建议本着一次调用执行多个动作,而不是多次调用每次只执行少量动作的原则

22.StringBuilder 和 String 的区别?

答:

String 在进行运算时(如赋值、拼接等)会产生一个新的实例,而 StringBuilder 则不会。所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder,不要使用 String

另外,对于 String 我们不得不多说几句:

1.它是引用类型,在堆上分配内存

2.运算时会产生一个新的实例

3.String 对象一旦生成不可改变(Immutable)

3.定义相等运算符(==!=)是为了比较 String 对象(而不是引用)的值

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example22
{
    class Program
    {
        static void Main(string[] args)
        {
            const int cycle = 10000;
 
            long vTickCount = Environment.TickCount;
            String str = null;
            for (int i = 0; i < cycle; i++)
                str += i.ToString();
            Console.WriteLine("String: {0} MSEL", Environment.TickCount - vTickCount);
 
            vTickCount = Environment.TickCount;
            //看到这个变量名我就生气,奇怪为什么大家都使它呢? :)
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < cycle; i++)
                sb.Append(i);
            Console.WriteLine("StringBuilder: {0} MSEL", Environment.TickCount - vTickCount);
 
            string tmpStr1 = "A";
            string tmpStr2 = tmpStr1;
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);
            //注意后面的输出结果,tmpStr1的值改变并未影响到tmpStr2的值
            tmpStr1 = "B";
            Console.WriteLine(tmpStr1);
            Console.WriteLine(tmpStr2);
 
            Console.ReadLine();
        }
    }
}

结果:
String: 375 MSEL
StringBuilder: 16 MSEL
A
A
B
A

23.explicit 和 implicit 的含义?

答:

explicit 和 implicit 属于转换运算符,如用这两者可以让我们自定义的类型支持相互交换

explicti 表示显式转换,如从 A -> B 必须进行强制类型转换(B = (B)A)

implicit 表示隐式转换,如从 B -> A 只需直接赋值(A = B)

隐式转换可以让我们的代码看上去更漂亮、更简洁易懂,所以最好多使用 implicit 运算符。不过!如果对象本身在转换时会损失一些信息(如精度),那么我们只能使用 explicit 运算符,以便在编译期就能警告客户调用端

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example23
{
    class Program
    {
        //本例灵感来源于大话西游经典台词“神仙?妖怪?”--主要是我实在想不出什么好例子了
        class Immortal
        {
            public string name;
            public Immortal(string Name)
            {
                name = Name;
            }
            public static implicit operator Monster(Immortal value)
            {
                return new Monster(value.name + ":神仙变妖怪?偷偷下凡即可。。。");
            }
        }
        class Monster
        {
            public string name;
            public Monster(string Name)
            {
                name = Name;
            }
            public static explicit operator Immortal(Monster value)
            {
                return new Immortal(value.name + ":妖怪想当神仙?再去修炼五百年!");
            }
        }
        static void Main(string[] args)
        {
            Immortal tmpImmortal = new Immortal("紫霞仙子");
            //隐式转换
            Monster tmpObj1 = tmpImmortal;
            Console.WriteLine(tmpObj1.name);
 
            Monster tmpMonster = new Monster("孙悟空");
            //显式转换
            Immortal tmpObj2 = (Immortal)tmpMonster;
            Console.WriteLine(tmpObj2.name);
 
            Console.ReadLine();
        }
    }
}

结果:
紫霞仙子:神仙变妖怪?偷偷下凡即可。。。
孙悟空:妖怪想当神仙?再去修炼五百年!


24.params 有什么用?

答:

params 关键字在方法成员的参数列表中使用,为该方法提供了参数个数可变的能力

它在只能出现一次并且不能在其后再有参数定义,之前可以

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace ConsoleApplication1
{
    class App
    {
        //第一个参数必须是整型,但后面的参数个数是可变的。
        //而且由于定的是object数组,所有的数据类型都可以做为参数传入
        public static void UseParams(int id, params object[] list)
        {
            Console.WriteLine(id);
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i]);
            }
        }
 
        static void Main()
        {
            //可变参数部分传入了三个参数,都是字符串类型
            UseParams(1, "a", "b", "c");
            //可变参数部分传入了四个参数,分别为字符串、整数、浮点数和双精度浮点数数组
            UseParams(2, "d", 100, 33.33, new double[] { 1.1, 2.2 });
 
            Console.ReadLine();
        }
    }
}

结果:
1
a
b
c
2
d
100
33.33
System.Double[]


25.什么是反射?

答:

反射,Reflection,通过它我们可以在运行时获得各种信息,如程序集、模块、类型、字段、属性、方法和事件

通过对类型动态实例化后,还可以对其执行操作

简单来说就是用string可以在runtime为所欲为的东西,实际上就是一个.net framework内建的万能工厂

一般用于插件式框架程序和设计模式的实现,当然反射是一种手段可以充分发挥其能量来完成你想做的任何事情(前面好象见过一位高人用反射调用一个官方类库中未说明的函数。。。)

示例:

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Example25Lib
{
    public class Class1
    {
        private string name;
        private int age;
 
        //如果显式的声明了无参数构造函数,客户端只需要用程序集的CreateInstance即可实例化该类
        //在此特意不实现,以便在客户调用端体现构造函数的反射实现
        //public Class1()
        //{
        //}
        public Class1(string Name, int Age)
        {
            name = Name;
            age = Age;
        }
        public void ChangeName(string NewName)
        {
            name = NewName;
        }
        public void ChangeAge(int NewAge)
        {
            age = NewAge;
        }
        public override string ToString()
        {
            return string.Format("Name: {0}, Age: {1}", name, age);
        }
    }
}

反射实例化对象并调用其方法,属性和事件的反射调用略去

using System;
using System.Collections.Generic;
using System.Text;
 
//注意添加该反射的命名空间
using System.Reflection;
 
namespace Example25
{
    class Program
    {
        static void Main(string[] args)
        {
            //加载程序集
            Assembly tmpAss = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "Example25Lib.dll");
 
            //遍历程序集内所有的类型,并实例化
            Type[] tmpTypes = tmpAss.GetTypes();
            foreach (Type tmpType in tmpTypes)
            {
                //获取第一个类型的构造函数信息
                ConstructorInfo[] tmpConsInfos = tmpType.GetConstructors();
                foreach (ConstructorInfo tmpConsInfo in tmpConsInfos)
                {
                    //为构造函数生成调用的参数集合
                    ParameterInfo[] tmpParamInfos = tmpConsInfo.GetParameters(); 
                    object[] tmpParams = new object[tmpParamInfos.Length];
                    for (int i = 0; i < tmpParamInfos.Length; i++)
                    {
                        tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                        if (tmpParamInfos[i].ParameterType.FullName == "System.String")
                        {
                            tmpParams[i] = "Clark";
                        }
                    }
 
                    //实例化对象
                    object tmpObj = tmpConsInfo.Invoke(tmpParams);
                    Console.WriteLine(tmpObj);
 
                    //获取所有方法并执行
                    foreach (MethodInfo tmpMethod in tmpType.GetMethods())
                    {
                        //为方法的调用创建参数集合
                        tmpParamInfos = tmpMethod.GetParameters();
                        tmpParams = new object[tmpParamInfos.Length];
                        for (int i = 0; i < tmpParamInfos.Length; i++)
                        {
                            tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);
                            if (tmpParamInfos[i].ParameterType.FullName == "System.String")
                            {
                                tmpParams[i] = "Clark Zheng";
                            }
                            if (tmpParamInfos[i].ParameterType.FullName == "System.Int32")
                            {
                                tmpParams[i] = 27;
                            }
                        }
                        tmpMethod.Invoke(tmpObj, tmpParams);
                    }
 
                    //调用完方法后再次打印对象,比较结果
                    Console.WriteLine(tmpObj);
                }
            }
 
            Console.ReadLine();
        }
    }
}

结果:
Name: Clark, Age: 0
Name: Clark Zheng, Age: 27

示例下载:http://files.cnblogs.com/reonlyrun/CSharp25QExample07.rar

如果你认为还有哪些概念比较重要或容易混淆,可以在回复中提出,我会及时更新这篇随笔


一些话:

To: watson hua,谢谢你帮我改正了第4、11、14和19点的错误,并且让我对索引指示器的理解更全面!

To: xiao,谢谢你关于“实例化”的详细解释,让这篇随笔中的措词更加精确!

To: charleschen,谢谢你追问,让第1、第8的提法更恰当!

To: 装配脑袋,谢谢你提供 internal protected 含义的正确答案!


分类: A. .NET
4
0
(请您对文章做出评价)
« 博主前一篇:我也搞了个皮肤
» 博主后一篇:访问过万,抓张图留个纪念
Posted on 2007-04-05 13:44 Clark Zheng 阅读(38573) 评论(143) 编辑 收藏

Feedback

评论共2页: 上一页 1 2 

#44楼  回复 引用 查看  

2007-04-06 10:50 by 天龙之吻     
signed :)

#45楼  回复 引用  

2007-04-06 10:52 by xiao[未注册用户]
@天下
类实例化指的是调用类的静态构造器,一个类只能有一个无参无修饰符的静态构造器,它只能调用一次,用于初始化类中静态字段的状态
对象实例化指的是调用通常意义上的构造器,它用于创建类的一个具体实例,这种构造器一个类中可以有多个重载版本
代码如下:
sealed class Xiao{
private static string str;
//此为类构造器,可查看IL,其中编译为cctor
static Xiao()
{
str = "qpppp";
}
//此为实例构造器,可查看IL,其中编译为ctor
public Xiao()
{
//当然实例构造器也能作用于静态字段
str = "eeeeeeeeeee";
}
}

#46楼  回复 引用 查看  

2007-04-06 11:03 by lavy     
@Clark Zheng
this "限定被相似的名称隐藏的成员"
是MSDN的解释 :)
你的解释,我懂了!~谢谢!

#47楼  回复 引用 查看  

2007-04-06 11:11 by watson hua     
@Clark Zheng
类实例化和对象实例化xiao兄已经举例,不赘述。最初听到类实例化是在李建忠老师那里,我的理解也是建立在他翻译的applied .net framework programming,这里的问题书上都有讲道。
谢谢Sephil兄,帮我复习一下久违的c++,怀念...
关于第19题,我说的语气没表述出来。我的语气是带一点反话的。我的意思是using只在它所在的名空间内有用,换而言之,如果单个文件有多个嵌套名空间,using只在它所直接隶属的名空间内可用。当然,如果它没有放在名空间内的话,作用域就是整个文件了。

#48楼[楼主]  回复 引用 查看  

2007-04-06 11:17 by Clark Zheng     
@lavy
MSDN。。。不是忘看了就是看了忘记了,谢谢你的提醒

#49楼  回复 引用 查看  

2007-04-06 11:22 by watson hua     
@Clark Zheng
clark兄,关于称呼抱歉抱歉。:)我有的地方是直接粘的。
这篇post貌似very popular。
clark兄可以整理一下,再置顶于个人主页上,长期讨论...
当然欢迎clark兄就其他技术问题作讨论。

#50楼[楼主]  回复 引用 查看  

2007-04-06 12:17 by Clark Zheng     
@xiao
感谢,正文已修改

#51楼[楼主]  回复 引用 查看  

2007-04-06 13:07 by Clark Zheng     
@watson hua
改了第20题的提法
改了第22题的内容和示例,增加了对String的解释

示例下载已更新

#52楼[楼主]  回复 引用 查看  

2007-04-06 13:38 by Clark Zheng     
@charleschen
你的追问中关于静态函数与非静态函数的问题,我已在第1题中做了修改
关于属性访问器的用处,也已在第8题中做了修改

其它两个问题我还不能理解题面的意思,期待着你的回复

#53楼  回复 引用 查看  

2007-04-06 13:49 by yunhuasheng     
楼主挺认真的!!;)

#54楼  回复 引用 查看  

2007-04-06 14:26 by 想飞的猪     
支持LZ,让俺重温了一遍....

#55楼  回复 引用 查看  

2007-04-06 14:31 by 装配脑袋     
internal protected的语意应该是internal | protected,而不是internal && protected。相信不少没有用过的老手也不知道。

#56楼  回复 引用 查看  

2007-04-06 14:58 by 阿齐     
类实例化指的是把一个类实例化的过程,即把类的静态成员初始化的过程;
而对象实例化,就是构造一个该类的实例,然后初始化该实例的实例成员

#57楼  回复 引用 查看  

2007-04-06 15:38 by 装配脑袋     
我尝试从这些语法的最直接效果作答这些问题:

1.静态成员和非静态成员的区别?
静态字段为类型所有实例所共享,而实例字段则为每个对象实例所专有。
静态方法不能访问实例成员,而且无需对象实例即可调用。
静态构造方法仅在AppDomain初始化类型时执行一次,而且具有AppDomain级别的线程安全性。而实例构造函数则在对象初始化时执行。

2.const 和 static readonly 区别?
const的字段在编译时会将其字面值直接写到引用它的地方,而且必须用字面常量在编译时初始化。
static readonly可以在运行时初始化。

3.extern 是什么意思?
extern表示函数体在其他地方定义。因此这样的函数只有声明没有定义。

4.abstract 是什么意思?
abstract用于类表示该类不能实例化,用于成员表示它是子类必须重写的过程。

5.internal 修饰符起什么作用?
表示该类型或成员仅在同一程序集中可被其他类型所访问。

6.sealed 修饰符是干什么的?
表示该类型不能被继承,或该(虚拟)成员不能再被子类所重写。

7.override 和 overload 的区别?
我其实不太愿意讨论两个范畴的东西有什么区别,因为硬要说区别就等于把两者的定义分别写一遍。

8.什么是索引指示器?
是一种带参数的属性,通过obj[params]的语法进行调用。

9.new 修饰符是起什么作用?
它指示该过程在MethodTable中开启一个新的“slot”,从而断开基类同名虚成员对其的调用关系。

10.this 关键字的含义?
在引用类型中,它表示所调用的对象实例的引用。在值类型中,它是一个符号,将this上的各种操作转嫁给所调用的值类型对象实例。

11.可以使用抽象函数重写基类中的虚函数吗?
当且仅当基类中相应的函数也为抽象函数。

12.密封类可以有虚函数吗?
可以,甚至有些封闭类带有新声明的虚函数(所有委托类型)。

13.什么是属性访问器?
使用访问变量的语法访问属性时,实际被调用的过程。

14.abstract 可以和 virtual 一起使用吗?可以和 override 一起使用吗?
可以和override一起使用,当且仅当重写一个父类的虚成员时。

15.接口可以包含哪些成员?
接口仅可以包含过程,即方法、属性、事件。而且只能定义过程的签名,不能定义他们的方法体、访问级别等。

16.类和结构的区别?
类为引用类型
结构为值类型
结构没有终结器
结构不能继承
结构必须有一个默认构造方法,且不能自定义无参数构造方法
结构的成员不能在声明时赋值
结构默认有专门实现的不同==和GetHashCode方法

17.接口的多继承会带来哪些问题?
任何特性均在正确使用时发挥正确的效果。因此我们应该看到多继承的优势。

18.抽象类和接口的区别?
抽象类可以有构造方法
抽象类可以有终结器
抽象类可以有字段
抽象类可以有静态成员
抽象类可以没有抽象方法
抽象类可以有实例方法
一个类只能继承一个抽象类,而可以实现多个接口
抽象类的成员可以带有访问性级别
抽象类之间不能多继承,接口则可以
抽象类可以有静态构造方法

19.别名指示符是什么?
命名空间别名限定符::专名用来限定所用的名字要从指定别名所表示的范围开始搜索。别名为extern或using关键字定义的命名空间或根别名。

20.如何手工释放资源?
没有手工释放托管资源的功能,尽管有些看其来是在释放其实不是。只能手工释放非托管资源。

21.P/Invoke是什么?
通过Runtime进行封送(Marshal),调用公开方式的非托管代码,包括DLL和COM等。

22.StringBuilder 和 String 的区别?
基本上是写出两者定义的那种“区别”

23.explicit 和 implicit 的含义?
这是两个类型转换运算符,explicit运算符需要明确指出目标类型名,而implicit会根据上下文自动调用。

24.params 有什么用?
一种提供参数数目可变的参数传递方法。任意数目的参数可转化为一个数组。

25.什么是反射?
通过程序基内的元数据和Runtime的支持在运行时读取程序集、模块、类型和成员的信息,以及在运行时通过这种途径访问对象的成员或执行对象的方法。甚至动态改变类型和方法的组成。

#58楼[楼主]  回复 引用 查看  

2007-04-06 16:02 by Clark Zheng     
@装配脑袋
感谢你精心的回答,让我受益菲浅,之所以没有使用这种“最直接的效果”来做答案也许是为了让一些人看得更明白,也许是因为我的语言组织能力没有这么强。:)
真心希望你能将你的回答写成随笔,让我有机会在正文中将这些回答做为引用,方便大家更全面的了解这些概念。

ps:关于internal protected的语意能不能详细讨论一下?如果这里不方便可以通过MSN与我联系,谢谢!

#59楼[楼主]  回复 引用 查看  

2007-04-06 16:05 by Clark Zheng     
@watson
@Sephil
@天龙之吻
@yunhuasheng
@想飞的猪
@阿齐
谢谢你们的支持!

#60楼  回复 引用 查看  

2007-04-06 16:47 by 装配脑袋     
internal protected其实很简单,只是看字面意思容易弄错。许多人认为internal protected应该是“只有同一个程序集中的子类可以访问”的意思,但其实不是这样的。internal protected表示“同一个程序集中的所有类,以及所有程序集中的子类都可以访问”。也就是说是“protected或internal”的访问级别。

#61楼  回复 引用 查看  

2007-04-06 18:34 by watson hua     
@装配脑袋
我记错了。谢谢。internal protected是protected或internal

#62楼[楼主]  回复 引用 查看  

2007-04-07 02:02 by Clark Zheng     
@装配脑袋
在第5点的答案里增加了对 internal protected 的解释,谢谢你的指点!

示例下载地址也已更新

#63楼  回复 引用 查看  

2007-04-07 20:51 by 大豆男生     
收藏

#64楼[楼主]  回复 引用 查看  

2007-04-07 21:53 by Clark Zheng     
@大豆男生
谢谢支持

#65楼[楼主]  回复 引用 查看  

2007-04-07 21:54 by Clark Zheng     
@watson hua
关于第19题,别名指示符的作用域已调整

示例下载地址已更新

#66楼  回复 引用 查看  

2007-04-08 21:15 by heqing     
great!,but I have a problem.
declare attribute field above:

abstract public String Attribute
{
get;
}

why not
abstract public string Attribute
{
get;
}

#67楼  回复 引用 查看  

2007-04-08 22:04 by 玉开     
这篇随便的质量很高,谢谢楼主

#68楼[楼主]  回复 引用 查看  

2007-04-09 10:40 by Clark Zheng     
@heqing
"string is an alias for String in the .NET Framework"--MSDN
So, i free to use both of them in my code...

#69楼[楼主]  回复 引用 查看  

2007-04-09 10:41 by Clark Zheng     
@玉开
谢谢
第9个问题.程序中第二行注释中的“显示”应该是“显式”,从第11个问题的答案中可以看出
第22个问题答案第三点String 对象一量生成不可改变,是不是一旦生成不可改变

#71楼[楼主]  回复 引用 查看  

2007-04-09 12:19 by Clark Zheng     
@http://salonliudong.cnblogs.com
谢谢你的细心,正文和示例下载都已修正。

#72楼  回复 引用  

2007-04-09 18:12 by 小莫[未注册用户]
比较有价值的贴,顶一下。
能不能说一下 委托、事件、异步、多线程的知识呢?

#74楼[楼主]  回复 引用 查看  

2007-04-12 13:33 by Clark Zheng     
@金色海洋(jyk)
委托和事件在以上二十五里的示例里用了很多,通过看这些代码应该能有所理解
关于多线程,我只做过简单的研究,请参照我的另一篇随笔
http://www.cnblogs.com/reonlyrun/archive/2006/12/26/640993.html

#75楼  回复 引用  

2007-04-13 10:08 by 森林[未注册用户]
在子类中,重写有什么作用啊?

#76楼[楼主]  回复 引用 查看  

2007-04-13 13:38 by Clark Zheng     
@森林
扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现

面向对象编程里多态的实现手段

#77楼  回复 引用 查看  

2007-04-20 14:39 by 清晨风     
终于看完了,还有几处不懂,没基础啦,过几天再看一遍.
非常感谢,~_~

#78楼  回复 引用  

2007-04-23 11:42 by ZhuZhu[未注册用户]
Application Block 是什么? SqlHelper ?

#79楼  回复 引用 查看  

2007-04-24 11:09 by 拔掉内存     
你好!关于你的第十四个问题的例子,你把DeriveClass1类定义成abstract, 但又继承了BaseClass,这样可以吗?DeriveClass1类可以理解成基类,但又去继承别的类?你能解释一下吗?

#80楼  回复 引用  

2007-04-25 22:40 by Thanks[未注册用户]
非常感谢!
不过,说真的,楼主,不知道是你的表达能力太差还是其实你自己也没理解透,感觉很多地方表述不清楚或者不准确,例子也写得不好。
还是装配脑袋强,几句话,说的清楚明了。

#81楼  回复 引用 查看  

2007-04-26 14:57 by Hunts.C     
Mark:)

#82楼  回复 引用  

2007-04-27 10:43 by Jz[未注册用户]
类被实例化是什么意思?
也就是说创建类的对象吗?如果是这样第一点就有点小问题咯。

#83楼[楼主]  回复 引用 查看  

2007-04-28 17:58 by Clark Zheng     
@Thanks
虚心接受您的批评,我在写这篇随笔时是尽自己的努力来完成的,如果有哪些不清楚地方请指出来,我会进一步改进,包括例子,让以后看到这篇随笔的朋友可以更容易理解

#84楼[楼主]  回复 引用 查看  

2007-04-28 17:59 by Clark Zheng     
@Jz
类被实例化和对象被实例化是两个概念,有区别的。看一下回复记录也许你就能明白了

#85楼[楼主]  回复 引用 查看  

2007-04-28 18:22 by Clark Zheng     
@拔掉内存
抽象类也可以继承自其它类,在这个例子中我主要是为了体现“abstract是可以和override一起使用的”,而只有一个类中有抽象方法这个类就必须被声明为抽象类

#86楼  回复 引用  

2007-05-06 21:06 by IDreamer[未注册用户]
表达的的确不太好,特别是有的例子不够好。不过这种学习方法很好,我正在学java也是这样进行的。顺便说一下,java真是一个混乱的语言,平台和语法都混乱,比起来可爱的C#我们要知足了,ms真不愧是王中之王。

thanks,lz,学习

#87楼  回复 引用  

2007-05-08 11:08 by mgdn.com.cn[未注册用户]
基本上是IT公司是C#面试题,呵呵

#88楼  回复 引用  

2007-05-09 09:52 by tqj[未注册用户]
继承接口中的有的方法编译时怎么说
修饰符“virtual”对该项无效
修饰符“public”对该项无效
呢请指点

#89楼  回复 引用 查看  

2007-05-10 09:29 by 清晨风     
在msdn上看到这样一段话"静态成员在第一次被访问之前并且在任何静态构造函数(如调用的话)之前初始化"(网址:http://msdn2.microsoft.com/zh-cn/library/79b3xss3(VS.80).aspx),我测试过,好象只有静态字段才是这样的,其他静态成员如静态属性都是在静态构造函数之后才初始化的,不知是不是我理解有问题,请楼主帮忙解释一下.
我用的测试类如下:
public sealed class Singleton
{
static Singleton instance = null;
Singleton()
{
}
static Singleton()
{
}
public static Singleton Instance
{
get
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}

#90楼  回复 引用  

2007-05-16 11:12 by BoatBoy[未注册用户]
@装配脑袋
11.可以使用抽象函数重写基类中的虚函数吗?
当且仅当基类中相应的函数也为抽象函数。

怎么感觉和Clark Zheng的文章有出入呢?
看原文的14条,抽象函数重写了基类的虚函数,但是基类中的函数好像不是抽象的吧。

另外
7.override 和 overload 的区别?
我其实不太愿意讨论两个范畴的东西有什么区别,因为硬要说区别就等于把两者的定义分别写一遍。

这里我觉得两者应该不是绝然不同的两个东西,想想多态的概念两者都是对多态的实现。不过一个是在类内部,一个在继承类之间而已。

请指教。

#91楼  回复 引用 查看  

2007-05-21 16:57 by winnerzone     
还真没有好好注意这些问题过.

#92楼  回复 引用  

2007-05-30 20:25 by 刘阿大[未注册用户]
我认为关于静态的表述有点问题----“类的实例化时创建”应该表述为“类在第一次实例化时”;关于非静态变量的“在对象实例化时创建”就更有问题,对象本身就是实例化后的产物。
还有关于this的说法我觉得会让初学者误解,“在类的方法中出现表示对调用该方法的对象的引用”,其实我们知道不是这样,this代表被调用的类.

#93楼  回复 引用  

2007-06-06 23:09 by SWP[未注册用户]
支持.....真强

我是什么都不会的初学者 对我很有用 谢咯

#94楼  回复 引用  

2007-06-11 14:22 by VB客[未注册用户]
感觉还是vb.net的语义描述比较清晰易懂,所以我还是坚持使用vb而没有转向c#,建议初学者还是从vb.net入手比较好,因为在.net中,两种编程语言的功能上的差别几乎可以忽略了,除非想搞些更底层的东西.

#95楼  回复 引用  

2007-06-15 00:08 by JAY[未注册用户]
好家伙..\
谢拉

#96楼  回复 引用  

2007-06-20 15:09 by 2008kou[未注册用户]
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; }
}
}
X: 1, Y: 1, Z: 1
X: 6, Y: 6, Z: 6
X: 9, Y: 9, Z: 9
X: 9, Y: 9, Z: 9
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 y; }
set { y = value; }
}
public double Z
{
get { return z; }
set { z = value; }
}
}

X: 1, Y: 2, Z: 3
X: 4, Y: 5, Z: 6
X: 7, Y: 8, Z: 9
X: 7, Y: 8, Z: 9

#97楼  回复 引用  

2007-06-20 17:43 by lzm_kof[未注册用户]
@没剑
那是在JAVA 里是这么说的,在C#里可能不一样,这里的重写是JAVA里的方法覆盖,
而这里的函数也是JAVA里的方法,
这里的重载就没有改变,JAVA也是这个意思,

哈哈,看来这些80年代诞生的OOP语言是源于一个人的,他就是:Dennis M. Ritchie .
我很喜欢的一个人.@
他开创了现在丰富的软件时代.@

#98楼  回复 引用 查看  

2007-07-05 16:35 by Standing     
楼主辛苦,强烈支持

#99楼  回复 引用 查看  

2007-07-14 16:31 by AK47     
hao

#100楼  回复 引用 查看  

2007-07-27 10:27 by Dusy     
转发一下哈...

#101楼  回复 引用  

2007-08-01 20:13 by 匿名[未注册用户]
初学者最好不要看,会混淆视听的!
作者本来水平就不深,这会误导别人的!!
-_-!!!

#102楼  回复 引用  

2007-08-02 23:08 by Lin[未注册用户]
Good

#103楼  回复 引用 查看  

2007-08-11 20:34 by Robot     
sealed 用于方法和属性时,表示该方法或属性不能再被继承
=======================
是不是应该改成
sealed 用于方法和属性时,表示该方法或属性不能再被重写
?????

#104楼[楼主]  回复 引用 查看  

2007-08-14 10:13 by Clark Zheng     
@Robot
感谢你的执着与认真,同意你的观点,已修正

#105楼  回复 引用  

2007-08-15 14:42 by 风起的落叶
tanks

#106楼  回复 引用 查看  

2007-08-15 14:43 by 风起的落叶     
thanks

#107楼  回复 引用  

2007-08-21 12:39 by 童心未改[未注册用户]
我不太理解事件,以及事件怎样才能得到触发,上面的例子虽然讲了很多,但只是定义了一下,在您的程序里很少被使用到,楼主能否在有空的时间,多写几个关于事件的例子,谢谢哈。。。

#108楼  回复 引用 查看  

2007-08-23 16:47 by lbq1221119     
我想请问你什么叫对象的实例化?

#109楼  回复 引用 查看  

2007-09-05 10:05 by 1-2-3.cnblogs.com     
好文章。用了好几年 .Net 了,原来还有自己不知道的基础概念。期待本文的 VS2008 版

#110楼  回复 引用  

2007-10-02 10:19 by stlh[未注册用户]
学到很多,谢谢
相当经典的文章,概括了C#大部分的基础知识...!!
我也是搞C#开发的,如有兴趣,加我QQ:277617291
--引用--------------------------------------------------
匿名: 初学者最好不要看,会混淆视听的!
作者本来水平就不深,这会误导别人的!!
-_-!!!
--------------------------------------------------------
哈,博客嘛,本来就上为了混个名声。
哈哈。

#113楼  回复 引用 查看  

2007-10-23 12:41 by 钢钢     
楼主,我不喜欢黑色背景
我把你的这篇文章引用到了我的空间,特此声明并谢谢!
http://www.cnblogs.com/xugang/archive/2007/10/23/934319.html

#114楼  回复 引用 查看  

2007-10-29 10:55 by 随风逝去     
还没来得及看,先收藏!

#115楼  回复 引用  

2007-11-27 21:14 by 王云鹏[未注册用户]
我想知道些事情很简单的事!~就是C#的基本数据类型和他的取值范围?我在网上找了很多感觉特别可笑。太可笑了现在人们的复制粘贴的功能太强了。不管对不对我都服了找了30个网站都是同一个答案。都没有换样的。都犯了很多可笑的问题。
“short:存储16带符号整数。short变量的最小可能值为32768,最大可能值为32767。”
你们觉得不可笑么?还有很多错误我用计算器也算了错的漏洞百出。不知道真的是我错了还是网上的答案错了知道的告诉下谢谢。联系方式QQ549419274
或者给我发Email 549419274@qq.com谢谢了。

#116楼  回复 引用  

2007-12-17 00:30 by senge[未注册用户]
想我这么笨的人都在努力学习,你还找什么理由呢?

#117楼  回复 引用  

2007-12-18 22:30 by sealong[未注册用户]
颇有感受,安安静静的复习了一遍,谢谢

#118楼[楼主]  回复 引用 查看  

2008-01-14 09:23 by Clark Zheng     
@许明会
你说的很对,由const是编译时常量,const还存在着无法二进制共享,这意味着如果更新值要整站编译

#119楼  回复 引用 查看  

2008-01-14 10:35 by 许明会     
@Clark Zheng
相同点:
常量符号属于类名,和static静态变量一样,通过类名引用。
不同点:
在方法的内部:const常量符号将直接用其值替代,static静态变量保留符号。

我的思考:既然const常量能保留符号,为什么在方法内却用常量值替代符号呢,难道是性能考虑;
反过来想,含有const常量的程序集修改后必然需要编译,
那么引用程序集的部分自然不用修改(自然不用整站编译了),而含有const的程序集的性能又提升了,倒是好事了。

下面是测试代码:
/*--===------------------------------------------===---
作者:许明会
日期:2008年1月14日 8:54:48
目的:static变量和const变量有何区别?
环境:Windows Server 2003 + NetFramework3.5
编译方法:csc /t:library static.cs
--===------------------------------------------===---*/
using System;

namespace xumh
{
public class myClass
{
public const double PI=3.14;
public double CircleArea(double r)
{
return PI*r*r;
}

public static readonly string VERSION="2.18";
public string GetVersion()
{
return VERSION;
}
}
}

/*--===------------------------------------------===---
作者:许明会
日期:2008年1月14日 9:59:52
目的:可以通过程序集引用const常量和static静态成员
--===------------------------------------------===---*/
using System;

namespace xumh
{
public class runMyApp
{
static void Main()
{
myClass test = new myClass();
Console.WriteLine("半径为5.0的圆的面积为:{0}",test.CircleArea(5.0));
Console.WriteLine("程序的当前版本是:{0}.",test.GetVersion());
Console.WriteLine("public const double PI:{0}", myClass.VERSION );
//Console.WriteLine("", test.PI);
Console.WriteLine("public static readonly string VERSION:{0}", myClass.PI);
}
}
}
/*--===------------------------------------------===---
半径为5.0的圆的面积为:78.5
程序的当前版本是:2.18.
public const double PI:2.18
public static readonly string VERSION:3.14
--===------------------------------------------===---*/

#120楼[楼主]  回复 引用 查看  

2008-01-14 10:58 by Clark Zheng     
@许明会
好象你试的还是不全面吧,据我所知const声明的变量在编译时就被替换好了,如果修改了值,引用的程序集也要得新编译

#121楼  回复 引用 查看  

2008-01-19 22:15 by 克隆     
tag

#122楼  回复 引用  

2008-01-24 15:41 by Mr.Bobby[未注册用户]
TAG

#123楼  回复 引用 查看  

2008-02-01 15:36 by jillzhang     
不错,支持一下

#124楼  回复 引用 查看  

2008-03-06 17:15 by 破曉之陽     
不错。就是背景看的眼睛太难难受了。。

#125楼  回复 引用  

2008-04-13 04:05 by xmlspy[未注册用户]
我原先是做java的,最近转到c#
感觉c#把简单问题复杂化了.把C#搞得不伦不类的

#126楼  回复 引用 查看  

2008-05-21 11:06 by TerryDing     
第25个问题中的下面这句话(出现两次)去掉也能正常运行,能解释一下是做什么用途的吗?
tmpParams[i] = tmpAss.CreateInstance(tmpParamInfos[i].ParameterType.FullName);

#127楼[楼主]  回复 引用 查看  

2008-05-21 11:25 by Clark Zheng     
@TerryDing
第一个是为构造函数生成参数集合
第二个是为调用方法生成的参数集合

第一个如果不给应该可以成功,因为默认都会有一个无参数的构造函数,但第二个应该不能省略因为要调用ChangName和ChangeAge这两个方法,如果省略了两次打印的内容应该就一样了

#128楼  回复 引用 查看  

2008-11-04 00:19 by 傻傻的笨猪     
我以为我搜C#基础概念会没有结果,没想到看到楼主的这么一篇惊人的总结。还有这么的朋友发表观点,和提出问题,真是高手如云哈。。楼主和各位朋友辛苦啦。我大体看了,我要收藏起来,好好研究一下,有问题再来请教哈!!!

#129楼  回复 引用 查看  

2008-11-04 08:49 by Terry Sun     
@傻傻的笨猪
你确实需要好好研究,因为上面的解释中不都是对的,还是要自己研究

#130楼  回复 引用 查看  

2008-11-04 17:57 by 傻傻的笨猪     
我昨天收藏,今天刚要研究,但是遇到第一个问题,就把我绕不出来啦。读你们的解释就像在转圈圈一样。弄的糊里糊涂的。55555 你说:一个类的所有实例的同一静态变量都是同一个值。那意思是不能改变它的值了嘛?还是??
我在程序中,构造函数里初始化了静态变量,但是在调用的时候,还可以再次:类名.静态变量=value; 还可以继续变化啊?怎么说是同一个值啦?当我输出的时候,输出的是我改变之后的值,根本不是原来的值。
现在是云里雾里啦,希望可以帮我解答一下。

#131楼[楼主]  回复 引用 查看  

2008-11-04 18:15 by Clark Zheng     
@傻傻的笨猪
你创建两个该类的对象A和B,修改A的静态变量值,然后输出B的静态变量值,看看是不是受影响了?这里说的同一个值是指同一个类的所有实例的同一静态变量地址是一样的,改其中一个时另一个也会受到影响,明白了吧

#132楼  回复 引用 查看  

2008-11-04 18:37 by 傻傻的笨猪     
@Clark Zheng
-------------------------------------------------
你创建两个该类的对象A和B,修改A的静态变量值,然后输出B的静态变量值
----------------------------------------------------------
我创建了对象A,B,但是A,B不能调用静态成员变量。所以我没看到效果。。
不是说静态变量只能由类名调用的嘛?

#133楼[楼主]  回复 引用 查看  

2008-11-04 18:47 by Clark Zheng     
@傻傻的笨猪
这个。。。既然只能通过类名调用当然所有实例的值是一样的啦。。。为了方便理解你可以通过在类里建一个属性把静态变量的值暴露出来,这样就和我上面说的效果一样了

#134楼  回复 引用 查看  

2008-11-04 20:22 by 傻傻的笨猪     
楼主:7.override 和 overload 的区别?
这里我想问一下覆盖与重写有什么不同? 你在这里解释的是:重写是用于继承类对基类中虚成员的实现。那么覆盖就是对非虚成员的实现嘛?呵呵,给我解释一下哈。

#135楼  回复 引用 查看  

2008-11-04 20:44 by 傻傻的笨猪     
new 修饰符用于声明类或类的成员,表示隐藏了基类中同名的成员 这里的隐藏了怎么理解啊?什么意思

#136楼  回复 引用  

2008-11-12 10:21 by captainyuming[未注册用户]
@傻傻的笨猪
覆盖和重写的区别:若覆盖,父类的实例调用父类的方法,子类的实例调用子类的方法;若重写,父类和子类的方法都调用子类的方法。主要,这里的父类的实例是通过子类实例化的,如:A是B的父类, A a=new B();
呵呵。

#137楼  回复 引用 查看  

2009-04-29 16:12 by 根本风流     
你好~!在5.internal 修饰符起什么作用?
这个例子中,我有点不明白,什么叫同一程序集,程序集到底是个什么概念,看了好多资料还是不明白,希望你能讲解一下

#138楼[楼主]  回复 引用 查看  

2009-05-04 15:42 by Clark Zheng     
同一程序集就是在一个Project里的两个类

#139楼  回复 引用  

2009-06-26 17:39 by 微微笑
up 辛苦了

#140楼  回复 引用 查看  

2009-09-07 22:03 by 咸鱼翻身     
我看行

#141楼  回复 引用 查看  

2010-05-04 19:11 by Daybreak     
收了~~

#142楼  回复 引用 查看  

2010-11-19 16:35 by bings     
这个文章真的很不错,可能巩固一下自己的知识。。。。。、

#143楼  回复 引用 查看  

2011-04-20 16:08 by Kevan     
马克思主义啊!
1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:270031次
    • 积分:2266
    • 等级:
    • 排名:第16676名
    • 原创:43篇
    • 转载:20篇
    • 译文:0篇
    • 评论:57条
    文章分类
    最新评论