wpf 129

System.IO.IOException

HResult=0x80131620

Message=找不到资源"example2window.xaml"。

Source=PresentationFramework

StackTrace:

在 MS.Internal.AppModel.ResourcePart.GetStreamCore(FileMode mode, FileAccess access) 在 MS.Internal.AppModel\ResourcePart.cs 中: 第 40 行

在 System.IO.Packaging.PackagePart.GetStream(FileMode mode, FileAccess access)

在 MS.Internal.IO.Packaging.PackagePartExtensions.GetSeekableStream(PackagePart packPart, FileMode mode, FileAccess access)

在 System.Windows.Application.LoadComponent(Uri resourceLocator, Boolean bSkipJournaledProperties) 在 System.Windows\Application.cs 中: 第 713 行

在 System.Windows.Application.DoStartup() 在 System.Windows\Application.cs 中: 第 997 行

在 System.Windows.Application.<.ctor>b__1_0(Object unused) 在 System.Windows\Application.cs 中: 第 546 行

在 System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)

在 System.Windows.Threading.ExceptionWrapper.TryCatchWhen(Object source, Delegate callback, Object args, Int32 numArgs, Delegate catchHandler)

在 System.Windows.Threading.DispatcherOperation.InvokeImpl()

在 MS.Internal.CulturePreservingExecutionContext.CallbackWrapper(Object obj)

在 System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)

--- 上一位置中堆栈跟踪的末尾 ---

在 System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)

在 MS.Internal.CulturePreservingExecutionContext.Run(CulturePreservingExecutionContext executionContext, ContextCallback callback, Object state)

在 System.Windows.Threading.DispatcherOperation.Invoke()

在 System.Windows.Threading.Dispatcher.ProcessQueue()

在 System.Windows.Threading.Dispatcher.WndProcHook(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)

在 MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)

在 MS.Win32.HwndSubclass.DispatcherCallbackOperation(Object o)

在 System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)

在 System.Windows.Threading.ExceptionWrapper.TryCatchWhen(Object source, Delegate callback, Object args, Int32 numArgs, Delegate catchHandler)

在 System.Windows.Threading.Dispatcher.LegacyInvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs)

在 MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam)

在 MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg)

在 System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame)

在 System.Windows.Application.RunDispatcher(Object ignore) 在 System.Windows\Application.cs 中: 第 1409 行

在 System.Windows.Application.RunInternal(Window window) 在 System.Windows\Application.cs 中: 第 1084 行

在 WpfApp1.App.Main()

RichTextBox

<DataGridTemplateColumn Header="自定义"> <!-- 1. 定义列 -->
    <DataGridTemplateColumn.CellTemplate> <!-- 2. 显示状态的"皮肤" -->
        <DataTemplate>
            <Grid>
                <TextBlock Text="{Binding Name}"/> <!-- 3.1 显示文本 -->
                <Image Source="/Images/Logo.jpg"/> <!-- 3.2 显示图片 -->
            </Grid>
        </DataTemplate>
    </DataGridTemplateColumn.CellTemplate>
    <DataGridTemplateColumn.CellEditingTemplate> <!-- 4. 编辑状态的"皮肤" -->
        <DataTemplate>
            <TextBox Text="{Binding Name}"/> <!-- 4.1 可编辑的文本框 -->
        </DataTemplate>
    </DataGridTemplateColumn.CellEditingTemplate>
</DataGridTemplateColumn>

MenuMenu

Expander

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

namespace WpfApp1
{
    /// <summary>
    /// DispatcherWindow.xaml 的交互逻辑
    /// </summary>
    public partial class DispatcherWindow : Window
    {
        public DispatcherWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Task.Run(async () =>
            {
                try
                {
                    var value = 200;
                    await Task.Delay(2000);
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        this.tb.Text = value.ToString();
                    }));
                }
                catch (Exception ex) { }
            });

        }
    }
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    Task.Run(async () => // 在后台线程池中启动一个新任务
    {
        try
        {
            var value = 200;
            await Task.Delay(2000); // 模拟一个耗时2秒的操作
            this.Dispatcher.Invoke(new Action(() => // 通过Dispatcher切回UI线程
            {
                this.tb.Text = value.ToString(); // 安全更新UI
            }));
        }
        catch (Exception ex) { }
    });
}

步骤

说明

关键概念

1. 点击按钮
   用户点击按钮，触发 Button_Click事件处理器。此事件在 UI 线程 上执行。
   UI 线程：负责处理用户输入和更新界面的主线程。
2. 启动后台任务
   Task.Run将 lambda 表达式中的代码安排到线程池中的一个后台线程上执行。这避免了在UI线程上执行耗时操作导致的界面"卡死"。
   后台线程：用于执行耗时操作，以免阻塞UI线程。
3. 执行耗时操作
   在后台线程中，await Task.Delay(2000)模拟了一个耗时2秒的操作（如网络请求或复杂计算）。
   异步编程：使用 async/await可以高效地等待而不会阻塞线程。
