博客园_TCSJ

WPF binding（转）

2011-10-21T01:40:00Z

WPF里分三种Binding：Binding， PriorityBinding, MultiBinding,这三种Binding的基类都是BindingBase，而BindingBase又继承于MarkupExtension

Binding

提供对绑定定义的高级别访问，绑定将绑定目标对象（通常为 WPF 元素）的属性与任何数据源（例如数据库、XML 文件或包含数据的任何对象）连接起来。

常见的使用Binding的代码：
C#

Binding binding = new Binding();  // Set source object  binding.Source = treeView;  // Set source property  binding.Path = new PropertyPath("SelectedItem.Header");  // Attach to target property  currentFolder.SetBinding(TextBlock.TextProperty, binding);

XAML：

<TextBlock x:Name=”currentFolder” DockPanel.Dock=”Top”  Text=”{Binding ElementName=treeView, Path=SelectedItem.Header}”  Background=”AliceBlue” FontSize=”16”/>

所有FrameworkElement都包含SetBinding方法：SetBinding(DependencyProperty dp, String path)， SetBinding(DependencyProperty dp, BindingBase binding)，可以看出，FrameworkElement中的SetBinding只对DependencyProperty有效。

另一种设置Binding的方法是：BindingOperations.SetBinding(currentFolder, TextBlock.TextProperty, binding);
BindingOperations.SetBinding的原型是

public static BindingExpressionBase SetBinding(   DependencyObject target,   DependencyProperty dp,   BindingBase binding  )

第一个参数是DependencyObject，所以我们可以对自定义DependencyObject或者继承自DependencyObject的类进行绑定。当然第二个参数还是DependencyProperty。

清除Binding：
BindingOperations.ClearBinding(currentFolder, TextBlock.TextProperty); //删除currentFolder上的TextBlock.TextProperty绑定
BindingOperations.ClearAllBindings(currentFolder); //删除currentFolder上的所有绑定

直接对dependency property赋值也可以解除binding，不过只对单向binding有效。

Bingding的源：

有三个属性用来设置源：ElementName(string)、Source(Object) 和 RelativeSource(RelativeSource)。注：这三个只能指定一个，否则异常。
ElementName：源为一个元素(Element)，这里用的是此元素中设置的Name属性。
Source：以object作为源。<TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=PersonName}"/>
RelativeSource：源相对于绑定目标的位置。
                        源是元素本身：{Binding RelativeSource={RelativeSource Self}}
                        源是Tempalte中元素的Parent：{Binding RelativeSource={RelativeSource TemplatedParent}}
                        源是绑定以collection形式的前一个数据：{Binding RelativeSource={RelativeSource PreviousData}}，MSDN上关于PreviousData的说明并不多，这里有一篇文章可以参考
                        以上三项为RelativeSource中的Static值，使用这些值可以减少内存开销
                        源是Ancestor(可能比parent还高)：{Binding RelativeSource={RelativeSource FindAncestor,
                                                                     AncestorLevel=n, AncestorType={x:Type desiredType}}}

Path:

Binding中的Path是 PropertyPath对象。

在最简单的情况下，Path 属性值是要用于绑定的源对象的属性名称，如 Path=PropertyName。

通过类似于 C# 中使用的语法，可以指定属性的子属性。例如，子句 Path=ShoppingCart.Order 将绑定设置为对象的子属性 Order 或属性 ShoppingCart。

若要绑定到附加属性，请将附加属性用括号括起。例如，若要绑定到附加属性 DockPanel.Dock，则语法为 Path=(DockPanel.Dock)。

在应用了索引器的属性名称之后的方括号内，可以指定属性的索引器。例如，子句 Path=ShoppingCart[0] 将绑定设置为与属性的内部索引处理文本字符串“0”的方式对应的索引。此外，还支持多个索引器。

在 Path 子句中可以同时使用索引器和子属性，例如，Path=ShoppingCart.ShippingInfo[MailingAddress,Street]。

在索引器内部，可以有多个由逗号 (,) 分隔的索引器参数。可以使用圆括号指定每个参数的类型。例如，可以使用 Path="[(sys:Int32)42,(sys:Int32)24]"，其中 sys 映射到 System 命名空间。

如果源为集合视图，则可以用斜杠 (/) 指定当前项。例如，子句 Path=/ 设置到视图中当前项的绑定。如果源为集合，则此语法指定默认集合视图的当前项。

可以结合使用属性名和斜杠来遍历作为集合的属性。例如，Path=/Offices/ManagerName 指定源集合的当前项，该源集合包含同样是集合的 Offices 属性。其当前项是包含 ManagerName 属性的对象。

也可以使用句点 (.)路径绑定到当前源。例如，Text=”{Binding}” 等效于 Text=”{Binding Path=.}”。

BindingExpression

Binding 类是高级别类。BindingExpression 类是基础对象，用于保持绑定源与绑定目标之间的连接。Binding 中包含可在多个 BindingExpression 对象之间共享的所有信息。也就是说，可以把一个Binding对象绑定对n个元素上，而针对这n个元素，分别有相应的n个BindingExpresion对象。
Binding可以直接绑定普通的.net实例，比如int值。但是如果后台改变int值了，前台不能显示改变后的值，这时可以调用UpdateTarget()方法更新绑定。如下：BindingExpression be = button.GetBindingExpression(Button.ContentProperty);
be.UpdateTarget();

还有UpdateSource方法用来更新源。

绑定到.net属性/对象：

上面提到Binding绑到普通的.net属性，如果source变化了，UI上是不会显示的，除了用BindingExpression每次显式更新Target外，还可以使用如下技术：

绑定到单个对象需实现INotifyPropertyChanged接口，这个接口只有一个成员：

event PropertyChangedEventHandler PropertyChanged

实现INotifyPropertyChanged的示例如下：

