博客园_小庄

Lync 2010 标准版安装注意事项

2011-08-23T09:51:00Z

今天在虚机机上安装了Lync2010的标准版，用来进行Lync 2010 SDK的相关开发，主要参考风之羽翼的文章：http://fengxja.blog.51cto.com/1410070/d-3，一步一步照着做就可以了；但在安装过程中也碰到了几个问题，记录如下：

1、在Lync服务器上安装Web服务器（IIS）角色的时候到底要勾选那些功能（不用命令的情况下）？这里http://technet.microsoft.com/zh-cn/library/gg398321.aspx有个列表，照着勾选就可以了。

角色服务	功能
常见的 HTTP 功能	HTTP 重定向
应用程序开发	ASP.NET
应用程序开发	.NET 扩展性
应用程序开发	ISAPI 扩展
应用程序开发	ISAPI 筛选器
运行状况和诊断	日志记录工具
运行状况和诊断	跟踪
安全性	基本身份验证
安全性	Windows 身份验证
管理工具	IIS 管理脚本和工具
管理工具	IIS 6 管理兼容性

2、注意要手工设置share文件夹为共享，不然发布架构的时候会报错，可设置成共享后重新发布架构。

3、如果系统是2008r2+sp1,在安装或删除Lync Server组件环节会出错，提示Wmf2008R2组件安装失败，需要以管理员身份在cmd中运行如下命令：

%systemroot%\system32\dism.exe /online /add-package /packagepath:%windir%\servicing\Packages\Microsoft-Windows-Media-Format-Package~31bf3856ad364e35~amd64~~6.1.7601.17514.mum /ignorecheck

请参考：http://zhengyu213.blog.51cto.com/2774511/516896

本文链接

[Silverlight]用Prism打造自己的程序开发架构

2011-07-25T09:54:00Z

大家都知道Prism自带的StockTraderRI的例子，这个例子给我们展示了由不同的功能模块（包括里面的页面）组合成主界面（shell）的方法；我当初看到这个例子总觉得怪怪的，原因是我的项目经验中基本没有出现过这样的需求，而出现最多的是“在主界面中显示（调用）不同的模块中的页面”：例如我在主界面有个菜单，如图：

1、我想在点击某个菜单项的时候将某个模块中的某个页面显示在主界面菜单下面的的内容区，而且要有显示的动画效果，如图：

这个动画效果不太好截图，其实是通过向左滑动来切换页面，大家下载代码看看就明白了，
2、各个模块都要按需加载，模块加载过程中要有进度显示，如图：

3、全部采用MVVM设计。
我想可能也有其他人有过我这样的困惑，所以为了让大家少走弯路，少造轮子，就有了这篇随笔，让我们不再困惑于StockTraderRI的那个例子，实现更适合自己项目的程序开发框架。

我的项目结构如图：

PrismDemoMain是主Silverlight程序，PrismDemoMain.Web用来宿主主程序；
PrimDemoCommon是Silverlight类库，提供给主程序和各个模块项目用来引用（提供公共对象）。
Modules解决方案文件夹下面的两个项目ModuleA和ModuleB是分别对应两个模块ModuleA和ModuleB，例如ModuleA的对象代码如下：

using System;
using Microsoft.Practices.Prism.Modularity;
using Microsoft.Practices.Prism.MefExtensions.Modularity;
using System.ComponentModel.Composition;
using PrismDemoCommon;

namespace ModuleA
{
    [ModuleExport(typeof(ModuleA))]
    public class ModuleA : IModule
    {

        public void Initialize()
        {
            //throw new NotImplementedException();
        }
    }
}

by the way，我个人更喜欢用MEF，Prism中我也只用MEF的那个扩展，例如MefBootstrapper等，甚至有点讨厌unity那个，可能是代码洁癖的原因吧，其实整个程序都可以用MEF来管理对象的初始化，杜绝new object代码，可以参照我上一篇随笔中的代码。

ModuleA项目中包含两个文件夹Views和Viewmodels，这两个文件夹各放什么大家都知道；值得一提的是，我将Views中的各个View分成两类，一类是MainView，继承自IMainView接口，另一类则不用继承这个接口，MainView是用来显示在主界面内容区的View，继承自IMainView也是为了能在主界面内容区显示方便，而其他View则是被MainView调用的View。

ModuleA中的View1的代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.ComponentModel.Composition;
using ModuleA.ViewModels;
using PrismDemoCommon;

namespace ModuleA.Views
{
    [Export("ModuleA$View1", typeof(IMainView))]
    [PartCreationPolicy(CreationPolicy.Shared)]
    public partial class View1 : UserControl,IMainView
    {
        [ImportingConstructor]
        public View1(ViewModel1 viewModel)
        {
            InitializeComponent();
            this.DataContext = viewModel;
        }


    }
}

看一下模块ModulesCatalog.xaml文件，很简单。

<Modularity:ModuleCatalog xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:sys="clr-namespace:System;assembly=mscorlib"
                          xmlns:Modularity="clr-namespace:Microsoft.Practices.Prism.Modularity;assembly=Microsoft.Practices.Prism">
    
    <Modularity:ModuleInfo Ref="ModuleA.xap" ModuleName="ModuleA" ModuleType="ModuleA.ModuleA, ModuleA" InitializationMode="OnDemand" />
    <Modularity:ModuleInfo Ref="ModuleB.xap" ModuleName="ModuleB" ModuleType="ModuleB.ModuleB, ModuleB" InitializationMode="OnDemand" />
