博客园_Technological achievements dream

HTML 5 Step by Step(一) 拖放API

2012-02-08T13:44:00Z

在Html4中，我们可以通过监听mousedown、mousemove、mouseup来实现拖放效果。在Html5中，直接提供了支持拖放操作的API，我们可以很简单的几步就可以实现拖放的效果。

实现的概要

首先我们了解下跟拖动相关的事件：

事件	产生的源对象	说明
dragstart	被拖动的元素	开始拖放动作
drag	被拖动的元素	拖放过程中
dragenter	拖动过程中鼠标经过的元素	被拖动的元素开始进入本元素的范围内
dragleave	拖动过程中鼠标经过的元素	被拖动的元素离开本元素的范围
drop	拖放的目标元素	有其他元素拖动到了本元素中
dragend	拖动的对象元素	拖动结束
dragover	拖动过程中鼠标经过的元素	被拖动的元素在本元素上移动

实现步骤：

1.我们要想一个元素可以被拖动，同时需要将元素的draggable属性设置为true（img、a默认允许拖放）；

2.监听拖动相关的事件。

Demo

我们实现一个将几个商品拖入的购物车的一个简单Demo，效果如下：

首先看下Html代码：

<body onload="init()">
    <span>商品列表</span>
    <div class="goodsList">
        <div class="goods" draggable="true">
            ThinkPad T410i</div>
        <div class="goods" draggable="true">
            Ipad 2</div>
    </div>
    <span>已选商品：</span>
    <div id="box" style="width: 200px; height: 200px; border: 1px solid green;">
    </div>
</body>

Javascirpt:

          function init() {
            var goodsList = getElementsbyClassName('goods');
            var box = document.getElementById('box');
            for (var i = 0; i < goodsList.length; i++) {
                goodsList[i].addEventListener('dragstart', function (ev) {
                    var dt = ev.dataTransfer;
                    dt.effectAllowed = 'all';
                    dt.setData('text/plain', this.textContent);
                }, false);
            }
            box.addEventListener('dragend', function (ev) {
                ev.preventDefault();
            }, false);
            box.addEventListener('drop', function (ev) {
                var dt = ev.dataTransfer;
                var goodsName = dt.getData('text/plain');
                box.textContent += goodsName;
                ev.preventDefault();
                ev.stopPropagation();
            }, false);
        }

解释下上面的代码：

1.获取class为goods的元素，在dragstart的时候，将自己本元素的textContext传递给dataTransfer（下面会说明dataTransfer对象的作用）；

2.在将goods拖动到box时候，获取dataTransfer数据，并显示出来；

3.preventDefault的作用是，对于目标元素，默认的情况下是不允许接收元素的，所以必须在dragend或则dragover事件内调用preventDefault。

关于DataTransfer对象

我们通过上面的例子知道拖动时是通过DataTransfer来进行拖动元素之间的数据传递的，同时我们也可以通过设置DataTansfer里面的相关属性来实现一些拖动的额外效果。下面看下DataTransfer的属性与方法：

属性/方法	作用
dropEffect属性	拖放操作的视觉效果，可以指定为none、copy、link、move
effectAllowed属性	指定当元素被拖放时所允许的视觉效果
types属性	存入数据的种类
cleraData(DomString format)	清楚DataTransfer对象中存放的数据
setData(DOMString format,DomString data)	存入数据
DOMString getData(DOMString format)	从DataTransfer对象中读取数据
setDragImange(Element image，long x,long y)	用img元素来设置拖放图标

这里有几个要说明的：

1.现在拖动处理所支持的MIME类型为以下几种：

text/plain:文本文字；

text/html:HTML文字；

text/xml:xml；

text/uri-list:url列表。

对于dropEffect、effectAllowed属性使用的几个注意的地方：

一般的时候我们在ondragstart事件中去设置effectAllowed值，在ondragover事件中指定dropEffect值。其中如果effectAllowed属性设置为none，则不允许拖动，如果dropEffect属性设置为none，则不允许拖放到目标元素中。

总结

通过本篇Post，了解了Html5中拖放的新的API，比起html4实现起来要简单很多。下面的文章会继续一步步学习Html5其他方面的相关特性。

本文链接

Git学习笔记（一）初识Git

2012-02-02T12:38:00Z

Git/GitHub已经火爆很长时间了，我已经落伍了。不管怎样现在学习也不为晚，今年也争取走出.Net，看看外面的世界。

安装Git

这里只在Window下进行的，首先从这里下载Git.exe。下载完成后，然后就进行Next、Next、Next…

生成SSH

安装完成后，进行SSH的生成跟设置，打开“Git Bash”

1.判断是否已经创建了ssh:

$ cd ~/.ssh

第一次安装完，一般提示为No.

2.生成ssh

$ ssh-keygen -t rsa -C henllyee@126.com

这里使用您自己的邮箱

默认会生成id_dsa.pub文件在C:\Users\YourUserName\.ssh

3.将ssh key 跟Git Hub联系起来

点击“Account Setting”，选择，点击"Add another public key ",将刚才生成的文件里面的内容拷贝到Key中。

4.测试是否可以连接上Github

$ ssh -T git@github.com

提示以下信息表示OK.

到这里，我们的SSH Key就生成完成了。这步的主要作用是，机器上的Git要跟GitHub进行连接必须要进行身份认证，ssh key即身份认证的凭证。

设置自己的用户信息

1.设置用户名称和邮箱信息

$ git config --global user.name "Firstname Lastname"

$ git config --global user.email "your_email@youremail.com"

2.设置Token

为了在一些其他工具使用git的时候并没有没有ssh key，这个时候需要我们配置我们的API token。在Account Setting里面选择“Account Admin”，可以找到我们的Token信息。

$ git config --global github.user username

$ git config --global github.token yourtoken

创建第一个Repository

1.创建Repository