using System.ComponentModel;    namespace SDKSample  {    // This class implements INotifyPropertyChanged    // to support one-way and two-way bindings    // (such that the UI element updates when the source    // has been changed dynamically)    public class Person : INotifyPropertyChanged    {        private string name;        // Declare the event        public event PropertyChangedEventHandler PropertyChanged;          public Person()        {        }          public Person(string value)        {            this.name = value;        }          public string PersonName        {            get { return name; }            set            {                name = value;                // Call OnPropertyChanged whenever the property is updated                OnPropertyChanged("PersonName");            }        }          // Create the OnPropertyChanged method to raise the event        protected void OnPropertyChanged(string name)        {            PropertyChangedEventHandler handler = PropertyChanged;            if (handler != null)            {                handler(this, new PropertyChangedEventArgs(name));            }        }    }  }  或者显式实现INotifyPropertyChanged：

#region INotifyPropertyChanged Members  event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged  {      add      {          this.PropertyChanged = (PropertyChangedEventHandler)Delegate.Combine(this.PropertyChanged, value);      }      remove      {          this.PropertyChanged = (PropertyChangedEventHandler)Delegate.Remove(this.PropertyChanged, value);      }  }  #endregion

看了上面代码着实没看出source值改变了，前台是通过什么机制反映的，正常的情况下公开了一个事件，必须有一个对此事件的实现体，而上面代码并没有实现PropertyChanged的方法。

我猜想是Binding内部获取了这个接口并对PropertyChanged进行了赋值，因为在debug时，这个事件确实被赋值的，而赋值前的Stack是External Code调用的。

绑定到集合需实现INotifyCollectionChanged，但是推荐使用ObservableCollection<T>，这个类实现了INotifyCollectionChanged和INotifyPropertyChanged。

附：当绑定到普通的.net属性时，WPF使用反射取得source的值，当对象实现ICustomTypeDescriptor时，WPF使用这个接口取得值，性能上会有所提升。

DataContext:

DataContext在共享资源时最有用。

<StackPanel x:Name="parent" DataContext="{StaticResource photos}">  <Label x:Name="numItemsLabel"  Content="{Binding Path=Count}"  DockPanel.Dock="Bottom"/>

也可以在代码这么写parent.DataContext = photos;

Value Converters:

IValueConverter可以在绑定时加入自己的逻辑，很好。

public class RawCountToDescriptionConverter : IValueConverter  {   public object Convert(object value, Type targetType, object parameter,    CultureInfo culture)   {    // Let Parse throw an exception if the input is bad    int num = int.Parse(value.ToString());    return num + (num == 1 ? " item" : " items");   }     public object ConvertBack(object value, Type targetType, object parameter,    CultureInfo culture)   {    throw new NotSupportedException();   }  }

IValueConverter就两个方法需要自己实现，Convert和ConvertBack，一个转过来，一个转过去。

XAML代码如下

<Label Background="{Binding Path=Count, Converter={StaticResource myConverter},  Source={StaticResource photos}}"/>

这里的myConverter是个resource，需要在xaml中预先定义：

<Window.Resources>  <local:CountToBackgroundConverter x:Key="myConverter"/>  </Window.Resources>

Path对应的Count值会作为第一个参数value传给Convert方法。

注意，返回的值一定要是绑定时对应的值，比如绑定时需要绑到Geometry类上，那么Convert返回的也必须是Geometry类。

Convert方法还带有一个parameter参数，可以在xaml中这么使用

<Label Background="{Binding Path=Count, Converter={StaticResource myConverter},   ConverterParameter=Yellow, Source={StaticResource photos}}"/>

ConverterParameter是object类型。
C#代码中就可以得到parameter的值了。

TIP：
可以用Binding.DoNothing作返回值，以指示绑定引擎不要执行任何操作。
可用使用[ValueConversion(typeof(DateTime), typeof(String))]来标识Converter要转化和返回的值类型，第一个参数是soure，第二个参数是target。这样在编译时，如果类型不匹配的话，编译器会抛出异常：error CS0592: Attribute 'ValueConversion' is not valid on this declaration type. It is only valid on 'class' declarations.

.net自带一些converter，比如常用的BooleanToVisibilityConverter，可以根据checkbox是否勾上来隐藏其他控件。

在collection中使用converter：使用DateTemplate，在其中使用Converter。（也可以使用Converter对整个collection进行转化，但是可能效率不好）

Binding.Mode

指示源和目标间数据流的方向。

OneWay 源更新时，目标也更新
TwoWay 源更新时目标也更新，或者目标更新时同时更新源
OneTime 仅当应用程序启动时或 DataContext 进行更改时更新目标属性。绑一次就不更维护更新，目标相当于源的一次性镜像
OneWayToSource 目标更新时更新源，和OneWay相反

大部分WPF自带的控件的dependency property默认的是OneWay，像TextBox.Text默认的是TwoWay。
值得注意的事，只读属性只能设置成OneWay，不能是TwoWay，否则运行时异常。

对于 OneWay 或 TwoWay 绑定，对源的动态更改不会自动传播到目标。必须在源对象上实现INotifyPropertyChanged 接口。
对于 TwoWay 绑定，对目标的更改不会自动传播到源，除非绑定目标是 Text 属性。在这种情况下，更新仅在 TextBox 失去焦点时发生。
对于 OneTime 和 OneWay 绑定，对 SetValue 的调用会自动更改目标值并删除绑定。

再次提醒，源要实现了INotifyPropertyChanged 接口才能把改变反映到目标上。

OneWayToSource 用于多个目标更改一个源的情况，可以想像成多人录入。或者用来实现源和目标倒置的情况。

Binding.UpdateSourceTrigger

指示使用TwoWay或OneWayToSource时，目标在什么情况下更新源。有三个枚举值

PropertyChanged：目标属性改变时更新源
LostFocus：失去焦点时更新源
Explicit：只有在显式调用BindingExpression.UpdateSource方法时才更新源。BindingExpression可以通过BindingOperations.GetBindingExpression或FrameworkElement.GetBindingExpression方法获得

Binding类中提供了SourceUpdated和TargetUpdated事件，可以用来记些log，不过必须相应的NotifyOnSourceUpdated或NotifyOnTargetUpdated设置成true才会激发事件。

本文链接

ExcelEdit 操作类

2011-10-08T00:41:00Z

  #region [ ExcelEdit 操作类 ]
    /// <SUMMARY>
    /// ExcelEdit 的摘要说明 //引入Excel的COM组件
    /// </SUMMARY>
    public class ExcelEdit
    {
        public string mFilename;
        public Application app;
        public Workbooks wbs;
        public Excel.Workbook wb;
        public Excel.Worksheets wss;
        public Excel.Worksheet ws;
        public ExcelEdit()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        public void Create()//创建一个Excel对象
        {
            app = new Excel.Application();
            wbs = app.Workbooks;
            wb = wbs.Add(true);
        }
        public void Open(string FileName)//打开一个Excel文件
        {
            app = new Excel.Application();
            wbs = app.Workbooks;
            wb = wbs.Add(FileName);
            //wb = wbs.Open(FileName, 0, true, 5,"", "", true, Excel.XlPlatform.xlWindows, "t", false, false, 0, true,Type.Missing,Type.Missing);
            //wb = wbs.Open(FileName,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Excel.XlPlatform.xlWindows,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing);
            mFilename = FileName;
        }
        public Excel.Worksheet GetSheet(string SheetName)        //获取一个工作表
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets[SheetName];
            return s;
        }
        public Excel.Worksheet AddSheet(string SheetName)        //添加一个工作表
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
            s.Name = SheetName;
            return s;
        }
 
        public void DelSheet(string SheetName)//删除一个工作表
        {
            ((Excel.Worksheet)wb.Worksheets[SheetName]).Delete();
        }
        public Excel.Worksheet ReNameSheet(string OldSheetName, string NewSheetName)//重命名一个工作表一
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets[OldSheetName];
            s.Name = NewSheetName;
            return s;
        }
 
        public Excel.Worksheet ReNameSheet(Excel.Worksheet Sheet, string NewSheetName)//重命名一个工作表二
        {
 
            Sheet.Name = NewSheetName;
 
            return Sheet;
        }
 
        public void SetCellValue(Excel.Worksheet ws, int x, int y, object value)        //ws：要设值的工作表     X行Y列     value   值
        {
            ws.Cells[x, y] = value;
        }
        public void SetCellValue(string ws, int x, int y, object value)        //ws：要设值的工作表的名称 X行Y列 value 值
        {
 
            GetSheet(ws).Cells[x, y] = value;
        }
 
        public void SetCellProperty(Excel.Worksheet ws, int Startx, int Starty, int Endx, int Endy, int size, string name, Excel.Constants color, Excel.Constants HorizontalAlignment)        //设置一个单元格的属性   字体，   大小，颜色   ，对齐方式
        {
            name = "宋体";
            size = 12;
            color = Excel.Constants.xlAutomatic;
            HorizontalAlignment = Excel.Constants.xlRight;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;
        }
 
        public void SetCellProperty(string wsn, int Startx, int Starty, int Endx, int Endy, int size, string name, Excel.Constants color, Excel.Constants HorizontalAlignment)
        {
            //name = "宋体";
            //size = 12;
            //color = Excel.Constants.xlAutomatic;
            //HorizontalAlignment = Excel.Constants.xlRight;
 
            Excel.Worksheet ws = GetSheet(wsn);
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;
 
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;
        }
 
 
        public void UniteCells(Excel.Worksheet ws, int x1, int y1, int x2, int y2)        //合并单元格
        {
            ws.get_Range(ws.Cells[x1, y1], ws.Cells[x2, y2]).Merge(Type.Missing);
        }
 
        public void UniteCells(string ws, int x1, int y1, int x2, int y2)        //合并单元格
        {
            GetSheet(ws).get_Range(GetSheet(ws).Cells[x1, y1], GetSheet(ws).Cells[x2, y2]).Merge(Type.Missing);
 
        }
 
 
        public void InsertTable(System.Data.DataTable dt, string ws, int startX, int startY)//将内存中数据表格插入到Excel指定工作表的指定位置 为在使用模板时控制格式时使用一
        {
 
            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {
                    GetSheet(ws).Cells[startX+i, j + startY] = dt.Rows[i][j].ToString();
 
                }
 
            }
 
        }
        public void InsertTable(System.Data.DataTable dt, Excel.Worksheet ws, int startX, int startY)//将内存中数据表格插入到Excel指定工作表的指定位置二
        {
 
            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {
 
                    ws.Cells[startX+i, j + startY] = dt.Rows[i][j];
 
                }
 
            }
 
        }
 
 
        public void AddTable(System.Data.DataTable dt, string ws, int startX, int startY)//将内存中数据表格添加到Excel指定工作表的指定位置一
        {
 
            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {
 
                    GetSheet(ws).Cells[i + startX, j + startY] = dt.Rows[i][j];
 
                }
 
            }
 
        }
        public void AddTable(System.Data.DataTable dt, Excel.Worksheet ws, int startX, int startY)//将内存中数据表格添加到Excel指定工作表的指定位置二
        {
 
 
            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {
 
                    ws.Cells[i + startX, j + startY] = dt.Rows[i][j];
 
                }
            }
 
        }
        public void InsertPictures(string Filename, string ws)        //插入图片操作一
        {
            GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoFalse, MsoTriState.msoTrue, 10, 10, 150, 150);
            //后面的数字表示位置
        }
 
        public void InsertPictures(string Filename, string ws, int Height, int Width)       // 插入图片操作二
        {
            GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoFalse, MsoTriState.msoTrue, 10, 10, 150, 150);
            GetSheet(ws).Shapes.get_Range(Type.Missing).Height = Height;
            GetSheet(ws).Shapes.get_Range(Type.Missing).Width = Width;
        }
        public void InsertPictures(string Filename, string ws, int left, int top, int Height, int Width)      //插入图片操作三
        {
 
            GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoFalse, MsoTriState.msoTrue, 10, 10, 150, 150);
            GetSheet(ws).Shapes.get_Range(Type.Missing).IncrementLeft(left);
            GetSheet(ws).Shapes.get_Range(Type.Missing).IncrementTop(top);
            GetSheet(ws).Shapes.get_Range(Type.Missing).Height = Height;
            GetSheet(ws).Shapes.get_Range(Type.Missing).Width = Width;
        }
 
        public void InsertActiveChart(Excel.XlChartType ChartType, string ws, int DataSourcesX1, int DataSourcesY1, int DataSourcesX2, int DataSourcesY2, Excel.XlRowCol ChartDataType)        //插入图表操作
        {
            ChartDataType = Excel.XlRowCol.xlColumns;
            wb.Charts.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
            {
                wb.ActiveChart.ChartType = ChartType;
                wb.ActiveChart.SetSourceData(GetSheet(ws).get_Range(GetSheet(ws).Cells[DataSourcesX1, DataSourcesY1], GetSheet(ws).Cells[DataSourcesX2, DataSourcesY2]), ChartDataType);
                wb.ActiveChart.Location(Excel.XlChartLocation.xlLocationAsObject, ws);
            }
        }
        public bool Save()        //保存文档
        {
            if (mFilename == "")
            {
                return false;
            }
            else
            {
                try
                {
                    wb.Save();
                    return true;
                }
 
                catch (Exception ex)
                {
                    return false;
                }
            }
        }
        public bool SaveAs(object FileName)        //文档另存为
        {
            try
            {
                wb.SaveAs(FileName, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlExclusive, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                return true;
 
            }
 
            catch (Exception ex)
            {
                return false;
 
            }
        }
        public void Close()        //关闭一个Excel对象，销毁对象
        {
            //wb.Save();
            wb.Close(Type.Missing, Type.Missing, Type.Missing);
            wbs.Close();
            app.Quit();
            wb = null;
            wbs = null;
            app = null;
            GC.Collect();
        }
    }
    #endregion