</Modularity:ModuleCatalog>

PrismDemoMain主程序中有个MainPageModule的文件夹，其实里面也是一个Prism的模块，是该程序真正的主界面实现，采用View注入到shell中，shell中就一行代码：

这样做的好处是，假如我对这个主界面不满意，我可以方便的用其他的MainPageModule来替换这个，甚至可以做成多个主界面供用户选择。
载入模块，显示页面，动画效果等都是在这个模块完成的，例如点击菜单显示切换视图的代码如下：

private void ShowCurrentMainView()
        {
            //取得当前主视图的实例
            IMainView mainView = ServiceLocator.Current.GetInstance<IMainView>(currentMainViewName);
            if (mainView != null)
            {
                eventAggregator.GetEvent<ShowMainViewEvent>().Publish(mainView);
            }
        }

        private void ActiveView(object obj)
        {
            string mainViewName = obj.ToString();
            //如果当前视图就是要激活的视图，则返回
            if (currentMainViewName == mainViewName) return;
            currentMainViewName = mainViewName;
            //获取激活该视图需要的模块名称。
            string moduleName = currentMainViewName.Substring(0, currentMainViewName.IndexOf("$"));
            //初始化ModuleManager，加载事件等
            InitializeModuleManager();
            //根据模块名取得模块信息
            ModuleCatalog moduleCatalog = ServiceLocator.Current.GetInstance<ModuleCatalog>();
            if (moduleCatalog == null) return;
            ModuleInfo moduleInfo = moduleCatalog.Modules.FirstOrDefault(p => p.ModuleName == moduleName);
            if (moduleInfo == null) return;
            //判断模块是否已经初始化
            if (moduleInfo.State == ModuleState.Initialized)
            {
                //显示当前主视图
                ShowCurrentMainView();
            }
            else if (moduleManager != null)
            {
                moduleManager.LoadModule(moduleName);
            }
        }

引发显示主视图的事件，并动画显示主视图，请参考源代码。

本文链接

[Silverlight]WCF RIA Services+Mef+MVVM实现CRUD(增删改查)示例

2011-05-30T04:51:00Z

做这个示例的目的是为了给学习Silverlight的童鞋一些参考，并希望和大家讨论相关的一些问题，让这个示例更完善。
示例功能说明：实现了雇员的增删改查，雇员表（Employee）和部门表（Department）、雇员类型表（EmployeeType）有外键关联，并和字典表（DataDict）有字典关系

示例参考说明：主要参考了Codeproject上的http://www.codeproject.com/KB/silverlight/IssueVisionForSilverlight.aspx中的相关文章和代码。
示例采用技术说明：
1、采用了WCF RIA Services来和服务器端传输数据，具体来说就是Silverlight项目类型中的WCF RIA Services 类库项目，因为这个更快捷。
2、采用了MVVM设计模式来实现UI元素也UI界面逻辑分离，这个的好处地球人都知道。
3、采用了MEF来对Model和ViewModel、ViewModel和View之间的相互依赖进行解耦。
4、采用了Prism中的部分工具，例如采用CompositePresentationEvent来实现View和ViewModel，ViewModel和ViewModel之间的事件传递，采用NotificationObject作为ViewModel的基类，采用Prism自带的DelegateCommand。
示例项目结构说明：

1、RIAServicesLibrary 解决方案文件夹中是WCF RIA Services的两个项目,服务器端项目RIAServicesLibrary.Web为客户端提供DomainService，来实现实体的增删改查，客户

端项目RIAServicesLibrary通过RiA数据服务链接调用RIAServicesLibrary.Web，实现MVVM中的Models层，并对服务端传递过来的实体进行扩展。
2、SLWCFRIADemo主项目提供员工增删改查操作的所有相关View和ViewModel。
3、SLWCFRIADemo.Common项目顾名思义是公共层，被RIAServicesLibrary和SLWCFRIADemo引用。

在做这个Demo的过程中遇到的一些问题和解决办法：
1、怎样在Datagrid的行上触发ViewModel中的Command？
因Datagrid的ItemsSource指向ViewModel员工集合的属性，而编辑和删除Command是定义在ViewModel中的，所以在Datagrid中直接绑定编辑和删除Command是不起作用的，经查询

Google得出如下解决办法：
首先定义一个类DataContextProxy，故名思意是DataContext的代理类，代码如下：

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

namespace SLWCFRIADemo.Controls
{
public class DataContextProxy : FrameworkElement
{
public DataContextProxy()
{
this.Loaded += new RoutedEventHandler(DataContextProxy_Loaded);
}

void DataContextProxy_Loaded(object sender, RoutedEventArgs e)
{
Binding binding = new Binding();
if (!String.IsNullOrEmpty(BindingPropertyName))
{
binding.Path = new PropertyPath(BindingPropertyName);
}
binding.Source = this.DataContext;
binding.Mode = BindingMode;
this.SetBinding(DataContextProxy.DataSourceProperty, binding);
}

public Object DataSource
{
get { return (Object)GetValue(DataSourceProperty); }
set { SetValue(DataSourceProperty, value); }
}

public static readonly DependencyProperty DataSourceProperty =
DependencyProperty.Register("DataSource", typeof(Object), typeof(DataContextProxy), null);

public string BindingPropertyName { get; set; }

public BindingMode BindingMode { get; set; }

}

}