点击“New repository”,这里我们取名Repository名字为“Test”.

2.创建本地项目

$ mkdir Test

创建 “Test”目录

$ cd Test

$ git init

git初始化

$ touch README

$ git add README

增加README文件

$ git commit README

$ git commit -m 'first commit'
$ git remote add origin git@github.com:henllyee/Test.git

$ git push -u origin master

提交到github中

这个时候在Repository中就可以看到提交进去的README文件：

总结

本篇post主要是初步认识下git/github,后面详细学习下git的常用命令。

本文链接

DDD中的Specification模式

2011-09-12T08:44:00Z

在领域驱动开发中，我们会常用到Repository、Unit of Work等模式，而Specification模式并不是很常用，Specification模式在领域层中主要为我们实现领域规则的自由组合。

关于Specification

首先我们来看常见的Specification模式中的类图（来自于http://en.wikipedia.org/wiki/Specification_pattern）：

Specification，规格说明书，这里我们可以理解为规则约束，我们可以对每个规则定义一个Specification，同时也可以将不同的Specification进行组合使用。

简单实现

首先我们定义ISpecification接口：

public interface ISpecification<T>
{
    bool IsSatisfiedBy(T candidate);
}

我们定义ICompsiteSpecification，这里使用了Compsite模式（组合模式）

public interface ICompsiteSpecification<T>:ISpecification<T>
{
    ISpecification<T> Add(ISpecification<T> other);

    ISpecification<T> Or(ISpecification<T> other);

    ISpecification<T> Not();
}

AddSpecification:

public class AddSpecification<T>:ISpecification<T>
{
    private ISpecification<T> _Left;
    private ISpecification<T> _Right;

    public AddSpecification(ISpecification<T> left,ISpecification<T> right)
    {
        _Left = left;
        _Right = right;
    }

    public bool IsSatisfiedBy(T candidate)
    {
        return _Left.IsSatisfiedBy(candidate) && _Right.IsSatisfiedBy(candidate);
    }
}

OrSpecification:

public class OrSpecification<T>:ISpecification<T>
{
    private ISpecification<T> _Left;
    private ISpecification<T> _Right;

    public OrSpecification(ISpecification<T> left, ISpecification<T> right)
    {
        _Left = left;
        _Right = right;
    }

    public bool IsSatisfiedBy(T candidate)
    {
        return _Left.IsSatisfiedBy(candidate) || _Right.IsSatisfiedBy(candidate);
    }
}

NoSpecification:

public class NotSpecification<T>:ISpecification<T>
{
    private ISpecification<T> _Wrapped;

    public NotSpecification(ISpecification<T> wrapped)
    {
        _Wrapped = wrapped;
    }

    public bool IsSatisfiedBy(T candidate)
    {
        return (!_Wrapped.IsSatisfiedBy(candidate));
    }
}

CompositeSpecification:

public abstract class CompositeSpecification<T>:ICompsiteSpecification<T>
{

    public abstract bool IsSatisfiedBy(T candidate);

    public ISpecification<T> Add(ISpecification<T> other)
    {
        return new AddSpecification<T>(this, other);
    }

    public ISpecification<T> Or(ISpecification<T> other)
    {
        return new OrSpecification<T>(this, other);
    }

    public ISpecification<T> Not()
    {
        return new NotSpecification<T>(this);
    }
}

我们举了个实际的例子进行使用，比如我们要获取一个数组里面所有的大于0而且是偶数的数字。这个时候我们可以定义两个Specification，一个是整数的Specification，一个是偶数的Specification：

public class EvenSpecification:CompositeSpecification<int>
{
    public override bool IsSatisfiedBy(int candidate)
    {
        return candidate % 2 == 0;
    }
}

我们再定义一个判断为正数的Specification:

public class PositiveSpecification:CompositeSpecification<int>
{
    public override bool IsSatisfiedBy(int candidate)
    {
        return candidate > 0;
    }
}

使用:

static void Main(string[] args)
{
    var numbers = Enumerable.Range(-10,20);
    var postivieSpecification = new PositiveSpecification();
    var compositSpecification = postivieSpecification.Add(new EvenSpecification());
    foreach (var item in numbers.Where(i => compositSpecification.IsSatisfiedBy(i)))
    {
        Console.WriteLine(item);
    }
    Console.ReadKey();
}

DDD中使用

举个在我们实际业务中的查询来说明下吧。在.net 3.0之后我们有了Lambda表达式，我们可以通过更为优雅的一种方式来实现了:

public interface ISpecification<T>
{
    Expression<Func<T, bool>> IsSatisfiedBy();
}

在这里IsSatisfiedBy方法返回的不是bool类型的，而是返回一个Lambda表达式，是为了跟Where进行配合使用。

这个时候我们对Expression<Func<T,bool>>类型进行扩展增加其And、Or方法：

public static class ExpressionBuilder
{
    public static Expression<T> Compose<T>(this Expression<T> left,Expression<T> right,Func<Expression, Expression, Expression> merge)
    {
        var params1 = left.Parameters;
        var params2 = right.Parameters;
        var map = params1.Select((p,i)=> new {p,s= params2[i]}).ToDictionary(p=>p.s,p=>p.p);
        var rightBody = ParameterRebinder.ReplaceParameters(map,right.Body);
        return Expression.Lambda<T>(merge(left, rightBody), left.Parameters);
    }

    public static Expression<Func<T,bool>> And<T>(this Expression<Func<T,bool>> left,Expression<Func<T,bool>> right)
    {
       return left.Compose(right, Expression.Add);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        return left.Compose(right, Expression.Or);
    }
}

Visitor:

public class ParameterRebinder:ExpressionVisitor
{
    private readonly Dictionary<ParameterExpression, ParameterExpression> _Map;

