博客园_forgetu

Silverlight 通过点击按钮显示/隐藏DataGrid的RowDetail

2011-07-22T16:44:00Z

Silverlight 中 DataGrid 的 RowDetail 默认显示方式有三种：一、Collapsed 及不显示；二、Visible 及一直显示；三、VisibleWhenSelected 及选中行时显示。有时我们想让用户来选择显示或隐藏某行的详细信息，虽然使用 VisibleWhenSelected 模式会在选中一行时显示相应的详细信息，但是当更改选中行时，之前选中行的详细信息就会隐藏，而且选中一行后也无法隐藏详细信息。（SelectionModel 设置为 Extended ，RowDetailsVisibilityMode 设置为 VisibleWhenSelected ，按住 Ctrl 键选中多行时也会同时显示多行的详细信息，但是当松开 Ctrl 键再选择某一行时，其他行的详细信息就会自动隐藏）

下面我将通过一个非常简单的演示如何在 DataGrid 的每一行添加一个按钮，通过点击按钮来显示或隐藏相应行的详细信息。先看一下本示例的运行结果图。

一、新建一个 Silverlgiht 项目，命名为 SLDataGridExample 。

二、在项目中添加一个 Person 类，代码如下：

public class Person : INotifyPropertyChanged
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            NotifyPropertyChanged("Name");
        }
    }

    public int Age
    {
        get { return _age; }
        set
        {
            _age = value;
            NotifyPropertyChanged("Age");
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    public void NotifyPropertyChanged(string name)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(name));
    }
}

三、在 MainPage.xaml 添加一个 DataGrid 控件，将 DataGrid 的 RowDetailsVisiblityModel 设置为 Collapsed，将 SelectionModel 设置为 Single。DataGrid 的完整代码如下：

<sdk:DataGrid x:Name="datagrid1" AutoGenerateColumns="False" ItemsSource="{Binding}" RowDetailsVisibilityMode="Collapsed" SelectionMode="Single">
    <sdk:DataGrid.RowDetailsTemplate>
        <DataTemplate>
            <StackPanel Orientation="Vertical" Background="LightGray">
                <TextBlock Margin="20,10,0,10" Text="{Binding Name}" />
            </StackPanel>
        </DataTemplate>
    </sdk:DataGrid.RowDetailsTemplate>
    <sdk:DataGrid.Columns>
        <sdk:DataGridTextColumn Header="Name" Binding="{Binding Name}" Width="140" />
        <sdk:DataGridTextColumn Header="Age" Binding="{Binding Age}" Width="100" />
        <sdk:DataGridTemplateColumn Header="Show/Hide Detail" Width="140">
            <sdk:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Button Content="Show/Hide Detail" Width="120" Click="Button_Click" />
                </DataTemplate>
            </sdk:DataGridTemplateColumn.CellTemplate>
        </sdk:DataGridTemplateColumn>
    </sdk:DataGrid.Columns>
</sdk:DataGrid>

在 DataGrid 的最后一列中添加了一个按钮，DataGrid 的 RowDetailsVisiblityModel 设置为 Collapsed ，我们通过点击这个按钮来显示或隐藏 RowDetail。下面是该按钮的 Click 事件的代码：

FrameworkElement el = datagrid1.Columns.Last().GetCellContent(datagrid1.SelectedItem);
DataGridRow row = DataGridRow.GetRowContainingElement(el.Parent as FrameworkElement);
row.DetailsVisibility = row.DetailsVisibility == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible;

在按钮的 Click 事件中，我们通过当前选中的行获取到当前的 DataGridRow ，然后设置 DataGridRow 的 DetailsVisibility 属性来显示或隐藏当前行的详细信息。然后在代码中添加一些演示用的数据，运行示例，至此通过点击按钮显示或隐藏 RowDetail 效果已经实现，是不是非常简单呢。

示例代码下载 SLDataGridExample.7z

本文链接

Silverlight 应用程序之间在客户端通信

2011-06-30T15:55:00Z

运行在同一台电脑上的多个 Silverlight 应用程序可以通过本地消息进行通信，通信是在客户端进行的，不需要与服务端交互。使用这一功能可以使在同一页面承载的多个 Silverlight 应用程序之间或不同页面承载的 Silverlight 应用程序之间进行通信，在网页上承载的 Silverlight 应用程序也可以和运行在浏览器外的其他应用程序之间进行通信。

要在 Silverlight 应用程序之间的通信，需要建一个信息发送程序和一个信息接收程序，发送端使用 LocalMessageSender 来发送信息，接收端使用 LocalMessageReceiver 来接收信息。

信息发送端：

创建发送端时需要提供一个接收端的名称，同时也可以限定接收端所在的域，如果不提供接收端的域默认为 Global 。

public class MainViewModel : ViewModelBase
{
    private LocalMessageSender messageSender;
    private const int MAXRETRY = 10;
    private int retry = 1;

    public string SendResult
    {
        get;
        private set;
    }

    /// <summary>
    /// Initializes a new instance of the MainViewModel class.
    /// </summary>
    public MainViewModel()
    {
        SendMessageCommand = new RelayCommand<string>(SendMessage);
        messageSender = new LocalMessageSender("receiver1");
        messageSender.SendCompleted += new System.EventHandler<SendCompletedEventArgs>(messageSender_SendCompleted);
    }

    private void messageSender_SendCompleted(object sender, SendCompletedEventArgs e)
    {
        if (e.Error != null)
        {
            if (retry > MAXRETRY)
            {
                SendResult = "Could not send message.";
                RaisePropertyChanged("SendResult");
                return;
            }
            else
            {
                retry++;
                SendMessage(e.Message);
            }
        }
        else
        {
            retry = 1;
            SendResult = string.Concat(e.ReceiverName,":", e.Response);
            RaisePropertyChanged("SendResult");
        }
    }
        
    public RelayCommand<string> SendMessageCommand { get; private set; }
    private void SendMessage(string msg)
    {
        messageSender.SendAsync(msg);
    }
}

使用 SendAsync 方法来发送信息，当信息发送成功时引发 SendCompleted 事件，可以通过 SendCompletedEventArgs 的 Response 属性来获取从接收端返回的信息，当信息发送失败时会抛出 SendFailedException ，可以通过 SendCompletedEventArgs 的 Error 属性来获取。

信息接收端：

创建接收端时需要指定接收端的名称，同时也可以限定该名称的范围是限定为全局名称范围还是限定为接收方的特定域和限定接收方可从中接收消息的域。接收端的名称必须在全局范围内唯一，或者在接收端的宿主域内唯一。

public class MainViewModel : ViewModelBase
{
    private LocalMessageReceiver messageReceiver;

    public string Message
    {
        get;
        private set;
    }

