1.一表人才。

你不可用第一印象取段别人，但是别人会用第一印象取段你。

靠内心的含义。使自己不断的提高自己的修养

2.两套西装。

 要随和，不要太标新立异

3.三杯酒量。

适量的酒对你有好处。在嗜好上要保持一定的随和

4.四圈麻将。

 他们有什么活动，要和他们一起去活动。

人际关系是不能打草惊蛇，让人感觉你很随和。

5.五方交友

中国人喜欢道途听说，对每个一人保持一定安全距离，

但是必须每个人对你有好感。

6.六出祁山

只问应该不应该，不要问可能不可能。

7.七术打马

拍到像没有拍一样。人前要适合领导，人后要告诉领导什么事情不对!    70%拍马屁30%真诚

8.八口吹牛

功劳是让出来的。功劳是推来推去的，大家都有，抢来抢去，大家都没有。关系有人前有人后。要人捧人，不要人损人。

9.九分努力

做事情一定要努力，别人不会帮你一辈子的。

10.十分忍耐

如果没有忍耐，就没有前面的九个。

心好是没有人知道的，但是脾气不好是所有人都知道的。

叹，不易啊！

Well, I got some great replies on my appearently rookie question..;) .I'll post them here for others to learn from. that's what it's all about , isn't it?

The Problem: Given an XML string, create an instance of the XMLSerializer class, allowing you to construct or serialize an object of a specific type.

There were two solutions right away. They both seem pretty darn obvious - once you read them :) thanks folks!

Solution 1: Use a stringBuilder Object to create a stream

Solution 2:  Use a MemoryStream Object to translate the string into a stream, which is needed to intialize the XMLSerializer

十一出去玩很受罪，还好我没怎么出去玩，去了一趟故宫，感受皇家庭院的宏大，想象皇室生活的奢华...

去了一趟长城，搭乘动车S2线，从北京北到八达岭站，这趟旅游令人兴奋，车行驶在詹天佑设计的人字形铁路上，旁边巍峨的高山上，世界奇迹-长城-蜿蜒其上，实景给人一种震动，庞大的工程，空前的消耗，让人感叹。由于下小雨，烽火台都泛起了云雾，景色挺别致...

明天要上班了，又！

抽了点时间，熟悉一下3.0的新特性，发觉c#新特性及进步趋势是语言动态化（或者讲脚本化，也汲取了一些脚本语言的好特性），而内在是compiler做了更多的事情，而方便了程序员，几个新特性最终为Linq的实现服务（新特性是一层层叠加上去的，如class->delegate->lambda expression便是其一），而Linq则在ADO.NET Entity及其他查询中作用巨大。

主要参考自C# 3.0 Pocket Reference，未说到的细节到书中查看(google一下ebook)

1、Lambda Expressions：

类似于匿名方法，语法格式：

(parameters) => expression-or-statement-block

Compiler将为你编译出一个delegate，参数可以指定类型，可以指定return，如(int i)=>{return i*i;}

因此Framework lib中定义了两个常用的lambda expression，其实就是两个generic delegate，即Func和Action (Func的无返回版本)

delegate TResult Func <T, TResult>(T arg1) 等价于 (T arg1)=>(..return TResult)

Func<int,int> sqr = x => x * x;

Console.WriteLine (sqr(3));     // 9

2、Extension Methods：

不修改一个类型的定义，而为其增加方法，类型可以是接口（听起来挺强吧）

语法：将需增加的方法定义为一个static class的static method，第一参数指定扩展的类型并用this修饰

如：public static bool IsCapitalized (this string s)

使用：”hello”.IsCapitalized(),其实compile时compiler帮你改写成对static method IsCapitalized的调用，将”hello”作参数传入

public static T First<T> (this IEnumerable<T> sequence)

System.Linq.Enumerable类中便定义了n多扩展IEnumerable<>的方法

4、Anonymous Type：

语法：var dude = new { Name = "Bob", Age = 1 };

有脚本的感觉了吧，到现在才有，管谁的呐，好东西就应该拿过来

上述三样都是为下面这项服务的

5、Linq(Language Integrated Query):

上述的三样+Query syntax基本就有了linq

LINQ lets you query any collection implementing IEnumerable<>, whether an array, list, XML DOM, or remote data source (such as a table in SQL Server). LINQ offers the benefits of both compile-time type checking and dynamic query composition.

 算了，linq东西还是挺多的，就暂时不列了，参考一下c# 3.0 pocket reference可以作一下快速了解。