再在页面中引用这个代理类

xmlns:my="clr-namespace:SLWCFRIADemo.Controls"

并修改相关代码如下：

<sdk:DataGridTemplateColumn Header="修改 \ 删除" Width="100">
                                                    <sdk:DataGridTemplateColumn.CellTemplate>
                                                        <DataTemplate>
                                                            <StackPanel Orientation="Horizontal" HorizontalAlignment="Stretch">
                                                                <HyperlinkButton Margin="5"  Content="修改" Command="{Binding Source={StaticResource DataContextProxy},Path=DataSource.ModifyCommand}"/>
                                                                <HyperlinkButton Margin="5" Content="删除" Command="{Binding Source={StaticResource DataContextProxy},Path=DataSource.DeleteCommand}"/>
                                                            </StackPanel>
                                                        </DataTemplate>
                                                    </sdk:DataGridTemplateColumn.CellTemplate>
                                                </sdk:DataGridTemplateColumn>

搞定！
2、采用WCF RIA Services怎么处理字典表的问题。
因雇员表和字典表无外键关系，要在DataGrid中显示雇员的性别，不能直接绑定字典表实体，需要在雇员实体中做如下扩展（该扩展在RIAServicesLibrary项目）：

  private EntityRef<DataDict> employeeSexDict;
         [Association("EmployeeSex_DataDict", "EmployeeSex", "DictValue", IsForeignKey = false)]
        public DataDict EmployeeSexDict
        {
            get
            {
                if ((this.employeeSexDict == null))
                {
                    this.employeeSexDict = new EntityRef<DataDict>(this, "EmployeeSexDict", this.FilterEmployeeSexDict);
                }
                return this.employeeSexDict.Entity;
            }
            set
            {
                DataDict previous = this.EmployeeSexDict;
                if ((previous != value))
                {
                    this.ValidateProperty("EmployeeSexDict", value);
                    if ((previous != null))
                    {
                        this.employeeSexDict.Entity = null;
                    }
                    if ((value != null))
                    {
                        this.EmployeeSex = value.DictValue;
                    }
                    else
                    {
                        this.EmployeeSex = default(int);
                    }
                    this.employeeSexDict.Entity = value;
                    this.RaisePropertyChanged("EmployeeSexDict");
                }
            }
        }
        private bool FilterEmployeeSexDict(DataDict entity)
        {
            if (this.EmployeeSex.HasValue)
                return (entity.DictValue == this.EmployeeSex.Value);
            else
                return false;
        }

这样就可以直接绑定字典表实体了。
大家对这个示例有什么问题或意见？

更新（2011-05-31）：根据Mainz的这篇http://www.cnblogs.com/Mainz/archive/2011/05/27/2059940.html，对代码进行了修改，将查找和分页放在了服务器端，Mainz的代码有点小Bug，我进行了改正，具体请参照最新代码。

本文链接

WCF自定义授权

2010-11-25T02:35:00Z

以前写过一篇WCF自定义用户名密码认证，用户必须输入正确的用户名和密码才能调用WCF服务提供的操作契约（OperationContract），但没有限制某个用户可调用契约的范围，即默认每个用户都可调用该服务下的所有契约，WCF自定义授权用来为用户授权特定的操作契约，并在用户调用的时候对用户的授权进行验证，只有通过验证的用户才可调用该契约，这中将权限控制在OperationContract层次对企业级应用来说是必要的。
要实现WCF自定义授权必须先实现自定义用户名密码认证，要不然WCF怎么知道调用者是谁？因上次写的那个自定义用户名密码认证示例实在年代久远了，这次用VS2010重新写了个，并将WCF自定义授权加了进去，示例代码在评论一楼下载，先看下运行效果：

该服务共有三个操作契约（Operation001、Operation002、Operation003），用两个不用的用户（xiaozhuang001、xiaozhuang002）调用，xiaozhuang001具有调用Operation001和Operation003的权限，xiaozhuang002具有调用Operation002和Operation003的权限。
解决方案结构如图

由三个项目组成，MyWcfCustomAuthorization是WCF Service Library，MyWcfCustomAuthorizationServer控制台项目用来为MyWcfCustomAuthorization项目提供宿主，MyWcfCustomAuthorizationClient用来调用WCF服务契约。
MyWcfCustomAuthorization下面的的Security目录下分为四个文件：
1、DataProvider.cs顾名思义数据供应器
2、CustomUserNameValidator.cs实现自定义用户名密码认证功能
3、CustomAuthorizationPolicy.cs为用户授权操作契约
4、CustomServiceAuthorizationManager.cs对用户要调用的操作契约进行权限验证。
CustomAuthorizationPolicy.cs主要代码如下：