    /// <summary>
    /// Initializes a new instance of the MainViewModel class.
    /// </summary>
    public MainViewModel()
    {
        messageReceiver = new LocalMessageReceiver("receiver1");
        messageReceiver.MessageReceived += new System.EventHandler<MessageReceivedEventArgs>(messageReceiver_MessageReceived);
        try
        {
            messageReceiver.Listen();
        }
        catch (ListenFailedException e)
        {
            Message = e.Message;
            RaisePropertyChanged("Message");
        }
    }

    private void messageReceiver_MessageReceived(object sender, MessageReceivedEventArgs e)
    {
        e.Response = "Message received.";
        Message = e.Message;
        RaisePropertyChanged("Message");
    }
}

接收端通过 Listen 方法监听信息，当收到信息时引发 MessageReceived 事件，可以通过 MessageReceivedEventArgs 的 Message 属性来获取接收到的信息，同时可以设置 MessageReceivedEventArgs 的 Response 属性给发送端返回一个信息。

示例代码下载：SLCommunication

本文链接

Silverlight MVVM 模式下与子窗体交互

2011-06-29T16:02:00Z

Model View ViewModel（MVVM）是在 Silverlight 和 WPF 项目开发中应用最多的结构模式，也是 Silverlight 和 WPF 项目开发的最佳模式。本文的主要目的不是讲解 MVVM 模式，如果您不了解 MVVM 模式，可心参看这里和这里。目前已有很多 MVVM 框架可以用来简化 MVVM 开发，如 Prism、SilverlightFX、MvvmLight、Caliburn、Simple MVVM Toolkit等。

在程序开发中经常会遇到诸如弹出提示框、确认框、用户输入窗口等的情况，在 Silverlight 中这些情况都可以用子窗体（Child Window）来处理。在未使用 MVVM 模式的情况下，我们可以在用户控件或页面的后置代码（Code Behind）中实例化一个子窗体，调用子窗体的 Show 方法来弹出子窗体，然后通过子窗体的 Closed 方法处理用户的操作结果。但是在使用 MVVM 模式的情况下，为了使 Model 和 View 最大限度的分离，我们要使用尽可能少的后置代码。如果在后置代码中实例化并显示子窗体，这就使用代码和视图结合在一起了；当然也可以在 ViewModel 里实例化并显示子窗体，这样又使子窗体和 ViewModel 结合在一起了。

本文将使用 MvvmLight 框架来演示如何在 MVVM 模式下与子窗体交互，即如何在 ViewModel 中弹出一个子窗体并处理用户操作结果。关于 MvvmLight 的下载及安装请看这里。

首先我们来看一下示例程序的运行结果：

程序运行后当用户单击 New Customer 按钮时，就会弹出一个子窗体，用户输入Customer Id、Customer Name、Customer City 后单击 OK 按钮就会在主页面的客户列表中显示出刚才输入的客户信息。下面是本示例具体的实现。

新建一个 Silverlight 项目，然后在项目中添加Views、Models、ViewModels、Locators文件夹（如果是通过 MvvmLight 模板创建的 Silverlight 项目，默认 ViewModel Locator 和 ViewModel 在同一文件夹中）。添加对程序集 GalaSoft.MvvmLight.Extras.SL4 和 GalaSoft.MvvmLight.SL4 的引用（如果通过 MvvLight 模板创建则会自动引用）。在 Model 文件夹中新建一个 Customer Model，完整代码如下：

public class Customer : INotifyPropertyChanged
{
    private string customerId;
    public string CustomerId
    {
        get { return customerId; }
        set
        {
            customerId = value;
            NotifyPropertyChanged("CustomerID");
        }
    }

    private string customerName;
    public string CustomerName
    {
        get { return customerName; }
        set
        {
            customerName = value;
            NotifyPropertyChanged("CustomerName");
        }
    }

