WPF MVVW应用 模拟交通灯系统

已于 2024-07-13 12:44:10 修改
阅读量197 收藏
点赞数 2
文章标签： c#
于 2024-07-13 12:40:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhyangxianjun/article/details/140398012
版权

1、应用 net6 wpf MVVMToolkit 8.0 工程搭建

2、界面分离view,Model

3、自定义控件

using CommunityToolkit.Mvvm.Messaging;
using MVVMToolkit测试.Models;
using MVVMToolkit测试.ViewModels;
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 MVVMToolkit测试.Views
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        Task t1,t2;
        private bool runStatus;
        private CancellationTokenSource cts1,cts2;
        public MainWindow()
        {
            InitializeComponent();
            this.DataContext = new MainViewModel();
            WeakReferenceMessenger.Default.Register<string>(this, OnReceive);
            runStatus = false;
            cts1 = new CancellationTokenSource();
            cts2 = new CancellationTokenSource();

            //生产随机数
            WeakReferenceMessenger.Default.Register<string, string>(this, "Rand",ShowRandInfo);

        }

        private void ShowRandInfo(object recipient, string message)
        {
            Task.Run(() => {
                this.Dispatcher.Invoke(() => { 
                textBlockRandNuber.Text = message;
                
                });
            
            });
        }

        private void OnReceive(object recipient, string message)
        {
            string c = borderStatus.Background.ToString();
            if (c == Brushes.Red.ToString())
            {
                borderStatus.Background = new SolidColorBrush(Colors.Green);
            }
            else
            {
                borderStatus.Background = new SolidColorBrush(Colors.Red);
            }
            if (!runStatus)
            {
                runStatus = true;
                t1 = new Task(() => TaskMetod(),cts1.Token);
                t1.Start();
                t2 = new Task(new Action(Fun()),cts2.Token);
                t2.Start();

            }
            else
            {
                runStatus = false;
                cts1.Cancel();  
                cts2.Cancel();
    
            }
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {

        }

        #region task线程模拟交通灯
        private Action Fun()
        {
            return new Action(() => {

                Task.Run(() => {
                    this.Dispatcher.BeginInvoke(() => {
                        listBoxLog.Items.Add($"{DateTime.Now}:南北方向开始。。。");
                        if (listBoxLog.Items.Count > 20)
                        {
                            listBoxLog.Items.Clear();
                        }

                        RunLightGreen_A.Background = new SolidColorBrush(Colors.Red);
                        RunLightRed_A.Background = new SolidColorBrush(Colors.Gray);
                        RunLightYellow_A.Background = new SolidColorBrush(Colors.Gray);
                    });
                });

                while (runStatus)
                {
                    #region 业务流程
                    Task.Run(() =>
                    {
                        this.Dispatcher.Invoke(() =>
                        {
                            listBoxLog.Items.Add($"{DateTime.Now}:测试开始");
                            if (listBoxLog.Items.Count > 20)
                            {
                                listBoxLog.Items.Clear();
                            }

                        });
                    });
                    //绿灯 3S
                    Task.Run(async () =>
                    {
                        this.Dispatcher.Invoke(new Action(() =>
                        {
                            RunLightGreen_A.Background = new SolidColorBrush(Colors.Green);
                            RunLightRed_A.Background = new SolidColorBrush(Colors.Gray);
                            RunLightYellow_A.Background = new SolidColorBrush(Colors.Gray);

                        }));
                       
                    });
                    Thread.Sleep(3000);
                    //黄灯 闪2s
                    Task.Run(async () =>
                    {
                        this.Dispatcher.Invoke(new Action(() =>
                        {
                            RunLightGreen_A.Background = new SolidColorBrush(Colors.Gray);
                            RunLightRed_A.Background = new SolidColorBrush(Colors.Gray);
                            RunLightYellow_A.Background = new SolidColorBrush(Colors.Yellow);

                            RunLightYellow_A.State = State.EnableInit;


                        }));
                        
                    });
                    Thread.Sleep(2000);
                    
                    //红灯5S

                    Task.Run(async () =>
                    {
                       
                        this.Dispatcher.Invoke(new Action(() =>
                        {
                            RunLightYellow_A.State = State.Init;
                            RunLightRed_A.Background = new SolidColorBrush(Colors.Red);
                            RunLightGreen_A.Background = new SolidColorBrush(Colors.Gray);
                            RunLightYellow_A.Background = new SolidColorBrush(Colors.Gray);
                        }));
                        
                    });


                    Thread.Sleep(5000);

                   
                    
                   
                    Task.Run(() =>
                    {
                        this.Dispatcher.Invoke(() =>
                        {
                            listBoxLog.Items.Add($"{DateTime.Now}:测试结束");
                            if (listBoxLog.Items.Count > 20)
                            {
                                listBoxLog.Items.Clear();
                            }

                        });

                    });



                    Thread.Sleep(1000);
                }

                #endregion
            });
        }

        private void TaskMetod()
        {
            Task.Run(() => {
                this.Dispatcher.BeginInvoke(() => {
                    listBoxLog.Items.Add($"{DateTime.Now}:东西方向开始。。。");
                    if (listBoxLog.Items.Count > 20)
                    {
                        listBoxLog.Items.Clear();
                    }

                    RunLightGreen.Background = new SolidColorBrush(Colors.Red);
                    RunLightRed.Background = new SolidColorBrush(Colors.Gray);
                    RunLightYellow.Background = new SolidColorBrush(Colors.Gray);
                });
            });
           
            while (runStatus)
            {
                #region 业务流程
                Task.Run(() => {
                    this.Dispatcher.Invoke(() => {
                        listBoxLog.Items.Add($"{DateTime.Now}:测试开始");
                        if (listBoxLog.Items.Count > 20)
                        {
                            listBoxLog.Items.Clear();
                        }

                    });
                });

                //红灯5S
                Task.Run(() =>
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {

                        string color = LightRed.Background.ToString();
                        if (color == Brushes.Red.ToString())
                        {
                            LightRed.Background = new SolidColorBrush(Colors.Green);
                           
                        }
                        else
                        {
                            LightRed.Background = new SolidColorBrush(Colors.Red);
                            

                        }
                    }
                    ));
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        RunLightYellow.State = State.Init;
                        RunLightRed.Background = new SolidColorBrush(Colors.Red);
                        RunLightGreen.Background = new SolidColorBrush(Colors.Gray);
                        RunLightYellow.Background = new SolidColorBrush(Colors.Gray);
                    }));
                   
                });


                Thread.Sleep(5000);

                //绿灯3S
                Task.Run(() =>
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        
                        RunLightRed.Background = new SolidColorBrush(Colors.Gray);
                        RunLightYellow.Background = new SolidColorBrush(Colors.Gray);
                        RunLightGreen.Background = new SolidColorBrush(Colors.Green);

                    }));
                });

                Thread.Sleep(3000);
                //黄灯闪2S
                Task.Run(() =>
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        RunLightGreen.Background = new SolidColorBrush(Colors.Gray);
                        RunLightRed.Background = new SolidColorBrush(Colors.Gray);
                        RunLightYellow.Background = new SolidColorBrush(Colors.Yellow);

                        RunLightYellow.State = State.EnableInit;


                    }));
                });
                
               

                Thread.Sleep(2000);
                
                Task.Run(() => {
                    this.Dispatcher.Invoke(() => {
                        listBoxLog.Items.Add($"{DateTime.Now}:测试结束");
                        if (listBoxLog.Items.Count > 20)
                        {
                            listBoxLog.Items.Clear();
                        }

                    });

                });

                Task.Run(() =>
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        RunLightYellow.State = State.Init;

                    }));
                });
                Thread.Sleep(1000);

               
                
                #endregion

            }
        }

        #endregion



    }
}


 <Window x:Class="MVVMToolkit测试.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:MVVMToolkit测试.Views"
        xmlns:localA="clr-namespace:MVVMToolkit测试"
        
        
        mc:Ignorable="d"
        Title="MainWindow" Height="804" Width="800">
    <Grid>
        <StackPanel >
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="   a" Width="50"/>
                <TextBox Width="200" Text="{Binding  calculateModel.a}"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="   b" Width="50"/>
                <TextBox Width="200" Text="{Binding calculateModel.b}"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="   c" Width="50"/>
                <TextBox Width="200" Text="{Binding calculateModel.c}"/>
            </StackPanel>

            <Button Content="开始" Command="{Binding addCommand}" Height="30" Width="50" HorizontalAlignment="Left" Click="Button_Click" />
            <Border x:Name="borderStatus" Background="Red" Height="30" Width="66" HorizontalAlignment="Left" >

            </Border>
            <ListBox x:Name="listBoxLog"  Height="100" Background="Gray"/>
            <StackPanel Orientation="Horizontal" Margin="10">
                <localA:LightControl1  x:Name="RedLight" State="Warning" Width="50" Height="50" BorderThickness="5"/>
                <localA:LightControl1 x:Name="lc1" State="Init" Width="20" Height="20" BorderThickness="2"/>
                <localA:LightControl1 State="Running" Width="20" Height="20" BorderThickness="1"/>
                <localA:LightControl1  State="EnableWarning" Width="50" Height="50" BorderThickness="5"/>
                <localA:LightControl1  State="EnableInit" Width="20" Height="20" BorderThickness="2"/>
                <localA:LightControl1 State="EnableRunning" Width="20" Height="20" BorderThickness="1"/>


            </StackPanel>
            <Grid Height="275" Width="792">
                <StackPanel>
                    <Canvas>
                        <localA:LightControl1  x:Name="RunLightRed" State="Warning" Width="50" Height="50" BorderThickness="1" Canvas.Left="476" Canvas.Top="83" HorizontalAlignment="Center" VerticalAlignment="Top"/>
                        <localA:LightControl1  x:Name="RunLightGreen" State="Running" Width="50" Height="50" BorderThickness="1" HorizontalAlignment="Center" Canvas.Top="193" VerticalAlignment="Top" RenderTransformOrigin="0.437,0.914" Canvas.Left="476"/>
                        <localA:LightControl1  x:Name="RunLightYellow" State="Init" Width="50" Height="50" BorderThickness="1" HorizontalAlignment="Center" Canvas.Top="138" VerticalAlignment="Top" Canvas.Left="476"/>
                        <localA:LightControl1  x:Name="RunLightRed_A" State="Warning" Width="50" Height="50" BorderThickness="1" Canvas.Left="272" Canvas.Top="10" HorizontalAlignment="Left" VerticalAlignment="Top"/>
                        <localA:LightControl1  x:Name="RunLightGreen_A" State="Running" Width="50" Height="50" BorderThickness="1" Canvas.Top="10" RenderTransformOrigin="0.437,0.914" Canvas.Left="382" HorizontalAlignment="Left" VerticalAlignment="Center"/>
                        <localA:LightControl1  x:Name="RunLightYellow_A" State="Init" Width="50" Height="50" BorderThickness="1" Canvas.Top="10" Canvas.Left="327" HorizontalAlignment="Left" VerticalAlignment="Center"/>

                        <Border  x:Name="LightRed" Background="Red" Width="50" Height="50" CornerRadius="5" HorizontalAlignment="Left" VerticalAlignment="Top" Canvas.Left="7" Canvas.Top="147"/>
                    </Canvas>
                    <Label Content="交通灯模拟" Width="577" FontSize="20" RenderTransformOrigin="0.5,0.5">
                        <Label.RenderTransform>
                            <TransformGroup>
                                <ScaleTransform/>
                                <SkewTransform AngleY="-0.077"/>
                                <RotateTransform/>
                                <TranslateTransform Y="0.332"/>
                            </TransformGroup>
                        </Label.RenderTransform>
                    </Label>

                </StackPanel>

            </Grid>
            <StackPanel>
                <Label Content="当前时间" VerticalAlignment="Center" HorizontalAlignment="Center"/>
                <TextBox Width="200" Text="{Binding CurrentTime}" VerticalAlignment="Bottom"/>
                
            </StackPanel>
            <Canvas>
                <Button x:Name="btn_StartThread" Command="{Binding BackThreadCommand}"  Height="40" Width="100"  Content="后台线程"></Button>
                <TextBlock Text="0000" x:Name="textBlockRandNuber" Width="300" Height="40" HorizontalAlignment="Left" FontSize="20" TextAlignment="Center"  Background="DarkRed"  Canvas.Left="242" Canvas.Top="8"></TextBlock>
            </Canvas>
        </StackPanel>




    </Grid>