public class CustomAuthorizationPolicy : IAuthorizationPolicy
    {
        string id;

        public CustomAuthorizationPolicy()
        {
            id = Guid.NewGuid().ToString();
        }

        public bool Evaluate(EvaluationContext evaluationContext, ref object state)
        {
            bool bRet = false;
            CustomAuthState customstate = null;

            // If the state is null, then this has not been called before so
            // set up a custom state.
            if (state == null)
            {
                customstate = new CustomAuthState();
                state = customstate;
            }
            else
                customstate = (CustomAuthState)state;

            // If claims have not been added yet...
            if (!customstate.ClaimsAdded)
            {
                // Create an empty list of claims.
                IList<Claim> claims = new List<Claim>();

                // Iterate through each of the claim sets in the evaluation context.
                foreach (ClaimSet cs in evaluationContext.ClaimSets)
                    // Look for Name claims in the current claimset.
                    foreach (Claim c in cs.FindClaims(ClaimTypes.Name, Rights.PossessProperty))
                    {
                        // Get the list of operations the given username is allowed to call.
                        foreach (Right right in DataProvider.GetUserRightList(c.Resource.ToString()))
                        {
                            Console.WriteLine("正在给用户（" + c.Resource + "）赋权限：" + right.OperationName);
                            claims.Add(new Claim(DataProvider.ClaimType,right.OperationName, Rights.PossessProperty));
                            //Console.WriteLine("Claim added {0}", s);
                        }
                    }

                // Add claims to the evaluation context.
                evaluationContext.AddClaimSet(this, new DefaultClaimSet(this.Issuer, claims));

                // Record that claims were added.
                customstate.ClaimsAdded = true;

                // Return true, indicating that this method does not need to be called again.
                bRet = true;
            }
            else
            {
                // Should never get here, but just in case, return true.
                bRet = true;
            }

            return bRet;
        }

        public ClaimSet Issuer
        {
            get { return ClaimSet.System; }
        }

        public string Id
        {
            get { return id; }
        }

        // Internal class for keeping track of state.
        class CustomAuthState
        {
            bool bClaimsAdded;

            public CustomAuthState()
            {
                bClaimsAdded = false;
            }

            public bool ClaimsAdded
            {
                get { return bClaimsAdded; }
                set { bClaimsAdded = value; }
            }
        }
    }

从求值上下（EvaluationContext）文中找到用户名，根据用户名从DataProvider中取得该用户的操作契约集合，转换为权限集合，并将该用户的权限集合加入到求值上下文中,上面的代码大部分都是MSDN上的，但我调试发现：虽然代码中判断了如果已经增加过权限则再不增加的逻辑，但这个似乎没有作用，因为CustomAuthorizationPolicy这个对象的生存期只是在调用操作契约的过程中，所以每次调用契约都要创建实例，所以导致 if (state == null)这句的state永远都是空的，也就是每次调用都要增加一遍权限，这是个大问题，要是在这个类里面读数据库来获取用户权限的话会形成巨大的性能瓶颈，所以大家千万不要这么做。
CustomServiceAuthorizationManager.cs的主要代码如下：

public class CustomServiceAuthorizationManager : ServiceAuthorizationManager
    {
        protected override bool CheckAccessCore(OperationContext operationContext)
        {
            // Extract the action URI from the OperationContext. Match this against the claims
            // in the AuthorizationContext.
            string action = operationContext.RequestContext.RequestMessage.Headers.Action;

            // Iterate through the various claim sets in the AuthorizationContext.
            foreach (ClaimSet cs in operationContext.ServiceSecurityContext.AuthorizationContext.ClaimSets)
            {
                // Examine only those claim sets issued by System.
                if (cs.Issuer == ClaimSet.System)
                {
                    // Iterate through claims of type.
                    foreach (Claim c in cs.FindClaims(DataProvider.ClaimType, Rights.PossessProperty))
                    {
                        // If the Claim resource matches the action URI then return true to allow access.
                        Console.WriteLine("正在比较权限：" + action + "和" + c.Resource.ToString());
                        if (action == c.Resource.ToString())
                            return true;
                    }
                }
            }

            // If this point is reached, return false to deny access.
            return false;
        }

    }

从当前请求上下文中取得用户的操作契约，并和当前用户的权限集合中的操作契约对比，如果有相同的则说明该用户有调用该契约的权限。
配置文件部分

<system.serviceModel>
        <behaviors>
          <serviceBehaviors>
            <behavior>
              
              <serviceMetadata httpGetEnabled="true"/>
              
              <serviceDebug includeExceptionDetailInFaults="true"/>
              <serviceCredentials>
                <serviceCertificate findValue="xiaozhuang-PC" x509FindType="FindBySubjectName" storeLocation="LocalMachine" storeName="My"/>
                <userNameAuthentication userNamePasswordValidationMode="Custom" customUserNamePasswordValidatorType="MyWcfCustomAuthorization.Security.CustomUserNameValidator,MyWcfCustomAuthorization"/>
              </serviceCredentials>
              <serviceAuthorization serviceAuthorizationManagerType="MyWcfCustomAuthorization.Security.CustomServiceAuthorizationManager,MyWcfCustomAuthorization" >
                <authorizationPolicies>
                  <add policyType="MyWcfCustomAuthorization.Security.CustomAuthorizationPolicy,MyWcfCustomAuthorization"/>
                </authorizationPolicies>
              </serviceAuthorization>
            </behavior>
          </serviceBehaviors>
        </behaviors>
      <bindings>
        <wsHttpBinding>
          <binding>
            <security mode="Message">
              <message clientCredentialType="UserName"/>
            </security>
          </binding>
        </wsHttpBinding>
      </bindings>
        <services>
            <service name="MyWcfCustomAuthorization.TestService">
                <endpoint address="" binding="wsHttpBinding" contract="MyWcfCustomAuthorization.ITestService">
                    <identity>
                        <dns value="xiaozhuang-PC" />
                    </identity>
                </endpoint>
                <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
                <host>
                    <baseAddresses>
                        <add baseAddress="http://localhost:8000/MyWcfCustomAuthorization/TestService/" />
                    </baseAddresses>
                </host>
            </service>
        </services>
    </system.serviceModel>