    private string city;
    public string City
    {
        get { return city; }
        set
        {
            city = value;
            NotifyPropertyChanged("City");
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

下面是 MainPage 的后置代码:

public partial class MainPage : UserControl
{
    public MainPage()
    {
        InitializeComponent();

        Messenger.Default.Register<string>(
            this,
            "MainWindow",
            msg =>
            {
                NewCustomerView newCustomer = new NewCustomerView();
                newCustomer.Title = msg;
                newCustomer.Show();
            });
    }
}

从上面的代码中可以看到，我使用 MvvmLight 的 Messenger 在主窗体中注册了一个消息接收者，用于接收 ViewModel 发来的消息并弹出子窗体。下面是子窗体 NewCustomerView 的后置代码：

public partial class NewCustomerView : ChildWindow
{
    public NewCustomerView()
    {
        InitializeComponent();

        Messenger.Default.Register<Customer>(
            this,
            "ChildWindow",
            msg =>
            {
                this.DialogResult = true;
            });
    }
}

我同样在子窗体中也注册一个消息接收者，接收 ViewModel 发来的消息并关闭子窗体。注意主窗体中注册的消息接收者的 Token 为 “MainWindow”，子窗体中注册的消息接收者的 Token 为 “ChildWindow”，在 ViewModel 中发送消息时，只有与发送的消息的 Token 相同的接收者才收到消息。下面是 MainViewModel 的代码，这里只是为了演示，主窗体和子窗体共用了一个 ViewModel。

public class MainViewModel : ViewModelBase
{        
    public MainViewModel()
    {
        OKButtonCommand = new RelayCommand<Customer>(OKButtonClick);
        NewCustomerCommand = new RelayCommand(NewCustomer);

        _customer = new Customer();
        _customers = new ObservableCollection<Customer>();
        // 注册一个接收者 Token 为 ChildWindow
        Messenger.Default.Register<Customer>(this, "ChildWindow", AddCustomer);
    }

    private void AddCustomer(Customer param)
    {
        _customers.Add(param);
        RaisePropertyChanged("Customers");
    }

    // customer list
    private ObservableCollection<Customer> _customers;
    public ObservableCollection<Customer> Customers
    {
        get
        {
            return _customers;
        }
    }

    // customer model
    private Customer _customer;
    public Customer Model
    {
        get
        {
            return _customer;
        }
        set
        {
            _customer = value;
            RaisePropertyChanged("Model");
        }
    }

    // add customer command
    public RelayCommand NewCustomerCommand { get; private set; }
    private void NewCustomer()
    {
        /*
            * 发送一个字符串信息 New Customer
            * Token 为 MainWindow 只有具有相同 Token 接收者都会接收到该信息
            */
        Messenger.Default.Send("New Customer", "MainWindow");
    }

    public RelayCommand<Customer> OKButtonCommand { get; private set; }
    private void OKButtonClick(Customer param)
    {
        /*
            * 发送一个 Customer 信息
            * Token 为 ChildWindow 只有具有相同 Token 接收者都会接收到该信息
            */
        Messenger.Default.Send<Customer>(param, "ChildWindow");
    }
}

在 ViewModel 中也注册了一个消息接收者，用于接收子窗体返回的数据。ViewModel 中的 NewCustomerCommand 是绑定到主窗体的 NewCustomer 按钮的，单击按钮 NewCustomer 时调用 NewCustomer() 方法向主窗体发送一个消息，主窗体接收到消息后弹出子窗体。ViewModel 中的 OKButtonCommand 是绑定到子窗体的 OKButton 的，单击按钮 OKButton 时调用 OKButtonClick() 向子窗体和 ViewModel 发送一个消息，子窗体接收到消息时关闭，ViewModel 接收到消息时将参数 Customer 添加 Customer 列表中。以下是按钮的事件绑定代码：

<Button Content="New Customer" Width="120" Height="30">
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="Click">
            <cmd:EventToCommand Command="{Binding NewCustomerCommand}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</Button>

<Button x:Name="OkButton" Content="OK" Width="75" Height="23" HorizontalAlignment="Right" Margin="0,12,0,0" Grid.Row="1">
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="Click">
            <cmd:EventToCommand Command="{Binding OKButtonCommand}" CommandParameter="{Binding ElementName=Customer, Path=DataContext}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</Button>

本示例只是提供一个在 MVVM 模式下与子窗体交互的解决方法，这个解决方法也并不是纯粹的 MVVM，完整的示例请查看附件的示例代码。

示例代码下载：SLMvvmChildWindow

本文链接

Silverlight 通过索引器绑定动态数据

2011-06-17T16:13:00Z

绑定动态数据是做 Silverlight 程序时经常会遇到的问题。本文介绍 Silverlight 通过绑定索引器实现绑定动态数据，即在设计时不知道数据的结构，如在设计时不知道要绑定的类有哪些属性。

绑定索引器是 Silverlight 4 新增的特性，这一特性使用我们可以在设计时不必知道要绑定的类有哪些属性，但是还可以绑定。下面先看一下如何绑定索引器。

<TextBox Grid.Row="0" Height="23" Width="148" 
            HorizontalAlignment="Center" VerticalAlignment="Center" 
            Name="txtName" Text="{Binding Path=[name]}" />
<TextBox Grid.Row="1" Height="23" Width="148" 
            HorizontalAlignment="Center" VerticalAlignment="Center" 
            Name="txtAge" Text="{Binding Path=[age]}" />

绑定索引器的语法和通常绑定数据的语法非常相似，格式为：Binding="{Binding Path=[Key]}" 。下面新建一个要绑定的 Person 类，并添加一个索引器，完整的代码如下：

public class Person : INotifyPropertyChanged
{
    private Dictionary<string, object> data = new Dictionary<string, object>();

    public object this[string key]
    {
        get
        {
            if (!data.ContainsKey(key))
                data[key] = null;

            return data[key];
        }
        set
        {
            data[key] = value;
            NotifyPropertyChanged("");
        }
    }

    public string[] Keys
    {
        get
        {
            return data.Keys.ToArray();
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

下面新建一个 Person 类的实例，并绑定到第一段代码创建的两个TextBox上面。

Person person = new Person();
person["name"] = "avatar";
person["age"] = 123456;

LayoutRoot.DataContext = person;

运行结果如下：

上面的代码将索引器的参数名直接写在代码中了，如果在设计时不知道类的结构，上面的代码依然无法解决问题。我们可以通过下面的代码轻松解决这个问题：

Person person = new Person();
person["name"] = "avatar";
person["age"] = 123456;

LayoutRoot.DataContext = person;

for (int i = 0; i < person.Keys.Length; i++)
{
    TextBox txt = new TextBox()
    {
        Width = 200,
        HorizontalAlignment = HorizontalAlignment.Center,
        VerticalAlignment = VerticalAlignment.Center
    };
    Binding binding = new Binding("[" + person.Keys[i] + "]")
    {
        Mode = BindingMode.TwoWay
    };
    txt.SetBinding(TextBox.TextProperty, binding);

    txt.SetValue(Grid.RowProperty, i);
    LayoutRoot.Children.Add(txt);
}

这段代码的运行结果和上面的代码的运行结果完全一样。

以上讲的是通过索引器将单个类绑定到 Silverlight 控制上，如果要将包含多个类的列表绑定到 DataGrid 上呢？这个问题我们可以通过类似的方式轻松解决。下面是将多个类的列表绑定到 DataGrid 上的代码：

private List<Person> lst = new List<Person>();

Person person1 = new Person();
person1["name"] = "Avatar";
person1["age"] = 52342;

Person person2 = new Person();
person2["name"] = "Harry Potter";
person2["age"] = 33432;

lst.Add(person1);
lst.Add(person2);

string[] headers = person1.Keys;
for (int i = 0; i < headers.Length; i++)
{
    dataGrid1.Columns.Add(new DataGridTextColumn()
    {
        Header = headers[i],
        CanUserSort = true,
        IsReadOnly = false,
        Binding = new Binding("[" + headers[i] + "]")
        {
            Mode = BindingMode.TwoWay
        }
    });
}

dataGrid1.ItemsSource = lst;

注意：如果想让用户可以点击表头排序，需要设置每一列的 CanUserSort = true 。运行结果如下图：

如果需要显示 Person 类的性别，只需在上面的代码中添加：person1["gender"] = "男"; person2["gender"] = "男"; 就可以实现，运行结果如下：

示例代码下载：SLBindingDynamicObject.7z

本文链接

.NET 中的泛型

2011-05-08T07:15:00Z

泛型是 .NET 2.0 中引入的一个新特性，从 .NET 2.0 发布到现在已经过去好多年的时间了，到现在很多公司在面试时都喜欢问诸如用过泛型吗、什么是泛型、怎么写泛型之类的问题。似乎泛型是什么高深莫测的绝学了，犹如辟邪剑法一样，一般人难以运用。其实虽然每个 .NET 程序员的具体工作内容不一样，但是对于 .NET 里的一些基本的东西的运用相差不会很大，我想对于学过C# 的刚毕业的学生也不至于没有用过泛型。下面我就简单说一下泛型。

泛型将类型参数的概念引入了 .NET 中，类型参数使类和方法将一个或多个类型的指定推迟到客户端代码声明并实例化该类或方法的时候。使用泛型可以最大限度地重用代码、保护类型的安全以及提高性能。

泛型类型参数

在泛型类或方法的定义中，类型参数是客户端代码在实例化泛型类型的变量时指定的特定类型的占位符。通常我们使用 T 作为类型参数占位符，但这并不是必须的，我们可以使用一些更有意义的描述性的名称作为类型占位符，如 TInput、TOutput 等。

public class List<TInput, TOutput>

类型参数的约束

在定义泛型类型时可以对客户端代码在实例化类时用于类型参数的类型加以限制。如果客户端使用违反约束的类型来实例化类型，则会产生编译时错误。约束使用 where 关键字指定。

结束	说明
where T: struct	类型参数必须是值类型
where T: class	类型参数必须是引用类型
where T: new()	类型参数必须有一个 public 且无参数的构造函数
where T: <base classname>	类型参数必须继承至指定的基类（base class）
where T: <interface name>	类型参数必须是指定的接口或实现了指定接口的类型
where T: U	为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数

public class Student
    {
        public Student(string name, int age)
        {
            Name = name;
            Age = age;
        }
        public string Name { get; set; }

        public int Age { get; set; }
    }

    public class Teacher<T> where T : new()
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Course { get; set; }
    }

上面的代码中我们定义了一个 Student 类和一个 Teacher 类，其中 Student 类只有一个带两个参数的构造函数。Teacher 类是一个泛型类，它的类型参数必须有一个无参的构造函数，如果使用 Student 类去实例化 Teacher 类编辑器会给出错误提示。

使用约束可以使用我们对泛型成员执行操作时变得更加安全。

泛型类

泛型类封装非特定于具体数据类型的操作。泛型类通常用于集合。像从集合上添加、移除项这样的操作大致相同，且与数据类型无关。对于泛型类可以添加多个约束条件。如我们将上面定义的 Teacher<T> 泛型类的泛型类型参数限制为引用类型。注意在使用多个约束时，如果有 new() 约束，new() 必须放在最后面。

public class Teacher<T> where T : class, new()
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Course { get; set; }
    }

泛型接口

为泛型集合或集合中的项的泛型类指定接口通常很有用。将接口指定为泛型类型参数的约束时，只能使用实现该接口的类型。如下面我们为 Teacher<T> 泛型类的类型参数添加必须实现 IComparable<T> 接口限制条件，这样就只有实现了接口 IComparable<T> 且有一个无参的构造函数的引用类型才能作为实例化 Teacher<T> 时的类型参数。

public class Teacher<T> where T : class, IComparable<T>, new()
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Course { get; set; }
    }

泛型方法

泛型方法就是使用泛型类型参数声明的方法。如下示例：

static void Swap<T>(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}

调用泛型方法的方式如下：

int a = 1;
    int b = 2;

    Swap<int>(ref a, ref b);

调用泛型方法时也可以省略泛型类型参数，编译器会根据传入参数的类型推断它的类型。上面的调用方式也可写成这样：

Swap(ref a, ref b);

泛型方法也可以通过泛型类型参数重载。

void DoWork<T>() { }
void DoWork<T, U>() { }

泛型委托

委托也可以定义类型参数，可以像调用泛型类中的泛型方法一样调用泛型委托。例如在 System 命名空间里定义的没有返回值的泛型委托 Action<T>。

public delegate void Action<in T>(T obj)

例如 List<T> 的 ForEach( Action<T> action ) 的参数是个泛型委托，我们可以传入 Action<T> 泛型委托实例来对列表中的每个元素执行相同的操作。

[TestMethod]
        public void TestMethod1()
        {
            List<String> names = new List<String>();
            names.Add("Bruce");
            names.Add("Alfred");
            names.Add("Tim");
            names.Add("Richard");

            names.ForEach(Print);
        }

        private void Print(string s)
        {
            Console.WriteLine(s);
        }

使用泛型类型参数时，有一个问题就是由于我们并不知道这个参数是值类型还是引用类型，因此无法设置它的默认值。解决方法是使用 default 关键字，default 关键字对于引用类型会返回null，对于数值类型会返回0，对于结构会返回初始化为0或null的结构成员。

参考：http://msdn.microsoft.com/en-us/library/512aeb7t(v=VS.100)

本文链接

使用 .NET 4.0 中的Lazy<T> 实现延迟初始化

2011-05-06T16:32:00Z

延迟初始化就是将对象的初始化延迟到第一次使用该对象时。延迟初始化是我们在写程序时经常会遇到的情形，例如创建某一对象时需要花费很大的开销，而这一对象在系统的运行过程中不一定会用到，这时就可以使用延迟初始化，在第一次使用该对象时再对其进行初始化，使用延迟初始化可以提高程序的效率，使程序占用更少的内存。在 .NET 4.0 之前要实现延迟初始化，需要我们自己动手编写具体的实现方式（关于延迟初始化的实现方式，可以参看这个 http://msdn.microsoft.com/en-us/vcsharp/bb870976.aspx .NET 4.0 的 Lazy<T> 的实现方式与此相似）。在 .NET 4.0 中提供了一个泛型类 System.Lazy<T> 可以帮助我们实现延迟初始化。

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

class Program
    {
        static void Main(string[] args)
        {
            Lazy<Customer> customer = new Lazy<Customer>();
            if (!customer.IsValueCreated)
                Console.WriteLine("Customer 尚未初始化。");

            Console.WriteLine("客户姓名是：{0}", customer.Value.Name);

            if (customer.IsValueCreated)
                Console.WriteLine("Customer 已经初始化。");

            Console.ReadKey();
        }
    }

    public class Customer
    {
        public Customer()
        {
            Name = "张三";
            Console.WriteLine("调用 Customer 的构造函数。");
        }

        public string Name { get; set; }

        public List<Order> Orders { get; set; }
    }

    public class Order
    {
        public string ID { get; set; }
    }

下面是输出结果:

Customer 尚未初始化。
调用 Customer 的构造函数。
客户姓名是：张三
Customer 已经初始化。

当 customer.Value 被调用时 Customer 才被初始化。只读属性 Value 返回延迟初始化的对象，布尔属性 IsValueCreated 标识延迟初始化的对象是否已经初始化。在上面的示例代码中是在 Customer 类的构造函数中设置的 Name 属性的值，我们可以使用 Lazy<T> 的重载函数 Lazy< T> (Func< T> ) 传入一个带返回值的委托来设置延迟初始化对象的属性值。

Lazy<Customer> customer1 = new Lazy<Customer>(
            () =>
            {
                return new Customer { Name = "李四" };
            });

以下是输出结果：

Customer 尚未初始化。
调用 Customer 的构造函数。
客户姓名是：李四
Customer 已经初始化。

可以看到 customer1 的 Value 属性使用的是通过委托传入的参数初始化的。

要实现公共属性的延迟初始化，将属性对应的字段定义为 Lazy<T>，然后通过 get 访问器返回字段的 Value 属性。

public class Customer
    {
        public Customer()
        {
            Name = "张三";
            Console.WriteLine("调用 Customer 的构造函数。");

            _orders = new Lazy<List<Order>>(() =>
                {
                    // 初始化
                    return new List<Order>
                    {
                        new Order { ID = "1" },
                        new Order { ID = "2" },
                        new Order { ID = "3" }
                    };
                }
            );
        }

        public string Name { get; set; }

        private Lazy<List<Order>> _orders;
        public List<Order> Orders
        {
            get
            {
                return _orders.Value; // 将在第一次访问时创建
            }
        }
    }

    public class Order
    {
        public string ID { get; set; }
    }

Lazy<T> 对象初始化默认是线程安全的，在多线程环境下，第一个访问 Lazy<T> 对象的 Value 属性的线程将初始化 Lazy<T> 对象，以后访问的线程都将使用第一次初始化的数据。

参考：http://msdn.microsoft.com/en-us/library/dd997286.aspx

本文链接

C# 中的值类型和引用类型

2011-05-04T15:44:00Z

C# 中所有的数据类型不是值类型就是引用类型。本文就这两种类型在变量定义、赋值、和作为函数参数传递时的不同之外作简单讨论。

值类型是使用对象实际值来表示对象的数据类型。如果向一个变量分配值类型的实例，则该变量将被赋以该值的全新副本。

引用类型是使用对对象实际值的引用（类似于指针）来表示对象的数据类型。如果为某个变量分配一个引用类型，则该变量将引用（或指向）原始值。不创建任何副本。（来自MSDN）

值类型包括：

所有的数值类型
Boolean、Char 和 DateTime
所有的结构和枚举

引用类型包括：

String
数组
类、委托和接口

引用类型和值类型有不同的编译时规则和不同的运行时行为。

对于引用类型，创建对象时，将在堆上分配内存，变量只保存该对象的引用（类似于指针）。如 UriBuilder 是 System 命名空间中定义的一个类，Point 是 System.Drawing 命名空间中定义的一个结构。定义如下变量：

Point myPoint1 = new Point(20, 10); // Point 是一个结构
UriBuilder myUri1 = new UriBuilder("http://www.example.com"); // UriBuilder 是一个类

在上面的第一行代码中 CLR 将为变量 myPoint1 分配一块内存空间，而在第二行代码中 CLR 将要分配两块内存空间，一块存储 UriBuilder 对象，一块存储该对象的引用（myUri1）。第二行代码等价于：

UriBuilder myUri1; // CLR 为 UriBuilder 对象的引用 myUri1 分配一块内存空间
myUri1 = new UriBuilder("http://www.example.com"); // CLR 为 UriBuilder 对象分配一块内存空间

如果将上面定义的对象赋值给新的变量:

Point myPoint2 = myPoint1;
UriBuilder myUri2 = myUri1;

myPoint2 是一个结构，将被赋以 myPoint1 的一个全新的副本。而 myUri2 是一个类，只被赋以对 UriBuilder 对象的引用，myUri1 和 myUri2 都引用同一对象。

在 C# 中函数的参数默认是按值传递的，即当向函数传递参数时传递的是参数的隐式的副本。对于值类型的参数，传递的是该值的一个副本，对于引用类型的参数，传递的是该引用的一个副本。例如：

Point point = new Point(20, 5); // 值类型变量
UriBuilder myUri = new UriBuilder("http://www.example.com"); // 引用类型变量
Test(point, myUri); // Test 为下面定义的一个方法

void Test(Point p, UriBuilder uri)
{
	p.X = 10; // 不会影响 point，因为 p 是 point 的一个副本
	uri.Host = "www.example.org"; // 会影响 myUri因为 uri 和 myUri 引用的是同一对象
         uri = null; // 不会影响 myUri
}

将 uri 设置为 null 不会产生任何影响，因为 uri 只是 UriBuilder 对象引用的一个副本。

我们可以使用 ref 修饰符改变参数的传递方式，按引用传递时函数直接与调用者的参数交互。例如：

Point point = new Point(20, 5); // 值类型变量
UriBuilder myUri = new UriBuilder("http://www.example.com");// 引用类型变量
Test(ref point, ref myUri); // Test 是下面定义的函数

void Test(ref Point p, ref UriBuilder uri)
{
	p.X = 10; // 将会改变 point 的 X 值
	uri.Host = "www.example.org"; // 将会改变 myUri 的 Host 值
	uri = null; // 将会把 myUri 设置为 null
}

本文链接

Silverlight 选择和移动多个控件——移出边界检测和自动将选中的控件全部包含在选择框中

2010-09-08T14:33:00Z

在上一篇文章中介绍了 Silverlight 中同时选中和移动多个控件的实现方式，但是并没有对控件是否移出边界进行检测，因此可以把控件拖出容器边界外面，这实际应用中当然是不允许的。还有一点就选中的控件只有选中部分会包含在选择区域中，不会把整个控件都自动包含在选择区域中。以下就上面的两个问题的解决方式做一简单介绍。

1、对于第一个问题，只要在移动控件时，对控件移动到的新位置做一个判断就可以，下面是修改后的代码：

/* rect 的 X 轴值和 Y 轴值  */
double rLeft = (double)rect.GetValue(Canvas.LeftProperty);
double rTop = (double)rect.GetValue(Canvas.TopProperty);

double deltaV = e.GetPosition(rootCanvas).Y - origPoint.Y;
double deltaH = e.GetPosition(rootCanvas).X - origPoint.X;
double newTop = deltaV + rTop;
double newLeft = deltaH + rLeft;

if (newTop < 0)  // 已经拖出上侧边缘
{
	newTop = 0;
	deltaV = 0;
}
else if (newTop > rootCanvas.ActualHeight - rect.ActualHeight)  // 已经拖出下侧边缘
{
	newTop = rootCanvas.ActualHeight - rect.ActualHeight;
	deltaV = newTop - rTop;
}
if (newLeft < 0)  // 已经拖出左侧边缘
{
	newLeft = 0;
	deltaH = 0;
}
else if (newLeft > rootCanvas.ActualWidth - rect.ActualWidth)   // 已经拖出右侧边缘
{
	newLeft = rootCanvas.ActualWidth - rect.ActualWidth;
	deltaH = newLeft - rLeft;
}

foreach (var se in selectedElements)
{
	double cLeft = deltaH + (double)se.GetValue(Canvas.LeftProperty);
	double cTop = deltaV + (double)se.GetValue(Canvas.TopProperty);

	se.SetValue(Canvas.LeftProperty, cLeft);
	se.SetValue(Canvas.TopProperty, cTop);
}

注意对下侧边缘的判断要用容器的高减去 rect（选择区域）的高，对于右侧边缘的判断同样要用容器的宽减去 rect 的宽，这是因为通过e.GetPosition(UIElement).X和e.GetPosition(UIElement).Y取得值是 UIElement 的左侧和顶部距容器左侧和顶部的值。

2、对于第二个问题，如果某个控件被选中，只要将该选择区域扩大把控件所在的矩形区域包含在内即可实现（可以通过Rect的Union方法实现），修改后的代码如下：

Rect finalRect = Rect.Empty; // 最终要显示的选择区域
Rect temp = Rect.Empty;

do
{
	if (finalRect != Rect.Empty)
		temp = new Rect(finalRect.X, finalRect.Y, finalRect.Width, finalRect.Height);

	foreach (FrameworkElement item in rootCanvas.Children)
	{
		if (item as Rectangle != null) continue;

		double cLeft = (double)item.GetValue(Canvas.LeftProperty);
		double cTop = (double)item.GetValue(Canvas.TopProperty);

		Rect rc1 = new Rect(selectedRect.X, selectedRect.Y, selectedRect.Width, selectedRect.Height);
		Rect rc2 = new Rect(cLeft, cTop, item.ActualWidth, item.ActualHeight);
		rc1.Intersect(rc2); /* 判断控件所在的矩形区域与选择的矩形区域是否相交 */
		if (rc1 != Rect.Empty)
		{
			selectedRect.Union(rc2);  /*  扩展 selectedRect 时可能会有新控件包含进选择区域，因此用 do while 循环判断  */
			finalRect.Union(rc2);

			if (!selectedElements.Contains(item))
				selectedElements.Add(item);
		}
	}
} while (temp != finalRect);  /*   如果 temp == finalRect 说明没有新控件选择进来  */

if (finalRect != Rect.Empty)
{
	/*  重新设置选择区域的大小和位置   */
	rect.SetValue(Canvas.TopProperty, finalRect.Y);
	rect.SetValue(Canvas.LeftProperty, finalRect.X);
	rect.SetValue(Rectangle.WidthProperty, finalRect.Width);
	rect.SetValue(Rectangle.HeightProperty, finalRect.Height);
}

同时将上面的代码从鼠标的点击事件中移到了鼠标的弹起事件中，这样在鼠标弹起时就可以自动将选中的控件包含在选择区域内。代码可以到 http://zdd.me/myfiles 下载。

演示地址 http://v.zdd.me/testpage.html

本文链接

Silverlight 中用鼠标同时选中和移动多个控件

2010-09-04T02:40:00Z

在设计 WinForm 程序时，我们可以很方便的同时选择窗体上的多个控件来调整控件的位置。在 Silverlight 应用程序中有时我们也想实现同样的功能，以提供更好的用户体验。本文将要介绍的就是在 Silverlight 程序中实现同时选中和移动多个控件。

1、实现鼠标拖动选择时显示所选区域

2、移动所选区域时同时移动在该区域内的控件

要实现鼠标拖动选择时显示所选区域功能，可以在鼠标拖动时在 Canvas 容器中动态添加一个 Rectangle 来显示类似在 Windows 资源管理器拖动选择文件时的选择框。实现前面所述功能的操作：在 Canvas 容器中按下鼠标左键并拖动鼠标来修改选择区域，选定目标区域后松开鼠标按键，这时显示一个表示所选区域的矩形选框。由实现的操作可知，我们需要在鼠标左键按下时在 Canvas 容器中添加一个矩形框，然后在鼠标移动时根据鼠标的位置更新矩形框的大小，最后在鼠标左键弹起显示最终的选择区域并查找出在选择区域中的控件。

private Point origPoint;  /* 鼠标点击的位置   */
private Rectangle rect;   /*  选择的区域  */
private Rect selectedRect; /* 选择的矩形区域 */
private bool isMultipleSelected;
private List<FrameworkElement> selectedElements = new List<FrameworkElement>();

public MainPage()
{
	InitializeComponent();

	this.rootCanvas.MouseLeftButtonDown += Handle_MouseLeftButtonDown;
}

private void Handle_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
	if (e.OriginalSource is Canvas)
	{
		if (rect != null)
		{
			isMultipleSelected = false;

			rootCanvas.Children.Remove(rect);
			rect = null;
		}
		else
		{
			isMultipleSelected = true;

			rect = new Rectangle();
			origPoint = e.GetPosition(rootCanvas);

			rootCanvas.Children.Add(rect);
			rect.SetValue(Canvas.LeftProperty, origPoint.X);
			rect.SetValue(Canvas.TopProperty, origPoint.Y);

			rect.Fill = new SolidColorBrush(Colors.LightGray);
			rect.Stroke = new SolidColorBrush(Colors.Black);
			rect.StrokeThickness = 3;
			rect.Opacity = .5;

			rect.MouseLeftButtonDown += Handle_MouseLeftButtonDown;

			rootCanvas.MouseMove += Handle_MouseMove;
			rootCanvas.MouseLeftButtonUp += Handle_MouseLeftButtonUp;
		}
	}
	else if (e.OriginalSource is Rectangle)
	{
		isMultipleSelected = false;

		origPoint = e.GetPosition(rootCanvas);

		rect.MouseMove += Handle_MouseMove;
		rect.MouseLeftButtonUp += Handle_MouseLeftButtonUp;
		rect.CaptureMouse();

		/*
		 * 查找在选择范围内的控件
		 * 
		 */

		double rLeft = (double)rect.GetValue(Canvas.LeftProperty);
		double rTop = (double)rect.GetValue(Canvas.TopProperty);
		
		foreach (FrameworkElement item in rootCanvas.Children)
		{
			double cLeft = (double)item.GetValue(Canvas.LeftProperty);
			double cTop = (double)item.GetValue(Canvas.TopProperty);

			Rect rc1 = new Rect(selectedRect.X, selectedRect.Y, selectedRect.Width, selectedRect.Height);
			Rect rc2 = new Rect(cLeft, cTop, item.ActualWidth, item.ActualHeight);
			rc1.Intersect(rc2); /* 判断控件所在的矩形区域与选择的矩形区域是否相交 */
			if (rc1 != Rect.Empty)
			{
				if (!selectedElements.Contains(item))
					selectedElements.Add(item);
			}
		}
	}
}

private void Handle_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
	if (isMultipleSelected)
	{
		/*  所选区域的矩形  */
		selectedRect = new Rect((double)rect.GetValue(Canvas.LeftProperty), 
			(double)rect.GetValue(Canvas.TopProperty), rect.Width, rect.Height);
		
		rootCanvas.MouseLeftButtonUp -= Handle_MouseLeftButtonUp;
		rootCanvas.MouseMove -= Handle_MouseMove;
	}
}

private void Handle_MouseMove(object sender, MouseEventArgs e)
{
	if (isMultipleSelected)
	{
		Point curPoint = e.GetPosition(rootCanvas);
		if (curPoint.X > origPoint.X)
		{
			rect.Width = curPoint.X - origPoint.X;
		}
		if (curPoint.X < origPoint.X)
		{
			rect.SetValue(Canvas.LeftProperty, curPoint.X);
			rect.Width = origPoint.X - curPoint.X;
		}
		if (curPoint.Y > origPoint.Y)
		{
			rect.Height = curPoint.Y - origPoint.Y;
		}
		if (curPoint.Y < origPoint.Y)
		{
			rect.SetValue(Canvas.TopProperty, curPoint.Y);
			rect.Height = origPoint.Y - curPoint.Y;
		}
	}
}

在上面的代码中首先定义了几个要用到的变量：origPoint 用来保存鼠标点击时的位置，在动态修改矩形选框和移动控件时会用到；rect 显示矩形选框；selectedRect 矩形选框的矩形大小；isMultipleSelected 标识是否是拖动鼠标进行选择；selectedElements 保存在选择区域中的控件。

在鼠标左键单击事件中，先判断是在 Canvas 容器中单击的还是在 Rectangle 中单击的，注意我们是用 e.OriginalSource 来判断引发事件的对象的，因为 Canvas 和 Rectangle 都要处理鼠标左键单击事件，在 Rectangle 上单击时同时会触发 Canvas 上的单击事件，因此用 sender 来判断引发事件的对象是不准确的。如果是在 Canvas 中进行的单击，先判断 rect 变量是否为 null，如果 rect 不为 null 说明之前已进行过选择或单击，则在 Canvas 中移除 rect 并将 rect 设为 null，将 isMultipleSelected 设为 false；如果 rect 为 null，则将 isMultipleSelected 设为 true 表示当前操作是在进行选择，接着新建一个 Rectangle 并记下鼠标点击的位置，然后将新建的 rect 添加到 Canvas 中。如果是在 Rectangle 上进行的单击，则表示已经执行完选择操作了要进行移动选择区域的操作，首先记下鼠标点击的位置并附加相应的处理事件，然后通过遍历 Canvas 的子控件来找出在选择区域的所有控件并保存到selectedElements 中。在判断控件是否在选择区域中时用的是 Rect 的 Intersect （判断两个矩形是否相交）方法进行判断的，开始想到的是判断控件所在的矩形的四个顶点和选择区域的四个顶点的位置关系，网上打了一下很多人也是这么做的，后来想到 WinForm 中的 Rectangle 中有 Intersect 这个方法，Silverlight 中有没有呢，后来发现 Silverlight 中的 Rectangle 没有 Intersect 这个方法而 Rect 有这个方法，这就是代码中为什么要用 selectedRect 这个变量保存选择区域所在的矩形。

在鼠标左键的弹起事件中，首先判断是不是在进行选择，如果是则记下选择区域所在的矩形。

在鼠标移动事件中，如果是在进行选择，根据鼠标当前所在的位置更新 rect 选择区域的大小。

到这里我们已经完成了建立选择区域的操作，运行结果如下图所示：接下来实现移动选择区域时同时对选择的控件进行移动。

实现移动选择区域时现时对选择的控件进行移动的操作是：鼠标在选择区域上按下，接着移动鼠标，在移动鼠标时更新选择区域的位置同时也更新选择的控件的位置。我们需要处理的事件是 Rectangle 的鼠标单击、移动和弹起事件。

private bool isMouseCaptured;

首先新建一个 isMouseCaptured 变量，用来标识鼠标是否选中了矩形选框 rect，在 Canvas 的单击事件中将 isMouseCaptured 设为 false，在 Rectangle 的单击事件中将 isMouseCaptured 设为 true 。

选择区域的单击事件的处理代码在上面的代码中已经有了，移动事件和弹起事件的处理代码如下：

// 鼠标移动事件处理代码  加入Handle_MouseMove中
if (isMouseCaptured)
{
	double deltaV = e.GetPosition(rootCanvas).Y - origPoint.Y;
	double deltaH = e.GetPosition(rootCanvas).X - origPoint.X;
	double newTop = deltaV + (double)rect.GetValue(Canvas.TopProperty);
	double newLeft = deltaH + (double)rect.GetValue(Canvas.LeftProperty);

	foreach (var item in selectedElements)
	{
		double cLeft = (double)item.GetValue(Canvas.LeftProperty);
		double cTop = (double)item.GetValue(Canvas.TopProperty);

		item.SetValue(Canvas.LeftProperty, deltaH + cLeft);
		item.SetValue(Canvas.TopProperty, deltaV + cTop);
	}

	rect.SetValue(Canvas.TopProperty, newTop);
	rect.SetValue(Canvas.LeftProperty, newLeft);

	origPoint = e.GetPosition(rootCanvas);
}

// 鼠标左键弹起事件处理代码 加入Handle_MouseLeftButtonUp中
if (isMouseCaptured)
{
	selectedElements.Clear();
	rect.ReleaseMouseCapture();
	isMouseCaptured = false;

	rootCanvas.Children.Remove(rect);
	rect = null;
}

在鼠标移动事件中我们根据鼠标当前的位置更新选择区域的位置和选择的控件的位置，在鼠标左键弹起事件中将记录的选择的控件清除并把选择区域 rect 从 Canvas 容器中移除。

到这里我们已经实现了用鼠标现时选择和移动多个控件的操作。示例代码下载：http://zdd.me/myfiles

下面是演示(先用鼠标将上面的图标拖到下面，然后可以用鼠标拖动选择多个移动)：

本文链接

Silverlight 拖动复制控件

2010-08-31T14:48:00Z

Silverlight 拖动复制控件，就是将控件从一个容器中向另一个容器中拖动时，不是移动控件而把该控件到另一个容器中。这种情形在程序中经常遇到，下面是我做的一个拖动复制控件的示例，仅供有这种需求的朋友们参考。

新建一个 Silverlight 项目命名为 DragAndCopy ，在新建的项目中添加一个Silverlight 用户控件（Silverlight user control）命名为 DragObject。项目结构如下图所示：

其中 DragObject 就是要拖动的用户控件，DragObject 的 Xaml 代码如下：

<UserControl x:Class="DragAndCopy.DragObject"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
    <Image x:Name="icon" Width="128" Height="128" Stretch="Fill" />
</UserControl>

这里只是演示拖动复制效果，只在 DragObject 中显示一个图标。DragObject 的后置代码如下：

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;

namespace DragAndCopy
{
    public partial class DragObject : UserControl
    {
        public DragObject()
        {
            InitializeComponent();

            this.Loaded += new RoutedEventHandler(DragObject_Loaded);
        }