</Window>

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.Navigation;
using System.Windows.Shapes;

namespace MVVMToolkit测试
{
    public class LightControl1 : Control
    {
        public static readonly DependencyProperty StateProperty = DependencyProperty.Register(
            "State", typeof(State), typeof(LightControl1), new PropertyMetadata(State.Init, OnStateChanged));

        public State State
        {
            get { return (State)GetValue(StateProperty); }
            set { SetValue(StateProperty, value); }
        }

        static LightControl1()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(LightControl1), new FrameworkPropertyMetadata(typeof(LightControl1)));

        }

        public void UpdateBreathingLight()
        {
            if (State == State.EnableWarning || State == State.EnableRunning || State == State.EnableInit)
            {
                VisualStateManager.GoToState(this, "Enable", true);
            }
            else
            {
                VisualStateManager.GoToState(this, "UnEnable", true);
            }

        }

        //OnApplyTemplate方法保证在控件的模板被应用到控件上后会被调用。
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            UpdateBreathingLight();
        }

        private static void OnStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            LightControl1 control = d as LightControl1;
            control.UpdateBreathingLight();
        }

    }

    public enum State
    {
        Warning,
        Running,
        Init,
        EnableWarning,
        EnableRunning,
        EnableInit
    }

}


<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:MVVMToolkit测试">


    <Style TargetType="{x:Type local:LightControl1}">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type local:LightControl1}">
                    <Grid Width="{TemplateBinding Width}" Height="{TemplateBinding Height}">
                        <Border x:Name="stateLight" 
                                Background="{TemplateBinding Background}"
                                BorderBrush="Transparent" BorderThickness="{TemplateBinding BorderThickness}" CornerRadius="5" />
                        <Border 
                                Background="Transparent"
                                BorderBrush="Gray" BorderThickness="{TemplateBinding BorderThickness}" CornerRadius="5" />
                        <VisualStateManager.VisualStateGroups>
                            <VisualStateGroup x:Name="StateEnable">
                                <VisualState x:Name="Enable">
                                    <Storyboard>
                                        <DoubleAnimation AutoReverse="True" RepeatBehavior="Forever" Storyboard.TargetName="stateLight"
                                                         Storyboard.TargetProperty="Opacity" From="0.1" To="1"
                                                         Duration="0:0:0.3" />
                                    </Storyboard>
                                </VisualState>
                                <VisualState x:Name="UnEnable" />
                            </VisualStateGroup>
                        </VisualStateManager.VisualStateGroups>
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
        <Style.Triggers>
            <Trigger Property="State" Value="Init">
                <Setter Property="Background" Value="Orange" />
            </Trigger>
            <Trigger Property="State" Value="Warning">
                <Setter Property="Background" Value="Red" />
            </Trigger>
            <Trigger Property="State" Value="Running">
                <Setter Property="Background" Value="Green" />
            </Trigger>
            <Trigger Property="State" Value="EnableInit">
                <Setter Property="Background" Value="Orange" />
            </Trigger>
            <Trigger Property="State" Value="EnableWarning">
                <Setter Property="Background" Value="Red" />
            </Trigger>
            <Trigger Property="State" Value="EnableRunning">
                <Setter Property="Background" Value="Green" />
            </Trigger>
        </Style.Triggers>
    </Style>
