语源科技BlogJava-yunye 的 JavaBlog

Java单例模式(1)

yunye — Thu, 05 Jun 2008 04:43:00 GMT

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。正是由于这个特点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。

　　本文将探讨一下在多线程环境下，使用单例对象作配置信息管理时可能会带来的几个同步问题，并针对每个问题给出可选的解决办法。

　　问题描述

　　在多线程环境下，单例对象的同步问题主要体现在两个方面，单例对象的初始化和单例对象的属性更新。

　　本文描述的方法有如下假设：

　　1. 单例对象的属性（或成员变量）的获取，是通过单例对象的初始化实现的。也就是说，在单例对象初始化时，会从文件或数据库中读取最新的配置信息。

　　2. 其他对象不能直接改变单例对象的属性，单例对象属性的变化来源于配置文件或配置数据库数据的变化。

　　1.1 单例对象的初始化

　　首先，讨论一下单例对象的初始化同步。单例模式的通常处理方式是，在对象中有一个静态成员变量，其类型就是单例类型本身；如果该变量为null，则创建该单例类型的对象，并将该变量指向这个对象；如果该变量不为null，则直接使用该变量。

　　其过程如下面代码所示：

public class GlobalConfig {
    private static GlobalConfig instance = null;
    private Vector properties = null;
    private GlobalConfig() {
      //Load configuration information from DB or file
      //Set values for properties
    }
    public static GlobalConfig getInstance() {
      if (instance == null) {
        instance = new GlobalConfig();
      }
      return instance;
    }
    public Vector getProperties() {
      return properties;
    }
  }

这种处理方式在单线程的模式下可以很好的运行；但是在多线程模式下，可能产生问题。如果第一个线程发现成员变量为null，准备创建对象；这是第二个线程同时也发现成员变量为null，也会创建新对象。这就会造成在一个JVM中有多个单例类型的实例。如果这个单例类型的成员变量在运行过程中变化，会造成多个单例类型实例的不一致，产生一些很奇怪的现象。例如，某服务进程通过检查单例对象的某个属性来停止多个线程服务，如果存在多个单例对象的实例，就会造成部分线程服务停止，部分线程服务不能停止的情况。

　　1.2 单例对象的属性更新

　　通常，为了实现配置信息的实时更新，会有一个线程不停检测配置文件或配置数据库的内容，一旦发现变化，就更新到单例对象的属性中。在更新这些信息的时候，很可能还会有其他线程正在读取这些信息，造成意想不到的后果。还是以通过单例对象属性停止线程服务为例，如果更新属性时读写不同步，可能访问该属性时这个属性正好为空（null），程序就会抛出异常。

　　解决方法

　　2.1 单例对象的初始化同步

　　对于初始化的同步，可以通过如下代码所采用的方式解决。

  public class GlobalConfig {
    private static GlobalConfig instance = null;
    private Vector properties = null;
    private GlobalConfig() {
      //Load configuration information from DB or file
      //Set values for properties
    }
    private static synchronized void syncInit() {
      if (instance == null) {
        instance = new GlobalConfig();
      }
    }
    public static GlobalConfig getInstance() {
      if (instance == null) {
        syncInit();
      }
      return instance;
    }
    public Vector getProperties() {
      return properties;
    }
  }

　　这种处理方式虽然引入了同步代码，但是因为这段同步代码只会在最开始的时候执行一次或多次，所以对整个系统的性能不会有影响。

2.2 单例对象的属性更新同步

　　为了解决第2个问题，有两种方法：

　　1，参照读者/写者的处理方式

　　设置一个读计数器，每次读取配置信息前，将计数器加1，读完后将计数器减1.只有在读计数器为0时，才能更新数据，同时要阻塞所有读属性的调用。代码如下。

  public class GlobalConfig {
 private static GlobalConfig instance;
 private Vector properties = null;
 private boolean isUpdating = false;
 private int readCount = 0;
 private GlobalConfig() {
   //Load configuration information from DB or file
      //Set values for properties
 }
 private static synchronized void syncInit() {
  if (instance == null) {
   instance = new GlobalConfig();
  }
 }
 public static GlobalConfig getInstance() {
  if (instance==null) {
   syncInit();
  }
  return instance;
 }
 public synchronized void update(String p_data) {
  syncUpdateIn();
  //Update properties
 }
 private synchronized void syncUpdateIn() {
  while (readCount > 0) {
   try {
    wait();
   } catch (Exception e) {
   }
  }
 }
 private synchronized void syncReadIn() {
  readCount++;
 }
 private synchronized void syncReadOut() {
  readCount--;
  notifyAll();
 }
 public Vector getProperties() {
  syncReadIn();
  //Process data
  syncReadOut();
  return properties;
 }
  }