采用了WCF4.0中简化的配置方式，在behavior节中增加服务认证部分和授权部分并，指定自定义用户名密码实现的类，自定义授权管理器实现的类和授权策略实现的类，在binding节中指定认证类型为userName。
服务端宿主的代码比较简单，客户端调用部分代码如下：

static void Main(string[] args)
        {
            TestServiceClient client = new TestServiceClient();
            client.ClientCredentials.UserName.UserName = "xiaozhuang001";
            client.ClientCredentials.UserName.Password = "xiaozhuang001";
            string returnStr = "";
            try
            {
                returnStr = client.Operation001();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang001调用Operation001结果:" + returnStr);

            try
            {
                returnStr = client.Operation002();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang001调用Operation002结果:" + returnStr);
            try
            {
                returnStr = client.Operation003();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang001调用Operation003结果:" + returnStr);

            //Console.WriteLine("xiaozhuang002：");
            TestServiceClient client1 = new TestServiceClient();
            client1.ClientCredentials.UserName.UserName = "xiaozhuang002";
            client1.ClientCredentials.UserName.Password = "xiaozhuang002";
            try
            {
                returnStr = client1.Operation001();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang002调用Operation001结果:" + returnStr);

            try
            {
                returnStr = client1.Operation002();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang002调用Operation002结果:" + returnStr);
            try
            {
                returnStr = client1.Operation003();
            }
            catch (Exception ex)
            {
                returnStr = ex.Message;
            }
            Console.WriteLine("用户xiaozhuang002调用Operation003结果:" + returnStr);

            Console.ReadKey();
        }

代码很简单，无需说明。
补充：在WCF的用户名密码认证那篇中我用了makecert.exe这个生成测试证书的命令，所以还要对应在客户端写绕过测试证书的代码，这次的不用了，在网上找了个工具SelfSSL (SelfSSL.exe) 可以帮助您生成和安装自签名 SSL 证书。有了这个工具，生成的证书就不会再报是未签名的了；并将这个工具封装成了一个Winform程序，大家运行代码时先要运行该程序安装好证书，并修改对应的配置文件部分才可以，主要是查找证书部分和DNS部分，要是你的电脑也叫xiaozhuang-PC就不用改了。
遗留问题：我用控制台宿主WCF类库，但为啥我在类库中写的Console.Write()啥的都在宿主程序中看不见呢？害得我用附加进程的方式调试，真麻烦，还望知道的朋友指点一下。

本文链接

Silverlight异步Socket通信

2010-07-15T07:30:00Z

真是撞衫了，本来写好个DEMO，打算今天发上来的，可是早上发现翁玉礼http://www.cnblogs.com/wengyuli/同学也发了一个，不过翁同学是用来实现视频聊天的，我是打算用来实现XMPP的；既然大家都对SOCKET这么有兴趣，就放上来一起研究。
先看下实现效果
服务端WPF：

多个用户连接服务端，服务端接收所有用户发过来的信息，也可以向指定的用户发送信息。
客户端Silverlight：

客户端向服务端发送信息，并接收服务端发过来的信息。
这个DEMO的代码参考了这个http://msdn.microsoft.com/zh-cn/magazine/dd315415.aspx，还是官方的代码信得过！Silverlight的客户端没的说，只能用异步Socket实现，WPF的服务端也采用了.net 3.5以后才出现的异步Socket，据说这样可以大大增强服务器端的处理能力。
项目结构如图：

分为三个项目：服务端，客户端和用来宿主SL的web项目，服务端打开两个端口，943和4530，943用来向Silverlight提供跨域文件，4530用来和Silverlight程序通信，我主要说说这个DEMO里面我觉得比较好的地方：
1、客户端和服务端全部采用异步Socket，而没有采用多线程实现，增强程序稳定性，增强程序处理能力，例如信息接收部分：

  public void ReceiveAsync()
        {
            ReceiveAsync(_receiveSocketArgs);
        }

        private void ReceiveAsync(SocketAsyncEventArgs socketAsyncEventArgs)
        {
            if (!_acceptedSocket.ReceiveAsync(socketAsyncEventArgs))
            {
                ReceiveCallback(_acceptedSocket, socketAsyncEventArgs);
            }
        }

        void ReceiveCallback(object sender, SocketAsyncEventArgs e)
        {
            if (e.SocketError != SocketError.Success)
            {
                return;
            }
            _receiveBuffer.Offset += e.BytesTransferred;
            if (_receiveBuffer.IsMessageReceived())
            {
                if (OnReceive != null)
                {
                    NetworkMessage msg = NetworkMessage.Deserialize(_receiveBuffer.Buffer);
                    _receiveBuffer.AdjustBuffer();
                    OnReceive(this, new ReceiveArgs(msg));
                }
            }
            else
            {
                //adjust the buffer pointer
                e.SetBuffer(_receiveBuffer.Offset, _receiveBuffer.Remaining);
            }
            //queue a an async read request
            ReceiveAsync(_receiveSocketArgs);
        }

2、这篇文章中http://www.cnblogs.com/yjmyzz/archive/2009/12/02/1615204.html说的粘包的现象，好像在这个DEMO中是没有的，不知道我说的对不对？还望高人指点。
这里将发送数据进行封包，序列化并转化为byte数组后再发送，接收端执行同样相反的拆包动作，将要发送的数据大小放在封包好的byte数组的前四位，接收端配合接收缓冲，用来判断包是否已经被完整收到。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;

namespace SilverlightSocketDemo.Server
{
    [XmlInclude(typeof(MyMessage))]
    public abstract class NetworkMessage
    {
        public static readonly int LENGTH_BYTES = 4;

        //first 4 bytes of the buffer will contain the length of the serialized NetworkMessage
        //this function treats input argument as immutable
        public static NetworkMessage Deserialize(byte[] buffer)
        {
            int length = BitConverter.ToInt32(buffer, 0);
            int startIndex = sizeof(int);
            string strNetworkMessage = Encoding.UTF8.GetString(buffer, startIndex, length);

            StringReader stringReader = new StringReader(strNetworkMessage);
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(NetworkMessage));
            return (NetworkMessage)xmlSerializer.Deserialize(stringReader);

        }

        //the first 4 bytes of the serialized byte array will contain the length of the buffer that
        //contains the previously serialized NetworkMessage;
        public static byte[] Serialize(NetworkMessage msg)
        {
            StringWriter stringWriter = new StringWriter();
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(NetworkMessage));
            xmlSerializer.Serialize(stringWriter, msg);
            byte[] messageBytes = Encoding.UTF8.GetBytes(stringWriter.ToString());
            byte[] lengthBytes = BitConverter.GetBytes(messageBytes.Length);
            byte[] finalBytes = new byte[lengthBytes.Length + messageBytes.Length];
            //copy the length of the serialized object
            Array.Copy(lengthBytes, 0, finalBytes, 0, lengthBytes.Length);
            Array.Copy(messageBytes, 0, finalBytes, lengthBytes.Length, BitConverter.ToInt32(lengthBytes, 0));
            return finalBytes;
        }

    }

    public class MyMessage : NetworkMessage
    {
        public string User { get; set; }
        public string Content { get; set; }
        public override string ToString()
        {
            return User+":"+Content;
        }
    }

    public class SocketBuffer
    {
        public const int BUFFERSIZE = 1024;
        protected byte[] _buffer;
        protected int _offset = 0;
        public SocketBuffer()
        {
            _buffer = new byte[BUFFERSIZE];
        }
        public SocketBuffer(int size)
        {
            _buffer = new byte[size];
        }
        public byte[] Buffer
        {
            get { return _buffer; }
            set { _buffer = value; }
        }
        //offset will allways indicate the length of the buffer that is filled
        public int Offset
        {
            get { return _offset; }
            set { _offset = value; }
        }

        public int Remaining
        {
            get { return _buffer.Length - _offset; }
        }
    }

    public class ReceiveBuffer : SocketBuffer
    {
        //removes a serlialized message from the buffer, copies the partial message to the begining
        //and adjusts the offset
        public void AdjustBuffer()
        {
            int messageSize = BitConverter.ToInt32(_buffer, 0);
            int lengthToCopy = _offset - NetworkMessage.LENGTH_BYTES - messageSize;
            Array.Copy(_buffer, _offset, _buffer, 0, lengthToCopy);
            _offset = lengthToCopy;
        }
        //this method checks if a complete message is received
        public bool IsMessageReceived()
        {
            if (_offset < 4)
                return false;
            int sizeToRecieve = BitConverter.ToInt32(_buffer, 0);
            //check if we have a complete NetworkMessage
            if ((_offset - 4) < sizeToRecieve)
                return false; //we have not received the complete message yet
            //we received the complete message and may be more
            return true;
        }
    }
}

本文链接

Silverlight4 MVVM和Command 示例

2010-07-12T08:37:00Z

看了圣殿骑士的WPF 基础到企业应用系列3——WPF开发漫谈，圣殿骑士提供了一个Winform和WPF程序实现方式对比的程序，其实WPF的实现方式和SilverLight是差不多的，本来想用Silverlight把WPF的实现方式复制过来就可以了，但好像也没啥意思，所以就加了些MVVM和Command Binding之类的东西，希望能给一些初学者提供一个参考，高手路过也顺便指点一下。

本文链接

Prism学习之SilverlightWindowRegionAdapter

2010-06-04T03:14:00Z

很多应用都需要多窗口支持，例如IM通讯工具，多窗口显示也能够提高的操作的灵活性，这个论据可以参考windows OS，但Silverlight中却没有内置提供多窗口显示支持，我们只能自己开发个“窗口”控件了，其实这样也好，省得还要去掉Windows窗口那些默认的显示效果；开发Silverlight或者WPF的人都喜欢用Prism来作为开发框架（Prism2.2发布了，全面支持Silverlight4 ）；本文讨论的是解决在Prism中使用多窗口的问题。

Prism是靠一堆统一管理的“Region”来动态显示模块界面的：先在需要显示界面的地方放个Region

然后在模块文件（继承自IModule）中

this.regionManager.Regions["MainRegion"].Add(view);

这样就可以把指定的模块显示在指定的区域当中了。
Prism提供了三种类型的Region，分别是ContentControl、ItemsControl、Selector，偏偏没有用来显示“多窗口”的，我就找啊找啊，终于在这个项目http://compositewpfcontrib.codeplex.com/ 中找到了一个WPF的WindowRegionAdapter，所以我就依葫芦画瓢，给弄出个Silverlight的WindowRegionAdapter。

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Practices.Composite.Regions;
using Microsoft.Practices.Composite.Presentation.Regions;
using System.Collections.Specialized;

namespace CompositeTest1.Common.Utilities
{
    public class SLWindowRegionAdapter : RegionAdapterBase<Grid>
    {
        public SLWindowRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory)
            : base(regionBehaviorFactory)
        { }

        protected override void Adapt(IRegion region, Grid regionTarget)
        {
        }

        protected override IRegion CreateRegion()
        {
            return new SingleActiveRegion();
        }
        protected override void AttachBehaviors(IRegion region, Grid regionTarget)
        {
            base.AttachBehaviors(region, regionTarget);
            WindowRegionBehavior behavior = new WindowRegionBehavior(regionTarget, region);
            behavior.Attach();
        }
    }
    public class WindowRegionBehavior
    {
        private readonly WeakReference _ownerWeakReference;
        private readonly WeakReference _regionWeakReference;

        public WindowRegionBehavior(Grid owner, IRegion region)
        {
            _ownerWeakReference = new WeakReference(owner);
            _regionWeakReference = new WeakReference(region);
        }

        public void Attach()
        {
            IRegion region = _regionWeakReference.Target as IRegion;
            if (region != null)
            {
                region.Views.CollectionChanged += new NotifyCollectionChangedEventHandler(Views_CollectionChanged);
                region.ActiveViews.CollectionChanged += new NotifyCollectionChangedEventHandler(ActiveViews_CollectionChanged);
            }
        }

        public void Detach()
        {
            IRegion region = _regionWeakReference.Target as IRegion;
            if (region != null)
            {
                region.Views.CollectionChanged -= Views_CollectionChanged;
                region.ActiveViews.CollectionChanged -= ActiveViews_CollectionChanged;
            }
        }

        void window_LostFocus(object sender, RoutedEventArgs e)
        {
            IRegion region = _regionWeakReference.Target as IRegion;
            System.Windows.Controls.Window window = sender as System.Windows.Controls.Window;
            if (window != null && region != null)
                if (region.Views.Contains(window.Content))
                    region.Deactivate(window.Content);
        }

        void window_GotFocus(object sender, RoutedEventArgs e)
        {
            IRegion region = _regionWeakReference.Target as IRegion;
            System.Windows.Controls.Window window = sender as System.Windows.Controls.Window;
            if (window != null && !region.ActiveViews.Contains(window.Content) && region.Views.Contains(window.Content))
                region.Activate(window.Content);
        }
        private void window_Closed(object sender, EventArgs e)
        {
            System.Windows.Controls.Window window = sender as System.Windows.Controls.Window;
            IRegion region = _regionWeakReference.Target as IRegion;

            if (window != null && region != null)
                if (region.Views.Contains(window.Content))
                    region.Remove(window.Content);
             Grid owner = _ownerWeakReference.Target as Grid;
             StackPanel spanel = owner.FindName("SLWindow") as StackPanel;
             if (spanel != null)
             {
                 Button btn = spanel.FindName(window.Name.ToString().TrimEnd('M')) as Button;
                 spanel.Children.Remove(btn);
             }
        }

        private void ActiveViews_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            Grid owner = _ownerWeakReference.Target as Grid;

            if (owner == null)
            {
                Detach();
                return;
            }

            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                foreach (object view in e.NewItems)
                {
                    System.Windows.Controls.Window window = GetContainerWindow(owner, view);
                    if (window != null)
                    {
                        window.Focus();
                    }
                }
            }
        }

        private void Views_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            Grid owner = _ownerWeakReference.Target as Grid;
            if (owner == null)
            {
                Detach();
                return;
            }
            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                foreach (object view in e.NewItems)
                {
                    System.Windows.Controls.Window window = new System.Windows.Controls.Window();
                    window.GotFocus += new RoutedEventHandler(window_GotFocus);
                    window.LostFocus += new RoutedEventHandler(window_LostFocus);
                    window.Closed += new EventHandler(window_Closed);
                    window.Content = view;


                    StackPanel spanel = owner.FindName("SLWindow") as StackPanel;
                    if (spanel != null)
                    {
                        int index = spanel.Children.Count + 1;
                        Button btn = new Button() { Name = "Window" + index, Content = "窗口" + index };
                        window.Name = "Window" + index+"M";
                        window.TitleContent = "窗口" + index;
                        btn.Tag = window;
                        btn.Click += new RoutedEventHandler(btn_Click);
                        spanel.Children.Add(btn);
                    }

                    window.Container = owner;
                    window.Show(DialogMode.Default);
                }
            }
            else if (e.Action == NotifyCollectionChangedAction.Remove)
            {
                foreach (object view in e.OldItems)
                {
                    System.Windows.Controls.Window window = GetContainerWindow(owner, view);

                    if (window != null)
                        window.Close();
                }
            }
        }

        void btn_Click(object sender, RoutedEventArgs e)
        {
            Button btn = sender as Button;
            System.Windows.Controls.Window window = btn.Tag as System.Windows.Controls.Window;
            if (window != null)
            {
                window.Visibility = window.Visibility == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible;
            }
        }

        private System.Windows.Controls.Window GetContainerWindow(Grid owner, object view)
        {
            foreach (UIElement ui in owner.Children)
            {
                System.Windows.Controls.Window window = ui as System.Windows.Controls.Window;
                if (window != null && window.Content == view)
                    return window;
            }
            return null;
        }
    }
}