本文链接

WCF开发框架形成之旅--如何实现X509证书加密

2011-09-30T00:42:00Z

在前面几篇文章，均介绍了一些WCF服务的开发经验，对于数据的加密传输，重要性不言而喻。关于在WCF使用证书加密的重要性，在上篇随笔《

WCF开发框架形成之旅--您的数据是否需要加密》有详细的介绍，特别对于重要的、敏感的数据，加密传输非常重要。

因此自从开始使用WCF以来，一直想使用合适的数据加密传输来解决问题，WCF常用的就是使用X509证书来实现加密，开始创建WCF服务，并顺利调用，以为一且均很美好，但是这个X509加密处理方式却令人头痛不已，一直没能顺利调通，并参考了很多www.codeproject.com上的相关文章，里面有很多不错的文章，不过很多不够系统，也说得不够具体化。本文的意图就是详细、系统化介绍如何处理证书加密的操作，方便自己及他人日常开发WCF借鉴。

首先先介绍一下前人对WCF开发中应用证书加密的一些思路介绍，个人觉得比较靠谱的是这两篇文章

1、 http://www.codeproject.com/KB/WCF/9StepsWCF.aspx

2、 Using Certificate-based Authentication and Protection with Windows Communication Foundation (WCF)

第一篇文章基本已经介绍了证书加密操作的相关步骤了：创建证书、配置服务及客户端节点。不过没有说明我们一般通过那样创建的证书，其实是临时用的测试证书，不在配置文件的certificateValidationMode属性中使用除了“None"属性外的值，否则就不能顺利运行调用服务。这个问题其实可以通过在Windows2003中部署证书服务来创建合格的证书，具体可以参考文章实现：http://www.codeproject.com/KB/WCF/wcf_certificates.aspx

另外作者可能也只是在一台开发机器上部署服务和调用客户端或者是XP系统，因此也没有考虑给IIS授权的问题，因为在Windows2003等服务器机器上，要给IIS授权才能访问证书，需要使用WinHttpCertCfg.exe或者CertMgr.exe来实现证书的授权等操作，在这方面，文章http://www.codeproject.com/KB/WCF/CustomUserNamePassAuth2.aspx 介绍的有一点靠谱了，不过了解整篇文章却无助完整测试WCF服务的应用。

综上所述，要成功部署基于X509证书加密的操作，需要这几方面的知识和操作步骤。

1、创建WCF服务应用以及调用客户端。

2、创建客户证书和服务端的X509证书

3、配置服务端的配置文件，使之使用X509证书服务。

4、授权IIS访问服务器证书

5、在服务器证书管理中导入服务器端证书

6、在客户端导入客户端证书，完成X509证书配置并调用服务。

下面就这几方面分别介绍相关的处理。

1、创建WCF服务应用以及调用客户端。

这个是基本的操作，客户创建适合自己的WCF开发框架，基于我的Winform开发框架扩展而成的WCF框架，是一种比较完善、高效、弹性化的开发框架，详细步骤及说明请参考随笔《基于我的Winform开发框架扩展而成的WCF开发框架》，使用这种方式构造的开发框架，各层职责比较分明，而且方便管理。

2、创建客户证书和服务端的X509证书

在VS2008 的DOS命令提示中，输入下面的指令即可创建相关的服务器和客户端证书

makecert.exe -sr LocalMachine -ss My -a sha1 -n CN=ParkingServer -sky exchange -pe

makecert.exe -sr LocalMachine -ss My -a sha1 -n CN=ParkingClient -sky exchange -pe

下面是各种参数的介绍

属性	解析
-sr	指定的证书存储区中的注册表位置。 currentUser 指定注册版存储位置为 HKEY_CURRENT_USER. localMachine 指定注册版存储位置为 HKEY_LOCAL_MACHINE.
-ss	指定证书存储的位置。
-a	指定相关的算法，可以选择 MD5 算法或者 SHA1算法
-n	指定证书的名称。该名称遵循X.500命名标准。简单例子如 "CN=MyName" 格式，如果没有指定/n开关，证书默认的名称是"Joe's Software Emporium"。
-sky	证书键类型。可以设置为 exchange 或者 signature。
-pe	证书可导出

创建证书成功后，我们在开发的机器上就可以看到两个不同的证书了。

要看这两个证书，需要执行下面操作，开始-》运行-》mmc.exe=》在控制台中选择文件=》添加/删除管理单元=》添加=》选择证书=》弹出证书管理单元选择计算机账户，默认下一步确定回来，就看到下面的界面。

在上面我们可以看到创建在LocalMachine账户下的证书，我们双击查看证书可以看到这个证书是一个不受信任的证书，但是我们还是可以使用的，只是需要在Web.Config配置信息中，certificateValidationMode 属性指定为None，而不能指定其他信任值。

3、配置服务端的配置文件，使之使用X509证书服务。

根据创建的证书信息，我们修改Web.Config文件，使之应用X509证书加密，如下所示。关键的地方是设置验证方式使用证书。

而证书的相关信息指定如下。

上面标示证书名称是ParkingServer ，通过查找名字方式对应，并且存储在本地计算机账户、个人证书目录下的位置。

Web.Config 部分内容：

4、 授权IIS访问服务器证书

完成以上操作后，如果你的开发机器是XP，那么应该服务端是可以运行正常了，如果你的开发机器是Window2003，那么，恭喜你中奖了，运行服务后会出现下面的错误信息的：[ArgumentException: 证书“CN=ParkingServer”必须具有能够进行密钥交换的私钥。该进程必须具有访问私钥的权限。]，如下图所示。

要解决上面的错误，只需要给相应的账号分配权限即可，这里IIS访问证书密钥的权限可以通过WinHttpCertCfg.exe来处理，只需要通过命令行执行该程序即可，如下所示。

winhttpcertcfg -g -c LOCAL_MACHINE\My -s ParkingServer -a "NETWORKSERVICE"

运行命令后，在运行WCF服务，一切OK了

这里另外也介绍下WinHttpCertCfg.exe来进行处理的几个命令。

列出证书的授权列表
winhttpcertcfg -l -c LOCAL_MACHINE\My -s ParkingServer -a "NETWORKSERVICE"

给IIS的NETWORKSERVICE账户以基于证书名称模式授权
winhttpcertcfg -g -c LOCAL_MACHINE\My -s ParkingServer -a "NETWORKSERVICE"

给IIS的NETWORKSERVICE账户以基于证书文件模式授权
winhttpcertcfg -g -i "ParkingServer.pfx" -c LOCAL_MACHINE\My -a "NETWORKSERVICE" -p

移除账号对于证书的授权

winhttpcertcfg -r -c LOCAL_MACHINE\My -s ParkingServer -a "NETWORKSERVICE"

5、 在服务器证书管理中导入服务器端证书

