北海虽赊,扶摇可接,东隅已逝,桑榆非晚

C#基础概念二十五问

C#基础概念二十五问
注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除!
当初学 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://www.cnblogs.com/Files/reonlyrun/CSharp25QExample07.rar 如果你认为还有哪些概念比较重要或容易混淆,可以在回复中提出,我会及时更新这篇随笔 一些话: To: watson hua,谢谢你帮我改正了第4、11、14和19点的错误,并且让我对索引指示器的理解更全面! To: xiao,谢谢你关于“实例化”的详细解释,让这篇随笔中的措词更加精确! To: charleschen,谢谢你追问,让第1、第8的提法更恰当! To: 装配脑袋,谢谢你提供 internal protected 含义的正确答案! 本贴子以“现状”提供且没有任何担保,同时也没有授予任何权利 This posting is provided "AS IS" with no warranties, and confers no rights. posted on 2007-04-05 13:44 Clark Zheng 阅读(7028) 评论(101) 编辑 收藏 引用 网摘 所属分类: A. .NET 评论: # re: C#基础概念二十五问 2007-04-05 13:54 | 亚历山大同志 很重要的基础概念,每个C#的开发人员都应该弄明白先,不过...... 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 13:58 | 亚历山大同志 还有,我很喜欢用sb,呵呵,个人作品,公司的东西还是严格按照公司规范来 回复 更多评论 # C#基础概念二十五问[TrackBack] 2007-04-05 14:07 | CDplayer C#基础概念二十五问 注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除! 查看原文 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 14:09 | 非我 我先自测了一遍,按100分算只能打80+,惭愧…… 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 14:24 | 随风流月 什么时候做个 Visual Basic 的测验? 这些东西基本都看不懂,除了一些 CLR 共通的…… 回复 更多评论 # C#基础概念二十五问 [TrackBack] 2007-04-05 14:50 | Sean(陈阳) C#基础概念二十五问注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除! 查看原文 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-05 14:56 | fly_bluewolf 还有"unbox"和"box"这两个概念,很容易被人忽略. 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 15:23 | Clark Zheng @亚历山大同志 :) 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 15:24 | Clark Zheng @非我 不要以偶的参考答案评分,里面可能错误多多呢 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 15:24 | Clark Zheng @随风流月 我不会推出VB.NET的版本了,如果感兴趣,你可以写一个? 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 15:26 | Clark Zheng @fly_bluewolf 关于装箱和拆箱。。。我再看看吧,个人感觉真的没什么好写的 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 15:45 | 波→ONLINE 不错,不错。收藏了。 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 16:01 | 装配脑袋 @随风流月 如果想要VB的话…… 1.静态变量和非静态变量的区别? 2.Const和Shared Readonly 区别? 3.Declare是什么意思? 4.MustInherit/MustOverride是什么意思? 5.Friend修饰符起什么作用? 6.NotInheritable/NotOverridable修饰符是干什么的? 7.Overrides和 Overloads的区别? 8.什么是默认属性? 9.Shadows修饰符是起什么作用? 10.Me关键字的含义? 11.可以使用抽象函数重写基类中的虚函数吗?(答案与C#不同) 12.不可继承类可以有虚函数吗? 13.如果基类中的虚属性只有一个属性访问器,那么继承类重写该属性后可以有几个属性访问器?如果基类中有 Get 和 Set 两个呢?(答案与C#不同) 14.MustOverride可以和 Overridable一起使用吗?可以和 Overrides一起使用吗? 15.接口可以包含哪些成员? 16.类和结构体的区别? 17.接口的多继承会带来哪些问题? 18.抽象类和接口的区别? 19.Global关键字是什么? 20.如何释放非托管资源? 21.P/Invoke是什么? 22.StringBuilder 和 String 的区别? 23.Narrowing和 Widening的含义? 24.ParamArray有什么用? 25.什么是反射? 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 16:22 | charleschen 不错的文章, 追问: 静态方法和普通方法的区别? 显示接口与隐式接口的区别? 为什么要使用Get/Set 而不是直接操作类成员? GC释放资源有哪几种方法? 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 16:56 | Huacn Lee 不错的文章 以前看着这些名词都不知道什么意思,其实自已一直在用,呵呵 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 16:57 | Huacn Lee 我来回答@charleschen 用 Get/Set 因为是可以独立设置只写或只能写吧 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 17:19 | Dflying Chen @装配脑袋 真厉害…………人工翻译阿 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 17:24 | 流浪的狗 汗... 我连及格都不行. 基础太差. 回复 更多评论 # C#基础概念二十五问 [TrackBack] 2007-04-05 17:33 | 俺喜欢打篮球 C#基础概念二十五问 查看原文 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-05 17:40 | 没剑 override 表示重载,用于同一个类中同名方法不同参数(包括类型不同或个数不同)的实现 ------------ 这里的override应为overload 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 19:01 | Clark Zheng @装配脑袋 汗,真是C#.NET和VB.NET同时精通的人才呀。。。 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 19:04 | Clark Zheng @没剑 感谢你的细心,正文已修正! 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 20:01 | Aの扬凡 是一次做复习的机会 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:16 | 戴眼镜的太阳 呵呵,不错,学了不少,用C#写了一段时间的程序了,但是你里面的东西我还有好多没用过,继续研究C#:) 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:18 | 郭志坚 嗯,不错,基本上都清楚这些概念. 这一年没白混,呵呵 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:18 | Boler Guo 很好很好,图文并茂。11、12还是有点儿迷惑,主要是new, virtual, abstract, sealed 这几个概念容易混淆~ 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:35 | Clark Zheng @charleschen 1.静态方法和普通方法的区别? 答:静态方法是通过类型调用,在对象未实例化前就可以使用,因此在其实现中不能使用非静态的成员(如:非静态的变量、非静态的方法) 2.显式接口和隐式接口? 答:你是指显式接口成员吗? 3.为什么要使用Get/Set 而不是直接操作类成员? 答:get/set 是C#为实现属性而设计的访问器,提出这概念主要是为了实现OO中的“封装”。根据该思想,字段最好设为private,一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问 另外,在设计模式中提到如果你有一个public的方法,那么最好再设计一个protected的虚函数以方便子类中对该方法进行扩展,属性访问器的设计可以让我们完成该模式,不是吗? 4.GC释放资源有哪几种方法? 答:我不太理解这个题目,你想问什么呢?GC释放资源的流程? 以上回答还希望大家多多提意见,确认比较全面并且无误后,我会加到随笔正文 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:52 | Clark Zheng @Boler Guo new 比较特殊,这个关键字既是修饰符又是运算符,做为运算符时用于实例化类型,做为修饰符时,请参照第9点的答案 sealed 起密封作用,意味该类型或成员不会再有继承,所以虚函数会自动变成非虚函数。非函数在CLR查找其实现时速度会快一点,这也是我提到sealed有时可以提高程序运行效率的原因 virtual 没什么好说的吧,虚函数OO中多态的基础呀 abstract 请参照第4点的答案 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 21:58 | watson hua 大体上正确,但不精确,建议参照框架设计,说的深入一些。 还有一些个人看法,不算纠正,只算补充。 索引指示器实质是含参属性,也就是说,它的参数不限于int,把它比作数组未免... 可以使用抽象函数重写基类中的虚函数吗?这个问题我觉得楼主理解有一些问题,不需要加new修饰。所谓abstract,new,virtual只是虚函数的版本元数据的几个向量而已,当然你也可以把那个函数理解为new的,但这个new不是atttribute,而是函数的元数据里的一个标志位。所以你即便不加new修饰,编译器也不会报warning。 其他还有几个地方用词也值得斟酌。 算然已经很好了,但我们应该有更高的目标。 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 22:00 | watson hua @Clark Zheng quote"静态方法是通过类型调用,在类未实例时就可以使用" 类事例化前是不能使用的,我想你的意思应该是对象实例化前吧。 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 22:14 | lavy 关于THIS的用法 限定被相似的名称隐藏的成员,例如: public Employee(string name, string alias) { this.name = name; this.alias = alias; } 我有疑问: 什么是 被相似的名称隐藏的成员?? 相似指什么?什么时候会出现隐藏? 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-05 22:51 | 小鬼 真强,我一直想做这么一件事情,可一直都没有做,谢谢你为我提供了这么好的快速复习小册子。 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 23:23 | Clark Zheng @watson hua 谢谢你关于索引指示器的讲解,正文我已修订,并将示例更新了 关于”使用抽象函数重写基类中的虚函数“,如果不加 new 修饰符编译时会给警告。你可以把Example11示例中,DeriveClass的F函数去掉 new 修饰符,然后编译试一下 关于类实例化和对象实例化,我还是听从了你的意见,上面的回复也已改正 ps:非常希望你能帮其它几处用词不当的地方指出,我们就是应该有更高的目标! 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 23:30 | Clark Zheng @lavy 我的原文是”this 保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身“,并没有”限定被相似的名称隐藏的成员“ 针对第一个用处,我再详细说明一下: //正确,由于类本身的变量c和构造函数的参数c重名,这时就需要使用this显式指出是将参数的c赋值给类的变量c private double c; public Class1(double c) { //限定同名的隐藏成员 this.c = c; } //错误,会给出一个警告:对同一变量赋值。编译器没有看到我们实际想赋值的成员变量c,所以我们称它”隐藏“了 private double c; public Class1(double c) { c = c; } 回复 更多评论 # re: C#基础概念二十五问 2007-04-05 23:36 | Clark Zheng @Huacn Lee @Aの扬凡 @戴眼镜的太阳 @郭志坚 @Boler Guo @小鬼 谢谢你们的支持! 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 00:08 | watson hua @Clark Zheng 能够严肃的讨论技术实在是人生快事。 11.可以使用抽象函数重写基类中的虚函数吗? 不知这个重写是override还是overload,还是重名函数就算。 若是override,当然是可以的,但不要忘了加override修饰,编译器推倒不出的。 若是overload,当然是可以的,但凡不写new,是要抛warning的。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 00:26 | Clark Zheng @watson hua 本文把overload译为重载,把override译为重写,请参见第7点答案 我的问题是抽象函数(abstract)是否可以重写(override)基类中的虚函数,而 abstract 和 override修饰符是不可以同时使用的,会产生二义性,所以谈不上把 override 忘了 出本题的目的缘于我在引用一个类库时发现其中一个基类设计不合理,仅仅设为虚函数(virtual)并没有设成抽象函数(abstract)--具体情况这里略去。所以我想把它改成抽象函数,以便使用我的类库的开发人员如果继承该类必须强制性的重写(override)该函数。So,我碰到了一个警告,通过增加 new 修饰符解决了该问题。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 01:02 | watson hua using System; using System.Collections.Generic; using System.Text; namespace Example11 { class BaseClass { public virtual void F() { Console.WriteLine("BaseClass.F"); } } abstract class DeriveClass : BaseClass { public abstract override void F(); } class Program { static void Main(string[] args) { } } } 试一下吧 回复 更多评论 # (保存)C#基础概念二十五问[TrackBack] 2007-04-06 01:13 | nasa C#基础概念二十五问 注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除! 查看原文 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 01:55 | Clark Zheng @watson hua 请原谅我的浅见拙识,原文中已改正了所有关于 abstract 和 override 关系的地方,下载文件也已替换。 在此只好是”再次“感谢你了 🙂 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 03:36 | watson hua 再补充一点我的理解吧,我觉得@Clark Zheng的这篇文章写得相当用心,也足见@Clark Zheng做人,做程序员的责任心。 1.静态变量和非静态变量的区别? 静态变量在类实例化时创建,非静态变量在对象实例化时创建, 即静态变量在类构造函数调用的时候创建,非静态变量在对象构造函数调用时创建。 @Clark Zheng的sample里用的是一个可以使用一条语句就可以完成创建的静态变量,所以掩盖了这个问题。 @Clark Zheng说静态变量是类被装载时创建的,我不清楚他说的类被装载是什么时候。 assembly被装载到appdomain时是不会的,类在被使用前的一瞬,会调用静态构造函数完成类的实例化。 2.const 和 static readonly 区别? 完全正确,不再补充。 3.extern 是什么意思? 不知道存不存在其他功能,如cpp里的extern "C"。 4.abstract 是什么意思? 6.sealed 修饰符是干什么的? 7.override 和 overload 的区别? http://www.cnblogs.com/huazhihao/archive/2007/04/06/702083.html可以参考这篇">http://www.cnblogs.com/huazhihao/archive/2007/04/06/702083.html可以参考这篇。
5.internal 修饰符起什么作用?
没什么好说的,搞清楚和protected的区别就可以了,当然internal protected的语意是internal && protected
8.什么是索引指示器?
已经补充过了。
9.new 修饰符是起什么作用?
不是很喜欢这种关键词重载。
10.this 关键字的含义?
this很好理解。java里可以使用对象访问类属属性,相比起来,更喜欢c#里的设计。
11.可以使用抽象函数重写基类中的虚函数吗?
讨论过,答案是可以。absolutely。
12.密封类可以有虚函数吗?
问题是”密封类可以有虚函数吗”,结果回答的是”密封类的父类可以有虚函数”。照clark兄的意思是密封类可以包含虚的成员方法,我觉这个问题问得没有意义。sealed的类最起码是object的派生类,object有ToString(),答案是明显的。
13.如果基类中的虚属性只有一个属性访问器,那么继承类重写该属性后可以有几个属性访问器?如果基类中有 get 和 set 两个呢?
属性的实质是方法,若有一个virtual方法自然可以override。所以,派生类可以override父类的get,只要父类有get,set同理。
quote”如果基类中的虚属性只有一个属性访问器,那么继承类重写该属性后也应只有一个。如果基类中有 get 和 set 两个属性访问器,那么继承类中可以只有一个也可以同时有两个属性访问器”.@clark zhang 表述的不够准确。
14.abstract 可以和 virtual 一起使用吗?可以和 override 一起使用吗?
参见http://www.cnblogs.com/huazhihao/archive/2007/04/06/702083.html
15.接口可以包含哪些成员?
interface可以包含所有的可以被继承且可以被派生类实例化的成员,并且interface自己不能被实例化。interface遵照此原则。因为比较宽松,所以才会出现范型接口这种病态的但又不可或缺的东西。
16.类和结构的区别?
class和struct的区别再不交互时是很容易辨认的,当class里有struct,struct里又有class就很热闹了。
class和struct的比较重要的问题是,eqauls方法和原型方法的逻辑。当class里有struct,或struct里有class,不能靠object.equals了,既要考虑怎样重用父类里的equals,又要考虑便于派生类拓展,怎么样才算equals,非常复杂。而原型方法就是(iclonable).clone,深的还是浅的,多深多浅,要结合equals方法考虑。当然不要忘了重载==。
再提一句,stuct A{}的实质是class A:System.ValueType{},但是这个System.ValueType是一个class。想来有趣,有一点像夏娃,是用亚当的一根肋骨做程的。
17.接口的多继承会带来哪些问题?
这个问题改成”多接口的继承会带来哪些问题?”比较好。@clark zhang解释的还是正确的,只要不造成二义性,可以不用显示转型。
18.抽象类和接口的区别?
抽象类的原则是存在不可以被实例化的方法的类,接口的原则前面提到过。
19.别名指示符是什么?
using的一个作用,作用范围是using的所在名空间内,并且在using的语句后面。并非只在一个单元文件内起作用。
当然别名像多接口继承一样,也是要”去二义化”的。
20.如何释放非托管资源?
问题改成”如何强制释放资源”比较好。
不建议强制释放资源,除非逼不得已。gc,人间凶器阿…
21.P/Invoke是什么?
没怎么用过,不敢发表意见。
22.StringBuilder 和 String 的区别?
区别还是很大的。倒是string和值类型的近似行为更值得讲解。
另外cycle = 100000还是少一到两个零比较好,意思一下就好了么。
23.explicit 和 implicit 的含义?
例子很形象。Explicit存在的意义相当于c++里的拷贝构造函数。
24.params 有什么用?
public static void UseParams(int id, params object[] list)
{
Console.WriteLine(id);
for (int i = 0; i < list.Length; i++) { Console.WriteLine(list[i]); } } ... UseParams(2, "d", 100, 33.33, new double[] { 1.1, 2.2 }); 最后会输出System.Double[]是因为cw((object)o)的逻辑是cw(o.ToString()),而(object).ToString()默认输出(object).GetType().ToString() params的实质是一个ParamArrayAttribute,因为c#不支持默认参数,所以不定秩的形参只有靠它来。对比c++,可读性无疑增强了。c++里好像也有vlist ...的东西,名称记不得了,好像还要加一个头文件,用起来非常麻烦,还不可以做编译期的类型检查。不过c#里没有默认参数,如果要和vb,c++交互的话,要用Type.Missing来补空位,不可以用null。曾经调用office的com,一个函数里用了40个Type.Missing,无语啊。 25.什么是反射? 用string可以在runtime为所欲为的东西。实际上就是一个.net framework内建的万能工厂。 结: 这里的大部分问题的讨论结果已经不能算是基础概念了,而是底层概念了,希望能对大家有帮助。如果有不足的地方还请大家补充,如果我有理解错误的地方还请多指教。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 04:44 | Clark Zheng @watson hua 关于”类实例化“和”对象实例化“,有没有更好的说法?我一直表达不清楚两个概念,请教一下这两个词的”完美“程度如何? 关于extern,本文只讨论C#语言范畴,前面有说 internal protected的语意是internal && protected,perfect! 关于第12题,密封类可以有虚函数吗?你的这个object举得非常恰当,我也感觉这个问题没有意义了。。。 索引指示器的实质是带参属性、属性的实质是方法,佩服你的见解 偶再补充一句:事件的实质是属性 关于第19题,我的试验结果是只在一个单元文件内起作用 关于第20题我觉得你的提法比我强 关于cycle = 100000,不知道是不是偶的机器太过强悍,少一个零后,输出结果如下:(我只是想让第二个不是0呀,另外特别声明一个常量做为循环次数就是方便各位朋友修改,不是我编码风格有多好。。。) String: 343 MSEL StringBuilder: 0 MSEL ps:偶的名字是Clark Zheng,不是@Clark Zheng。 🙂 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 08:38 | ddr888 Attribute 重要不? 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 08:47 | watson 不错,很详细~ 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 09:28 | Sephil @watson hua void writeError(int err, ...) { va_list vaList; va_start(vaList, err); // your code here va_end(vaList); } 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-06 10:05 | 天下 @watson hua 静态变量在类实例化时创建,非静态变量在对象实例化时创建 --没明白这句话的意思。 我想对象实例化就是通过new来调用构造器吧 那什么叫类实例化呢? 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 10:13 | Clark Zheng @ddr888 嗯,很重要,不过按这种一回一答的方式好象不容易写好。 我考虑一下,正好把那个第12题换掉 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 10:50 | 天龙之吻 signed 🙂 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-06 10:52 | xiao @天下 类实例化指的是调用类的静态构造器,一个类只能有一个无参无修饰符的静态构造器,它只能调用一次,用于初始化类中静态字段的状态 对象实例化指的是调用通常意义上的构造器,它用于创建类的一个具体实例,这种构造器一个类中可以有多个重载版本 代码如下: sealed class Xiao{ private static string str; //此为类构造器,可查看IL,其中编译为cctor static Xiao() { str = "qpppp"; } //此为实例构造器,可查看IL,其中编译为ctor public Xiao() { //当然实例构造器也能作用于静态字段 str = "eeeeeeeeeee"; } } 回复 更多评论 # [收藏]C#基础概念二十五问[TrackBack] 2007-04-06 10:57 | 天龙之吻 //滚动子标题 varmarqueeContent=newArray(); marqueeContent[0]='真心感谢我的老婆'; marqueeContent... 查看原文 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 11:03 | lavy @Clark Zheng this "限定被相似的名称隐藏的成员" 是MSDN的解释 🙂 你的解释,我懂了!~谢谢! 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 11:11 | watson hua @Clark Zheng 类实例化和对象实例化xiao兄已经举例,不赘述。最初听到类实例化是在李建忠老师那里,我的理解也是建立在他翻译的applied .net framework programming,这里的问题书上都有讲道。 谢谢Sephil兄,帮我复习一下久违的c++,怀念... 关于第19题,我说的语气没表述出来。我的语气是带一点反话的。我的意思是using只在它所在的名空间内有用,换而言之,如果单个文件有多个嵌套名空间,using只在它所直接隶属的名空间内可用。当然,如果它没有放在名空间内的话,作用域就是整个文件了。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 11:17 | Clark Zheng @lavy MSDN。。。不是忘看了就是看了忘记了,谢谢你的提醒 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 11:22 | watson hua @Clark Zheng clark兄,关于称呼抱歉抱歉。:)我有的地方是直接粘的。 这篇post貌似very popular。 clark兄可以整理一下,再置顶于个人主页上,长期讨论... 当然欢迎clark兄就其他技术问题作讨论。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 12:17 | Clark Zheng @xiao 感谢,正文已修改 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 13:07 | Clark Zheng @watson hua 改了第20题的提法 改了第22题的内容和示例,增加了对String的解释 示例下载已更新 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 13:38 | Clark Zheng @charleschen 你的追问中关于静态函数与非静态函数的问题,我已在第1题中做了修改 关于属性访问器的用处,也已在第8题中做了修改 其它两个问题我还不能理解题面的意思,期待着你的回复 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 13:49 | yunhuasheng 楼主挺认真的!!;) 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 14:26 | 想飞的猪 支持LZ,让俺重温了一遍.... 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 14:31 | 装配脑袋 internal protected的语意应该是internal | protected,而不是internal && protected。相信不少没有用过的老手也不知道。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 14:58 | 阿齐 类实例化指的是把一个类实例化的过程,即把类的静态成员初始化的过程; 而对象实例化,就是构造一个该类的实例,然后初始化该实例的实例成员 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 15:38 | 装配脑袋 我尝试从这些语法的最直接效果作答这些问题: 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的支持在运行时读取程序集、模块、类型和成员的信息,以及在运行时通过这种途径访问对象的成员或执行对象的方法。甚至动态改变类型和方法的组成。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 16:02 | Clark Zheng @装配脑袋 感谢你精心的回答,让我受益菲浅,之所以没有使用这种“最直接的效果”来做答案也许是为了让一些人看得更明白,也许是因为我的语言组织能力没有这么强。:) 真心希望你能将你的回答写成随笔,让我有机会在正文中将这些回答做为引用,方便大家更全面的了解这些概念。 ps:关于internal protected的语意能不能详细讨论一下?如果这里不方便可以通过MSN与我联系,谢谢! 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 16:05 | Clark Zheng @watson @Sephil @天龙之吻 @yunhuasheng @想飞的猪 @阿齐 谢谢你们的支持! 回复 更多评论 # C#基础概念二十五问(转)[TrackBack] 2007-04-06 16:18 | eric.123 C#基础概念二十五问注:本文部份资料来自网络,如有侵权,请与我联系,我会在第一时间声明引用或将其删除! 查看原文 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 16:47 | 装配脑袋 internal protected其实很简单,只是看字面意思容易弄错。许多人认为internal protected应该是“只有同一个程序集中的子类可以访问”的意思,但其实不是这样的。internal protected表示“同一个程序集中的所有类,以及所有程序集中的子类都可以访问”。也就是说是“protected或internal”的访问级别。 回复 更多评论 # re: C#基础概念二十五问 2007-04-06 18:34 | watson hua @装配脑袋 我记错了。谢谢。internal protected是protected或internal 回复 更多评论 # re: C#基础概念二十五问 2007-04-07 02:02 | Clark Zheng @装配脑袋 在第5点的答案里增加了对 internal protected 的解释,谢谢你的指点! 示例下载地址也已更新 回复 更多评论 # re: C#基础概念二十五问 2007-04-07 20:51 | 大豆男生 收藏 回复 更多评论 # re: C#基础概念二十五问 2007-04-07 21:53 | Clark Zheng @大豆男生 谢谢支持 回复 更多评论 # re: C#基础概念二十五问 2007-04-07 21:54 | Clark Zheng @watson hua 关于第19题,别名指示符的作用域已调整 示例下载地址已更新 回复 更多评论 # re: C#基础概念二十五问 2007-04-08 21:15 | heqing great!,but I have a problem. declare attribute field above: abstract public String Attribute { get; } why not abstract public string Attribute { get; } 回复 更多评论 # re: C#基础概念二十五问 2007-04-08 22:04 | 玉开 这篇随便的质量很高,谢谢楼主 回复 更多评论 # re: C#基础概念二十五问 2007-04-09 10:40 | 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... 回复 更多评论 # re: C#基础概念二十五问 2007-04-09 10:41 | Clark Zheng @玉开 谢谢 回复 更多评论 # re: C#基础概念二十五问 2007-04-09 10:58 | http://salonliudong.cnblogs.com 第9个问题.程序中第二行注释中的“显示”应该是“显式”,从第11个问题的答案中可以看出 第22个问题答案第三点String 对象一量生成不可改变,是不是一旦生成不可改变 回复 更多评论 # re: C#基础概念二十五问 2007-04-09 12:19 | Clark Zheng @http://salonliudong.cnblogs.com 谢谢你的细心,正文和示例下载都已修正。 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-09 18:12 | 小莫 比较有价值的贴,顶一下。 回复 更多评论 # re: C#基础概念二十五问 2007-04-12 13:14 | 金色海洋(jyk) 能不能说一下 委托、事件、异步、多线程的知识呢? 回复 更多评论 # re: C#基础概念二十五问 2007-04-12 13:33 | Clark Zheng @金色海洋(jyk) 委托和事件在以上二十五里的示例里用了很多,通过看这些代码应该能有所理解 关于多线程,我只做过简单的研究,请参照我的另一篇随笔 http://www.cnblogs.com/reonlyrun/archive/2006/12/26/640993.html 回复 更多评论 # re: C#基础概念二十五问 2007-04-13 10:08 | 森林 在子类中,重写有什么作用啊? 回复 更多评论 # re: C#基础概念二十五问 2007-04-13 13:38 | Clark Zheng @森林 扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现 面向对象编程里多态的实现手段 回复 更多评论 # re: C#基础概念二十五问 2007-04-20 14:39 | 清晨风 终于看完了,还有几处不懂,没基础啦,过几天再看一遍. 非常感谢,~_~ 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-23 11:42 | ZhuZhu Application Block 是什么? SqlHelper ? 回复 更多评论 # re: C#基础概念二十五问 2007-04-24 11:09 | 拔掉内存 你好!关于你的第十四个问题的例子,你把DeriveClass1类定义成abstract, 但又继承了BaseClass,这样可以吗?DeriveClass1类可以理解成基类,但又去继承别的类?你能解释一下吗? 回复 更多评论 # C#基础概念二十五问 [TrackBack] 2007-04-25 14:38 | mbskys http://www.cnblogs.com/reonlyrun/archive/2007/04/05/CSharp_25_Question.html 注:本文部份资料来自网络,如有侵权,请与我联系... 查看原文 回复 更多评论 # re: C#基础概念二十五问[未登录] 2007-04-25 22:40 | Thanks 非常感谢! 不过,说真的,楼主,不知道是你的表达能力太差还是其实你自己也没理解透,感觉很多地方表述不清楚或者不准确,例子也写得不好。 还是装配脑袋强,几句话,说的清楚明了。 回复 更多评论 # re: C#基础概念二十五问 2007-04-26 14:57 | Hunts.C Mark:) 回复 更多评论 # re: C#基础概念二十五问 2007-04-27 10:43 | Jz 类被实例化是什么意思? 也就是说创建类的对象吗?如果是这样第一点就有点小问题咯。 回复 更多评论 # re: C#基础概念二十五问 2007-04-28 17:58 | Clark Zheng @Thanks 虚心接受您的批评,我在写这篇随笔时是尽自己的努力来完成的,如果有哪些不清楚地方请指出来,我会进一步改进,包括例子,让以后看到这篇随笔的朋友可以更容易理解 回复 更多评论 # re: C#基础概念二十五问 2007-04-28 17:59 | Clark Zheng @Jz 类被实例化和对象被实例化是两个概念,有区别的。看一下回复记录也许你就能明白了 回复 更多评论 # re: C#基础概念二十五问 2007-04-28 18:22 | Clark Zheng @拔掉内存 抽象类也可以继承自其它类,在这个例子中我主要是为了体现“abstract是可以和override一起使用的”,而只有一个类中有抽象方法这个类就必须被声明为抽象类 回复 更多评论 # re: C#基础概念二十五问 2007-05-06 21:06 | IDreamer 表达的的确不太好,特别是有的例子不够好。不过这种学习方法很好,我正在学java也是这样进行的。顺便说一下,java真是一个混乱的语言,平台和语法都混乱,比起来可爱的C#我们要知足了,ms真不愧是王中之王。 thanks,lz,学习 回复 更多评论 # C#基礎二十五問(轉)[TrackBack] 2007-05-07 11:47 | Ammy http://www.cnblogs.com/reonlyrun/archive/2007/04/05/CSharp_25_Question.html 查看原文 回复 更多评论 # re: C#基础概念二十五问 2007-05-08 11:08 | mgdn.com.cn 基本上是IT公司是C#面试题,呵呵 回复 更多评论 # re: C#基础概念二十五问 2007-05-09 09:52 | tqj 继承接口中的有的方法编译时怎么说 修饰符“virtual”对该项无效 修饰符“public”对该项无效 呢请指点 回复 更多评论 # re: C#基础概念二十五问 2007-05-10 09:29 | 清晨风 在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; } } }

来源八四三一标题C#基础概念二十五问

除非注明,八四三一文章均为原创,转载请以链接形式标明本文地址
本文标题:C#基础概念二十五问
本文地址:http://www.8431.info/post/123151.html

上一篇:« 下一篇: »
  • 相关文章推荐阅读:
  • 暂无相关文章

欢迎您发表评论:

 站内搜索

文章归档


站点统计

  • 文章总数:201篇
  • 评论总数:106条
  • 标签总数:15 个
  • 浏览总数: 33542 次

友情链接(不分先后)

控制面板

图标汇集

  • 八四三一
www.8431.info  © 2018 八四三一 
星云博客 | 页面装载时间:0.273毫秒,36查询