在Blend中创建WPF自定义Button控件

在Blend中创建WPF自定义Button控件，可以按照以下步骤进行：

1. 打开Blend，创建一个新的WPF项目。

2. 在“项目”面板中，右键单击“控件”文件夹，选择“添加”->“新建项”。

3. 在“添加新项”对话框中，选择“WPF”->“Custom Control”，设置名称为“CustomButton”并选择位置，点击“添加”按钮。

4. Blend会自动生成一个名为“CustomButton”的自定义控件的类文件和一个默认的控件模板文件。

5. 双击控件模板文件，进入“编辑模板”模式。在这里，你可以自由地编辑控件的外观和布局。

6. 在“对象和时间”面板中，可以选择控件的外观和行为。例如，你可以添加按钮、文本框等控件，设置它们的属性和事件处理程序。

7. 在控件模板中，找到名为“PART_Button”控件的模板，这是自定义控件中的按钮。你可以编辑它的外观和行为，以实现自定义Button控件的功能和样式。

8. 在编辑完成后，保存模板文件并退出“编辑模板”模式。

9. 在CustomButton类中，添加自定义属性和事件处理程序，以实现自定义Button控件的功能。

10. 在应用程序中，使用自定义Button控件，只需要在XAML中添加一个CustomButton标记，然后设置它的属性和事件处理程序即可。

以上就是在Blend中创建WPF自定义Button控件的基本步骤。需要注意的是，在创建控件时，应该考虑控件的可重用性和灵活性，以便在不同的场景中使用。同时，应该设计好控件的外观和行为，以便用户可以方便地使用和定制控件。

相关问题

WPF MVMLIGHT 带自定义控件使用 工程示例

以下是一个使用WPF MVVM Light框架和自定义控件的示例工程：

1. 创建一个WPF应用程序项目，并在NuGet包管理器中安装MVVM Light框架。在App.xaml文件中添加以下代码：

<Application x:Class="WpfApp1.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WpfApp1"
             StartupUri="MainWindow.xaml">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/MyCustomControls;component/Themes/Generic.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>

这段代码将MyCustomControls库中的通用样式应用到应用程序中。

2. 创建一个自定义控件库项目，添加自定义控件。例如，我们添加一个名为MyCustomButton的自定义按钮控件。

3. 在MyCustomButton项目中，创建一个名为Generic.xaml的文件，并在其中添加以下代码：

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Style TargetType="{x:Type local:MyCustomButton}">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type local:MyCustomButton}">
                    <Border Background="{TemplateBinding Background}"
                            BorderBrush="{TemplateBinding BorderBrush}"
                            BorderThickness="{TemplateBinding BorderThickness}">
                        <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                                            VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
                    </Border>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

这段代码定义了MyCustomButton控件的样式模板。

4. 在MyCustomButton项目中，在AssemblyInfo.cs文件中添加以下代码，使样式模板可用于外部应用程序：

[assembly: ThemeInfo(ResourceDictionaryLocation.None, ResourceDictionaryLocation.SourceAssembly)]

5. 在WPF应用程序项目中，添加对MyCustomButton项目的引用，并在MainWindow.xaml中添加以下代码：

<Window x:Class="WpfApp1.MainWindow"
        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:WpfApp1"
        xmlns:controls="clr-namespace:MyCustomControls;assembly=MyCustomControls"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <controls:MyCustomButton Content="Click me!" />
    </Grid>
</Window>

这段代码将MyCustomButton控件添加到窗口中。

6. 创建一个名为MainViewModel的视图模型类，并在其中添加以下代码：

using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;

namespace WpfApp1
{
    public class MainViewModel : ViewModelBase
    {
        public RelayCommand ClickCommand { get; }

        public MainViewModel()
        {
            ClickCommand = new RelayCommand(() =>
            {
                // Do something when the button is clicked
            });
        }
    }
}

这段代码创建了一个名为ClickCommand的命令，并在构造函数中初始化了该命令。