完成以上步骤，如果服务配置文件正确，基本上在开发机器上不会有什么问题了，但是如果把服务部署到另外一台服务器机器上，那么就会可能出现找不到证书的错误。因为服务还没有导入创建好的证书呢。

首先我们在开发机器上，在证书的控制台中选定服务端证书并导出即可把服务端证书导出到文件中，如下图所示。

记得在导出的时候选择带私钥的选项即可，导出的文件保存为ParkingServer.pfx。然后我们在服务器中，在相同的控制台中把服务端的证书导入即可使得WCF服务在服务器中也可以正常访问了。

6、在客户端导入客户端证书，完成X509证书配置并调用服务。

如果客户端需要部署很多个，那么每个客户端需要把第二步创建的客户端证书导入，才能正常方便服务器的WCF服务，否则会出现证书的各种提示错误。

如果这些操作完成，那么真诚恭喜你，真的可以使用WCF服务了，而且是使用了X509证书加密的WCF服务。

最后把整个测试例子放上来，供大家参考学习：http://files.cnblogs.com/wuhuacong/TestWcfService.rar

本文链接

WPF中的ControlTemplate(控件模板)

2011-09-28T08:38:00Z

WPF中的ControlTemplate(控件模板)
周银辉

WPF包含数据模板和控件模板，其中控件模板又包括ControlTemplate和ItemsPanelTemplate，这里讨论一下ControlTemplate。

其实WPF的每一个控件都有一个默认的模板，该模板描述了控件的外观以及外观对外界刺激所做出的反应。我们可以自定义一个模板来替换掉控件的默认模板以便打造个性化的控件。

与Style不同，Style只能改变控件的已有属性值（比如颜色字体）来定制控件，但控件模板可以改变控件的内部结构（VisualTree，视觉树）来完成更为复杂的定制，比如我们可以定制这样的按钮：在它的左办部分显示一个小图标而它的右半部分显示文本。

要替换控件的模板，我们只需要声明一个ControlTemplate对象，并对该ControlTemplate对象做相应的配置，然后将该ControlTemplate对象赋值给控件的Template属性就可以了。

ControlTemplate包含两个重要的属性：
1，VisualTree，该模板的视觉树，其实我们就是使用这个属性来描述控件的外观的
2，Triggers，触发器列表，里面包含一些触发器Trigger，我们可以定制这个触发器列表来使控件对外界的刺激发生反应，比如鼠标经过时文本变成粗体等。

参考以下代码

在上面的代码中，我们修改了Button的Template属性，我们定义了一个ControlTemplate，在<ControlTemplate> ... </ControlTemplate>之间包含的是模板的视觉树，也就是如何显示控件的外观，我们这里使用了一个Ellipse（椭圆）和一个TextBlock（文本块）来定义控件的外观。
很容易联想到一个问题：控件（Button）的一些属性，比如高度、宽度、文本等如何在新定义的外观中表现出来呢？
我们使用TemplateBinding 将控件的属性与新外观中的元素的属性关联起来Width="{TemplateBinding Button.Width}" ，这样我们就使得椭圆的宽度与按钮的宽度绑定在一起而保持一致，同理我们使用Text="{TemplateBinding Button.Content}"将TextBlock的文本与按钮的Content属性绑定在一起。

除了定义控件的默认外观外，也许我们想还定义当外界刺激我们的控件时，控件外观做出相应的变化，这是我们需要触发器。参考以下代码：

在上面的代码中注意到<ControlTemplate.Triggers>... </ControlTemplate.Triggers>之间的部分，我们定义了触发器 <Trigger Property="Button.IsMouseOver" Value="True">，其表示当我们Button的IsMouseIOver属性变成True时，将使用设置器<Setter Property="Button.Foreground" Value="Red" /> 来将Button的Foreground属性设置为Red。这里有一个隐含的意思是：当Button的IsMouseIOver属性变成False时，设置器中设置的属性将回复原值。

你可以粘贴以下代码到XamlPad查看效果：

接下来的一个问题是：如果我要重用我的模板，应该怎么办呢？
你需要将模板定义为资源，其实大多数情况下，我们也是这样做的
参考以下代码：

<Window.Resources>
    <ControlTemplate TargetType="Button" x:Key="ButtonTemplate">
        
        <Grid>
          <Ellipse Name="faceEllipse" Width="{TemplateBinding Button.Width}" Height="{TemplateBinding Control.Height}"  Fill="{TemplateBinding Button.Background}"/>
          <TextBlock Name="txtBlock" Margin="{TemplateBinding Button.Padding}" VerticalAlignment="Center"  HorizontalAlignment="Center"  Text="{TemplateBinding Button.Content}" />
        </Grid>
        
        
        <ControlTemplate.Triggers>
          <Trigger  Property="Button.IsMouseOver"  Value="True">
            <Setter Property="Button.Foreground" Value="Red" />
          </Trigger>
        </ControlTemplate.Triggers>
        
    </ControlTemplate>
  </Window.Resources>

上面的代码将我们原来的模板定义为窗体范围内的资源，其中TargetType="Button"指示我们的模板作用对象为Button，这样在整个窗体范围内的按钮都可以使用这个模板了，模板的使用方法也很简单：

其中的ButtonTemplate是我们定义的模板的x:Key

你可以粘贴以下代码到XamlPad查看效果：

额外提一下的是，我们也可以在触发器中，调用一个故事板来达到对事件响应时的动画效果
参考以下代码

<ControlTemplate.Resources>
        <Storyboard x:Key="MouseClickButtonStoryboard">
          <DoubleAnimationUsingKeyFrames Storyboard.TargetName="faceEllipse" Storyboard.TargetProperty="Width" BeginTime="00:00:00">
            <SplineDoubleKeyFrame KeyTime="00:00:00" Value="50"/>
            <SplineDoubleKeyFrame KeyTime="00:00:00.3" Value="100"/>
          </DoubleAnimationUsingKeyFrames>
        </Storyboard>
      </ControlTemplate.Resources>

我们为模板定义了一个动画资源，此后在模板的触发器中我们就可以调用该资源来实现一个动画效果了：

你可以粘贴以下代码到XamlPad查看效果：

最好的模板示例：我们知道每个控件都有自己默认的模板，这是MS编写的，如果我们能够得到这些模板的XAML代码，那么它将是学习模板的最好的示例，
要想获得某个控件ctrl的默认模板，请调用以下方法：

string GetTemplateXamlCode(Control ctrl)
        {

            FrameworkTemplate template = ctrl.Template;

            string xaml = "";

            if (template != null)
            {

                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                settings.IndentChars = new string(' ', 4);
                settings.NewLineOnAttributes = true;

                StringBuilder strbuild = new StringBuilder();
                XmlWriter xmlwrite = XmlWriter.Create(strbuild, settings);

                try
                {
                    XamlWriter.Save(template, xmlwrite);
                    xaml = strbuild.ToString();
                }
                catch (Exception exc)
                {
                    xaml = exc.Message;
                }
            }
            else
            {
                xaml = "no template";
            }

            return xaml;
        }

本文链接

WPF中的Style(风格,样式)

2011-09-28T08:37:00Z

WPF中的Style(风格,样式)
周银辉

在WPF中我们可以使用Style来设置控件的某些属性值，并使该设置影响到指定范围内的所有该类控件或影响指定的某一控件，比如说我们想将窗口中的所有按钮都保持某一种风格，那么我们可以设置一个Style，而不必分别设置每个按钮的风格。

Style是作为一种资源被保存下来的. 看下面的例子：

<Window.Resources>
    <Style TargetType="Button">
      <Setter Property="Foreground"  Value="Blue"/>
      <Setter Property="FontFamily " Value="CourierNew"/>
    </Style>
</Window.Resources>

我们声明了一个Style，它被声明在Window.Resources中说明它的有效范围是当前窗体，TargetType="Button" 指示该Style的作用对象是Button类的实例，也就是说在当前窗体中的所有Button实例都将受到该Style的影响（除非某Button有明确地指明它所使用的是另外的Style）。
<Setter Property="Foreground" Value="Blue"/> 这里的Setter是一个设置器，用来设置该Style要对TargetType的那些属性或对象进行设置，我们这里设置的是Button的Foreground属性，将其值设置为Blue，同理，我们将Button的FontFamily属性设置为CourierNew

这样一来，在默认情况下，被加载到窗口中的所有Button对象都将受到这个Style的影响，从而文本变成统一的蓝色CourierNew字体。
你可以粘贴以下代码到XamlPad中查看效果:

接下来很容易想到的一个问题是，想上述代码的强制窗口的所有按钮都受声明的Style的影响是不是有点强奸民意，如果我只想我定义的Style影响指定的Button对象而不是所有的Button对象应该怎么办呢？
参考以下代码：我们为Style添加一个x:Key="ButtonStyle"

然后我们使用Button的Style属性来指定该Button所要使用的Style，而其他没有将我们声明的Style指定为其样式的按钮将不受到该Style的影响。

