桌面应用开发

public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
        btnSubmit.Click += BtnSubmit_Click;
        txtInput.TextChanged += TxtInput_TextChanged;
    }

    private void MainForm_Load(object sender, EventArgs e)
    {
        comboBox1.Items.AddRange(new[] { "选项A", "选项B", "选项C" });
        comboBox1.SelectedIndex = 0;
    }

    private void BtnSubmit_Click(object sender, EventArgs e)
    {
        MessageBox.Show($"输入内容：{txtInput.Text}", "提示", 
            MessageBoxButtons.OK, MessageBoxIcon.Information);
    }

    private void TxtInput_TextChanged(object sender, EventArgs e)
    {
        lblCharCount.Text = $"字符数：{txtInput.TextLength}";
    }
}

public partial class DataForm : Form
{
    private BindingSource _bindingSource = new BindingSource();
    private List<Employee> _employees;

    public DataForm()
    {
        InitializeComponent();
        LoadData();
        SetupBinding();
    }

    private void LoadData()
    {
        _employees = GetEmployeesFromDatabase();
        _bindingSource.DataSource = _employees;
    }

    private void SetupBinding()
    {
        txtName.DataBindings.Add("Text", _bindingSource, "Name");
        txtAge.DataBindings.Add("Text", _bindingSource, "Age");
        dataGridView1.DataSource = _bindingSource;
        
        btnPrev.Click += (s, e) => _bindingSource.MovePrevious();
        btnNext.Click += (s, e) => _bindingSource.MoveNext();
    }

    private void ApplyFilter(string department)
    {
        _bindingSource.Filter = $"Department = '{department}'";
    }
}

public class Employee : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get => _name;
        set { _name = value; OnPropertyChanged(); }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// 方式一：使用 Invoke
private void BtnLoad_Click(object sender, EventArgs e)
{
    Task.Run(() =>
    {
        var data = LoadHeavyData();
        Invoke(new Action(() =>
        {
            dataGridView1.DataSource = data;
            lblStatus.Text = "加载完成";
        }));
    });
}

// 方式二：async/await（推荐）
private async void BtnProcess_Click(object sender, EventArgs e)
{
    btnProcess.Enabled = false;
    var progress = new Progress<int>(p => progressBar1.Value = p);
    
    await Task.Run(() => ProcessData(progress));
    
    lblStatus.Text = "处理完成";
    btnProcess.Enabled = true;
}

// 用户控件 - 带验证的输入框
public partial class ValidatedTextBox : UserControl
{
    public ValidatedTextBox()
    {
        InitializeComponent();
        txtInput.Validating += TxtInput_Validating;
    }

    [Browsable(true), Category("Behavior"), Description("是否必填")]
    public bool IsRequired { get; set; }

    [Browsable(true), Category("Behavior"), Description("输入值")]
    public string Value
    {
        get => txtInput.Text;
        set => txtInput.Text = value;
    }

    private void TxtInput_Validating(object sender, CancelEventArgs e)
    {
        if (IsRequired && string.IsNullOrWhiteSpace(txtInput.Text))
        {
            errorProvider1.SetError(txtInput, "此项为必填");
            e.Cancel = true;
        }
        else
        {
            errorProvider1.SetError(txtInput, "");
        }
    }
}

// 自定义绘制 - 圆形进度条
public class CircularProgress : Control
{
    public CircularProgress()
    {
        SetStyle(ControlStyles.AllPaintingInWmPaint | 
                 ControlStyles.UserPaint | 
                 ControlStyles.OptimizedDoubleBuffer, true);
    }

    private int _value = 75;
    [Browsable(true), Category("Appearance")]
    public int Value
    {
        get => _value;
        set { _value = value; Invalidate(); }
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        var g = e.Graphics;
        g.SmoothingMode = SmoothingMode.AntiAlias;

        var rect = new Rectangle(10, 10, Width - 20, Height - 20);
        using var pen = new Pen(Color.LightGray, 8);
        g.DrawEllipse(pen, rect);

        using var progressPen = new Pen(Color.Blue, 8);
        var sweepAngle = 360f * _value / 100;
        g.DrawArc(progressPen, rect, -90, sweepAngle);
    }
}