　　2，采用"影子实例"的办法

　　具体说，就是在更新属性时，直接生成另一个单例对象实例，这个新生成的单例对象实例将从数据库或文件中读取最新的配置信息；然后将这些配置信息直接赋值给旧单例对象的属性。如下面代码所示。

  public class GlobalConfig {
    private static GlobalConfig instance = null;
    private Vector properties = null;
    private GlobalConfig() {
      //Load configuration information from DB or file
      //Set values for properties
    }
    private static synchronized void syncInit() {
      if (instance = null) {
        instance = new GlobalConfig();
      }
    }
    public static GlobalConfig getInstance() {
      if (instance = null) {
        syncInit();
      }
      return instance;
    }
    public Vector getProperties() {
      return properties;
    }
    public void updateProperties() {
      //Load updated configuration information by new a GlobalConfig object
      GlobalConfig shadow = new GlobalConfig();
      properties = shadow.getProperties();
    }
  }

　　注意：在更新方法中，通过生成新的GlobalConfig的实例，从文件或数据库中得到最新配置信息，并存放到properties属性中。

　　上面两个方法比较起来，第二个方法更好，首先，编程更简单；其次，没有那么多的同步操作，对性能的影响也不大。

yunye 2008-06-05 12:43 发表评论

如何获得标签中一条记录的属性呢？

yunye — Tue, 15 Apr 2008 14:11:00 GMT

摘要: 以下是得到职员列表的 JSP 页面。列出数据库中所有职员的信息。现在我想通过点击“删除” < TD > 删除 <... 阅读全文

yunye 2008-04-15 22:11 发表评论

求救Hibernate 问题，急，请帮我看下我的代码，好么！

yunye — Tue, 25 Mar 2008 12:58:00 GMT

我想在 JSP 页面中向数据库表 staff 插入一条记录：页面能跳转到 addStaffSuccess.jsp ；

刷新页面时，添加的记录能在页面中显示出来，我还以为成功了，于是我想通过企业管理器打开数据库表看是不是数据库表更新了，发现数据库表不显示数据，我插入的是第二条记录，于是我让它返回首行，首行正常显示。我用查询分析器查询 Staff 表的数据，一直是“正在执行批查询状态 ……… ”说明我对数据库的操作影响到了数据库，但是出了我不知道的异常或错误，但是又不报错，我不知道怎么去找原因。忘了，当我停止 tomcat 时，数据表正常显示，但插入的数据没有显示在表里，说明没有插入。难道是我没停止 tomcat 前，数据库一直在更新么？

我用的环境是， eclipse3.2+Myeclipse5.5 + MS SQL server2000+ tomcat5.5

我添加了 struts 和 hibernate 支持，各个持久化类和 DAO 类 , 是通过映射后 hibernate 自动生成的。 Action 代码是我写的，不足道有错没，请指正。

添加后，返回原页面，显示了添加的信息：（但数据库没更新，郁闷！）

数据库：