<Button>normal button</Button>
<Button Style="{StaticResource ButtonStyle}">styled button</Button>

这样就很好的解决了Style强制影响每个Button的问题，你可以粘贴以下代码到XamlPad中查看效果:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="StyleDemo" Height="417" Width="579"
    >


  <Window.Resources>
    <Style TargetType="Button" x:Key="ButtonStyle">
      <Setter Property="Foreground"  Value="Blue"/>
      <Setter Property="FontFamily " Value="CourierNew"/>
    </Style>
  </Window.Resources>


    <Grid ShowGridLines="True">

      <Grid.ColumnDefinitions>
        <ColumnDefinition  Width="50*"/>
        <ColumnDefinition Width="50*" />
      </Grid.ColumnDefinitions>
      <Grid.RowDefinitions>
        <RowDefinition  Height="25*"/>
        <RowDefinition  Height="25*"/>
        <RowDefinition  Height="25*"/>
      </Grid.RowDefinitions>

      <Button Grid.Column="0" Grid.ColumnSpan="1" Grid.Row="0" Grid.RowSpan="1">normal button</Button>
      <Button Grid.Column="1" Grid.ColumnSpan="1" Grid.Row="1" Grid.RowSpan="1" Style="{StaticResource ButtonStyle}">styled button1</Button>
      <Button Grid.Column="0" Grid.ColumnSpan="1" Grid.Row="2" Grid.RowSpan="1" Style="{StaticResource ButtonStyle}">styled button2</Button>

    </Grid>

</Window>

为了让我们的Style对外界的交互做出外观上的相应，比如当鼠标按下时蓝色的文本变成红色，当鼠标松开时文本又恢复蓝色，我们可以在Style中添加Trigger（触发器），除此之外，与类的继承原理相类似，我们还可以使用BaseOn来使一个Style“继承”另一个Style。
参考以下代码：

<Window.Resources>

    <Style TargetType="Button" x:Key="ButtonStyle">
      <Setter Property="Foreground"  Value="Blue"/>
      <Setter Property="FontFamily " Value="CourierNew"/>
    </Style>

    <Style TargetType="Button" x:Key="TriggerButtonStyle" BasedOn="{StaticResource ButtonStyle}">
      <Style.Triggers>
        <Trigger  Property="IsPressed" Value="True">
          <Setter Property="Foreground" Value="Red"/>
        </Trigger>
      </Style.Triggers>
    </Style>

  </Window.Resources>

我们所声明的第二个Style，即TriggerButtonStyle，它“继承”于ButtonStyle，那么TriggerButtonStyle将会从ButtonStyle那里得到蓝色CourierNew文本的性质。然后我们使用了Trigger来响应鼠标按下， <Trigger Property="IsPressed" Value="True"> 表示当Button的IsPressed属性值变为True的时候，将做如下设置<Setter Property="Foreground" Value="Red"/>，即将Button的Foreground属性设置为Red。这里有一个隐含的意思是：当当Button的IsPressed属性值变为False的时候，Foreground属性将恢复原值。
你可以粘贴以下代码到XamlPad中查看效果:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="StyleDemo" Height="417" Width="579"
    >


  <Window.Resources>

    <Style TargetType="Button" x:Key="ButtonStyle">
      <Setter Property="Foreground"  Value="Blue"/>
      <Setter Property="FontFamily " Value="CourierNew"/>
    </Style>

    <Style TargetType="Button" x:Key="TriggerButtonStyle" BasedOn="{StaticResource ButtonStyle}">
      <Style.Triggers>
        <Trigger  Property="IsPressed" Value="True">
          <Setter Property="Foreground" Value="Red"/>
        </Trigger>
      </Style.Triggers>
    </Style>

  </Window.Resources>


    <Grid ShowGridLines="True">

      <Grid.ColumnDefinitions>
        <ColumnDefinition  Width="50*"/>
        <ColumnDefinition Width="50*" />
      </Grid.ColumnDefinitions>
      <Grid.RowDefinitions>
        <RowDefinition  Height="25*"/>
        <RowDefinition  Height="25*"/>
        <RowDefinition  Height="25*"/>
      </Grid.RowDefinitions>

      <Button Grid.Column="0" Grid.ColumnSpan="1" Grid.Row="0" Grid.RowSpan="1">normal button</Button>
      <Button Grid.Column="1" Grid.ColumnSpan="1" Grid.Row="1" Grid.RowSpan="1" Style="{StaticResource ButtonStyle}">styled button</Button>
      <Button Grid.Column="0" Grid.ColumnSpan="1" Grid.Row="2" Grid.RowSpan="1" Style="{StaticResource TriggerButtonStyle}">trigger button</Button>

    </Grid>

</Window>

分类: WPF

本文链接

C#4.0新Feature官方文档和Sample Code下载 [本文提供Office编程的一段Sample Code作为预览]

2011-09-27T05:12:00Z

C#4.0新Feature官方文档和Sample Code下载 [本文提供Office编程的一段Sample Code作为预览]

先把重点写在前头:

http://code.msdn.microsoft.com/Release/ProjectReleases.aspx?ProjectName=csharpfuture&ReleaseId=1686

以上这个地址是下载官方C#4.0的最新文档和Sample Code，而以下正是我看到第一个例子，关于Office的操作。可见它的例子质量还是蛮高的，值得学习，所以分享给大家，也许有些人已经知道这个链接，如果不能下载，留言告诉我，我到时下载到cnblogs里。

前言：

从C#1.0,2.0,3.0,4.0一路走来，我们可能不是去掌握它的技术，而是掌握它为什么会这样变化，从2.0的泛型，到3.0的Lamda,Linq,集合对象初始化等，再到现在4.0的动态编程,可选参数等,微软的种种更新让我们都跟着很累，但是，如果我们深入进去多看看“为什么”，也许就不是很累，而是会发现这些更新都是必然。

下面代码在.NET4.0环境下编译，是关于将一些数据写入Excel并操作Word的一小段代码，代码很简单，但需要注意到是下面的一些C#3.0/4.0里的知识，如Lamda, Named Parameter等。

源代码

using System;
using System.Collections.Generic;

using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;
namespace Zivsoft.OfficeDemo
{
    /// <summary>
    /// 域名信息
    /// </summary>
    public class DomainInfo
    {
        public string DomainName { get; set; }
        public string Owner { get; set; }
    }

    public class Program
    {
        /// <summary>
        /// 入口
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //注意定义方式(C#3.0)
            var checkAccounts = new List<DomainInfo> {
                   new DomainInfo {
                                      DomainName = "www.zivsoft.com",
                                      Owner = "zivsoft"
                               },
                   new DomainInfo {
                                      DomainName = "lihua.club.officelive.com",
                                      Owner = "microsoft"
                               }
               };

            DisplayInExcel(checkAccounts, (domain, cell) =>//注意参数2, Lambda, domain是自定义类DomainInfo，cell是Excel.Range
            {
                // Lambda内部业务
                cell.Value2 = domain.DomainName;
                cell.get_Offset(0, 1).Value2 = domain.Owner;

                if (domain.Owner == "zivsoft")//如果owner是zivsoft，改变颜色
                {
                    cell.Interior.Color = 255;
                    cell.get_Offset(0, 1).Interior.Color = 255;
                }
            });

            //操作Word对象
            var word = new Word.Application();
            word.Visible = true;
            word.Documents.Add();
            word.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);//注意这是C#4.0中可选参数用法
        }

        public static void DisplayInExcel(IEnumerable<DomainInfo> accounts,
                               Action<DomainInfo, Excel.Range> DisplayFunc)//参数2中的Action是一个泛型delegate
        {
            //操作Excel对象
            var xl = new Excel.Application();

            xl.Workbooks.Add();
            xl.Visible = true;
            xl.Cells[1, 1] = "域名";
            xl.Cells[1, 2] = "拥有者";
            xl.Cells[2, 1].Select();
            foreach (var ac in accounts)
            {
                DisplayFunc(ac, xl.ActiveCell);
                xl.ActiveCell.get_Offset(1, 0).Select();
            }

            xl.get_Range("A1:B3").Copy();

            xl.Columns[1].AutoFit();
            xl.Columns[2].AutoFit();
        }
    }
}

程序运行结果

本文链接

给力分享新的ORM => Dapper

2011-09-16T08:20:00Z

最近一直很痛苦，想选一个好点的ORM来做项目，实在没遇到好的。昨天忽然的看到Dapper，立刻迷恋上了。这个ORM实在太强大了，可惜资料少的可怜。就发点资料来介绍吧。官方资料点击这里

Dapper是一个轻型的ORM类。代码就一个SqlMapper.cs文件。文件见下。编译后就40K的一个很小的Dll.（估计其他的ORM要哭了。）

Dapper很快，有多快。实验下就知道了。官方给了点测试包，想玩的时候就去测试下。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。（更多的ORM泪奔了，好多ORM弱爆了。）