    public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
    {
        _Map = map;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        ParameterExpression replacement;
        if (_Map.TryGetValue(node,out replacement))
        {
            node = replacement;
        }
        return base.VisitParameter(node);
    }

    public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
    {
        return (new ParameterRebinder(map)).Visit(exp);
    }
}

上面的扩展为了我们方便的实现Expression<Func<T,bool>>类型进行我们逻辑And、Or操作。对于表达式书不太熟悉的同学可以参考MSDN上面的两篇文章：http://msdn.microsoft.com/zh-cn/library/bb397951.aspx、http://msdn.microsoft.com/zh-cn/library/bb546136.aspx

为了方便我们进行And、Or动作，我们可以对操作符进行重载：

public abstract  class Specification<T>:ISpecification<T>
{

    public abstract Expression<Func<T, bool>> IsSatisfiedBy();

    public static ISpecification<T> operator |(Specification<T> left, Specification<T> right)
    {
        return new OrSpecification<T>(left, right);
    }

    public static ISpecification<T> operator &(Specification<T> left, Specification<T> right)
    {
        return new AddSpecification<T>(left, right);
    }

    public static ISpecification<T> operator !(Specification<T> specification)
    {
        return new NotSpecification<T>(specification);
    }

    public static bool operator false(Specification<T> specification)
    {
        return false;
    }

    public static bool operator true(Specification<T> specification)
    {
        return true;
    }
}

CompositeSpecification:

public abstract class CompositeSpecification<T>:Specification<T>
{
    public abstract ISpecification<T> Left { get; }

    public abstract ISpecification<T> Right { get; }
    
}

And:

public class AddSpecification<T>:CompositeSpecification<T>
{
    private ISpecification<T> _Left;
    private ISpecification<T> _Right;

    public AddSpecification(ISpecification<T> left,ISpecification<T> right)
    {
        _Left = left;
        _Right = right;
    }

    public override ISpecification<T> Left
    {
        get { return _Left; }
    }

    public override ISpecification<T> Right
    {
        get { return _Right; }
    }



    public override Expression<Func<T,bool>> IsSatisfiedBy()
    {
        return _Left.IsSatisfiedBy().And(_Right.IsSatisfiedBy());
    }
}

Or:

public class OrSpecification<T> : CompositeSpecification<T>
{
    private ISpecification<T> _Left;
    private ISpecification<T> _Right;

    public OrSpecification(ISpecification<T> left, ISpecification<T> right)
    {
        _Left = left;
        _Right = right;
    }

    public override ISpecification<T> Left
    {
        get { return _Left; }
    }

    public override ISpecification<T> Right
    {
        get { return _Right; }
    }


    public override Expression<Func<T, bool>> IsSatisfiedBy()
    {
        return _Left.IsSatisfiedBy().Or(_Right.IsSatisfiedBy());
    }

}

Not:

public class NotSpecification<T>:Specification<T>
{
    private ISpecification<T> _Wrapped;

    public NotSpecification(ISpecification<T> wrapped)
    {
        _Wrapped = wrapped;
    }

    public override Expression<Func<T,bool>> IsSatisfiedBy()
    {
        return Expression.Lambda<Func<T, bool>>(Expression.Not(_Wrapped.IsSatisfiedBy().Body),
                                                     _Wrapped.IsSatisfiedBy().Parameters.Single());
    }
}

其实我们上面的实现的类图是这样的一种结构：

举个例子，比如我们在实际的查询中，可以定义自己的Specification，同时可以通过And、Or进行查询规则的组合，然后传递给Repository.

总结

本文中主要讲解了Specification模式，以及我们在项目中如何使用Specification的。希望对您有用。

作者：Henllyee Cui
出处： http://henllyee.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明。

本文链接

Silverlight 4之旅（三）数据绑定（中）

2011-08-07T09:07:00Z

在上篇文章中我们已经看过了绑定的基础知识，以及绑定数据源的选择问题。在本篇文章中我们看下绑定时Target的现实的问题。

自定义显示

很多时候我们的DataSource存储的数据并不可以直接用来显示，比如说我们对于Bool类型，需要显示为“是”或则“否”而不是“True”,“False”，甚至有的时候我们需要将DataSource的某个属性在多个不同的UI的地方进行不同的显示。

在我们进行绑定的时候，绑定机制默认选择类型的ToString方法进行绑定到UI上面，还好，在Silverlight中提供了Formatting的机制让我们来自定义我们的显示。我们可以通过Formatting来定义格式化我们的显示，同时我们也可以通过Convert来进行转换，下面我们来看看Formatting部分。

Formatting&Converter

在我们编写的代码中，我们可以通过String.Format方法进行一个值的格式化，在绑定时我们也可以使用,其语法类似于String.Format。比如我们我们希望将一个Decimal类型的显示为￥2011，我们可以通过这种方式：

<TextBlock Text="{Binding Total,StringFormat=\{0:C\}}"></TextBlock>

可是大部分时候,简单的Format对我们来说是不够用的，更多时候我们需要Convert来转换我们Source的值，比如说我们需要Bool值类型的显示为否\是.我们在定义一个Convert时必须需要继承于IValueConverter接口，在IValueConverter中有两个方法：Convert、ConvertBack。Convert方法是指将将Source数据绑定到Target时转换动作，而ConvertBack是指将Target的数据返回到Source时的转换。下面我们来定义一个BooleanConvert:

public class BooleanConvert : IValueConverter
{

    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var booleanValue = Boolean.Parse(value.ToString());
        if (booleanValue) return "Yes";
        return "No";
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var strValue = value.ToString().ToLower();
        if (strValue.Equals("yes"))
            return true;
        return false;
    }
}

我们看看如何使用，在原来的Person中增加了Married属性：

private bool _Married;
public bool Married { 
    get { return _Married; }
    set {
        _Married = value;
        NotifyPropertyChanged("Married");
    }
}

然后我们再资源中增加BooleanConver的引用：