staff (staffid,// 主键

staffname,//not null

password,//not null

departmentname;// 允许空

sex;// 允许空

email;// 允许空

mobile;// 允许空 )

在 StaffDAO 里面：（这是 hibernate 映射数据库表后自动生成的方法）

public void save(Staff transientInstance) {

log .debug( "saving Staff instance" );

try {

getSession().save(transientInstance);

log .debug( "save successful" );

} catch ( RuntimeException re) {

log .error( "save failed" , re);

throw re;

}

在 AddStaffAction 里面：

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response) {

// 获得表单信息；

AddStaffForm addStaffForm = (AddStaffForm) form; // TODO Auto-generated method stub

String staffid = addStaffForm.getStaffid();

String staffname = addStaffForm.getStaffname();

String departmentname = addStaffForm.getDepartmentname();

String sex = addStaffForm.getSex();

String password = new String( "000000" );

// 转换字符格式

try {

staffid = new String(staffid.getBytes( "ISO-8859-1" ), "GB2312" );

staffname = new String(staffname.getBytes( "ISO-8859-1" ), "GB2312" );

departmentname = new String(departmentname.getBytes( "ISO-8859-1" ), "GB2312" );

sex = new String(sex.getBytes( "ISO-8859-1" ), "GB2312" );

password = new String(password.getBytes( "ISO-8859-1" ), "GB2312" );

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

Staff staff = new Staff();

staff.setStaffid(staffid);

staff.setStaffname(staffname);

staff.setPassword(password);

staff.setDepartmentname(departmentname);

staff.setSex(sex);

try {

StaffDAO dao = new StaffDAO();

dao.save(staff);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return mapping.findForward( "addStaffSuccess" ); }

yunye 2008-03-25 20:58 发表评论

jsp超级链接实现"目标另存为"功能

yunye — Fri, 21 Mar 2008 17:40:00 GMT

jsp:

<% @ page language = " java " contentType = " text/html; charset=GB18030 "
pageEncoding = " GB18030 " %>
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv ="Content-Type" content ="text/html; charset=GB18030" >
< title > Insert title here title >
head >
< body >
< a href ="/test/test.do" > 1322 a >
body >
html >

action:

package action;

import java.io.FileOutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class TeAction extends Action {

     public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
         // TODO Auto-generated method stub

         StringBuilder sb = new StringBuilder();
         sb.append( " 1 " );
         response.addHeader( " Content-Disposition " , " attachment; filename=test.txt " );
         response.setContentType( " application/octet-stream " );
         response.setCharacterEncoding( " GB2312 " );
         response.getWriter().write(sb.toString());
         response.flushBuffer();

         return null ;
    }
}

yunye 2008-03-22 01:40 发表评论

在jsp客户端限制表单重复提交

yunye — Fri, 21 Mar 2008 17:39:00 GMT

在客户端限制表单重复提交有两种方法：
         第一种：在javascript脚本中设置一个标志变量，来区分表单是否已经提交。如果已经提交，则弹出对话框告诉用户“重复提交”。
        第二种：在单击提交按钮以后将提交按钮设置为disabled状态，这样用户就无法再提交按钮，客户端也就无法重复提交。
        采用第一种方法：

1.新建一个ClientTest1.jsp文件，代码如下：

<%@ page language="java" contentType="text/html; charset=Gb2312"
pageEncoding="GB2312"%>

客户端限制重复提交

2.如果重复提交表单就会弹出错误提示对话框

采用第二种方法：
1.新建一个ClientTest2.jsp文件，代码如下：

<%@ page language="java" contentType="text/html; charset=GB2312"
pageEncoding="Gb2312"%>

客户端限制重复提交-2

2.如果重复提交表单就会弹出错误提示对话框

yunye 2008-03-22 01:39 发表评论

如何在JSP中利用java文件操作大全

yunye — Fri, 21 Mar 2008 17:37:00 GMT

文件的建立/检查与删除

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

文件的建立、检查与删除

<%
String path=request.getRealPath("");
//out.println(path);
File f=new File(path,"File.txt");
//out.println(f);
//out.println(f.exists());

if(f.exists()){//检查File.txt是否存在
f.delete();//删除File.txt文件
out.println(path + "\\File.txt 存在，已删除。");
}else{
f.createNewFile();//在当前目录下建立一个名为File.txt的文件
out.println(path + "\\File.txt 不存在，已建立。");//输出目前所在的目录路径
}
%>

目录的建立/检查与删除

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

目录的建立/检查与删除

<%
String path=request.getRealPath("");
path=path + "\\Sub";//将要建立的目录路径
File d=new File(path);//建立代表Sub目录的File对象，并得到它的一个引用
if(d.exists()){//检查Sub目录是否存在
d.delete();
out.println("Sub目录存在，已删除");
}else{
d.mkdir();//建立Sub目录
out.println("Sub目录不存在，已建立");
}
%>

如何在JSP中处理虚拟目录

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

JSP中如何处理虚拟目录

取得虚拟目录对应的磁盘路径

Web站点主目录的位置为<%=request.getRealPath("/")%>

JSP网页所在的目录位置<%=request.getRealPath("./")%>

JSP网页所在目录上一层目录的位置<%=request.getRealPath("../")%>

文件属性的取得

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date,java.io.*"%>

文件属性的取得

<%
String path=request.getRealPath("/");
File f=new File(path,"ReadData.txt");
if(f.exists()){
%>
<%=f.getName()%>的属性如下：

文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%>

<%=f.isDirectory()?"是目录":"不是目录"%>

<%=f.canRead()?"可读取":"不可读取"%>

<%=f.canWrite()?"可写入":"不可写入"%>

<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%>

文件的最后修改日期为：<%=new Date(f.lastModified())%>

<%
}else{
f.createNewFile();//在当前目录下建立一个名为ReaData.txt的文件
%>
<%=f.getName()%>的属性如下：

文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%>

<%=f.isDirectory()?"是目录":"不是目录"%>

<%=f.canRead()?"可读取":"不可读取"%>

<%=f.canWrite()?"可写入":"不可写入"%>

<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%>

文件的最后修改日期为：<%=new Date(f.lastModified())%>

<%
}
%>

取出目录中文件的方法

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

取出目录中文件的方法--列出目录中的文件

<%
String path=request.getRealPath("/");
File d=new File(path);//建立当前目录中文件的File对象
File list[]=d.listFiles();//取得代表目录中所有文件的File对象数组
out.println("" + path + "目录下的文件：
");
for(int i=0;iif(list.isFile()){
out.println(list.getName() + "
");
}
}
out.println("
" + path + "目录下的目录：
");
for(int i=0;iif(list.isDirectory()){
out.println(list.getName() + "
");
}
}
%>

判断是否为空白文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

判断是否为空白文件

<%
String path=request.getRealPath("/");
out.println(path);
FileReader fr=new FileReader(path + "\\AtEnd.txt");//建立FileReader对象，并实例化为fr
//对FileReader类生成的对象使用read()方法，可以从字符流中读取下一个字符。
if(fr.read()==-1)//判断是否已读到文件的结尾
{
out.print("AtEnd.txt文件中没有数据
");
}else{
out.println("AtEnd.txt文件中有数据");
}
fr.close();
%>

读取所有的文件数据

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*,java.lang.*"%>

读取所有的文件数据

<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
//关键在于读取过程中，要判断所读取的字符是否已经到了文件的末尾，并且这个字符是不是文件中的断行符，即判断该字符值是否为13。
int c=fr.read();//从文件中读取一个字符
//判断是否已读到文件结尾
while(c!=-1){
out.print((char)c);//输出读到的数据
c=fr.read();//从文件中继续读取数据
if(c==13){//判断是否为断行字符
out.print("
");//输出分行标签
fr.skip(1);//略过一个字符
//c=fr.read();//读取一个字符
}
}
fr.close();
%>

一行一行读取数据

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

文件读取

<%
String path=request.getRealPath("");//取得当前目录的路径
FileReader fr=new FileReader(path + "\\file\\inc\\t.txt");//建立FileReader对象，并实例化为fr
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();//从文件读取一行字符串
//判断读取到的字符串是否不为空
while(Line!=null){
out.println(Line + "
");//输出从文件中读取的数据
Line=br.readLine();//从文件中继续读取一行数据
}
br.close();//关闭BufferedReader对象
fr.close();//关闭文件
%>

略过文件中的字符不读取

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

略过字节不读取

<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
fr.skip(2);//跳过2个字节
int c=fr.read();//读取一个字节
while(c!=-1){
out.print((char)c);
c=fr.read();
}
fr.close();
%>

将数据写入文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

将数据写入文件

<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");//建立FileWriter对象，并实例化fw
//将字符串写入文件
fw.write("大家好！");
fw.write("本书是《JSP编程技巧》");
fw.write("请多多指教！");
fw.write("email:stride@sina.com");
fw.close();

FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();
//读取一行数据
out.println(Line + "
");
br.close();//关闭BufferedReader对象
fr.close();
%>

将写入文件的数据分行

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

将写入文件的数据分行

<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大家好！");
bw.write("本书是《JSP编程技巧》。");
bw.newLine();//断行
bw.write("请多多指教！");
bw.newLine();//断行
bw.write("email: stride@sina.com");
bw.flush();//将数据更新至文件
fw.close();//关闭文件流
out.println("写入文件内容为：
");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);
String Line=br.readLine();//读取一行数据
while(Line!=null){
out.println(Line + "
");
Line=br.readLine();
}
fr.close();
%>

如何将数据追加写入到文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>

将写入文件的数据分行

<%
String path=request.getRealPath(".");
RandomAccessFile rf=new RandomAccessFile(path + "\\WriteData.txt","rw");//定义一个类RandomAccessFile的对象，并实例化
rf.seek(rf.length());//将指针移动到文件末尾
rf.writeBytes("\nAppend a line to the file!");
rf.close();//关闭文件流
out.println("写入文件内容为：
");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//读取文件的BufferedRead对象
String Line=br.readLine();
while(Line!=null){
out.println(Line + "
");
Line=br.readLine();
}
fr.close();//关闭文件
%>

yunye 2008-03-22 01:37 发表评论

C#基础概念二十五问

yunye — Fri, 21 Mar 2008 17:30:00 GMT

1.静态变量和非静态变量的区别？

2.const 和 static readonly 区别？

3.extern 是什么意思？

4.abstract 是什么意思？

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

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

7.override 和 overload 的区别？

8.什么是索引指示器？

9.new 修饰符是起什么作用？

10.this 关键字的含义？

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

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

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

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 、override 一起使用

声明为 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 修饰符

示例

Example05Lib 项目的 Class1

using System；using System.Collections.Generic；using System.Text；

namespace Example05Lib { public class Class1 { internal String strInternal = null；public String strPublic；}结果Example05Lib 项目的 Class2 类可以访问到 Class1 的 strInternal 成员

Example05 项目的 Program 类无法访问到 Class1 的 strInternal 成员

[NextPage]

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 thundershower！

Today is cloudy！

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

[NextPage]

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

答：

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

示例：

class BaseClass { public virtual void F（）

{ Console.WriteLine（"BaseClass.F"）；} abstract class DeriveClass ： BaseClass { public new abstract void F（）；}

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

答：

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

示例：

class BaseClass { public virtual void F（）

{ Console.WriteLine（"BaseClass.F"）；} sealed class DeriveClass ： BaseClass { //基类中的虚函数F被隐式的转化为非虚函数

//密封类中不能再声明新的虚函数G //public virtual void G（）

//{ // Console.WriteLine（"DeriveClass.G"）；//} }

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

答：

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

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

答：

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

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

答：

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

16.类和结构的区别？

答：类：

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

类有构造和析构函数

类可以继承和被继承

结构：

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

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

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

示例：

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

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

using System；using System.Collections.Generic；using System.Text；

namespace Example16 { interface IPoint { double X { get；set；} double Y { get；set；} double Z { get；set；} //结构也可以从接口继承struct Point： IPoint { private double x， y， z；//结构也可以增加构造函数public Point（double X， double Y， double Z）

{ this.x = X；this.y = Y；this.z = Z；} public double X { get { return x； } set { x = value； } } public double Y { get { return x； } set { x = value； } } public double Z { get { return x； } set { x = value； } } //在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作class PointGeometry { private Point value；

public PointGeometry（double X， double Y， double Z）

{ value = new Point（X， Y， Z）；} public PointGeometry（Point value）

{ //结构的赋值将分配新的内存this.value = value；} public double X { get { return value.X； } set { this.value.X = value； } } public double Y { get { return value.Y； } set { this.value.Y = value； } } public double Z { get { return value.Z； } set { this.value.Z = value； } } public static PointGeometry operator +（PointGeometry Left， PointGeometry Rigth）

{ return new PointGeometry（Left.X + Rigth.X， Left.Y + Rigth.Y， Left.Z + Rigth.Z）；} public override string ToString（）

{ return string.Format（"X： {0}， Y： {1}， Z： {2}"， value.X， value.Y， value.Z）；} class Program { static void Main（string[] args）

{ Point tmpPoint = new Point（1， 2， 3）；

PointGeometry tmpPG1 = new PointGeometry（tmpPoint）；PointGeometry tmpPG2 = new PointGeometry（tmpPoint）；tmpPG2.X = 4；tmpPG2.Y = 5；tmpPG2.Z = 6；

//由于结构是值类型，tmpPG1 和 tmpPG2 的坐标并不一样Console.WriteLine（tmpPG1）；Console.WriteLine（tmpPG2）；

//由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3 PointGeometry tmpPG3 = tmpPG1；tmpPG1.X = 7；tmpPG1.Y = 8；tmpPG1.Z = 9；Console.WriteLine（tmpPG1）；Console.WriteLine（tmpPG3）；

Console.ReadLine（）；}结果：X： 1， Y： 2， Z： 3 X： 4， Y： 5， Z： 6 X： 7， Y： 8， Z： 9

[NextPage]

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

答：

C# 中的接口与类不同，可以使用多继承，即一个子接口可以有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性（这也正是 C# 中类取消了多继承的原因之一），这时在实现时最好使用显式的声明

示例：

using System；using System.Collections.Generic；using System.Text；

namespace Example17 { class Program { //一个完整的接口声明示例interface IExample { //属性string P { get；set；} //方法string F（int Value）；//事件event EventHandler E；//索引指示器string this[int Index] { get；set；} interface IA { int Count { get； set；} } interface IB { int Count（）；} //IC接口从IA和IB多重继承interface IC ： IA， IB { } class C ： IC { private int count = 100；//显式声明实现IA接口中的Count属性int IA.Count { get { return 100； } set { count = value； } } //显式声明实现IB接口中的Count方法int IB.Count（）

{ return count * count；} static void Main（string[] args）

{ C tmpObj = new C（）；

//调用时也要显式转换Console.WriteLine（"Count property： {0}"，（（IA）tmpObj）。Count）；Console.WriteLine（"Count function： {0}"，（（IB）tmpObj）。Count（））；

Console.ReadLine（）；}结果：Count property： 100 Count function： 10000

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

答：

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

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

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

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

19.别名指示符是什么？

答：

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

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

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

示例：

Class1.cs：

using System；using System.Collections.Generic；using System.Text；

namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01 { class Class1 { public override string ToString（）

{ return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01's Class1"；} Class2.cs

using System；using System.Collections.Generic；using System.Text；

namespace com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02 { class Class1 { public override string ToString（）

{ return "com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02's Class1"；}主单元（Program.cs）：

using System；using System.Collections.Generic；using System.Text；

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

namespace Example19 { class Program { static void Main（string[] args）

{ Lib01Class1 tmpObj1 = new Lib01Class1（）；Lib02Class2 tmpObj2 = new Lib02Class2（）；

Console.WriteLine（tmpObj1）；Console.WriteLine（tmpObj2）；

Console.ReadLine（）；}结果：com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib01's Class1 com.nblogs.reonlyrun.CSharp26QExample.Example19.Lib02's Class1

20.如何释放非托管资源？

答：

。NET 平台在内存管理方面提供了GC（Garbage Collection），负责自动释放托管资源和内存回收的工作，但它无法对非托管资源进行释放，这时我们必须自己提供方法来释放对象内分配的非托管资源，比如你在对象的实现代码中使用了一个COM对象

最简单的办法，可以通过实现protected void Finalize（）（析构函数会在编译时变成这个东东）来释放非托管资源，因为GC在释放对象时会检查该对象是否实现了 Finalize（）方法，如果是则调用它。但，据说这样会降低效率……

有一种更好的，那就是通过实现一个接口显式的提供给客户调用端手工释放对象的方法，而不是傻傻的等着GC来释放我们的对象（何况效率又那么低）

System 命名空间内有一个 IDisposable 接口，拿来做这事非常合适，就省得我们自己再声明一个接口了

另外补充一句，这种实现并不一定要使用了非托管资源后才用，如果你设计的类会在运行时有大些的实例（象 GIS 中的Geometry），为了优化程序性能，你也可以通过实现该接口让客户调用端在确认不需要这些对象时手工释放它们

示例：

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 条指令，算起来开销也不少，所以我们要尽量少调用事务

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

[NextPage]

22.StringBuilder 和 String 的区别？

答：

String 虽然是一个引用类型，但在赋值操作时会产生一个新的对象，而 StringBuilder 则不会

所以在大量字符串拼接或频繁对某一字符串进行操作时最好使用 StringBuilder，不要使用 String

示例：

using System；using System.Collections.Generic；using System.Text；

namespace Example22 { class Program { static void Main（string[] args）

{ const int cycle = 100000；

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）；

Console.ReadLine（）；}结果：String： 102047 MSEL StringBuilder： 46 MSEL

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，通过它我们可以在运行时获得各种信息，如程序集、模块、类型、字段、属性、方法和事件

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

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

示例：

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）；}

yunye 2008-03-22 01:30 发表评论

奋斗

yunye — Fri, 21 Mar 2008 17:06:00 GMT

     “
        有时觉得奋斗真好，可以勇敢的抬头，任阳光在脸上绽放；奋斗真好，可以不计利益损失，按照自己的意愿生活，大有一片我的生活我作主的豪迈；奋斗真好，就算输得一塌糊涂，可是还有青春这张王牌给我们绝处逢生的喜悦；奋斗真好，可以潇洒的爱，可以痛快的哭，可以一贫如洗，也可以一步登天；奋斗真好，还有长长久久的明天可以去拼搏……
       ”

yunye 2008-03-22 01:06 发表评论

Struts使用Tiles辅助开发(转载)

yunye — Tue, 18 Mar 2008 06:37:00 GMT

Jplateau（原作）来自：http://www.javaresearch.org/article/8134.htm

对于在页面的布局管理以及可重用方面，Tiles做得很优秀，使我们在开发过程中思路非常流畅，特别是在用struts开发项目过程中，如果使用tiels来辅助开发，往往能带到事半功倍的效果。

如果要看Tiles的详细文档，请访问http://www.lifl.fr/~dumoulin/tiles/

在此我想从使用方式上说一下自己的经验：

往往我们的一个项目中，大部分的页面的布局都是一样的，这其中如果我们把一样风格的页面归为一类的话，这样的分类就不会很多了。（不同的项目这样的分类多少为有区别，要看页面风格规划的是否高效）

假设我们提出一类页面（如产品管理）的风格，布局如下：

那么我们可以在tiles-defs.xml中定义这样一个总的类型，如下：

tiles-defs.xml 放在/yourwebapp/WEB-INF/下

"1.0" encoding="ISO-8859-1" ?>
"-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd">
"mainLayout" path="/homepage.jsp">
"top" value="/header.jsp" />
"menu" value="/menu.jsp"/>
"main" value="/main.jsp" />
"footer" value="/footer.jsp" />
……
……
……

以上定义了一种布局类型，假设命名为A布局，下面要列举两个属于该类型风格的页面的布局方法添加产品页面，最终我们要关心的时addProducts.jsp这个页面，但是我们如何使用A布局的布局风格呢？

如下：

……接上tiles-defs.xml……

"mainLayout" path="/homepage.jsp">
"top" value="/header.jsp" />
"menu" value="/menu.jsp"/>
"main" value="/main.jsp" />
"footer" value="/footer.jsp" />
extends=” mainLayout”>
extends=” mainLayout”>
……
……

以上只是以一种布局类型来说明，其他的布局类型（如：布局B，布局C。。。。。）都用相通的方法扩展，没有什么难的地方。

下面简要说一些tiles在struts-config.xml中的配置，在struts1.1种tiles是利用struts的扩展机制来完成装载的，代码很简单如下：

//struts-config.xml
……
"org.apache.struts.tiles.TilesPlugin" >
"definitions-config"
value="/WEB-INF/tiles-defs.xml" />

如果你些多个tiles配置文件，那么用“，”号隔开。
下面在举一个使用tiles以后action mapping 的写法

如我们要进行添加商品的请求，在添加页面里要先进行商品类型的装载：

addProductAction.do――〉ProductAction――〉addProducts.jsp
ProductAction完成商品类型的集合返回client端

//Struts-config.xml
…………
type=”com.***. ProductAction”>
…………

好了，以上对一个操作的流程采用tiles以后的写法进行了简要的说明，具体Tiles的文档请参看上面给出的连接。

Struts发布包里也有tilse的文档和例子。

yunye 2008-03-18 14:37 发表评论