</ResourceDictionary>


using MVVMToolkit测试.ViewModels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Input;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Messaging;

namespace MVVMToolkit测试.Models
{

    public class MainViewModel : ObservableObject
    {

        public CalucateModel? calculateModel { get; set; }

        private string currentTime;
        public MainViewModel()
        {
            calculateModel = new CalucateModel();
            calculateModel.a = 1;
            calculateModel.b = 10;
            calculateModel.c = calculateModel.a + calculateModel.b;
            //第三步：给命令赋值一个方法，当命令被触发时会自动调用赋值的方法
            addCommand = new RelayCommand(add);
            BackThreadCommand = new RelayCommand(GetSourceNumber);
            StartUpdateTimer();
        }

        //第一步：定义一个命令
        public RelayCommand addCommand { get; set; }

        //顶二步：定义一个普通的方法
        public void add()
        {
            //calculateModel.a = 11;
            //calculateModel.b = 11;
            calculateModel.c = calculateModel.a + calculateModel.b;
            WeakReferenceMessenger.Default.Send<string>(calculateModel.c.ToString());
        }



        public string CurrentTime
        {
            get => currentTime;
            set => SetProperty(ref currentTime, value);
        }

        private void StartUpdateTimer()
        {
            System.Windows.Threading.DispatcherTimer dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
            dispatcherTimer.Interval = TimeSpan.FromSeconds(1);
            dispatcherTimer.Tick += (a, b) => UpdateTime();
            dispatcherTimer.Start();
        }