<UserControl.Resources>
        <local:BooleanConvert x:Key="BooleanConvert"></local:BooleanConvert>
    </UserControl.Resources>

在ListBox中增加Married:

<TextBlock Text="Married:" FontSize="12" Margin="3,3,0,0" Grid.Column="2"></TextBlock>
<TextBlock Text="{Binding Married,Converter={StaticResource BooleanConvert}}"
            FontSize="12" Margin="0,3,0,0" Grid.Column="3"></TextBlock>

运行效果：

在有的时候我们会出现转换错误，这个时候我们需要提供默认的fallback Value，下面我们看下两个中特殊情况下的处理。

fallback values & null values

在绑定时候，总会出现错误的情况，比如在一个属性的Geter中发生错误了等等，这个时候我们在绑定的表达式中指定下FallbackValue是非常有用的，我们可以这样指定：

<TextBlock Text="{Binding Married,Converter={StaticResource BooleanConvert},FallbackValue=Error}"
            FontSize="12" Margin="0,3,0,0" Grid.Column="3"></TextBlock>

有的时候我们的源数据中是Null值的时候，我们也需要额外的进行显示，在表达式中，我们可以通过指定TargetNullValue：

<TextBlock Text="{Binding Married,Converter={StaticResource BooleanConvert},FallbackValue=Error,TargetNullValue=Miss}"
            FontSize="12" Margin="0,3,0,0" Grid.Column="3"></TextBlock>

总结

本篇文章中我们主要看过了数据绑定时的自定义显示方面的内容，下篇文章中会就数据模板进行了解。

本文链接

Silverlight 4之旅（二）数据绑定（上）

2011-07-20T12:39:00Z

在上篇Post中通过一个简单的Demo，跟Silverlight有了一次接触，本篇文章中会就Silverlight 4中的绑定进行些说明。绑定可以说是Silverlight跟WPF中最为重要的技术，绑定的作用就是让我们的数据源跟SilverlightUI现实进行动态绑定。

绑定的基础概念

绑定是一种比较有效的建立UI跟Data之间的链接，在Silverlight中我们可以将UI的控件中的某个属性进行绑定，也可以将UI的几个属性之间进行相互绑定。绑定中有三个核心的概念：Source(数据源)、Binding Model（绑定模式）、Traget（目标UI）。这张图可以很好说明这三者之间的关系：

绑定的数据源一般是我们的CLR Object；Binding Mode是指我们使用绑定是所选择绑定的模式，共三种类型；目标我们的UI。我们先说说绑定的基本的语法。

语法基础

其实绑定的核心是通过Binding类建立Source跟Target之间的链接的，我们可以通过运行时指定，也可以通过在设计时进行指定。我们先看看运行时指定的语法：

首先我们在xaml中拥有如下控件：

<TextBox x:Name="dateTextBox" />

我们在后台代码中指定其绑定到当前时间:

var dateNow = DateTime.Now;
var binding = new Binding("dateNow");
binding.Source = dateNow;
binding.Mode = BindingMode.OneWay;
dateTextBox.SetBinding(TextBox.TextProperty, binding);

上面的代码的中,首先我们构建了Bingding对象，然后设置其Source以及BingdingMode，然后dateTextBox将其绑定设置到其TextProperty上面。这里面的Source即dateNow,BingMode选择的是OnWay的方式，Target即dateTextBox，正是上面说说的绑定的三个核心的概念。

下面我们看下如何在设计时指定：

<TextBox x:Name="dateTextBox" Text="{Binding TimeOfDay,Mode=OneWay}" />

在后台中我们指定了dateTextBox的DataContext属性：

var dateNow = DateTime.Now;
dateTextBox.DataContext = dateNow;

其实上面的{}方式只是一种简洁的方式，其实上面的绑定语法可以如此表达：

<TextBox x:Name="dateTextBox">
    <TextBox.Text>
        <Binding Path="TimeOfDay" Mode="OneWay"></Binding>
    </TextBox.Text>
</TextBox>

绑定Mode

绑定类型一共分为三种:1.OneTime;2.OneWay;TowWay.这三种模式在Source到Target绑定时，决定三种不同的绑定的类型。

1) OneTime

当我们使用OneTime绑定模式的时候，当Source发生改变的时候不会通知Target，只有在Source初始化时才会将其绑定到Target上面。

2) OneWay

OneWay是绑定Mode的默认值，在这种绑定的模式下，当Source发生改变的时候会通知并响应到Target上，如果Source的属性发生改变的时候，Target上面的属性就会自动改变。当时Target发生改变的时候，不会通知Source.

3) TwoWay

TowWay模式是指Target跟Source之间的改变会相互影响，我们在一些表单详细时会经常用到。

绑定Source

在绑定的源中,可以是一个CLR类型的Object，也可以是其他UI的某些属性上面，同事也可以绑定到自己本身的属性上面。下面我们来看下各种类型的绑定数据源的使用。

1）绑定到属性上面

在之前的例子里面我们看到了，将datetime的TimeOfDay绑定到了textblok上面，同时也是使用的OneWay的方式，即TimeOfDay发生改变，会更新到textblok上面，但是我们发现一个问题，就是现实的时候时间便没有自动更新。原因就是TimeOfDay属性没有做改变通知。我们回到第一篇文章中的Person类型，在这里面我们如何实现属性通知呢：

public class Person:INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private string _Name;
    public string Name
    {
        get { return _Name; }
        set {
            _Name = value;
            NotifyPropertyChanged("Name");
        }
    }

    private ImageSource _HeadImg;
    public ImageSource HeadImg
    {
        get { return _HeadImg; }
        set { 
            _HeadImg = value;
            NotifyPropertyChanged("HeadImg");
        }
    }

    public void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this,
            new PropertyChangedEventArgs(propertyName));
        }
    }
}