Dapper支持什么数据库。Dapper支持Mysql,SqlLite,Mssql2000,Mssql2005,Oracle等一系列的数据库，当然如果你知道原理也可以让它支持Mongo db.（有的ORM泪奔了）

Dapper的r支持多表并联的对象。支持一对多多对多的关系。并且没侵入性，想用就用，不想用就不用。无XML无属性。代码以前怎么写现在还怎么写。（更更更更多的ORM泪奔了，看到其他的ORM又是XML又是属性，Map来Map去，设计来设计去，缓存来缓存去，然后还是那么的慢。）

Dapper原理通过Emit反射IDataReader的序列队列，来快速的得到和产生对象。性能实在高高高。（更更更更更更更多的ORM泪奔了）

Dapper支持net2.0,3.0,3.5,4.0。不过就是要配置下。如果不知道如何配置查看我博客里的在2.0下使用3.5就可以了。（更更更更更更更更更更更多的ORM泪奔了）

Dapper的语法是这样的。语法十分简单。并且无须迁就数据库的设计。（我X，无敌了）


public static readonly string sqlconnectionString = "Data Source=xxx;Initial Catalog=Express;User ID=sa;Password=123";

public static readonly string mysqlconnectionString = @"server=xxx;database=dddd;uid=xxx;pwd=123;charset='gbk'";

public static SqlConnection SqlConnection()

{

    var connection = new SqlConnection(sqlconnectionString);

    connection.Open();

    return connection;

}

public static  MySqlConnection  MySqlConnection()

{

    var connection = new MySqlConnection(mysqlconnectionString);

    connection.Open();

    return connection;

}

调用方法


SqlConnection connection = Program.SqlConnection();

for (int i = 0; i < 100000; i++)

{

    //connection.Execute("INSERT INTO dog (Age,Name,Weight) VALUES (@age,@name,@Weight)",

       //  new { @age = i,@name = Guid.NewGuid().ToString(), @Weight = i });

}

var d = connection.Query<Dog>("select * from dog where id = 1", null).Single<Dog>();

var dd = connection.Query<Dog>("select * from dog where id < 10", null).ToList<Dog>();

试用感觉

30W条数据，取其中的一个对象，和第一页前15条数据，耗时0.0906879秒。这个速度超过Datable。

官方的测试代码以及数据

Performance of `SELECT` mapping over 500 iterations - POCO serialization

Method Duration Remarks

Hand coded (using a `SqlDataReader`) 47ms

Dapper `ExecuteMapperQuery<Post>` 49ms

PetaPoco 52ms Can be faster

BLToolkit 80ms

SubSonic CodingHorror 107ms

NHibernate SQL 104ms

Linq 2 SQL `ExecuteQuery` 181ms

Entity framework `ExecuteStoreQuery` 631ms

Performance of `SELECT` mapping over 500 iterations - dynamic serialization

Method Duration Remarks

Dapper `ExecuteMapperQuery (dynamic)` 48ms

Massive 52ms

Simple.Data 95ms

Performance of `SELECT` mapping over 500 iterations - typical usage

Method Duration Remarks

Linq 2 SQL `CompiledQuery` 81ms Not super typical involves complex code

NHibernate HQL 118ms

Linq 2 SQL 559ms

Entity framework 859ms

SubSonic `ActiveRecord.SingleOrDefault` 3619ms

Performance benchmarks are available here: http://code.google.com/p/dapper-dot-net/source/browse/Tests/PerformanceTests.cs , Feel free to submit patches that include other ORMs - when running benchmarks, be sure to compile in Release and not attach a debugger (ctrl F5)

内存控制非常好。

结论不管你用不用，我反正是用它了。

我编译好了一份发上来了。点击下载。代码如下有点长
本文链接

穿过任意防火墙NAT的远程控制软件TeamViewer

2011-09-16T03:39:00Z

这两天有个想法，就是把自己收集的大量视频教程文档和各位网友分享一下。因为很多资源在网上很难找到，或者是即便找到了要么是收费下载要么是下载速度慢到难以忍受的程度，好不容易找到一个rayfile或者纳米盘的又发现资源早已删除了。但是我所处的环境是校园内网的一个普通实验室中，学校的出口是防火墙，限制极为严格，所有网络都是NAT跑出去的，NAT这东西很厉害，不仅仅是节约IP地址，更重要的是安全，他是不允许外部网路向内部网络发起连接的。这也就是为啥灰鸽子那种反弹木马能流行的原因。

我收集的教程都放在实验室的一个存储服务器上，由于是内网，所以我做不了ftp服务器，试过花生壳等动态域名解析程序，可惜那些只对家庭用户的简单网络比较有效，对于学校或者企业这种内部网络相对复杂的是没有一点作用的。

但是遇到问题就要想解决的办法，这是一个IT技术人员最基本的素质。于是我开始搜索大量的共享方法。首先就是BT和电驴这种软件，这种软件设计的目的就是共享资源，但是由于学校的出口做了限制，只允许正常的端口如80，21等访问，所以，BT那些端口到了防火墙也全被被咔嚓，毫无意义。

第二种方式就是zapr，zapr是这样介绍的“Zapr是一款操作简单的免费共享软件，让您的个人电脑成为一台操作简单而安全的网络服务器。它能将您个人电脑里任何需要共享的文件或文件夹创建成一个普通的网络链接地址。当访问者点击该链接，Zapr会将您共享的内容呈现在他们面前，而他们无需注册、无需安装客户端，便可以浏览或下载相关的内容了。整个过程无需上传，也没有文件大小或类型的限制，并且非常安全可靠”。看上去很美，其实面对我这种网络环境依然没有一丁点用。

第三种就是vpn，vpn虽然好用，但是免费的几乎没有，好的都是要收费的，于是也放弃了这种选择。

最后发现了一款非常牛X的软件，号称可以穿过任意防火墙NAT的软件，其实，作为一个搞网络的，明白这个穿过二字是啥意思，说白了就是绕过去了，没走你那条被封的道。这个牛X软件就叫TeamViewer，字面解释就是团队查看，主要用于远程协助帮忙，无论你处在一个网络多么复杂的环境中，只要你能上网，对方也能上网，哦了，那你们俩就能相互连来连去，彼此访问远程控制。你还别不信，现在就给你演示一下，这还真应了51cto那句话，技术成就梦想，哈哈。

我在网上找了个绿色版，这个软件是免费的，大家可以到他的官方网站下载www.teamviewer.com，绿色的版本可以下载我这篇文章屁股后面的附件。

软件界面非常简洁漂亮，让人看着很舒服。启动以后会自动连接他的服务器，然后为你这台电脑生成一个ID，ID是啥，就是身份证了，表示你身份的，还有一个随机密码，当然，这个密码能改，我们稍后提到。把这个ID和密码发送给你想让连接你的电脑的人，让他也运行一下这个软件，然后在右侧创建连接处输入你的ID，就可以连接到你了。

单击连接后会提示输入密码，输入正确的密码即可看到桌面并进行控制了

看，登录成功了，并提示了一下你所具有的权限，这个控制窗口是不是很帅，和REALVNC有点像。现在你就可以为所欲为啦。同样，你如果知道对方的ID和密码，一样可以连接到他。而且无论你是在内网还是家庭宽带等。

我们来设置一下权限，这样避免别人连上来就把我们的电脑关掉或者删了很多文件，有时我们可能只是临时给对方用一下。设置权限当然要在服务端了。

单击上图中的配置可以进行详细的权限配置，当然，这里指的详细并非像系统中的那样详细，而是指针对每个功能的设置。权限一共是三个等级，确认后、已拒绝、已允许。确认后表示当有相应的请求接入时，会提示给服务端，有10秒的等待时间，10秒内如果服务端确认，那么操作方可继续进行，如果服务端不确认或者拒绝，那么客户端将无法对服务端进行相应的操作。已拒绝表示直接拒绝，已允许表示直接允许。

确认后权限的效果

文件传输功能比较有趣，类似一个FTP客户端，如图

下载文件时漂亮的进度条

服务端也会有文件传输日志

最后说一下修改密码，默认情况下这个软件每启动一次会随机生成一个密码，我们可以手工修改成一个固定的密码，单击额外中的选项中的常规，在密码一栏设置。

设置固定密码后的效果，密码栏变成了预置的。

ok，到此这个非常牛X可以自由穿过防火墙NAT的远程控制软件就演示完成了，希望对各位朋友能有所帮助

本文链接

.NET 动态脚本语言Script.NET 入门指南 Quick Start

2011-09-16T00:17:00Z

Script.NET是一种动态的脚本语言，它使得程序可扩展，可定制，和维护性好。和Office系列的VB Script相似，可以在应用中嵌入大量的代码块，以便在运行时才执行这些代码。

Script.NET的设计理念是：简单(simplicity)，有效率(efficiency)，容易上手(intuitive)。先通过例子，来做一个基本的了解。

