1.Dictionary本身是不支持序列化的，所以必须继承IXmlSerializable.

2.使用StringWriter进行最终String的转换工作，使用MemoryStream进行String输出，还是有异常报错。如：“十六进制Error!”

案例代码如下：

Step 1: Create Class ,Name Call SerializableDictionary

Step 2: Create Entity,Call Enity

Step 3:Ready Demo Data

Step 4:Coding Serializer and Deserialize For Dictionary

Step 5:WebService and AnyWhere ,Apply to this Case

Step 6: Output Results

参考资源：

http://www.mattberther.com/2004/06/14/serializing-an-idictionary-object/

http://sholliday.spaces.live.com/Blog/cns!A68482B9628A842A!114.entry

　　值得注意的是，今年3月1日个税起征点刚刚从每月1600元调至2000元，在短短不到半年的时间内，个税起征点是否有必要再次大幅上调？答案是肯定的。

　　在国内通胀压力加大的情况下，无论百姓个人还是国内企业都已经感受到了很大的压力。数据显示，6月份CPI同比上涨7.1%，连续两个月出现回落，但考虑到上游工业品价格高企，其传导效应无法让人对通胀的前景掉以轻心。在企业层面，“中国制造”也不堪重负，发出了“SOS”的求救信号。

　　汪康懋分析认为，此前提升企业员工工资标准的政策出台虽然在一定层面上解决了提高居民收入的问题，但由此引发的成本增加却是一些中小企业难以承受的；再加上人民币升值和部分商品出口退税政策取消等因素的影响，这些中小企业的生存空间被进一步压缩。

　　与企业加工资和“发红包”相比，调高个税的起征点，“还富于民”，或许是一个更为两全其美的办法：一方面，中国中小企业可在与产品附加值更高、管理更为高效的国外企业竞争中继续保持人力成本方面的优势，保持“中国制造”在国际舞台之中的竞争力；另一方面，百姓也将在新的税收政策下得到实惠，切实分享到中国经济发展的成果。何况，国家税务总局原副局长许善达也曾表示，“个税起征点还有上升空间。”

　　此外，业内另有评论认为，国库储备过于丰厚也许并不能发挥其应有的作用，反而因受到汇率波动等因素的影响，面临资产“蒸发”的风险。如以我国已经达到1.8万亿美元规模的外汇储备为例，记者经初步估算后发现，假设外汇储备都以美元的形式进行配置，那么从今年1月2日美元兑人民币中间价7.2996到7月24日中间价6.8297期间，美元兑人民币中间价年内跌幅将近6.44%，外汇储备的“蒸发规模”也将达到1158.72亿美元之巨。

颜色注释： SQL LinqToSql Lambda QA

1、 查询Student表中的所有记录的Sname、Ssex和Class列。
select sname,ssex,class from student
Linq:
    from s in Students
    select new {
        s.SNAME,
        s.SSEX,
        s.CLASS
    }
Lambda:
    Students.Select( s => new {
        SNAME = s.SNAME,SSEX = s.SSEX,CLASS = s.CLASS
    })

2、 查询教师所有的单位即不重复的Depart列。
select distinct depart from teacher
Linq:
    from t in Teachers.Distinct()
    select t.DEPART
Lambda:
    Teachers.Distinct().Select( t => t.DEPART)

3、 查询Student表的所有记录。
select * from student
Linq:
    from s in Students
    select s
Lambda:
    Students.Select( s => s)

4、 查询Score表中成绩在60到80之间的所有记录。
select * from score where degree between 60 and 80
Linq:
    from s in Scores
    where s.DEGREE >= 60 && s.DEGREE < 80
    select s
Lambda:
    Scores.Where(
        s => (
                s.DEGREE >= 60 && s.DEGREE < 80
             )
    )

5、 查询Score表中成绩为85，86或88的记录。
select * from score where degree in (85,86,88)
Linq:
In
    from s in Scores
    where (
            new decimal[]{85,86,88}
          ).Contains(s.DEGREE)
    select s
Lambda:
    Scores.Where( s => new Decimal[] {85,86,88}.Contains(s.DEGREE))
Not in
    from s in Scores
    where !(
            new decimal[]{85,86,88}
          ).Contains(s.DEGREE)
    select s
Lambda:
    Scores.Where( s => !(new Decimal[]{85,86,88}.Contains(s.DEGREE)))

    Any()应用：双表进行Any时，必须是主键为(String)
    CustomerDemographics CustomerTypeID（String）
    CustomerCustomerDemos (CustomerID CustomerTypeID) (String)
    一个主键与二个主建进行Any(或者是一对一关键进行Any)
    不可，以二个主键于与一个主键进行Any
   
    from e in CustomerDemographics
    where !e.CustomerCustomerDemos.Any()
    select e
   
    from c in Categories
    where !c.Products.Any()
    select c