        private void UpdateTime()
        {
            CurrentTime = DateTime.Now.ToString("F");
        }

        public RelayCommand BackThreadCommand { get; set; }

        public void GetSourceNumber()
        {
            string result = GetRandomString(10);
            WeakReferenceMessenger.Default.Send<string, string>(result, "Rand");
        }
        int time;
        public string GetRandomString(int num)
        {
            string randomString = "";
            for (int i = 0; i < num; i++)
            {
                randomString += CreateRandomString();

            }

            return randomString.Substring(0,10);

        }

        public string CreateRandomString()
        {
            int number;
            char ch1;
            string randomStr = null;
            //为了让每次的随机数不同
            this.time++;
            long num2 = DateTime.Now.Ticks + this.time;
            Random random = new Random(((int)(((ulong)num2) & 0xffffffffL)) | ((int)(num2 >> this.time)));
            int temp = random.Next();
            //如果随机的长度为0，设为1
            if (temp % 11 == 0)
            {
                temp = 1;
            }
            //长度为1-10位，根据随机数字的奇偶性来确定是字母还是数字
            for (int j = 0; j < temp % 11; j++)
            {
                number = random.Next();
                if (number % 2 == 0)
                    ch1 = (char)('0' + (char)(number % 10));
                else
                    ch1 = (char)('A' + (char)(number % 26));
                randomStr += ch1.ToString();
            }

            return randomStr;

        }



    }


    
}