        /// <summary>
        /// 唯一标识一个控件
        /// </summary>
        public string UUID
        {
            get;
            set;
        }

        /// <summary>
        /// 鼠标点击的位置
        /// </summary>
        public Point ClickPos
        {
            get;
            set;
        }

        /// <summary>
        /// 图标地址（相对）
        /// </summary>
        public string ImageUri
        {
            get;
            set;
        }

        void DragObject_Loaded(object sender, RoutedEventArgs e)
        {
            if (!string.IsNullOrEmpty(ImageUri))
            {
                BitmapImage bitmap = new BitmapImage(new Uri(ImageUri, UriKind.Relative));
                icon.Source = bitmap;
            }
        }
    }
}

DragObject 的 UUID 属性用来唯一标识一个 DragObject 实例，在鼠标点击 DragObject 时也是通过 UUID 来判断是进行移动还是复制。ClickPos 属性是鼠标点击 DragObject 的位置，ImageUri 属性是 DragObject 的图标的相对地址。

接下来在 MainPage 中添加几个 DragObject 的实例，并添加一 Canvas 容器。

<UserControl x:Class="DragAndCopy.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:DragAndCopy"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
    <Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition Height="160" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Border Grid.Row="0" CornerRadius="5,5,5,5" BorderBrush="Green" BorderThickness="1,1,1,1">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" Margin="5,10,5,10">
                <local:DragObject ImageUri="icons/chrome.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown" 
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
                <local:DragObject ImageUri="icons/flock.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown"
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
                <local:DragObject ImageUri="icons/galeon.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown" 
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
                <local:DragObject ImageUri="icons/ie7.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown" 
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
                <local:DragObject ImageUri="icons/konqueror.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown" 
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
                <local:DragObject ImageUri="icons/mfirefox.png" 
                              Margin="5,5,5,5" 
                              MouseLeftButtonDown="Handle_MouseLeftButtonDown" 
                              MouseLeftButtonUp="Handle_MouseLeftButtonUp" />
            </StackPanel>
        </Border>