7. 在MainWindow.xaml中，将窗口的DataContext属性设置为MainViewModel的实例，并将MyCustomButton的Command属性绑定到ClickCommand命令：

<Window x:Class="WpfApp1.MainWindow"
        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:WpfApp1"
        xmlns:controls="clr-namespace:MyCustomControls;assembly=MyCustomControls"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800"
        DataContext="{Binding Main, Source={StaticResource Locator}}">
    <Grid>
        <controls:MyCustomButton Content="Click me!" Command="{Binding ClickCommand}" />
    </Grid>
</Window>

这段代码使用MVVM Light框架中的ViewModelLocator将MainViewModel实例绑定到窗口的DataContext属性，并将MyCustomButton的Command属性绑定到ClickCommand命令。

现在，你可以在自定义控件中使用MVVM Light框架来实现你的应用程序逻辑了。

wpf mvvm框架搭建 使用自定义控件工程事例

好的，下面是一个 WPF MVVM 框架搭建并使用自定义控件的工程事例：

1. 创建一个 WPF 应用程序项目。

2. 在项目中添加一个名为 Models 的文件夹，并在其中添加一个名为 Student.cs 的类，该类包含学生的姓名和年龄属性：

namespace WpfMvvmDemo.Models
{
    public class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

3. 在项目中添加一个名为 ViewModels 的文件夹，并在其中添加一个名为 MainViewModel.cs 的类，该类包含一个名为 Students 的可观察集合属性，用于存储学生对象，并在构造函数中初始化该集合：

using System.Collections.ObjectModel;
using WpfMvvmDemo.Models;

namespace WpfMvvmDemo.ViewModels
{
    public class MainViewModel
    {
        public ObservableCollection<Student> Students { get; set; }

        public MainViewModel()
        {
            Students = new ObservableCollection<Student>
            {
                new Student { Name = "张三", Age = 18 },
                new Student { Name = "李四", Age = 19 },
                new Student { Name = "王五", Age = 20 }
            };
        }
    }
}

4. 在项目中添加一个名为 Controls 的文件夹，并在其中添加一个名为 StudentControl.xaml 的自定义控件。该控件包含一个 TextBlock 控件和一个 Button 控件，用于显示学生的姓名和年龄，并提供一个名为 DeleteCommand 的依赖属性，以便在删除按钮被点击时执行删除操作：

<UserControl x:Class="WpfMvvmDemo.Controls.StudentControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:WpfMvvmDemo.Controls"
             mc:Ignorable="d" 
             d:DesignHeight="30" d:DesignWidth="200">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="Auto" />
        </Grid.ColumnDefinitions>
        <TextBlock Text="{Binding Name}" Margin="5" />
        <Button Grid.Column="1" Content="删除" Margin="5" Command="{Binding DeleteCommand}" />
    </Grid>
</UserControl>

5. 在 StudentControl.xaml.cs 中，定义 DeleteCommand 依赖属性，并在构造函数中为该属性设置默认值：

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace WpfMvvmDemo.Controls
{
    public partial class StudentControl : UserControl
    {
        public static readonly DependencyProperty DeleteCommandProperty =
            DependencyProperty.Register("DeleteCommand", typeof(ICommand), typeof(StudentControl), new PropertyMetadata(null));

        public ICommand DeleteCommand
        {
            get { return (ICommand)GetValue(DeleteCommandProperty); }
            set { SetValue(DeleteCommandProperty, value); }
        }

        public StudentControl()
        {
            InitializeComponent();
            DeleteCommand = new RelayCommand(Delete);
        }

        private void Delete(object parameter)
        {
            // 执行删除操作
        }
    }
}

6. 在项目中添加一个名为 Commands 的文件夹，并在其中添加一个名为 RelayCommand.cs 的类，该类实现了 ICommand 接口，用于在控件中执行命令：

using System;
using System.Windows.Input;

namespace WpfMvvmDemo.Commands
{
    public class RelayCommand : ICommand
    {
        private readonly Action<object> _execute;
        private readonly Predicate<object> _canExecute;