// 值转换器
public class BooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return (value is bool isVisible && isVisible) 
            ? Visibility.Visible 
            : Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is Visibility visibility && visibility == Visibility.Visible;
    }
}

// ViewModel 实现通知
public class UserViewModel : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get => _name;
        set { _name = value; OnPropertyChanged(); }
    }

    private bool _isAdmin;
    public bool IsAdmin
    {
        get => _isAdmin;
        set { _isAdmin = value; OnPropertyChanged(); }
    }

    public ObservableCollection<Order> Orders { get; } = new();

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// 基础 ViewModel
public class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string name = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }
}

// 命令实现
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;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke(parameter) ?? true;
    public void Execute(object parameter) => _execute(parameter);
    public event EventHandler CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }
}

// 具体 ViewModel
public class ProductViewModel : ViewModelBase
{
    private readonly IProductService _productService;
    private readonly IMessenger _messenger;

    public ProductViewModel(IProductService productService, IMessenger messenger)
    {
        _productService = productService;
        _messenger = messenger;
        LoadCommand = new RelayCommand(LoadProducts);
        DeleteCommand = new RelayCommand(DeleteProduct, CanDelete);
    }

    private ObservableCollection<Product> _products;
    public ObservableCollection<Product> Products
    {
        get => _products;
        set { _products = value; OnPropertyChanged(); }
    }

    private Product _selectedProduct;
    public Product SelectedProduct
    {
        get => _selectedProduct;
        set { _selectedProduct = value; OnPropertyChanged(); }
    }

    public ICommand LoadCommand { get; }
    public ICommand DeleteCommand { get; }

    private async void LoadProducts(object parameter)
    {
        Products = new ObservableCollection<Product>(
            await _productService.GetAllAsync());
    }

    private void DeleteProduct(object parameter)
    {
        if (SelectedProduct != null)
        {
            _productService.Delete(SelectedProduct.Id);
            Products.Remove(SelectedProduct);
            _messenger.Send(new ProductDeletedMessage(SelectedProduct));
        }
    }

    private bool CanDelete(object parameter) => SelectedProduct != null;
}

public class CustomControl : Control
{
    // 注册依赖属性
    public static readonly DependencyProperty LabelProperty =
        DependencyProperty.Register(
            nameof(Label),
            typeof(string),
            typeof(CustomControl),
            new FrameworkPropertyMetadata(
                "默认标签",
                FrameworkPropertyMetadataOptions.AffectsRender,
                OnLabelChanged));

    public string Label
    {
        get => (string)GetValue(LabelProperty);
        set => SetValue(LabelProperty, value);
    }

    private static void OnLabelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (CustomControl)d;
        control.UpdateVisualState();
    }

    // 注册路由事件
    public static readonly RoutedEvent ValueChangedEvent =
        EventManager.RegisterRoutedEvent(
            nameof(ValueChanged),
            RoutingStrategy.Bubble,
            typeof(RoutedPropertyChangedEventHandler<double>),
            typeof(CustomControl));

    public event RoutedPropertyChangedEventHandler<double> ValueChanged
    {
        add => AddHandler(ValueChangedEvent, value);
        remove => RemoveHandler(ValueChangedEvent, value);
    }

    protected virtual void OnValueChanged(double oldValue, double newValue)
    {
        var args = new RoutedEventArgs(ValueChangedEvent);
        RaiseEvent(args);
    }
}

// 在 WinForms 中托管 WPF 控件（ElementHost）
public partial class HybridForm : Form
{
    public HybridForm()
    {
        InitializeComponent();
        
        var elementHost = new ElementHost
        {
            Dock = DockStyle.Fill,
            Child = new WpfUserControl()
        };
        
        panel1.Controls.Add(elementHost);
    }
}

// WPF MVVM
public class CounterViewModel : ViewModelBase
{
    private int _count;
    public int Count
    {
        get => _count;
        set { _count = value; OnPropertyChanged(); }
    }
    public ICommand IncrementCommand { get; }
}