        <Canvas x:Name="rootCanvas" Grid.Row="1" Background="White">
            
        </Canvas>
    </Grid>
</UserControl>

接着实现将 DragObject 从 StackPanel 容器中拖动到 Canvas 容器中时，复制一个 DragObject 到 Canvas 容器。拖动复制这个动作是在 StackPanel 中的 DragObject 上按下鼠标左键，然后将鼠标指针拖动到 Canvas 中后弹起鼠标左键，由此可知 StackPanel 中的 DragObject 需要响应鼠标左键的按下事件，Canvas 需要响应鼠标左键的弹起事件。

先定义两个变量

view plain

print ?

`1`	`private` `DragObject curDrag;`

`2`	`private` `bool` `isMouseCaptured;`

curDrag 是用来保存要复制的控件的中间变量，isMouseCaptured 用来判断是否按鼠标左键。

事件处理代码如下：

view plain

print ?

`01`	`void` `Handle_MouseLeftButtonDown(object` `sender, MouseButtonEventArgs e)�`

02 {

`03`	`DragObject dragObj = sender` `as` `DragObject;`

`04`	`if` `(dragObj !=` `null)` `// 鼠标左键在 DragObject 上按下`

05 {

`06`	`if` `(string.IsNullOrEmpty(dragObj.UUID))` `// 在控件栏中的 DragObject 上按下`

07 {

`08`	`// 复制要拖动的控件`

`09`	`curDrag =` `new` `DragObject();`

`10`	`curDrag.UUID = Guid.NewGuid().ToString("N");` `// 使用 Guid 标识复制的每个控件`

`11`	`curDrag.ImageUri = dragObj.ImageUri;`

`12`	`curDrag.ClickPos = e.GetPosition(dragObj);`

13 }

`14`	`isMouseCaptured =` `true;`

15 }

16 }

view plain

print ?

`01`	`void` `Handle_MouseLeftButtonUp(object` `sender, MouseButtonEventArgs e)`

02 {

`03`	`DragObject dragObj = sender` `as` `DragObject;`

`04`	`if` `(sender` `is` `Canvas)` `// 鼠标左键在容器上弹起`

05 {

`06`	`if` `(isMouseCaptured)`

07 {

`08`	`isMouseCaptured =` `false;`

`09`	`if` `(!rootCanvas.Children.Contains(curDrag))` `// 复制控件`

10 {

`11`	`double` `x = e.GetPosition(rootCanvas).X;`

`12`	`double` `y = e.GetPosition(rootCanvas).Y;`

13

`14`	`rootCanvas.Children.Add(new` `DragObject`

15 {

`16`	`ImageUri = curDrag.ImageUri,`

`17`	`UUID = curDrag.UUID,`

`18`	`ClickPos = curDrag.ClickPos`

19 });

20

`21`	`// 添加控件的鼠标左键按下、弹起事件、设置控件的位置`

`22`	`DragObject obj = rootCanvas.Children.First(ue => (ue` `as` `DragObject).UUID == curDrag.UUID)` `as` `DragObject;`

`23`	`//obj.MouseMove += Handle_MouseMove;`

`24`	`obj.MouseLeftButtonDown += Handle_MouseLeftButtonDown;`

25

`26`	`obj.SetValue(Canvas.TopProperty, y - obj.ClickPos.Y);`

`27`	`obj.SetValue(Canvas.LeftProperty, x - obj.ClickPos.X);`

28 }

29 }

30 }

31 }