自定义的RegionAdapter要实现RegionAdapterBase<T>,这个T就是要承载Region的容器owner，我们的Window控件是需要一个Grid的容器的，所以就是RegionAdapterBase<Grid>，注意里面并没有直接实现Adapt方法，而是在重载AttachBehaviors方法中实现了对region.Views和region.ActiveViews的管理，并实现了窗口操作对View的影响，里面我还加了个类似于Windows任务栏的功能，当然实现的不完善，需要改进。

我们需要把自定义的RegionAdapter介绍给Prism中，让Prism认识他，通过在Bootstrapper中重载ConfigureRegionAdapterMappings方法实现

  protected override RegionAdapterMappings ConfigureRegionAdapterMappings()
        {
            RegionAdapterMappings regionAdapterMappings = Container.TryResolve<RegionAdapterMappings>();
            IRegionBehaviorFactory regionBehaviorFactory = Container.TryResolve<IRegionBehaviorFactory>();
            if (regionAdapterMappings != null && regionBehaviorFactory != null)
            {
                regionAdapterMappings.RegisterMapping(typeof(Grid), new SLWindowRegionAdapter(regionBehaviorFactory));
            }
            return base.ConfigureRegionAdapterMappings();
        }

然后在我需要承载弹出窗口的Grid更改成