我们继承了INotifyPropertyChanged,INotifyPropertyChanged的作用就是做属性改变的广播通知,INotifyPropertyChanged可以保证我们在使用OneWay或则TowWay的模式的时候UI Target跟Source Property保证同步的。但是INotifyPropertyChanged的同步是通过 PropertyChangedEventHandler委托去告诉的，所以我们在属性改变时去触发事件PropertyChanged。

2）绑定到对象

在上面的例子里面我们主要都是看到了将一个数据源中的属性绑定上去的，其实更多的时候我们会将整个Object作为数据源来进行绑定。这个时候我们可以将Object指定到DataContext属性上面，DataContext是一个DepencyProperty允许我们共享数据，关键的是，我们在一个控件上指定了DataContext之后，其子element也可以使用到这个数据源。

我们在后台代码中：

var personList = GetPersons();
this.DataContext = personList[0];

前台Xaml中：

<Image Height="100" Width="100" Source="{Binding HeadImg}"></Image>
<TextBlock Text="{Binding Name}" FontSize="14" Margin="3"></TextBlock>

运行效果：

3）绑定到一个UIElement上面

SilverLight绑定源中也可以是UI控件的属性，我们来看下面的示例，一个新浪微博输入字符提示的示例，输入剩余字符个数的提醒：

<StackPanel Orientation="Vertical" Margin="50">
    <TextBox x:Name="weiboText"
    MaxLength="140"
    Text="Hi Henry" />
    <StackPanel Orientation="Horizontal">
        <TextBlock Text="{Binding Text.Length, ElementName=weiboText}" />
        <TextBlock Text="/" />
        <TextBlock Text="{Binding MaxLength, ElementName=weiboText}" />
    </StackPanel>
</StackPanel>

我们看到运行效果如下：

在上面的例子里面我们通过ElemetName属性去指定到某个控件上面。

4）绑定到集合类型上

其实在绑定到集合类型的数据源上面我们在上篇文章中见过了，主要需要指定其数据源到一个继承与ItemControl上的控件的ItemSource属性上。

总结

本篇文章中，主要介绍了绑定的基础知识、绑定的Mode的选择以及各种类型Source如何进行绑定。下篇文章中我们主要看下Target的显示问题。

本文链接

Silverlight 4之旅（一）

2011-07-17T05:53:00Z

由于工作的关系，现在的项目要求表现层使用Silverlight来实现，本人也不得不走向Silverlight这条路了。也许只是匆匆过客，但是还是做个记录吧。

简介

Microsoft Silverlight 是一种跨浏览器、跨平台的 .NET Framework 实现，用于为 Web 生成和提供下一代媒体体验和丰富的交互式应用程序 (RIA)。Silverlight 统一了服务器、Web 和桌面的功能，统一了托管代码和动态语言、声明性编程和传统编程以及 Windows Presentation Foundation (WPF) 的功能。

Silverlight 允许您创建具有以下功能的最先进的应用程序：

它是一种跨浏览器、跨平台的技术。它在所有常见的 Web 浏览器中运行，包括 Microsoft Internet Explorer、Mozilla Firefox 以及 Apple Safari 和谷歌浏览器，并在 Microsoft Windows 和 Apple Mac OS X 上运行。
它由可在数秒内安装的很小的下载程序支持。
它对视频和音频进行流处理。它将视频品质调整到适合各种环境：从移动设备到桌面浏览器以及 720p HDTV 视频模式。
它包括用户可以直接在浏览器中操作（拖动、旋转和缩放）的足够清晰的图形。
它读取数据并更新显示内容，但是不通过刷新整个页面来打断用户。
应用程序可以在 Web 浏览器中运行；您也可以配置应用程序，使用户可以在自己的计算机上运行该应用程序（浏览器外）。

第一个Demo

第一个例子一般都是从Hello World开始，这里我就不从Hello World开始了，我建立一个稍微有点实际意义的一个Demo来开始第一次之旅吧。Get Person——获取人员的信息。

首先定义了Person：

public class Person
{
    public string Name
    {
        get;
        set;
    }

    public ImageSource HeadImg
    {
        get;
        set;
    }
}

我们获取两位牛人的信息：

private ObservableCollection<Person> GetPersons()
{
    return new ObservableCollection<Person>{
        new Person{
            Name="Bill Gates",
            HeadImg =  new BitmapImage(new Uri(@"http://album.jinti.com/Stars/UpFiles/FCKFiles/specialreports_2edb_bill_gates.jpg"))
        },
        new Person{
            Name = "Steve Jobs",
            HeadImg = new BitmapImage(new Uri(@"http://photocdn.sohu.com/20080115/Img254675210.jpg"))
        }
    };
}

然后定义了一个按钮以及一个List来显示：

<Button Content="Get Persons" Height="24" Width="100" 
                HorizontalAlignment="Left" Margin="10,5,0,0" Click="Button_Click" ></Button>
        <ListBox x:Name="lstPersons" Margin="10,10,0,0" Width="400">
            
        </ListBox>

按钮中的代码:

private void Button_Click(object sender, RoutedEventArgs e)
{
    var personList = GetPersons();
    this.lstPersons.ItemsSource = personList;
}

看下运行的效果:

这好像不是我们要的效果,下面我们来做些改变。

改善

我们需要List里面的信息能够按照我们期望的方式进行现实，我们需要自定义Template:

<ListBox x:Name="lstPersons" Margin="10,10,0,0" >
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="Auto" />
                            <ColumnDefinition Width="*" />
                        </Grid.ColumnDefinitions>
                        <Image Height="100" Width="100" Grid.Column="0" Source="{Binding HeadImg}"></Image>
                        <TextBlock Text="{Binding Name}" FontSize="14" Margin="3" Grid.Column="1"></TextBlock>
                    </Grid>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>

这下我们来看下运行的效果:

总结