        public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        public bool CanExecute(object parameter)
        {
            return _canExecute?.Invoke(parameter) ?? true;
        }

        public void Execute(object parameter)
        {
            _execute(parameter);
        }
    }
}

7. 在项目中添加一个名为 Converters 的文件夹，并在其中添加一个名为 AgeToStringConverter.cs 的类，该类实现了 IValueConverter 接口，用于将学生的年龄转换为字符串：

using System;
using System.Globalization;
using System.Windows.Data;

namespace WpfMvvmDemo.Converters
{
    public class AgeToStringConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is int age)
            {
                return $"{age} 岁";
            }
            return null;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}

8. 在 MainWindow.xaml 中，使用 StudentControl 自定义控件，将 ItemsControl 控件绑定到 MainViewModel 中的 Students 属性，并使用 AgeToStringConverter 将学生的年龄转换为字符串：

<Window x:Class="WpfMvvmDemo.Views.MainWindow"
        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:WpfMvvmDemo.Views"
        xmlns:viewModel="clr-namespace:WpfMvvmDemo.ViewModels"
        xmlns:controls="clr-namespace:WpfMvvmDemo.Controls"
        xmlns:converters="clr-namespace:WpfMvvmDemo.Converters"
        xmlns:commands="clr-namespace:WpfMvvmDemo.Commands"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <viewModel:MainViewModel />
    </Window.DataContext>
    <Window.Resources>
        <converters:AgeToStringConverter x:Key="AgeToStringConverter" />
    </Window.Resources>
    <Grid>
        <ItemsControl ItemsSource="{Binding Students}">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <controls:StudentControl>
                        <controls:StudentControl.DataContext>
                            <viewModel:StudentViewModel Name="{Binding Name}" Age="{Binding Age}" DeleteCommand="{Binding DataContext.DeleteStudentCommand, RelativeSource={RelativeSource AncestorType=Window}}" />
                        </controls:StudentControl.DataContext>
                        <StackPanel Orientation="Horizontal">
                            <TextBlock Text="{Binding Name}" Margin="5" />
                            <TextBlock Text="{Binding Age, Converter={StaticResource AgeToStringConverter}}" Margin="5" />
                        </StackPanel>
                    </controls:StudentControl>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </Grid>
</Window>

9. 在项目中添加一个名为 StudentViewModel.cs 的类，该类用于将学生对象转换为可供 StudentControl 使用的视图模型，并包含一个名为 DeleteCommand 的命令，用于删除该学生：

using System.Windows.Input;
using WpfMvvmDemo.Commands;

namespace WpfMvvmDemo.ViewModels
{
    public class StudentViewModel
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public ICommand DeleteCommand { get; set; }

        public StudentViewModel(string name, int age, ICommand deleteCommand)
        {
            Name = name;
            Age = age;
            DeleteCommand = deleteCommand;
        }
    }
}

10. 在 MainViewModel.cs 中，添加一个名为 DeleteStudentCommand 的命令，用于删除选定的学生：

using System.Collections.ObjectModel;
using System.Windows.Input;
using WpfMvvmDemo.Commands;
using WpfMvvmDemo.Models;

namespace WpfMvvmDemo.ViewModels
{
    public class MainViewModel
    {
        public ObservableCollection<Student> Students { get; set; }
        public ICommand DeleteStudentCommand { get; set; }

        public MainViewModel()
        {
            Students = new ObservableCollection<Student>
            {
                new Student { Name = "张三", Age = 18 },
                new Student { Name = "李四", Age = 19 },
                new Student { Name = "王五", Age = 20 }
            };
            DeleteStudentCommand = new RelayCommand(DeleteStudent);
        }

        private void DeleteStudent(object parameter)
        {
            if (parameter is Student student)
            {
                Students.Remove(student);
            }
        }
    }
}

这就是一个 WPF MVVM 框架搭建并使用自定义控件的工程事例。通过这个例子，你可以学习到如何使用自定义控件和视图模型，实现更加灵活的界面设计和命令操作。