6、 查询Student表中"95031"班或性别为"女"的同学记录。
select * from student where class ='95031' or ssex= N'女'
Linq:
    from s in Students
    where s.CLASS == "95031"
       || s.CLASS == "女"
    select s
Lambda:
    Students.Where(s => ( s.CLASS == "95031" || s.CLASS == "女"))

7、 以Class降序查询Student表的所有记录。
select * from student order by Class DESC
Linq:
    from s in Students
    orderby s.CLASS descending
    select s
Lambda:
    Students.OrderByDescending(s => s.CLASS)

8、 以Cno升序、Degree降序查询Score表的所有记录。
select * from score order by Cno ASC,Degree DESC
Linq:(这里Cno ASC在linq中要写在最外面)
    from s in Scores
    orderby s.DEGREE descending
    orderby s.CNO ascending
    select s
Lambda:
    Scores.OrderByDescending( s => s.DEGREE)
          .OrderBy( s => s.CNO)

9、 查询"95031"班的学生人数。
select count(*) from student where class = '95031'
Linq:
    (    from s in Students
        where s.CLASS == "95031"
        select s
    ).Count()
Lambda:
    Students.Where( s => s.CLASS == "95031" )
                .Select( s => s)
                    .Count()

10、查询Score表中的最高分的学生学号和课程号。
select distinct s.Sno,c.Cno from student as s,course as c ,score as sc
where s.sno=(select sno from score where degree = (select max(degree) from score))
and c.cno = (select cno from score where degree = (select max(degree) from score))
Linq:
    (
        from s in Students
        from c in Courses
        from sc in Scores
        let maxDegree = (from sss in Scores
                        select sss.DEGREE
                        ).Max()
        let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).Single().ToString()
        let cno = (from ssss in Scores
                where ssss.DEGREE == maxDegree
                select ssss.CNO).Single().ToString()
        where s.SNO == sno && c.CNO == cno
        select new {
            s.SNO,
            c.CNO
        }
    ).Distinct()
操作时问题？执行时报错： where s.SNO == sno（这行报出来的） 运算符"=="无法应用于"string"和"System.Linq.IQueryable<string>"类型的操作数
解决：
原：let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).ToString()
Queryable().Single()返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常。
解：let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).Single().ToString()

11、查询'3-105'号课程的平均分。
select avg(degree) from score where cno = '3-105'
Linq:
    (
        from s in Scores
        where s.CNO == "3-105"
        select s.DEGREE
    ).Average()
Lambda:
    Scores.Where( s => s.CNO == "3-105")
            .Select( s => s.DEGREE)
                .Average()

12、查询Score表中至少有5名学生选修的并以3开头的课程的平均分数。
select avg(degree) from score where cno like '3%' group by Cno having count(*)>=5
Linq:
        from s in Scores
        where s.CNO.StartsWith("3")
        group s by s.CNO
        into cc
        where cc.Count() >= 5
        select cc.Average( c => c.DEGREE)
Lambda:
    Scores.Where( s => s.CNO.StartsWith("3") )
            .GroupBy( s => s.CNO )
              .Where( cc => ( cc.Count() >= 5) )
                .Select( cc => cc.Average( c => c.DEGREE) )
Linq: SqlMethod
like也可以这样写:
    s.CNO.StartsWith("3") or SqlMethods.Like(s.CNO,"%3")

13、查询最低分大于70，最高分小于90的Sno列。
select sno from score group by sno having min(degree) > 70 and max(degree) < 90
Linq:
    from s in Scores
    group s by s.SNO
    into ss
    where ss.Min(cc => cc.DEGREE) > 70 && ss.Max( cc => cc.DEGREE) < 90
    select new
    {
        sno = ss.Key
    }
Lambda:
    Scores.GroupBy (s => s.SNO)
               .Where (ss => ((ss.Min (cc => cc.DEGREE) > 70) && (ss.Max (cc => cc.DEGREE) < 90)))
                   .Select ( ss => new {
                                        sno = ss.Key
                                     })

14、查询所有学生的Sname、Cno和Degree列。
select s.sname,sc.cno,sc.degree from student as s,score as sc where s.sno = sc.sno
Linq:
    from s in Students
    join sc in Scores
    on s.SNO equals sc.SNO
    select new
    {
        s.SNAME,
        sc.CNO,
        sc.DEGREE
    }