这是Silverlight 4之旅的第一站，下面开始进入详细学习Silverlight中绑定的知识。

本文链接

.Net 4.0 Parallel 编程之旅

2011-06-06T05:28:00Z

在过去的时间里写了9篇Post关于.Net 4.0 Parallel 编程部分的内容，现在整理下，方便自己以后回顾阅读。

首先我们从基础的Loop开始：

1）.Net4.0 Parallel编程（一）Data Parallelism 上

2）.Net4.0 Parallel编程（二）Data Parallelism 中

3）.Net4.0 Parallel编程（三）Data Parallelism下

然后我们看看Task:

1).Net 4.0 Parallel 编程（四） Task(上)

2).Net 4.0 Parallel 编程（五）Task(中)

3).Net 4.0 Parallel 编程（六）Task（下）

数据同步共享是我们不可回避的问题:

.Net 4.0 Parallel 编程（七）Task中的数据共享（上）

.Net 4.0 Parallel编程（八）Task中的数据共享（中）

.Net 4.0 Parallel 编程（九）Task中的数据共享（下）

Parallel 中的Linq

.Net 4.0 Parallel 编程（十）PLinq(上)

.Net 4.0 Parallel 编程（十一）PLinq(下)

Parallel中的扩展

本文链接

.Net 4.0 Parallel 编程（九）Task中的数据共享（下）

2011-04-21T02:17:00Z

在上篇Post中我们看过了几种常用的同步类型，本篇文章会介绍下申明性的同步的实现以及对于集合类型数据共享的问题，首先看下申明性同步的实现。

申明性同步

我们可以通过使用Synchronization 特性来标识一个类，从而使一个类型的字段以及方法都实现同步化。在使用Synchronization 时，我们需要将我们的目标同步的类继承于System.ContextBoundObject类型。我们来看看之前的例子我们同步标识Synchronization 的实现：

[Synchronization]
class SumClass : ContextBoundObject
{
    private int _Sum;

    public void Increment()
    {
        _Sum++;
    }

    public int GetSum()
    {
        return _Sum;
    }
}
class Program
{
    static void Main(string[] args)
    {
        var sum = new SumClass();
        Task[] tasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            tasks[i] = new Task(() =>
            {
                for (int j = 0; j < 1000; j++)
                {
                    sum.Increment();
                }
            });
            tasks[i].Start();
        }
        Task.WaitAll(tasks);
        Console.WriteLine("Expected value {0}, Parallel value: {1}",
        10000, sum.GetSum());
        Console.ReadLine();
    }
}

并发集合

在某些时候我们需要并发的操作集合类型，对于集合类型也存在数据共享的问题，我们来看一个例子，在例子中我们创建一个队列，然后多个Task同步进行出队列操作，看会不会出现同步出一个元素的情况，其中我们通过一个计数器进行统计出队列的次数：

static void Main(string[] args)
{
    for (var j = 0; j < 10; j++)
    {
        var queue = new Queue<int>();
        var count = 0;
        for (var i = 0; i < 1000; i++)
        {
            queue.Enqueue(i);
        }
        var tasks = new Task[10];
        for (var i = 0; i < tasks.Length; i++)
        {
            tasks[i] = new Task(() =>
            {
                while (queue.Count > 0)
                {
                    var item = queue.Dequeue();
                    Interlocked.Increment(ref count);
                }
            });
            tasks[i].Start();
        }
        try
        {
            Task.WaitAll(tasks);
        }
        catch (AggregateException e)
        {
            e.Handle((ex) =>
            {
                Console.WriteLine("Exception Message:{0}",ex.Message);
                return true;
            });
        }
        Console.WriteLine("Dequeue items count :{0}", count);
    }
    Console.ReadKey();
}

在上面的示例中，我们为了让效果更佳明显，看十次运行的结果：

在上面我们看到两个问题：1.出队列的次数超过了1000个；2.出现异常消息已经为空。出现这两个异常的原因是：1.多个线程同时在操作一个元素进行出的动作；2消息为空是因为当队列中剩下最后一个元素时，某个线程在访问“queue.Count > 0”时确实是大于0的，所以进入循环代码中准备进行出队列动作，而另外一个线程也进入循环中，已经将队列中出完了，就出现了数据争用的情况。

在.Net 4.0中提供了很多并发的集合类型来让我们处理数据同步的集合的问题，这里面包括：

1.ConcurrentQueue：提供并发安全的队列集合，以先进先出的方式进行操作；

2.ConcurrentStack：提供并发安全的堆栈集合，以先进后出的方式进行操作；

3.ConcurrentBag：提供并发安全的一种特殊的排序的集合；

4.ConcurrentDictionary：提供并发安全的一种key-value类型的集合。

我们在这里只做ConcurrentQueue的一个尝试，并发队列是一种线程安全的队列集合，我们可以通过Enqueue()进行排队、TryDequeue()进行出队列操作，在上面的例子中我们使用ConcurrentQueue时：

static void Main(string[] args)
{
    for (var j = 0; j < 10; j++)
    {
        var queue = new ConcurrentQueue<int>();
        var count = 0;
        for (var i = 0; i < 1000; i++)
        {
            queue.Enqueue(i);
        }
        var tasks = new Task[10];
        for (var i = 0; i < tasks.Length; i++)
        {
            tasks[i] = new Task(() =>
            {
                while (queue.Count > 0)
                {
                    int item;
                    var isDequeue = queue.TryDequeue(out item);
                    if(isDequeue) Interlocked.Increment(ref count);
                }
            });
            tasks[i].Start();
        }
        try
        {
            Task.WaitAll(tasks);
        }
        catch (AggregateException e)
        {
            e.Handle((ex) =>
            {
                Console.WriteLine("Exception Message:{0}",ex.Message);
                return true;
            });
        }
        Console.WriteLine("Dequeue items count :{0}", count);
    }
    Console.ReadKey();
}