有了以上的代码就可以实现用户控件的复制了。接下实现 Canvas 容器中的控件的拖动事件，拖动控件的是在控件上按下鼠标左键，然后移动鼠标，因此控件需要处理鼠标左键按下和鼠标移动事件。处理代码如下：

view plain

print ?

`01`	`void` `Handle_MouseLeftButtonDown(object` `sender, MouseButtonEventArgs e)`

02 {

`03`	`DragObject dragObj = sender` `as` `DragObject;`

`04`	`if` `(dragObj !=` `null)` `// 鼠标左键在 DragObject 上按下`

05 {

`06`	`dragObj.MouseMove -= Handle_MouseMove;`

`07`	`dragObj.MouseMove += Handle_MouseMove;`

08

`09`	`mouseVerticalPosition = e.GetPosition(null).Y;`

`10`	`mouseHorizontalPosition = e.GetPosition(null).X;`

`11`	`dragObj.CaptureMouse();`

`12`	`isMouseCaptured =` `true;`

13 }

14 }

鼠标移动事件处理代码如下：

view plain

print ?

`01`	`void` `Handle_MouseMove(object` `sender, MouseEventArgs e)`

02 {

`03`	`DragObject item = sender` `as` `DragObject;`

04

`05`	`if` `(item !=` `null` `&& isMouseCaptured)`

06 {

`07`	`double` `deltaV = e.GetPosition(null).Y - mouseVerticalPosition;`

`08`	`double` `deltaH = e.GetPosition(null).X - mouseHorizontalPosition;`

`09`	`double` `newTop = deltaV + (double)item.GetValue(Canvas.TopProperty);`

`10`	`double` `newLeft = deltaH + (double)item.GetValue(Canvas.LeftProperty);`

11

`12`	`// 设置新位置`

`13`	`item.SetValue(Canvas.TopProperty, newTop);`

`14`	`item.SetValue(Canvas.LeftProperty, newLeft);`

15

`16`	`// 更新全局变量`

`17`	`mouseVerticalPosition = e.GetPosition(null).Y;`

`18`	`mouseHorizontalPosition = e.GetPosition(null).X;`

19 }

20 }

通过以上代码我们实现的拖动复制及移动控件，但是上面的代码还有一些小 Bug，完整的示例代码请到http://zdd.me/myfiles下载。

下面是演示：

本文链接