Lambda:
    Students.Join(Scores, s => s.SNO,
                          sc => sc.SNO,
                          (s,sc) => new{
                                              SNAME = s.SNAME,
                                            CNO = sc.CNO,
                                            DEGREE = sc.DEGREE
                                          })

15、查询所有学生的Sno、Cname和Degree列。
select sc.sno,c.cname,sc.degree from course as c,score as sc where c.cno = sc.cno
Linq:
    from c in Courses
    join sc in Scores
    on c.CNO equals sc.CNO
    select new
    {
        sc.SNO,c.CNAME,sc.DEGREE
    }
Lambda:
    Courses.Join ( Scores, c => c.CNO,
                             sc => sc.CNO,
                             (c, sc) => new 
                                        {
                                            SNO = sc.SNO,
                                            CNAME = c.CNAME,
                                            DEGREE = sc.DEGREE
                                        })

16、查询所有学生的Sname、Cname和Degree列。
select s.sname,c.cname,sc.degree from student as s,course as c,score as sc where s.sno = sc.sno and c.cno = sc.cno
Linq:
    from s in Students
    from c in Courses
    from sc in Scores
    where s.SNO == sc.SNO && c.CNO == sc.CNO
    select new { s.SNAME,c.CNAME,sc.DEGREE }

/未完待续。。（一共43个）

1.WCF与DataService在一起使用，合适吗？

2.DataService身份验证的Exception?

1.WCF与DataService在一起使用，合适吗？

创建DataService时，会在web.config中自动配置一项：

       <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />

当WCF与DataService共存时，噢，不好的现象发生；看这张图，是什么，无好激活服务，

噢，不.不.不.WCF无法正常运行了；

为什么？就是因为上面这个配置项造成的吗？

    其实WCF 服务在 IIS 中可以与 ASP.NET 并行承载，也可以承载于兼容模式下。默认配置是与 ASP.NET 并行承载。

WCF 服务的请求由 ASP.NET 运行时接收，但它不参与这些请求的处理。在工作进程内，WCF 运行时会检测传入请求并通过 WCF 堆栈对其进行处理。

当 ASP.NET 和 WCF 并行工作时，有一些副作用需要引起注意。例如，您无法定义对 SVC 资源的访问控制列表，而且在此上下文中更为重要的是，当您从 WCF 服务内部进行访问时，HttpContext.Current 属性会始终返回 null。因此，对于 WCF 服务来说，无法获取任何有关 ASP.NET 登录用户的信息。

    通常，WCF 模型被设计为既适用于承载环境，又适用于传输机制。但是，要满足 AJAX 服务层中对安全的要求，WCF 与承载 ASP.NET 环境之间必须实施更为严格的协作。这正是 WCF 的 ASP.NET 兼容模式要解决的问题。

    在兼容模式下运行时，WCF 服务全面介入 ASP.NET 请求的生命周期。产生的实际效果是 WCF 服务有权访问与 ASMX Web 服务相同的信息。这将使基于文件的授权得到支持，而且更为重要的是，HttpContext.Current 得到了正确的设置。

兼容模式是在应用程序级启用的全局设置。但各项服务可以拒绝或接受此模式。要开启兼容模式，需要在配置文件中输入以下片段：

<system.serviceModel>
<serviceHostingEnvironment aspNetCompatibilityEnabled="true" />
</system.serviceModel>

各项服务通过 AspNetCompatibilityRequirements 属性的 RequirementsMode 属性（将针对服务类而不是约定进行设置）来声明它对兼容模式的支持。该属性的值为 Required、Allowed 和 NotAllowed。默认值为 NotAllowed，这意味着服务层中的每项 WCF 服务都必须将 RequirementsMode 属性改为 Allowed 或 Required。

看到这里知道，原来如此。代码如何做呢？：）