Types of Entities

Internal Entities

Do you ever get tired of typing the name of your company, "Yoyodyne Industries, Inc."? Have you ever had the pleasure of spelling it incorrectly in an important document? Internal entities offer a convenient solution to these problems.

Instead of typing the same text over and over again, you can define an internal entity to contain the text and then you only need to use the entity where you want to insert the text. Because the entity is expanded by the parser, you can be assured that you'll get the same text in every location. The parser will also catch typos if you misspell an entity name (so long as there's no entity name that matches your typo!).

To use an entity you insert an "entity reference" into your document. You're probably already familiar with some entity references because you need to use them for special characters that cannot be typed directly in an XML document, like "<" and "&". An entity reference is an ampersand (&), followed by the name of the entity, followed by a semicolon (;).

If you've defined the entity "yoyo" to contain the name of your company, then you can use it with the following entity reference "&yoyo;".

The text that is inserted by an entity reference is called the "replacement text". The replacement text of an internal entity can contain markup (elements, attributes, processing instructions, other entity references, etc.), but the content must be balanced (any element that you start in an entity must end in the same entity) and circular entity references are not allowed.

You create internal entities with entity declarations in the internal subset or the DTD.

Predefined Entities

Five internal entities are predefined in XML:

All XML processors are required to support references to these entities, even if they are not declared.

Character References

Character references, which are similar in appearance to entity references, allow you to reference arbitrary Unicode characters, even if they aren't available directly on your keyboard. Character references are not properly entities at all.

Character references are numeric and can be used without any special declaration.

The basic format of a character reference is either "&#nnn;" or "&#xhhh;" where "nnn" is a decimal Unicode character number and "hhh" is a hexadecimal Unicode character number.

A character reference inserts the specified Unicode character directly into your document. Note that this does not guarantee that your processing or display system will be able to do anything useful with the character. For example, &#x236E; would insert, in the words of the Unicode standard, an "APL Functional Symbol Semicolon Underbar". Whether or not you can print that character is an entirely different issue.

Character references differ from other entity references in a subtle but significant way. They are expanded immediately by the parser. Using '&#34;' is exactly the same as '"'. In particular, this means you can't use the character reference in an attribute value to escape the quotation characters.

External Entities

External entities offer a mechanism for dividing your document up into logical chunks. Rather than authoring a monolithic document, a book with 10 chapters for example, you can store each chapter in a separate file and use external entities to "source in" the 10 chapters.

Because external entities in different documents can refer to the same files on your file system, external entities provide an opportunity to implement reuse. Reuse of small, discrete components (figures, legal boilerplate, warning messages) is fairly easy to manage. Implementing reuse on a large scale requires an entity management system which XML, by itself, does not provide.

A few notes about external entities:

• External entities do not have to consist of a single element; you can make a sequence of three paragraphs, or even a bunch of character data with embedded inline markup into an external entity. But the tags in an external entity must be well balanced (you can't start a tag in an entity and end it in your document or in another entity).

• External entities can reference internal or other external entities, but you cannot have circular references.

• You can refer to the same external entity several times in a single document. Note, however, that if you do this, you will have to avoid using ID attributes in the external entity if you're concerned about validity. Using an external entity which contains an ID in more than one location in your document will produce a document that has multiple, duplicate IDs which is a validity error.

• It is legal to have several external entities that all refer to the same external file.

• There are no additional restrictions placed on the character encodings used by external entities. In particular, external entities with differing encodings can be used in the same document.

External entities, like internal entities, have names and are referenced in the same manner, although they are declared differently.

Parameter Entities

Internal and external entity references are not expanded in the DTD or the internal subset (this allows you to use entity references in the replacement text of other entities without concern about the order of declarations). If you want to have the effect of entities and entity references in your DTD, parameter entities must be used. Parameter entity references use the "%" character instead of the "&". Parameter entities can't be used in the content of your document; they simply aren't recognized.

It is legal to have a parameter entity and an internal or external entity with the same name. They are completely different types of entities and cannot conflict with each other.

One common use of parameter entities is in conditional sections. Conditional sections are a mechanism for parameterizing the DTD. Note, however, that you cannot use conditional sections in the internal subset of XML documents.

Readers Pick: 16 Sites for Web Design Inspiration

20 Websites To Help You Learn and Master CSS