总结

在本文中看过了数据共享中如何使用Synchronization 进行申明性同步，以及同步集合的一些介绍，希望对您有帮助。到此，Task中的数据共享就介绍结束了，下面我们看下PLinq中的内容。

作者：Henry Cui
出处： http://henllyee.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明。

本文链接

.Net 4.0 Parallel编程（八）Task中的数据共享（中）

2011-04-12T14:41:00Z

在上篇文章中我们看过了多线程中的数据共享问题，以及通过分离执行来解决的办法。本篇文章就数据共享的同步处理中的一些常见的方法进行一些介绍。

数据同步时的步骤

我之前的文章我们对数据共享问题处理的方式是“分离执行”，我们通过把每个Task执行完成后的各自计算的值进行最后的汇总，也就是说多个Task之间不存在数据共享了，各自做各自的事，完全分离开来。可是这毕竟不是我们常规的处理办法，这样我们会花更多的经历在分离上。其实我们主要的数据共享在Sum上：

for (int j = 0; j < 1000; j++)
{
    Sum++;
}

那我们可以通过一种有序的机制来访问Sum，即当一个Task在进行Sum访问时，其它的Task做等待，从达成对Sum的有序访问，避免对Sum的争用。准备做同步处理时，我们一般要做两个步骤：

1）确定数据共享的临界区域

2）确定使用的同步的类型

比如在之前的例子中，For语句中的Sum++就是临界区域，在这个地方可能会出现对Sum的争用。所以我们可以确定For语句中的区域为一个数据共享的临界区域。确定完成临界区域之后，我们需要决定使用那种同步的类型。这里首先解释下什么是同步类型，同步类型是一种用来调度Task访问临界区域的一种特殊类型。在.Net 4.0中提供了多种同步类型给我们使用，主要分为：轻量级的、重量级的和等待处理型的，在下面我们会介绍常用的同步处理类型。

常用的同步类型

首先来看看.Net 4.0中常见的几种同步类型以及处理的相关问题：

同步类型	解决问题
lock关键字、Montor类、SpinLock类	有序访问临界区域
Interlocked类	数值类型的增加或则减少
Mutex类	交叉同步
WaitAll方法	同步多个锁定（主要是Task之间的调度）
申明性的同步（如Synchronization）	使类中的所有的方法同步

下面我们就详细常见的同步类型的使用：

Lock

其实最简单同步类型的使用办法就是使用Lock关键字。在使用lock关键字时，首先我们需要创建一个锁定的object，而且这个object需要所有的task都能访问，其次能我们需要将我们的临界区域包含在lock块中。我们之前例子中代码可以这样加上lock:

int Sum = 0;
Task[] tasks = new Task[10];
var obj = new Object();
for (int i = 0; i < 10; i++)
{
    tasks[i] = new Task(() =>
    {
        for (int j = 0; j < 1000; j++)
        {
            lock (obj)
            {
                Sum = Sum + 1;
            }
        }
    });
    tasks[i].Start();
}
Task.WaitAll(tasks);
Console.WriteLine("Expected value {0}, Parallel value: {1}",
10000, Sum);

其实lock关键字是使用Monitor的一种简短的方式，其实上面的Lock部分可以理解成：

try
{
    Monitor.Enter(obj,ref lockAcquired);
    Sum = Sum + 1;
}
finally {
    if (lockAcquired) Monitor.Exit(obj);
}

lock关键字自动通过调用Monitor.Enter,Monitor.Exit方法来处理获得锁以及释放锁，在Enter方法中传递了bool值类型的参数，这个参数会在获得锁之后设置成True，我们在调用Exit是需要确认这个参数的值的。

Interlocked

Interlocked其实在之前的文章的我们已经使用过,Interlocked通过使用操作系统或则硬件的一些特性提供了一些列高效的静态的同步方法。其中主要提供了这些方法：Exchange、Add、Increment、CompareExchange四种类型的多个方法的重载。我们将上面的例子中使用Interlocked:

int Sum = 0;
Task[] tasks = new Task[10];
var obj = new Object();
for (int i = 0; i < 10; i++)
{
    tasks[i] = new Task(() =>
    {
        for (int j = 0; j < 1000; j++)
        {
            Interlocked.Increment(ref Sum);
        }
    });
    tasks[i].Start();
}
Task.WaitAll(tasks);
Console.WriteLine("Expected value {0}, Parallel value: {1}",
10000, Sum);

Mutex

Mutex也是一个同步类型，在多个线程进行访问的时候，它只向一个线程授权共享数据的独立访问。我们可以通过Mutex中的WaitOne方法来获取Mutex的所有权，但是同时我们要注意的是，我们在一个线程中多少次调用过WaitOne方法，就需要调用多少次ReleaseMutex方法来释放Mutex的占有。上面的例子我们通过Mutex这样实现：

int Sum = 0;
Task[] tasks = new Task[10];
var mutex = new Mutex();
for (int i = 0; i < 10; i++)
{
    tasks[i] = new Task(() =>
    {
        for (int j = 0; j < 1000; j++)
        {
            bool lockAcquired = mutex.WaitOne();
            try
            {
                Sum++;
            }
            finally
            {
                if (lockAcquired) mutex.ReleaseMutex();
            }
        }
    });
    tasks[i].Start();
}
Task.WaitAll(tasks);
Console.WriteLine("Expected value {0}, Parallel value: {1}",
10000, Sum);

同步类型使用建议

在上面的我们已经介绍过了三种同步类型的使用，其中想Lock这样的关键字是轻量级的，而Monitor则是重量级的，需要我们自己进行手动的获取锁释放锁，在使用同步类型的时候建议大家选择轻量级的类型。下面有几点建议让大家更加高效地同步：

1.更多的使用轻量级的同步类型

2.尽量不要使用自定义同步类型