using System;
using System.Diagnostics;
using System.IO;
using ScriptNET;
using ScriptNET.Runtime;
namespace Debug.Net
{
    class Program
    {
        static void Main(string[] args)
        {
            RuntimeHost.Initialize();
            Script s = Script.Compile("Console.WriteLine('Hello World');");
            s.Execute();
            RuntimeHost.CleanUp();         
        }
    }

}

为了编译这个例子，请先添加对程序集ScriptDotNet.dll的引用，它的Target是.NET 3.5。这个例子可以看出，Script.NET是如何调用.NET Framework的类型，并调用它的方法。再来看一个例子

RuntimeHost.Initialize();
object obj=Script.RunCode(" return 1+1;");
Console.WriteLine(obj);

这个例子演示了，如何运行Script.NET的代码片段。

数据类型，常量，表达式，语句

作为一门语言，一般会包含语法，数据类型，表达式，语句，这是语言层面的基础内容。来看下面的表格，

Script.NET支持的数据类型

常量，boolean类型的常量是true或false, null表示对象为空，字符串用单引号括起来。

运算符号：+, -, , / ,%, ! , | , & , != , > , < , is 。其中is用于对象类型。

请看下面的例子表达式，

X = (y+4)2;
Y = a[5] + 8;
Z = Math.Sqrt(256);
P = new System.Drawing.Point(3,4);

语句 Script.NET程序是语句的集合，有三种常用的语句：顺序(sequencing )，循环(loop)，分支(branching)

If ... Then ... Else ... if (Expression) statement else Statement

if (x>0) y = y + 1 ; else y = y ?1; if (x>0) message = 'X is positive';

For ... for (Expression1;Expression2;Expression3) Statement

sum=0;
for(i=0; i<10; i++)
sum = sum + a[i];

Foreach ... in ... foreach (Identifier in Expression) Statement

arr=[1,2,3,4,5]; sum = 0;
foreach(i in arr ) sum = sum + i;

While ... while (Expression) Statement

while (i>0) i = i-1;

Switch

switch (expr){
case expr1: statement
   ...
default: statement
}

switch (i){
   case 1: MessageBox.Show('Hello!');
   case 2: MessageBox.Show('?');
   default: MessageBox.Show('No way');
}

Break, Continue 只用于循环语句中，用于跳出循环

Return 用于返回函数(function)

函数 function

Script.NET是脚本语言，而不是面向对象的OOP语言。通常会将一将代码片段封装成函数，函数的定义语法如下

function(id1,id2,…,idn) {

statement}

function fac(n){

if (n==1) return 1;

else return n*fac(n-1);

}

MessageBox.Show(fac(5).ToString());

Func_pointer = fac;

Func_pointer(4);

下面的代码，演示了Script.NET与Host的交互，从Host中获取值

RuntimeHost.Initialize();         
List<int> vals = new List<int>();
vals.AddRange(new int[] { 1, 2, 3, 4 });
Script script = Script.Compile(@"
         rez = 0;
         foreach (number in numbers)
         rez += number;"
          );

script.Context.SetItem("numbers", vals);
object rez = script.Execute();
Console.WriteLine(rez);

运行程序，输出结果如下

Script Context 脚本上下文

脚本上下文存储运行时信息，变量，和引入的类型，它可以引入.NET的对象到脚本中，以运用.NET Framework的强大功能。下面的例子演示Script.NET与Host的类型互操作

