posts - 5,  comments - 2,  trackbacks - 0
  2009年10月9日
链接地址:http://edu.codepub.com/2009/0801/11839.php
posted @ 2009-10-09 12:53 SuperJoe 阅读(28) 评论(0) 编辑
转载自:http://www.ibm.com/developerworks/cn/xml/x-dtdint/index.html
这篇介绍性文章说明了如何创建 XML“文档类型定义(DTD)”和格式正确定义明确的 XML 文件,这些文件能够由您选择的 XML 语法分析器进行确认。虽然不必在产生的每个 XML 文件中都包含 DTD,但这样做将会使您的生活大为轻松。DTD 不仅强制使用为 XML 文件建立的语法,它还将允许文件由确认 XML 语法分析器进行语法分析。代码样本包括 DTD 和 XML 文档示例。

“可扩展标记语言”已经存在了十分长的一段时间,因此现在大多数人都熟悉其最基本的需求:所有 XML 文档都必须既格式正确又有效。但如何确定您的 XML 文档是否满足这些需求呢?简短的回答就是您不用确定。或者至少是不必。大多数时候,您会依赖于 XML 语法分析器来为您管理这些苦活。

在经过一些小调查(请参阅 参考资料)后您就会发现市场上到处充斥着 XML 语法分析器,其中大多数都可以从 Web 上免费获得。一个基本的 XML 语法分析器既强调 XML 语法规则(即,确保文件格式正确),又建立文件的有效性。XML 语法分析器可用于几乎每种相关的计算机语言,包括 C、C++、Perl、Python、Tcl 和 Java。

谈到确保 XML 格式正确时,您可以或多或少地指向一个语法分析器然后执行。然而为了确保文档有效,需要为语法分析器提供文档类型定义或 DTD。

模式如何?

最近,W3C 将长期以来一直讨论的 XML Schema 规范推进成“建议书”状态,这意味着它有可能为开发人员普遍所用。在某些方面,XML Schema 将替代 DTD。而在其它方面,DTD 仍是最好的解决方案。有关解释 XML Schema,以及将它与 DTD 进行功能和处理上的对比的 developerWorks 文章,请参阅 参考资料

本文回顾了 XML 文档格式正确究竟意味着什么,然后会谈到较少讨论的话题确认 - 更具体地说,是 DTD。我将讨论为什么您需要将 DTD 包含在 XML 文件中、介绍一些最常用的 DTD 语法,并使用几个简单的样本来教您开始编写自己的 DTD。

为什么要格式正确?

当 XML 开发人员谈到格式正确和格式不正确的 XML 时,我们并不是参加美学讨论。当然,格式正确的 XML 文档是满足以下三个基本结构需求的文档:

  • 有一个包含所有其它元素的父(或根)元素
  • 每个开始标记都有结束标记
  • 所有元素都正确嵌套的

清单 1 是一个格式正确的 XML 示例。请注意:该文档的父元素是 <person> ,每个开始标记都有一个结束标记,并且每个结束标记都有与其开始标记完全相同的定义。通常,开始标记和结束标记之间包括的是信息或文本。不过,在某些情况下,标记之间没有包括信息或文本。空标记必须用一个右斜杠来结束。<nothing/> 就是一个空标记。


清单 1. 格式正确的 XML
<person>
        <firstname>Jane</firstname>
        <lastname>Fung</lastname>
        <nothing/>
        </person>
        

清单 2 是一个格式不正确的 XML 示例。它举例说明了三种常见错误。首先,开始和结束 <firstname> 标记没有完全匹配。其次, <lastname> 标记没有结束标记。最后,空标记没有用一个右斜杠结束。


清单 2. 格式不正确的 XML
<person>
        <Firstname>Jane</firstname>
        <lastname>Fung
        <nothing>
        </person>
        





回页首


DTD 中有什么内容?

XML 的优点在于它允许您定义自己的有意义的标记,因此您可以最大程度地定制文档。但 XML 就是 XML(可扩展),而人就是人(疯狂的人),这可能很快就会无法控制。解决方案是 DTD,它指定了 XML 文档的标记。简而言之,DTD 指定:可以在文档中存在的元素、那些元素可以具有的属性、在元素内部元素的层次结构以及元素在整个文档中出现的顺序。