4. 切回UI线程更新UI
   操作完成后，通过 this.Dispatcher.Invoke将一个委托（更新 TextBox文本的操作）封送到 UI 线程 执行。
   Dispatcher.Invoke：这是一个同步调用。后台线程会等待UI线程执行完该委托后才继续。WPF 的线程亲和性模型规定，只有创建UI元素的线程（UI线程）才能修改它们，否则会抛出 InvalidOperationException。使用 Dispatcher是遵守此规则的标准方式
   
   
   
   
   
   

1. 

 <PasswordBox.InputBindings>
     <KeyBinding Key="Enter" Command="{Binding LoginCommand}"
             CommandParameter="{Binding ElementName=window}"/>
 </PasswordBox.InputBindings>

在C#中，this是一个关键字，它指代当前类的当前实例对象。让我详细解释一下：1. this指代什么？

在 btnMin_Click方法中，this指代当前正在运行的这个 MainView窗口对象

因为 MainView继承自 Window类，所以 this具有窗口的所有属性和方法2. 为什么能指代？

当代码运行时，每个类的实例（对象）都会在内存中创建

在这个实例内部调用方法时，this就是一个隐式参数，自动指向当前对象

编译器在背后处理这个指向关系

简单来说，this就是"当前这个对象自己"，在你的代码中就是"当前这个 MainView窗口"。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using TextManager.Common;
using TextManager.Model;

namespace TextManager.ViewModel
{
    public class MainViewModel:NotifyBase
    {
        public UserModel UserInfo { get; set; }
		private string _searchText;

		public string SearchText
		{
			get { return _searchText; }
			set
			{
				_searchText = value;
				this.DoNotify();
			}
		}

		private FrameworkElement _mainContent;

		public FrameworkElement MainContent
		{
			get { return _mainContent; }
			set
			{
                _mainContent = value;
				this.DoNotify();
			}
		}
        public CommandBase NavChangedCommand { get; set; }
		public MainViewModel() {
			UserInfo=new UserModel();

			this.NavChangedCommand = new CommandBase();
			this.NavChangedCommand.DoExecute = new Action<object>(DoNavChanged);
			this.NavChangedCommand.DoCanExecute = new Func<object, bool>((o) => true);
		}

		private void DoNavChanged(object obj) {
			Type type = Type.GetType("TextManager.View."+obj.ToString());
			ConstructorInfo cti=type.GetConstructor(System.Type.EmptyTypes);
			this.MainContent = (FrameworkElement)cti.Invoke(null);

		}
    }
}

 <ControlTemplate TargetType="RadioButton" x:Key="GenderRadioButtonTemple">
     <Grid>
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="auto"/>
             <ColumnDefinition/>
         </Grid.ColumnDefinitions>
         <Border Width="14" Height="14" CornerRadius="7" BorderThickness="1"
                 BorderBrush="#007dfa" Background="White" Margin="5,0" VerticalAlignment="Center">
             <Border Width="8" Height="8" CornerRadius="4" Background="#007dfa"
                     x:Name="point" Visibility="Collapsed"/>
         </Border>
         <ContentControl Content="{TemplateBinding Content}" VerticalAlignment="Center" Grid.Column="1"/>
     </Grid>
     <ControlTemplate.Triggers>
         <Trigger Property="IsChecked" Value="True">
             <Setter Property="Visibility" Value="Visible" TargetName="point"/>
         </Trigger>
     </ControlTemplate.Triggers>
 </ControlTemplate>

        <Grid Grid.Row="1">
            <Grid.ColumnDefinitions>
                <ColumnDefinition/>
                <ColumnDefinition/>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition/>
                <RowDefinition/>
            </Grid.RowDefinitions>

            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="40"/>
                    <RowDefinition/>
                </Grid.RowDefinitions>
                <TextBlock Text="学员监控" Foreground="#3f4c5d" VerticalAlignment="Center"
FontSize="15"   FontWeight="Bold"/>
            </Grid>
        </Grid>

<Grid>
    <lvc:CartesianChart Margin="0,0,0,45">
        <lvc:CartesianChart.Series >
            <lvc:LineSeries Stroke="#fecc71" Fill="#fff2de"
          PointGeometrySize="0"
          Values="1,2,3,40,5,6,7"/>
        </lvc:CartesianChart.Series>
        <lvc:CartesianChart.AxisX>
            <lvc:Axis ShowLabels="False"/>
        </lvc:CartesianChart.AxisX>
        <lvc:CartesianChart.AxisY>
            <lvc:Axis ShowLabels="False" MinValue="0" MaxValue="100"/>
        </lvc:CartesianChart.AxisY>
    </lvc:CartesianChart>

            <Border.Effect>
                <DropShadowEffect Color="#f2f2f2" ShadowDepth="10" BlurRadius="10"
Opacity="0.4" Direction="270"/>
            </Border.Effect>