[AspNetCompatibilityRequirements(
RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]
public class Service : IService
{
。。。。
}

看看结果，哎哟。不错不错
 

讲了不半天，有关于合适的话题好像还有没有，嗯？!谁知道，谁跟贴：）

2.DataService身份验证的Exception?

异常，噢，又是一个异常，一个黄页。。

其实解决很简单，三步走

Listen To Me

Step 1: Ctrl+R then Input Inetmgr

Step 2: unChecked anonymous visit

Step 3: return current project and Redo Create Virtual Directory(this Step is important .Remember it)

Step 2

Step3

噢，看看这是什么，结果出来，服务O了。睡觉了。：）

<ListBox Margin="0,40,0,0" Grid.Row="1">

        <ListBox.ItemTemplate>

              <DataTemplate/>

        </ListBox.ItemTemplate>

</ListBox>

有人问我：以上这段代码使用Blend 2.0在设计界面，如何设置出来？

这是需要费点事的。我在此把图贴出来，如果你也遇到的问题，你也可以参考一下吗？

Step 1.选中ListBox,在属性----杂项---ItemTemplate

Step 2.选择数据绑定

Step 3.添加CLR对象，创建DataTemplate

Step 4.已经有代码生成看出来 ItemTemplate="{Binding Mode=OneWay ....}"

Step 5.再次选择ItemTemplate，选择转换为本地值

Step 6.OK,Over

（当然对于开发人员肯定不会这样周折的！,那如果你不是开发人员呢？）

不过我在使用Blend做界面，还是感觉有时不如直接写代码快啊。

     Enumerable 是 .NET FX 3.5 System.Linq 中新增的类型，实现了大量 IEnumerable<T> 扩展方法， 所有直接或间接实现该接口的类型都可以使用 Linq to Object 语法； 而 Queryable 则针对 IQueryable<T> 扩展，主要用于 DLinq 的操作，IQueryable<T> 继承自 IEnumerable<T>。

提供对未指定数据类型的特定数据源的查询进行计算的功能。 IQueryable 接口由查询提供程序实现。 该接口只能由同时实现 IQueryable<(Of <(T>)>) 的提供程序实现。 如果该提供程序不实现 IQueryable<(Of <(T>)>)，则无法对提供程序数据源使用标准查询运算符。 IQueryable 接口继承 IEnumerable 接口，以便在前者表示一个查询时可以枚举该查询的结果。 枚举强制执行与 IQueryable 对象关联的表达式目录树。 “执行表达式目录树”的定义是查询提供程序所特有的。

例如，它可能涉及将表达式目录树转换为适用于基础数据源的查询语言。

在调用 Execute 方法时将执行不返回可枚举结果的查询。

IEnumerable和IQueryable的区别：

    In one of our current projects we're using LINQ TO SQL to conquer the object-relational impedance mismatch. We all had some experience with LINQ and deferred execution. But it was getting obvious that we all needed to deeply internalize the difference between IEnumerable and IQueryable. 
    EntitySet<T> and Table<T> both implement the IEnumerable<T> interface. However, if there would not be IQueryable all querying functionality - including filtering and sorting - would be executed on the client. To optimize a query for a specific data source we need a way to analyze a query and its definition. That’s where expression trees are coming in. As we know an expression tree represents the logical definition of a method call which can be manipulated and transformed. 
    So we have a mutable logical definition of our query on one side and a queryable data source on the other. The Property Provider on IQueryable now returns an IQueryProvider which is exactly what we need here. 

Code
public interface IQueryProvider { 
  IQueryable CreateQuery(Expression expression); 
  IQueryable<TElement> CreateQuery<TElement>(Expression expression); 
  object Execute(Expression expression); 
  TResult Execute<TResult>(Expression expression); 
} 

      There are 2 interesting operations and their generic counterparts. The generic versions are used most of the time and they perform better because we can avoid using reflection for object instantiation. CreateQuery() does precisely what we are looking for. It takes an expression tree as argument and returns another IQueryable based on the logical definition of the tree. When the returned IQueryable is enumerated it will invoke the query provider which will then process this specific query expression. 
    The Execute() method now is used to actually executing your query expression. This explicit entry point – instead of just relying on IEnumerator.GetEnumerator() – allows executing ET’s which do not necessarily yield sequences of elements. (For example aggregate functions like count or sum.) 
    We finally have our two worlds nicely connected together. The mutability of ET and the deferred execution of IEnumerable combined to a construct that can analyze an arbitrary mutated and extended query at the last possible moment and execute an optimized query against its data source. It’s not even too hard to implement your own IQueryProvider for your own data source. Maybe I’ll cover that in a later post. This is really nice work Eric Meijer and his team has done here.

     明白了以两者的区别和概念之后，下面再来以直观的代码方式看看有关于LINQ Set操作几个扩展方法 

LINQ Coding 目录

More Linq Coding

建议用1680*1050分辩浏览

    结果调用 DefaultIfEmpty 来执行左外部联接。

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public void LeftOuterJoinExample()
{
    Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
    Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
    Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
    Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };

    Pet barley = new Pet { Name = "Barley", Owner = terry };
    Pet boots = new Pet { Name = "Boots", Owner = terry };
    Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
    Pet bluemoon = new Pet { Name = "Blue Moon", Owner = terry };
    Pet daisy = new Pet { Name = "Daisy", Owner = magnus };

    // Create two lists.
    List<Person>