using CommunityToolkit.Mvvm.ComponentModel;

namespace MVVMToolkit测试.ViewModels
{
    public class CalucateModel : ObservableObject
    {
        //计算a+b=c
        private int _a;
        private int _b;
        private int _c;

        public int a
        {
            get { return _a; }
            set
            {
                SetProperty(ref _a, value);
            }
        }
        public int b
        {
            get { return _b; }
            set
            {
                SetProperty(ref _b, value);
            }
        }
        public int c
        {
            get { return _c; }
            set
            {
                SetProperty(ref _c, value);
            }
        }

    }
}

杨大军
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【愚公系列】2023年10月 WPF控件专题 WPF应用程序组成
时光隧道
08-08 5万+
🏆 作者简介，愚公搬代码🏆《头衔》：华为云特约编辑，华为云云享专家，华为开发者专家，华为产品云测专家，CSDN博客专家，阿里云专家博主，腾讯云优秀博主，掘金优秀博主，51CTO博客专家等。🏆《近期荣誉》：2022年CSDN博客之星TOP2，2022年华为云十佳博主等。🏆《博客内容》：.NET、Java、Python、Go、Node、前端、IOS、Android、鸿蒙、Linux、物联网、网络安全、大数据、人工智能、U3D游戏、小程序等相关领域知识。
C#WPF中三种定时器的应用
qq_30725967的博客
08-17 5879
C#WPF中三种定时器的应用
来瞧瞧，WPF 炫酷走马灯!
虚幻私塾
08-22 540
作者：WPFDevelopersOrg。控件名：SpotLight。
WPF 使用VisualStateManager实现自定义控件闪烁呼吸警报灯
weixin_65414269的博客
02-27 1122
1.添加一个新建的自定义控件LightControl1（注意不是用户控件！
WPF用Blend写的交通信号灯
LisenYang的专栏
01-16 6140
用Blend写WPF界面和Behavior特别方便，下面是我写的一个交通信号灯，用Blend写完后代码直接Copy到wpf窗体就可以了。
WPF 实现简单的跑马灯
Stay Hungry
09-22 5599
本文用WPF的动画实现一个简单的跑马灯 xmal: <Window x:Class="wpfstatusBar.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006
使用WPF技术模拟手机界面
qq_22408539的博客
01-02 2266
1. 前言 WPF（Windows Presentation Foundation），即“Windows呈现基础”，它的目的非常明确，就是用来把数据“显示”给用户看的（说白了就是用来做UI的）。接下来将会介绍一个小项目，用WPF来实现模拟手机界面设计。 2. 实现的功能 本项目模拟手机界面，实现了如下几个功能： 滑动解锁 顶部状态栏显示 查看系统时间 附有背景以及应用图标的界面及切换
WPF应用最小化至系统托盘运行
lordwish的专栏
06-30 4750
WPF应用要实现最小化至系统托盘运行需要使用WinForm中的方法。using System.Windows.Forms; namespace ServerApp { /// <summary> /// MainWindow.xaml 的交互逻辑 /// </summary> public partial class MainWindow : Window {
WPF中DataGrid自动滚动，跑马灯效果实现
Coder
06-25 2191
前端： <DataGrid x:Name="dg" AutoGenerateColumns="False" > <DataGrid.Columns> <DataGridTemplateColumn Width="200" > <DataGridTemplateColumn.CellTemplate> <Dat
C# WPF 中用代码模拟鼠标和键盘的操作
热门推荐
诗人江湖老的专栏
10-15 2万+
原文地址 　　C#开发者都知道，在Winform开发中，SendKeys类提供的方法是很实用的。但是可惜的是，在WPF中不能使用这个方法了。 　　我们知道，在WPF中非UI线程刷新UI线程，需要使用Dispatcher.Invoke((Action)delegate { /* Your code is put here */ });方法。这里调用System.Windows.Forms.Sen
C# WPF 科目一模拟考试系统.zip
01-04
C#、WPF使用技巧，实战应用开发小系统参考资料，源码参考。经测试可运行。 详细介绍了一些WPF框架的各种功能和模块，以及如何使用WPF进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够...
三层架构学生宿舍管理系统wpf应用.zip
01-04
C#、WPF使用技巧，实战应用开发小系统参考资料，源码参考。经测试可运行。 详细介绍了一些WPF框架的各种功能和模块，以及如何使用WPF进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够...
基于C# WPF实现的图书馆管理系统.zip
01-04
C#、WPF使用技巧，实战应用开发小系统参考资料，源码参考。经测试可运行。 详细介绍了一些WPF框架的各种功能和模块，以及如何使用WPF进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够...
wpf 监控系统.zip
01-04
C#、WPF使用技巧，实战应用开发小系统参考资料，源码参考。经测试可运行。 详细介绍了一些WPF框架的各种功能和模块，以及如何使用WPF进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够...
WPF管理系统 .zip
01-04
C#、WPF使用技巧，实战应用开发小系统参考资料，源码参考。经测试可运行。 详细介绍了一些WPF框架的各种功能和模块，以及如何使用WPF进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够...
C# 调用Webservice接口接受数据测试
qq_59062726的博客
07-30 213
调用Webservice接口接受天气数据
通过进程协作显示图像-C#
weixin_45114627的博客
07-30 520
如果一个软件比较复杂或者某些情况下需要拆解，可以考试将软件分解成两个或多个进程，但常规的消息传递又不能完全够用，使用消息+共享内存，实现图像传递，当然性能这个方面我并没有测试，仅是一种解决思路吧。
C# 浅谈异步编程 Thread、ThreadPool
a876106354的博客
07-30 539
从 .NET Framework 4 开始，使用多线程的推荐方法是使用任务并行库 (TPL) 和并行 LINQ (PLINQ)。任务并行库（TPL）说的是 System.Threading 和 System.Threading.Tasks 空间中的一组公共类型和 API。较为常见的就是Thread、ThreadPool、Task等。
Xlua原理分析 四
最新发布
qq_25978293的博客
07-30 649
Xlua hotfix原理
VS2010教程：WPF应用实战：创建与布局
本篇教程是关于使用Visual Studio 2010 Beta 1创建一个WPF（Windows Presentation Foundation）应用程序的指南。作者将详细介绍VS2010的使用过程，并展示其新特性的应用。教程针对Windows 7 RC Beta 1环境编写，但...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值