class Program
    {
        static void Main(string[] args)
        {
            RuntimeHost.Initialize();
            Type type = RuntimeHost.GetType("A");
            object script = Script.RunCode(@" a=new A();
                          a.Name='From Script.NET';
                           return a.Name;
                           ");
            Console.WriteLine(script);
        }
    }
    public class A
    {
        public string Name { get; set; }
    }

在Host中定义类型A,并引用它，可以在Script.NET中直接使用。也可在Host中定义类型，然后把它的值传到Script.NET中，请看例子

RuntimeHost.Initialize();
Type type = RuntimeHost.GetType("A");
A a = new A();
a.Name = "From Host";
Script script = Script.Compile(@"
                 ab.Name='From Script.NET';
                  return ab.Name;
                   ");
script.Context.SetItem("ab", a);
script.Execute();
Console.WriteLine(script);

启动调试，在script.Execute执行前后，对象a的Name属性值是不同的。

Runtime Configuration 运行时配置

在Script.NET压缩包的根目录，找到配置文件RuntimeConfig.xml，把它添加到项目中。它包含，要引用的程序集，类型映射，和运行Script.NET引擎时，可以指定的初试化代码。

……

</Types>

比如，可以在Initialization区域定义数值常量，或是初始化代码，如下所示

再回到Script.NET脚本代码中，代码如下

RuntimeHost.Initialize(new FileStream("RuntimeConfig.xml",FileMode.Open));
Script script = Script.Compile(@"
                 Console.WriteLine(Pi);                           
                   ");
script.Execute();
Console.WriteLine(script);

运行程序，可看到控制台输邮结果如下

注意，Script.NET的标识符是大小写敏感的,如果在脚本调用中把Pi写成了PI，会报异常。

Unhandled Exception: ScriptNET.Runtime.ScriptIdNotFoundException: Namespace PI is not found

Script.NET原来的名称是S#, 文档和实际的代码有差异。我是根据对.NET的理解来推断它的用法，发生错误的原因，再加上它本身是个开放源码的项目，可以直接集成到现有的应用程序中，发生错误也可以源代码的方式调试。以这种方式，可以将应用程序代码中，将需要动态编译的代码，转化为Script.NET的脚本，借助于Script.NET的强大功能，增加应用程序的灵活性。

官方网站
http://www.protsyk.com/scriptdotnet/wiki/index.php?title=Main_Page

另外，老外也写了一篇文章在这里
http://www.codeproject.com/KB/cs/ScriptNET.aspx

本文链接

.NET 动态脚本语言Script.NET 应用举例

2011-09-16T00:17:00Z

.NET 动态脚本语言Script.NET 应用举例

继续前面的两篇文章的动态脚本语言主题《.NET 动态脚本语言Script.NET 入门指南 Quick Start》和《.NET 动态脚本语言Script.NET 开发指南》，继续学习Script.NET的应用。

类型定义 type definition

Script.NET不是OOP的语言，但可以借助于属性(property bags)来模拟类型定义。

vector = [
  x -> 4,
  y -> 3,
   length -> function() {
       Math.Sqrt(me.x^2+me.y^2);
   } 
  ];

Console.WriteLine(vector.length());

这段代码输出的结果是5，这里模拟向量类型的定义，并定义函数length计算向量的长度。me与C#中的this相似。

再来看下面的例子，同样也是模拟OOP语言的类型定义

stack = [
             Test -> function() { return 'Hello Test';}
        ];
return stack.Test();

在Script.IDE中运行这段代码，它的结果是输出字符串Hello Test。

在property bags中，用->来指向定义的函数名称，对比一下Script.NET语法规定的函数定义

function swap(array, a, b)
{
    tmp=array[a];
    array[a]=array[b];
    array[b]=tmp;
}

也可以这样的语法形式定义函数,和JavaScript函数定义相似

Test = function (item) 
{
     y = item;
};

函数的作用域 Function Scopes

先看一下Script.NET官方文档中的一张解释scope的图片

程序语言中scope的作用是解析名称引用。比如，在C#中有如下的代码

class Program
{
      static void Main(string[] args)
      {    
            int x=100;
            Add();           
      }

      static int Add()
      {
           int x=10;
           return x;
      }
}

通过运行代码，可以知道Add方法(method,也可叫function)返回的值是10。C#是纯粹pure的OOP语言，没有全局变量。C语言则可以包涵全局变量，它在解析名称引用(scope)方面会复杂很多。抱歉，对C语言相当陌生，不能举例说明。

来看几个例子，加深对scope的理解。

a = 4; b = 2; c = 3;
function test1(a,b)    global(c)
{
    c = a+b;
    a = 15;
}
Console.WriteLine(test1(2,3));

Console.WriteLine( a);

Console.WriteLine( b);

Console.WriteLine( c);

这次的函数定义稍微有些改变，在函数的参数列表之后，加了global(c) 以表示它的的作用域是global,全局的。

在Script.NET IDE中运行，结果如下

这里先说明一下，函数如果没有定义return语句，则最后一个表达式的值，就是函数的返回值，所以test1(2,3)返回a=15;结果就是15。a和b的scope是local,在function中对它的改变，不会影响到它的值(这和C语言的堆栈定义，调用函数，取参数的副本，并把参数压入堆栈相同，如果要传入参数变量的引用，而不是副本，则要用到指针)。c因为定义为global，在函数test1中对它的改变，仍然会保留，所以最后一行输出结果5。

如果没有忘记前面的contract部分的内容，应该可以理解下面的函数定义格式。

a = 4; b = 2; c = 3;
function test1(a,b)   global(c)
[
    pre(a>0);
    post();
    invariant();
]
    {
        c = a+b;
        a = 15;
    }

如果在函数中应用global，却没有定义它的变量，像下面的语句，则会抛出异常ScriptIdNotFoundException

Test = function (item) global(y)
     {
               y = item;
      };
Test(2);

在C语言中，一定要先定义函数，再来调用函数，否则会找不到函数定义。如果要在定义函数的语句之前调用该函数，则需要前置声明。Visual C++中还要求在.h文件中声明类型和函数，在.cpp文件中实现，C#中则没有这个限制。

请看下面的代码

return f();

function f() {return 1;}

在定义函数f的语句代码之前，可以调用它而不用写任何语句，多亏了编译技术的进步。

运算符指派 Operators Dispatching

在程序语言中，如果运算符号(+,-%…)左右两边的类型不相同，则会发生类型转换，这还涉及到运算符号重载，比如加号+可以应用到数据运算，也可以应用于字符串连接。请体会下面的例子来理解运算符指派。

Console.WriteLine( 1+1);                //2
Console.WriteLine( 1.2+1 );              //2.2  
Console.WriteLine( '1'+1 );              //11
Console.WriteLine( 'Hello '+1+' Text' ); //Hello 1 Text
Console.WriteLine( 10-1);       //9
Console.WriteLine( 1.2-1);      //1.2-1=0.2
Console.WriteLine( 10*12);      //10*12
Console.WriteLine( 3.2*3);      //(double)3.2*3=9.6
Console.WriteLine( 3.5*21.5);   //(double)3.5 * 21.5=75.25
Console.WriteLine( 6/2);        //6 / 2 =3
Console.WriteLine( 10/12);      //10 / 12 =0
Console.WriteLine( 45.43/12.3); //(double)45.43 / 12.3=.69349593495935
Console.WriteLine( 3.5/21);     //(double)3.5 / 21=0.166666666666667
Console.WriteLine( 3/21.2);     //3 / (double)21.2=0=0.141509433962264
Console.WriteLine( 6%2);        //6 % 2=0
Console.WriteLine( 10%12);      //10 % 12=10
Console.WriteLine( 45.43%12.3); //(double)45.43 % 12.3=8.53
Console.WriteLine( 6^2);        //Math.Pow(6, 2)=36

如果运算符号不支持两边的数据类型，则发抛出异常NotSupportedException。比如

Console.WriteLine( '1'-1 );  //NotSupportedException

Scripting Runtime 运行时

Script.NET的作者画了一张漂亮的Runtime图，以解释他们的作用。

这个图可以解释下面的代码，为什么不需要添加类型Test的定义，也可以找到Test类型

//RuntimeHost.AddType("TestT", typeof(TestT));
Test rez = (Test)Script.RunCode(@"
         a = new Test();
         a.value = 'test';
         a.intVal = 20;

         return a; ")

原因就在AssemblyManager,它会sacn当前app domain中的程序集以及其中的类型定义，加入到Script Runtime中。

如果还记得前面文章中提到的RuntimeConfig.xml文件，它会在runtime 启动时，加载需要的程序集，类型映射，和初试代码片段。可以通过修改ScriptDotNet项目中的这个Embedded Resource的文件，达到初试化的目的。

也可以用下面的方法，加载自定义的runtime configuration。

public static Stream TestConfig
{
      get
      {
        Stream configStream = Assembly.GetExecutingAssembly().GetManifestResourceStream                                ("UnitTests.TestConfig.xml");
        configStream.Seek(0, SeekOrigin.Begin);
        return configStream;
      }
}

RuntimeHost.AssemblyManager = new BaseAssemblyManager();
RuntimeHost.Initialize(TestConfig);

RuntimeHost.Initialize();这一句是必须调用的，传入Stream对象，还可以这样调用

RuntimeHost.Initialize(new FileStream("RuntimeConfig.xml",FileMode.Open));

可以像下面的代码定义，这样阻止load程序集

RuntimeHost.AssemblyManager.BeforeAddAssembly +=
    (s, e) => {
       if (e.Assembly.FullName != "System.Data, Version=2.0.0.0, Culture=neutral,                                                            PublicKeyToken=b77a5c561934e089")
            throw new Exception();
        };

自定义运算符 Custom operator

再来看一个运算符的例子，我希望1234,$1234,都可以表示货币数量，$这个符号没有内置在系统的运算符中，需要用下面的方法，添加进来。

private class DollarHandler : IOperatorHandler
{    
      public object Process(HandleOperatorArgs args)
      {
        if (args.Arguments != null && args.Arguments.Length == 1)
        {
          string value = (string)args.Arguments[0];
          args.Cancel = true;
          return int.Parse(value);
        }
        throw new NotSupportedException();
    }
}
 
RuntimeHost.Initialize(TestConfig);
RuntimeHost.RegisterOperatorHandler("$", new DollarHandler());

Script script = Script.Compile(@"
              return $'1234';   ");
object rez = script.Execute();

通过Debug代码，可以看到rez的值是1234,没有抛出异常。

扩展类型的函数 Custom type’s function

再看下面的例子，Script.NET内置的类型没有ToString函数，我要给它扩展，添加ToString函数。

private class MyBinder : ObjectBinder
    {
      public override bool CanBind(MemberInfo member)
      {
          if (member.Name == "ToString")
              return true;         
        return base.CanBind(member);
      }
      public object ConvertTo(object value, Type targetType)
      {
          return value.ToString();
      }
}

再来举例调用上面添加的函数

RuntimeHost.Binder = new MyBinder();
RuntimeHost.Initialize(TestConfig);

Script script = Script.Compile(@"
            b = 'a';
            b.ToString();
            money=100;
            money.ToString();
       ");
object obj=script.Execute();

返回结果obj的值是100。这使我想到了C#的扩展方法，如下所示

public class DecimalHelper
 {
        public static string ToString(this decimal obj)
        {
            return obj.ToString();
        }
 }

下面这样的代码是可以通过编译的

decimal money = 100;
string howMuch=money.ToString();

这两者非常的相似。C#中的decimal有对象System.Decimal来表达同等的含义，而Script.NET没有对象的概念，只有基础的数据类型double,long,string,bool和数组array，同样可以做到扩展函数的功能。

本文链接

Method	Duration	Remarks
Hand coded (using a `SqlDataReader`)	47ms
Dapper `ExecuteMapperQuery<Post>`	49ms
PetaPoco	52ms	Can be faster
BLToolkit	80ms
SubSonic CodingHorror	107ms
NHibernate SQL	104ms
Linq 2 SQL `ExecuteQuery`	181ms
Entity framework `ExecuteStoreQuery`	631ms

博客园_TCSJ

WPF binding（转）

ExcelEdit 操作类

WCF开发框架形成之旅--如何实现X509证书加密

WPF中的ControlTemplate(控件模板)

WPF中的Style(风格,样式)

C#4.0新Feature官方文档和Sample Code下载 [本文提供Office编程的一段Sample Code作为预览]

给力分享新的ORM => Dapper

Performance of SELECT mapping over 500 iterations - dynamic serialization Method Duration Remarks Dapper ExecuteMapperQuery (dynamic) 48ms Massive 52ms Simple.Data 95ms

穿过任意防火墙NAT的远程控制软件TeamViewer

.NET 动态脚本语言Script.NET 入门指南 Quick Start

For ... for (Expression1;Expression2;Expression3) Statement sum=0; for(i=0; i<10; i++) sum = sum + a[i];

Foreach ... in ... foreach (Identifier in Expression) Statement arr=[1,2,3,4,5]; sum = 0; foreach(i in arr ) sum = sum + i;

While ... while (Expression) Statement while (i>0) i = i-1;

Switch switch (expr){ case expr1: statement ... default: statement } switch (i){ case 1: MessageBox.Show('Hello!'); case 2: MessageBox.Show('?'); default: MessageBox.Show('No way'); }

Break, Continue 只用于循环语句中，用于跳出循环

Return 用于返回函数(function)

.NET 动态脚本语言Script.NET 应用举例

Performance of `SELECT` mapping over 500 iterations - dynamic serialization

Method Duration Remarks

Dapper `ExecuteMapperQuery (dynamic)` 48ms

Massive 52ms

Simple.Data 95ms

For ... for (Expression1;Expression2;Expression3) Statement

sum=0;
for(i=0; i<10; i++)
sum = sum + a[i];

Foreach ... in ... foreach (Identifier in Expression) Statement

arr=[1,2,3,4,5]; sum = 0;
foreach(i in arr ) sum = sum + i;

While ... while (Expression) Statement

while (i>0) i = i-1;

Switch

switch (expr){
case expr1: statement
...
default: statement
}

switch (i){
case 1: MessageBox.Show('Hello!');
case 2: MessageBox.Show('?');
default: MessageBox.Show('No way');
}