3.不要同步得太多也不要同步得太少

总结

在本篇文章我们看过如何进行Task中的一些同步处理，同时看过常用的三种同步类型，希望对大家有帮助。在下篇文章中会介绍下其他的一些同步处理，以及一些常见的问题的处理。

作者：Henry Cui
出处： http://henllyee.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明。

本文链接

.Net 4.0 Parallel 编程（七）Task中的数据共享（上）

2011-04-07T05:08:00Z

在前几篇文章中我们看过Parallel Loop以及Task 部分内容，而在多线程的编程中我们较为痛疼的就是多线程中的数据共享问题以及数据同步的问题。本篇Post以及后面的几篇Post中会探讨下TPL中数据共享的常见问题以及其常规的解决办法。

引例

首先我们来看下面的一段代码：

static void Main(string[] args)
{
    int Sum = 0;
    Task[] tasks = new Task[10];
    for (int i = 0; i < 10; i++)
    {
        tasks[i] = new Task(() =>
        {
            for (int j = 0; j < 1000; j++)
            {
                Sum = Sum + 1;
            }
        });
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
    Console.WriteLine("Expected value {0}, Parallel value: {1}",
    10000, Sum);
    Console.ReadLine();
}

上面的代码我们期望是得到10个线程对Sum数据进行轮询累加，按照我们期望的情况，算出的结果应该是：10000，可是我们看看运行后的结果：

这是为什么呢？其实我们想想就会明白，主要是我们多个线程并行的进行了Sum的操作，我们可以通过一个时序图来看表示小两个线程同时操作Sum会出现的状况（下图中的表述可能不正确，请谅解）：

在Task1获取到sum值为0，Task2也获取到0，而两个Task都执行了0+1的操作之后并记录入Sum中，而不是我们预期的线程之间各自计算后的信息也进行累加。在我们在并行编程时，像这类数据共享问题是非常常见的。在上面的问题中，我们可以通过顺序执行的来解决这个问题，但是这不是我们希望的，毕竟我们还是希望以并行的方式去处理。在TPL中提供了分离执行的方法来解决这个问题。

分离执行

我们可以通过Task中传递的state参数来进行隔离执行：

static void Main(string[] args)
{
    int Sum = 0;
    Task<int>[] tasks = new Task<int>[10];
    for (int i = 0; i < 10; i++)
    {
        tasks[i] = new Task<int>((obj) =>
        {
            var start = (int)obj;
            for (int j = 0; j < 1000; j++)
            {
                start = start + 1;
            }
            return start;
        }, Sum);
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
    for (var i = 0; i < 10; i++)
    {
        Sum += tasks[i].Result;
    }
    Console.WriteLine("Expected value {0}, Parallel value: {1}",
    10000, Sum);
    Console.ReadLine();
}

上面的程序里面我们在每个Task执行时就不存在数据共享了，每个Task中计算自己值，最后我们汇总每个Task的Result。似乎我们的问题已经解决了，但是我们要知道在.Net 运行时里面并没有支持分离。也就是说，每次我们操作Task时，都要保证Task之间是没有数据共享的，确实是件麻烦的事。在.Net中提供了System.Threading.ThreadLocal来创建分离。

ThreadLocal

ThreadLocal是一种提供线程本地存储的类型，它可以给每个线程一个分离的实例，来提供每个线程单独的数据结果。上面的程序我们可以使用TreadLocal：

static void Main(string[] args)
{
    int Sum = 0;
    Task<int>[] tasks = new Task<int>[10];
    var tl = new ThreadLocal<int>();
    for (int i = 0; i < 10; i++)
    {
        tasks[i] = new Task<int>((obj) =>
        {
            tl.Value = (int)obj;
            for (int j = 0; j < 1000; j++)
            {
                tl.Value++;
            }
            return tl.Value;
        }, Sum);
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
    for (var i = 0; i < 10; i++)
    {
        Sum += tasks[i].Result;
    }
    Console.WriteLine("Expected value {0}, Parallel value: {1}",
    10000, Sum);
    Console.ReadLine();
}

但是我们要注意的一点TreadLocal是针对每个线程的，不是针对每个Task的。在TreadLocal构造函数中提供了一个重载的方法，以让我们来设置每个线程Result初始值。我们通过下面的例子来看看：

static void Main(string[] args)
{
    int Sum = 0;
    Task<int>[] tasks = new Task<int>[10];
    var tl = new ThreadLocal<int>(() => {
        Console.WriteLine(Sum);
        return Sum;
    });
    for (int i = 0; i < 10; i++)
    {
        tasks[i] = new Task<int>(() =>
        {
            for (int j = 0; j < 1000; j++)
            {
                tl.Value++;
            }
            return tl.Value;
        });
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
    for (var i = 0; i < 10; i++)
    {
        Sum += tasks[i].Result;
    }
    Console.WriteLine("Expected value {0}, Parallel value: {1}",
    10000, Sum);
    Console.ReadLine();
}

我们来看看执行的结果：

大家可能有疑问，我们是创建了10个Task，可是ThreadLocal只进行了4次初始化。我们要记住一点Task不是Thread，一个Tread中可能有多个Task。我Demo的机器是四核的，这里开启了四个线程去执行10个Task。之所以我们看到的结果会不对，是因为，在一个线程里面会有多个Task,每个Task之间计算时，第一Task计算出来的结果会传递给下一个Task，从而进行了一次累加，所以会出现计算出来的值不准确。所以ThreadLocal是魔鬼也是天使，我们在使用时也要额外注意。

总结

在本文中通过引例我们看到了多线程中数据共享的问题，以及了解了分离执行的办法，同时也了解了TreadLocal的原理，希望对您有用。下篇文章会就TPL中的数据共享问题进行继续地探讨。

作者：Henry Cui
出处： http://henllyee.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明。

本文链接