然后在要呈现弹出窗口的地方

IRegion region = this.regionManager.Regions["SLWindow"];
if (region != null)
region.Add(view);

搞定，看效果：
1、自动载入模块A，在模块A中弹出窗口显示模块A中的其他View

2、手动载入模块B，并在新的窗口中显示模块B的View

本文链接

使用Silverlight4无边窗口

2010-05-24T06:46:00Z

Silverlight4的这个特性使得我们可以在OOB模式下自定义主窗口的样式，让我们来做一个可以“安装”，并且自定义主窗口的样式的SilverlihgtOOB程序。
新建一个Silverlight项目的废话就不多说了，设置项目属性可运行在OOB模式下，勾选“Require elevated trust when runing outside the browser”,Window Style 选择为No Border;新建一个页面InstallPage.xaml，这个窗口是我们用来安装的该程序的页面，默认的MainPage.xaml是我们要自定义的主窗口，修改App.xaml.cs部分代码为：

private void Application_Startup(object sender, StartupEventArgs e)
        {
            if (App.Current.IsRunningOutOfBrowser && App.Current.HasElevatedPermissions)
            {
                this.RootVisual = new MainPage();
            }
            else
            {
                this.RootVisual = new InstallPage();
            }
        }

先看下运行效果：
1、在浏览器中运行

2、点击安装按钮进行安装

3、安装完成显示主窗口

两个页面的代码比较简单，都在源文件中，主实现了窗口的基本操作：最大化，最小化，关闭，位置拖动，大小拖动。
大家觉得这个主窗口的样式好看不？

本文链接

微软更新KB974571导致OCS服务器前端服务不能启动

2009-10-16T10:01:00Z

微软更新KB974571导致OCS服务器前端服务不能启动症状：事件类型:错误事件来源:OCS Server事件种类:(1000)事件 ID:12290日期:2009-10-16事件:17:21:18用户:N/A计算机:OCS描述:Microsoft Office Communications Server 2007 的评估期限已过。请从此产品的评估版升级到完整发行版。有关更多信息，请参阅在 ht...

使用Silverlight3中的DataPager实现服务器端分页

2009-08-17T07:15:00Z

代振军同学的blog中描述了使用DataPager实现客户端分页：http://www.cnblogs.com/daizhj/archive/2009/08/07/1529331.html一般说来，在项目中一般很少使用这种客户端的分页方式，除非数据量很少（干脆不分页算了）。把大量的数据一次性传输到客户端可不是个明智的做法，我们一般都是从客户端传入查找条件参数（包括过滤条件和分页条件参数），然后服务...