<Border.Background>
    <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
        <GradientStop Color="white" Offset="0"/>
        <GradientStop Color="#edfaf0" Offset="0.5"/>
    </LinearGradientBrush>
</Border.Background>

DoExecute?.Invoke(parameter);

你好！作为初学者，看到代码中的 DoExecute?.Invoke(parameter); 可能会感到困惑。别担心，我来用简单易懂的方式解释这段代码做了什么、如何实现，以及各个变量的作用。

这段代码来自你提供的文档11（CommandBase.cs），它是 WPF（Windows Presentation Foundation）中 命令模式 的核心部分，用于处理用户交互（比如按钮点击）。下面我会分步解析。

1. 这段代码做了什么？

• 简单来说：当用户触发一个命令（如点击按钮）时，这段代码会安全地执行一个预先定义好的方法。

• 具体逻辑：

• DoExecute 是一个"委托"（可以理解为一个存储方法的变量），它保存了要执行的逻辑（比如登录、关闭窗口等）。

• ?. 是"空条件运算符"，意思是"如果 DoExecute 不为空，才执行后面的操作"；如果为空，就什么都不做（避免程序崩溃）。

• Invoke(parameter) 是调用 DoExecute 存储的方法，并传入一个参数 parameter（比如按钮传递的数据）。

类比：就像你按电梯按钮------按下按钮（触发命令）后，电梯系统检查按钮是否有效（?. 判断），如果有效就执行对应楼层的逻辑（Invoke）。

2. 各个功能如何实现？

这段代码是 CommandBase 类中 Execute 方法的一部分：

public void Execute(object parameter)

{

DoExecute?.Invoke(parameter); // 关键行

}

• 触发条件：当 WPF 界面元素（如按钮）绑定了这个命令，用户点击时，WPF 自动调用 Execute 方法。

• 安全机制：使用 ?. 避免空引用错误。如果 DoExecute 未被赋值（为 null），则跳过执行，不会报错。

• 参数传递：parameter 来自界面绑定，例如按钮的 CommandParameter 属性（如传递用户输入的文字）。

示例：在登录功能中（文档20-LoginViewModel.cs），LoginCommand 的 DoExecute 被设置为 DoLogin 方法。当用户点击登录按钮时：

1. 按钮触发 Execute(parameter)。

2. 代码调用 DoExecute?.Invoke(parameter)，实际执行 DoLogin(parameter)。

3. DoLogin 方法验证用户名和密码。

4. 各个变量的具体作用

• DoExecute（类型：Action）：

• 作用：它是一个委托变量，保存了要执行的业务逻辑方法（比如登录、筛选课程）。

• 赋值来源：由 ViewModel（如 LoginViewModel）在构造函数中设置。例如：

this.LoginCommand.DoExecute = new Action(DoLogin);

• 为什么需要：让命令的逻辑可以灵活定义，而不需要修改底层代码。

• parameter（类型：object）：

• 作用：是传递给执行方法的参数，可以是任意对象（如字符串、数字或自定义数据）。

• 来源：从 WPF 界面通过绑定传递。例如，按钮的 CommandParameter="{Binding UserName}" 会将用户名作为参数传入。

• 实际用途：在登录时，parameter 可能包含窗口引用（用于关闭窗口）；在课程筛选中，可能包含老师姓名。

• ?. 运算符：

• 作用：安全保护。如果 DoExecute 是 null（未设置方法），则跳过调用，防止程序崩溃。

• 对比：如果没有 ?.，直接写 DoExecute.Invoke(parameter) 在 DoExecute 为 null 时会抛出异常。

整体流程举例（以登录为例）

1. 用户点击登录按钮 → WPF 触发绑定的 LoginCommand。
2. 调用 Execute(parameter) → 执行 DoExecute?.Invoke(parameter)。
3. 因为 DoExecute 指向 DoLogin → 实际运行 DoLogin(parameter) 方法。
4. DoLogin 使用参数 → 检查输入并调用数据库验证。

给初学者的提示

• 命令模式的意义：将界面操作（如点击）与业务逻辑解耦，让代码更易维护。

• 常见用法：在 WPF MVVM 中，按钮等控件不直接事件，而是绑定 ViewModel 中的命令（如 LoginCommand）。

• 调试技巧：如果命令不生效，检查 DoExecute 是否被正确赋值（非 null）。

如果还有具体部分不理解，可以继续问我！编程是一个积累的过程，多动手写简单例子会更容易掌握。加油！

coursepageviewmodel

  private void InitCourseList()
  {
      //throw new NotImplementedException();
      for (int i = 0; i < 10; i++)
      {
          CourseList.Add(new CourseModel { IsShowSkeleton = true });
          Task.Run(new Action(async () =>
          {
              courseAll = LocalDataAccess.GetInstance().GetCourses();
              await Task.Delay(4000);
              Application.Current.Dispatcher.Invoke(new Action(() =>
              {
                  CourseList.Clear();
                  foreach (var item in courseAll)
                      CourseList.Add(item);
              }));
          })); 
          } }