虽然 DTD 不是必需的,但它们确实带来方便。DTD 适合三个基本用途。它能:

  • 对标记编制文档
  • 加强标记参数内部的一致性
  • 使 XML 语法分析器能够确认文档

如果不对 XML 文档进行 DTD 定义,文档就无法由 XML 语法分析器进行确认。使用 XML Schema 实例来代替 DTD 如何?(请参阅侧栏 模式如何?)清单 3 是清单 1 中显示的 XML 文档的 DTD。


清单 3. 精简 person.xml 的 DTD
<!ELEMENT person (firstname, lastname)>
        <!ELEMENT firstname (#PCDATA)>
        <!ELEMENT lastname (#PCDATA)>
        <!ELEMENT nothing EMPTY>
        

关于示例的几点说明

清单 3 中 DTD 的第一行定义了 XML 文档的父元素: person 。person 元素有两个子元素: firstname 和 lastname 。

第二和第三行包含了元素属性 #PCDATA ,它表明 firstname 和 lastname 元素可能包含经过语法分析的字符数据(在这种情况下是文本)。DTD 文件的最后一行描述了一个空标记: nothing 。

从清单 3 中的 DTD 可以看出,任何阅读我们的 XML 文档的人(以及对它进行语法分析的语法分析器)都知道 person 元素仅包含两个文本元素: firstname和 lastname 。此外,DTD 规定,在整个文档中, firstname 元素必须在 lastname 元素之前出现。

在转到更复杂的示例之前,让我们回顾一下一些最常用的 DTD 语法元素。可以在 W3C 主页上找到完整的 DTD 规范(请参阅 参考资料)。





回页首


DTD 语法快速指南

A、B、C 和 D 是在下例中代表元素的变量。

元素必须有正好一个 A 、至少一个 B (由加号表示)、零个或多个 C (由星号表示)以及零个或一个 D (由问号表示):

<!ELEMENT element (A, B+, C*, D?)>
        

元素可能有 A 或 B 或 C 之一:

<!ELEMENT element (A | B | C)>
        

元素不包含任何内容:

<!ELEMENT element EMPTY>
        

元素可以包含在 DTD 中列出的任何元素:

<!ELEMENT element ANY>
        

元素可能包含经过语法分析的字符数据或另一个元素( element2 )。星号(*)表示混合内容模型 — 其中元素可以包含不同类型的属性。

<!ELEMENT element (#PCDATA|element2)*>
        

下例将文本 "entity reference" 插到文档中它出现的任何地方:

<!ENTITY element "entity reference">
        

可以看到在 XML 文档中该实体引用元素如下:

&element;
        

下例表明其元素是一个包含三个属性的空标记:属性 1( att1 )是一个可选属性,属性 2( att2 )是带有固定值 "A" 的属性,属性 3( att3 )是必需的文本属性。

   <!ELEMENT element EMPTY>
        <!ATTLIST element
        att1 ID #IMPLIED
        att2 CDATA #FIXED "A"
        att3 CDATA #REQUIRED>
        

可以看到在 XML 文档中使用的这个元素如下:

<element att2="A" att3="MustHave"/>
        

属性 CDATA 表示包括的信息应该是文本。 ID 属性表明必须填入唯一的标识。每个元素只能有一个 ID 属性。另外, CDATA 表示 att2 和 att3 可能包含任何字符串。

如果您对该语法还未完全熟悉,请继续阅读。下一部分中的工作示例应该能帮助您消除疑虑。





回页首


工作示例

可以使用 Microsoft Internet Explorer 5 或更高版本查看清单 4 中显示的 XML 文档 ― 前面示例中使用的 people.xml 文件的扩展版本。如果在 IE5 中打开 people.xml,应该看到一个树结构。这是因为 IE5 带有能够将 XML 文档语法分析成元素树的 XML 语法分析器。

还可以在 参考资料中找到这个文件及其 DTD。


清单 4. people.xml 的完整清单
<?xml version="1.0"?>
        <!DOCTYPE people SYSTEM "people.dtd">
        <people>
        <person>
        <name>
        <firstname>Jane</firstname>
        <lastname>Fung</lastname>
        </name>
        <look>good-looking</look>
        <possession>
        <car>
        <model>Civic</model>
        </car>
        <job>&IBM;</job>
        </possession>
        </person>
        <person>
        <name>
        <firstname>G.I.</firstname>
        <lastname>Jane</lastname>
        </name>
        <look>tough</look>
        <possession>
        <house country="CANADA" city="Toronto">
        <townhouse townhouse_type="good" />
        </house>
        <bankaccount bankaccount_number="sg-123">
        <![CDATA[<greeting>5000</greeting>]]>
        </bankaccount>
        </possession>
        <other>
        <car>she has a car</car>
        <house country="CANADA" city="Toronto">
        <townhouse townhouse_type="good" />
        </house>
        </other>
        </person>
        </people>
        

关于 XML 的几点说明

对 XML 的深入探讨主要考虑的是文档头中的几个元素,从以下开始:

<?xml version="1.0"?>
        

每个 XML 文档都必须包含这样的一个头,向 XML 语法分析器表示它是一个 XML 文档。头中的下一行告诉 XML 语法分析器该文档是使用什么字符编码来创建的:

<!DOCTYPE people SYSTEM "people.dtd">
        

在 Unix 系统上创建的 XML 文档和在 Windows 系统上创建的 XML 文档可能有不同的编码。

还可以为第一行设置可选的 standalone 属性。standalone 的缺省值是 no。 no 值表示该 DTD 定义是在另一个文件中描述的。 yes 值表明该 DTD 应该在 XML 文档内部定义。我没有为示例设置这个属性;如果想设置,它应该看起来如下:

   <?xml version="1.0" standalone='yes'?>
        <!DOCTYPE people [
        <!ELEMENT people (person+)>
        <!ELEMENT person (#PCDATA)>
        ]>
        

还应该注意使这个文档格式正确的方法。例如,所有空标记都用一个右斜杠结束,如下所示:

<townhouse townhouse_type="good" />
        

还请注意 CDATA 用于对所有若不进行转义就会以 XML 语言解释的任何数据进行转义,例如:

<![CDATA[<greeting>5000</greeting>]]>
        

如果适当的格式化,这一行将以文本内容显示:

<greeting> 5000 </greeting>
        

可以从 XML 文件的进一步研究中获益,甚至可能从对您自己的文件运行 XML 语法分析器获益(请参阅 参考资料)。但是现在,让我们看一下 people.xml 文件的 DTD。


清单 5. people.dtd 的完整清单
<!ELEMENT people (person+)>
        <!ELEMENT person (name, look*, possession?, other?)>
        <!ELEMENT name (firstname, lastname)>
        <!ELEMENT firstname (#PCDATA)>
        <!ELEMENT lastname (#PCDATA)>
        <!ELEMENT look (#PCDATA)>
        <!ELEMENT possession (car?, house?, bankaccount?, job?)>
        <!ELEMENT car (#PCDATA|model)*>
        <!ELEMENT model (#PCDATA)>
        <!ELEMENT house (apartment|standalone|townhouse)>
        <!ATTLIST house house_area ID #IMPLIED country CDATA #FIXED
        "CANADA" city CDATA #IMPLIED>
        <!ELEMENT apartment EMPTY>
        <!ELEMENT standalone EMPTY>
        <!ELEMENT townhouse EMPTY>
        <!ATTLIST townhouse townhouse_type ID #IMPLIED>
        <!ELEMENT bankaccount (#PCDATA)>
        <!ATTLIST bankaccount bankaccount_number ID #REQUIRED>
        <!ELEMENT job (#PCDATA)>
        <!ELEMENT other ANY>
        <!ENTITY IBM "Proud to work for IBM">
        

关于 DTD 的几点说明

使用 快速指南作为参考,通过比较 XML 文件及其 DTD,您应该能够方便地定义 DTD 和 XML 文件中各元素之间的关系。不过,还有两个剩下的元素,您可能感兴趣。

清单 4 包含了对实体的引用。

<job>&IBM;</job>
        

实体引用用于代替在 DTD 文档中定义的特定字符或字符串。进行了语法分析后,该实体引用将读作:

<job> Proud to work for IBM </job>
        

还应该注意, <other> 标记的内容类型是 ANY 。这表示 <other> 可能包含所有以前已在 DTD 中声明过的元素。因此, other 元素可能包含 car 和 house 元素,如下:

   <other>
        <car>she has a car</car>
        <house country="CANADA" city="Toronto">
        <townhouse townhouse_type="good" />
        </house>
        </other>
        





回页首


结束语

这就结束了对创建格式和定义均正确的 XML 文件的基本介绍。您可能想要继续自己研究 people.xml 和 people.dtd 文件。如果想要尝试使用 XML 语法分析器对这些文件进行语法分析,请参阅“参考资料”来查找可供下载的语法分析器的列表。

posted @ 2009-10-09 12:32 SuperJoe 阅读(60) 评论(0) 编辑
  2009年10月8日
文章转载自:http://www.webkey.cn/code/view.asp?id=7504

关于字符串的驻留的机制,对于那些了解它的人肯定会认为很简单,但是我相信会有很大一部分人对它存在迷惑。在开始关于字符串的驻留之前,先给出一个有趣的Sample: 
   
  Code Snip: 
   
   
  static void Main(string[] args) 
   { 
   string str1 = "ABCD1234"; 
   string str2 = "ABCD1234"; 
   string str3 = "ABCD"; 
   string str4 = "1234"; 
   string str5 = "ABCD" + "1234"; 
   string str6 = "ABCD" + str4; 
   string str7 = str3 + str4; 
   
   Console.WriteLine("string str1 = \"ABCD1234\";"); 
   Console.WriteLine("string str2 = \"ABCD1234\";"); 
   Console.WriteLine("string str3 = \"ABCD\";"); 
   Console.WriteLine("string str4 = \"1234\";"); 
   Console.WriteLine("string str5 = \"ABCD\" + \"1234\";"); 
   Console.WriteLine("string str6 = \"ABCD\" + str4;"); 
   Console.WriteLine("string str7 = str3 + str4;"); 
   
   Console.WriteLine("\nobject.ReferenceEquals(str1, str2) = {0}", object.ReferenceEquals(str1, str2)); 
   Console.WriteLine("object.ReferenceEquals(str1, \"ABCD1234\") = {0}", object.ReferenceEquals(str1, "ABCD1234")); 
   
   Console.WriteLine("\nobject.ReferenceEquals(str1, str5) = {0}", object.ReferenceEquals(str1, str5)); 
   Console.WriteLine("object.ReferenceEquals(str1, str6) = {0}", object.ReferenceEquals(str1, str6)); 
   Console.WriteLine("object.ReferenceEquals(str1, str7) = {0}", object.ReferenceEquals(str1, str7)); 
   
   Console.WriteLine("\nobject.ReferenceEquals(str1, string.Intern(str6)) = {0}", object.ReferenceEquals(str1, string.Intern(str6))); 
   Console.WriteLine("object.ReferenceEquals(str1, string.Intern(str7)) = {0}", object.ReferenceEquals(str1, string.Intern(str7))); 
   } 
   
   
  下边是输出的结果: 
   
  接下来我们来逐句地分析这段代码: 
   
  首先我们创建了两个完全相同的字符串(ABCD1234),并将他们分别赋予了两个字符创变量——str1和str2。然后把它们传给了object.ReferenceEquals。我们知道object.ReferenceEquals是用于确定两个变量是否具有相同的引用——换句话说,当两个变量引用的是同一块托管推的内存快的时候,返回True,否则返回False。 
   
  string str1 = "ABCD1234"; 
  string str2 = "ABCD1234"; 
  object.ReferenceEquals(str1, str2)= True; 
  object.ReferenceEquals(str1, "ABCD1234")) = True; 
   
  令我们感到奇怪的是,当我们分别创建的引用类型两个变量——string是引用类型。照理说CLR会在托管堆(Managed Heap)中为它们分配两段内存快,他们不可能具有相同的引用才对,但是为什么object.ReferenceEquals 方法会返回True呢。而对于第二个比较——一个字符串变量和一个和他具有相同内容的字符串("ABCD1234";)直接进行比较,按照我们对CLR内存的分配的一般理解,应该是CLR首先会在托管堆中为这段字符串("ABCD1234")分配内存快,然后把相对应的引用传递给object.ReferenceEquals方法(由于分配在托管堆的这段字符串并没有被任何变量引用,所以当垃圾回收的时候会被回收掉),所以无论如何也不应该返回True。 
   
  我们先把问题留到最后,接着分析我们的Sample。上面们对字符串变量之间以及变量与字符串之间进行了比较,如果我们对一个字符串变量和一个动态创建的字符串(通过+Operator把两个字符串连接起来)进行比较,结果又会如何呢?我们来看看下面的伪代码演示: 
   
  string str3 = "ABCD"; 
  string str4 = "1234"; 
  string str5 = "ABCD" + "1234"; 
  string str6 = "ABCD" + str4; 
  string str7 = str3 + str4; 
  object.ReferenceEquals(str1, str5) = True 
  object.ReferenceEquals(str1, str6) = False 
  object.ReferenceEquals(str1, str7)) = False 
   
  在上面的例子中,我们用三种不同的方式创建了3个字符串变量(str5,str6,str7)——string+string;string+variable;variable+variable。然后分别和我们已经创建的、和它们具有相同字符串“值”的变量(str1)作比较。同样令我们感到奇怪的是第一个返回True,而后两个则为False。带着这些疑惑我们来看看对于string这一特殊的类型说采用的特殊的使用机制。 
   
  1. System.String虽然是一个引用类型,但是它具有其自身的特殊性。我们最容易想到的是它创建的特殊性——一般的对象在创建的时候需要通过new关键字调用对应的构造函数来实现;而创建一段string不需要这么做——我们只需要把对应的字符换赋给给对应的字符串变量就可以了。之所以存在着这种差异,是因为他们在创建过程中使用的IL指令时不同的——一般的引用对象的创建是通过newobj这样一个IL指令来实现的,而创建一个字符串变量的IL指令则是ldstr (load string)。(象C#,VB.NET这样的语言毕竟是高级语言,进行了高度的抽象,站在这样的角度分析问题往往不能够看到其实质,所以有时候我们把应该从交底层上面找突破口——比如分析IL,Metadata…); 
   
  2. 由于String是我们做到频率最高的一种类型,CLR考虑性能的提升和内存节约上,对于相同的字符串,一般不会为他们分别分配内存块,相反地,他们会共享一块内存。CLR实际上采用这个的机制来实现的:CLR内部维护着一块特殊的数据结构——我们可以把它看成是一个Hash table,这个Hash table维护者大部分创建的string(我这里没有说全部,因为有特例)。这个Hash table的Key对应的相应的string本身,而Value则是分配给这个string的内存块的引用。当CLR初始化的时候创建这个Hash table。一般地,在程序运行过程中,如果需要的创建一个string,CLR会根据这个string的Hash Code试着在Hash table中找这个相同的string,如果找到,则直接把找到的string的地址赋给相应的变量,如果没有则在托管堆中创建一个string,CLR会先在managed heap中创建该strng,并在Hash table中创建一个Key-Value Pair——Key为这个string本身,Value位这个新创建的string的内存地址,这个地址最重被赋给响应的变量。这样我们就能解释上面的疑问了。 
   
  string str1 = "ABCD1234"; 
  string str2 = "ABCD1234"; 
  object.ReferenceEquals(str1, str2)= True; 
  object.ReferenceEquals(str1, "ABCD1234")) = True; 
   
  当创建str1的时候,CLR现在我们上面提到的Hash table中找“ABCD1234”这样的一个string,没有找到,则在托管堆中为这个string分配一块内存,然后在Hash table为该string添加一个Key-Value Pair。接着创建str2,CLR仍然会在Hash table找ABCD1234这样的一个string,这回它会找到我们新创建的这个Entry,所以这个Key-Value Pair中Value(string的地址)会赋给str2。因为str1和str2 具有相同的引用,所以调用object.ReferenceEquals返回True。同理当我们对str1和"ABCD1234"进行比较的时候,str1直接传入该方法,放传入"ABCD1234"这个字符串的时候,CLR同样会在Hash table找ABCD1234这样的一个string,相同的Entry被找到,这个Entry(Key-Value Pair)的Value(string的地址)被传到object.ReferenceEquals,所以他们仍然相同的引用,结果返回True。 
   
  3. 并非所有的情况下字符串的驻留都会起作用。对于对一个动态创建的字符串(比如string+variable;variable+variable),这种驻留机制便不会起作用。因为对于这样的字符串,是不会被添加到内部的Hash table中的。但是对于string+string则不同,因为当这样的语句被编译成IL的时候,编译器是先把结构计算出来,然后再调用ldstr指令——而对于string+variable;variable+variable这种情况,所对应的IL指令是Concat。所以对于string+string字符串的驻留仍然有效。 
   
  比如对于以下一段代码: 
   
   static void Main(string[] args) 
   { 
   string str1 = "ABC"; 
   string str2 = str1 + "123"; 
   string str3 = "ABC" + "123"; 
  } 
   
  对应的IL Code是: 
   
   
  .method private hidebysig static void Main(string[] args) cil managed 
  { 
   .entrypoint 
   // Code size 26 (0x1a) 
   .maxstack 2 
   .locals init ([0] string str1, 
   [1] string str2, 
   [2] string str3) 
   IL_0000: nop 
   IL_0001: ldstr "ABC" 
   IL_0006: stloc.0 
   IL_0007: ldloc.0 
   IL_0008: ldstr "123" 
   IL_000d: call string [mscorlib]System.String::Concat(string, 
   string) 
   IL_0012: stloc.1 
   IL_0013: ldstr "ABC123" 
   IL_0018: stloc.2 
   IL_0019: ret 
  } // end of method Program::Main 
   
   
  所以现在我们就可以解释第二个疑问了。 
   
  虽然对于对一个动态创建的字符串(比如string+variable;variable+variable),驻留机制便不会起作用。但是我们可以手工的启用驻留机制——那就是调用定义的System.String中的静态方法Intern。这个方法接受一个字符串作为他的输入参数,返回的经过驻留处理的string。他的实现机制是:如果能在内部的Hash Table中找到传入的string,则返回对应的string引用,否则就在Hash Table添加该string对应的Entry,并返回string的引用。所以下面的代码就不难解释了。 
   
   Console.WriteLine("\nobject.ReferenceEquals(str1, string.Intern(str6)) = {0}", object.ReferenceEquals(str1, string.Intern(str6))); 
   Console.WriteLine("object.ReferenceEquals(str1, string.Intern(str7)) = {0}", object.ReferenceEquals(str1, string.Intern(str7))); 
posted @ 2009-10-08 22:46 SuperJoe 阅读(111) 评论(0) 编辑
   最近发现自己的基础知识很薄弱,跟朋友交流的时候经常发现很多基础知识自己是一知半解,似懂非懂。每每这个时候我觉得很有必要去彻底弄懂它,至少应该有个清晰的认识。最近跟一个朋友讨论到C#继承中构造函数的问题,看代码说问题吧。
    public class A
    {
        
public A(string a) { }
    }
    
public class B:A
    {
        
public B() { }
    }
这段代码编译后,会有个错误提示:A does not contain a constructor that takes '0' arguments ,中文意思类A没有包含无参构造函数。按照提示,我在类A中,添加了无参构造函数,问题解决了。那么为什么会这样呢,我们知道,子类在创建对象执行构造函数之前会先执行父类的构造函数,那么假如父类中有多个构造函数,又是执行哪个呢,这时候base这个关键字我想可以来说明一切。还是看代码吧:
    public class A
    {
        
public A() { }
        
public A(string a) { }
    }
    
public class B:A
    {
        
public B():base()
        { }
    }
跟上面的代码差不多,我在A中添加了无参构造函数,然后在B中修改了这句:pubic B():base(){},然后我们测试下,创建一个B对象,在A类中的2个构造函数中设置断点,发现无参构造函数执行了,我想正是因为这个base在这里发挥了作用,是base()指向了父类的无参构造函数。其实,在类B中,我们完全可以省略 base(),也能正常运行,我想,这是系统默认指向了父类的无参构造函数的原因吧,所以也可以省略了,其实大多数时候,我们都是省略不写的。看到这里,我想你应该知道第一段代码中提示的错误的原因了吧,原因是A类中没有无参的构造函数,这样在执行B中的构造函数的时候,就没法执行A中的无参构造函数了。 下面我在写一段不使用无参构造函数的代码,看了会更加清晰:
Code
B中的构造函数指定了调用父类的A(string a)构造函数。这样我们创建B对象在执行构造函数前就会执行父类中对应的指定的构造函数了。
第一次写博客,憋了很久才写出来,这些都是自己跟朋友讨论出来的,加上代码测试跟自己的理解,希望能帮到一些C#的初学者,我想,很多初学者在这里也肯定很迷惑(也包括我)。如果园子里的大牛看到了,也希望你们能指点一二,不知道自己描述的是否确切。
posted @ 2009-10-08 15:01 SuperJoe 阅读(1152) 评论(1) 编辑
在博客园安家了,加油。
posted @ 2009-10-08 10:40 SuperJoe 阅读(9) 评论(0) 编辑