WPF的MVVM DataGrid用法

最新推荐文章于 2024-04-01 07:58:06 发布
最新推荐文章于 2024-04-01 07:58:06 发布
阅读量1.8k 收藏 10
点赞数 1
分类专栏： WPF/Blend
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litao2/article/details/75969595
版权

效果：


一、验证、属性变更、

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows.Data;
using AutomaticConfigurationCore.Model;

namespace AutomaticConfigurationCore.ModelValidationRule
{
    public class ProductsValidationRule : ValidationRule
    {
        public static string errormessage = string.Empty;
        /// <summary>
        /// 当前列表，判断名称是否有重复的
        /// </summary>
        public static List<ProductsModel> lpm = new List<ProductsModel>();
        //重写时，对值执行验证检查
        public override ValidationResult Validate(object value,
            System.Globalization.CultureInfo cultureInfo)
        {
            errormessage = "";
            if (value is BindingGroup)
            {
                BindingGroup group = (BindingGroup)value;
                foreach (var item in group.Items)
                {
                    ProductsModel pm = item as ProductsModel;
                    if (string.IsNullOrEmpty(pm.Name) || string.IsNullOrEmpty(pm.TermType)
                        || string.IsNullOrEmpty(pm.Queries))
                    {
                        errormessage = "终端名、终端型号、查询帧都不能为空！";
                        return new ValidationResult(false, errormessage);
                    }
                    
                }

                if (lpm.GroupBy(i => i.Name).Where(g => g.Count() > 1).Count() > 0)
                {
                    errormessage = "终端名有重复的！";
                    //lpm.Remove(lpm[lpm.Count - 1]);
                    return new ValidationResult(false, errormessage);
                }
                
            }
            return ValidationResult.ValidResult;
        }
    }
}



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;

namespace AutomaticConfigurationCore.Commons
{
    [Serializable]
    public class NotificationBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        public void NotifyPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
namespace AutomaticConfigurationCore.Commons
{
    public class DelegateCommand : ICommand
    {
        public Action<object> ExecuteCommand = null;
        public Func<object, bool> CanExecuteCommand = null;

        public event EventHandler CanExecuteChanged;

        public bool CanExecute(object parameter)
        {
            if (CanExecuteCommand != null)
            {
                return this.CanExecuteCommand(parameter);
            }
            else
            {
                return true;
            }
        }
        public void Execute(object parameter)
        {
            if (this.ExecuteCommand != null) this.ExecuteCommand(parameter);
        }
        public void RaiseCanExecuteChanged()
        {
            if (CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }

    }
}

二、Model层 


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AutomaticConfigurationCore.Commons;
using System.Runtime.Serialization;

namespace AutomaticConfigurationCore.Model
{
    [DataContract]
    [Serializable]
    public abstract class BaseModel : NotificationBase
    {

    }

}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.Windows.Controls;
using System.Windows.Data;
using AutomaticConfigurationCore.Commons;
using System.Collections.ObjectModel;

namespace AutomaticConfigurationCore.Model
{
    [DataContract]
    [Serializable]
    public class ProductsModel : BaseModel
    {
        /// <summary>
        /// 终端名称
        /// </summary>
        private string name;
        [DataMember]
        public string Name
        {
            get { return name; }
            set { 
                name = value;
                NotifyPropertyChanged("Name");
            }
        }

        /// <summary>
        /// 终端型号
        /// </summary>
        private string  termtype;
        [DataMember]
        public string  TermType
        {
            get { return termtype; }
            set { 
                termtype = value;
                NotifyPropertyChanged("TermType");
            }
        }

        /// <summary>
        /// 查询帧
        /// </summary>
        private string  queries;
        [DataMember]
        public string  Queries
        {
            get { return queries; }
            set { queries = value;
            NotifyPropertyChanged("Queries");
            }
        }

        
        /// <summary>
        /// 终端变量
        /// </summary>
        private ObservableCollection<VariableModel> variable;
        [DataMember]
        public ObservableCollection<VariableModel> Variable
        {
            get {
            return variable;
        } set {
                variable = value;
                NotifyPropertyChanged("Variable");
             } 
        }


    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;

namespace AutomaticConfigurationCore.Model
{
    [DataContract]
    [Serializable]
    public class VariableModel : BaseModel
    {
        /// <summary>
        /// 变量号
        /// </summary>
        private int id;
        [DataMember]
        public int Id
        {
            get { return id; }
            set { id = value;
                NotifyPropertyChanged("Id");
            }
        }

        /// <summary>
        /// 变量名
        /// </summary>
        private string name;
        [DataMember]
        public string Name
        {
            get { return name; }
            set { name = value;
                NotifyPropertyChanged("Name");
            }
        }

        /// <summary>
        /// 变量说明
        /// </summary>
        private string description;
        [DataMember]
        public string Description
        {
            get { return description; }
            set { description = value;
            NotifyPropertyChanged("Description");
            }
        }

        /// <summary>
        /// 数据类型
        /// </summary>
        private string vtype;
        [DataMember]
        public string VType
        {
            get { return vtype; }
            set { vtype = value;
            NotifyPropertyChanged("VType");
            }
        }

        /// <summary>
        /// 内存地址
        /// </summary>
        private string link;
        [DataMember]
        public string Link
        {
            get { return link; }
            set { link = value;
            NotifyPropertyChanged("Link");
            }
        }

        /// <summary>
        /// 表达式
        /// </summary>
        private string  formula;
        [DataMember]
        public string  Formula
        {
            get { return formula; }
            set { formula = value;
            NotifyPropertyChanged("Formula");
            }
        }

        /// <summary>
        /// 变量单位
        /// </summary>
        private string unit;
        [DataMember]
        public string Unit
        {
            get { return unit; }
            set { unit = value;
            NotifyPropertyChanged("Unit");
            }
        }

        /// <summary>
        /// 小数位数
        /// </summary>
        private string digit;
        [DataMember]
        public string Digit
        {
            get { return digit; }
            set { digit = value;
            NotifyPropertyChanged("Digit");
            }
        }

        /// <summary>
        /// 零浮点处理范围
        /// </summary>
        private string zerofloat;
        [DataMember]
        public string ZeroFloat
        {
            get { return zerofloat; }
            set { zerofloat = value;
            NotifyPropertyChanged("ZeroFloat");
            }
        }

        /// <summary>
        /// 初始值
        /// </summary>
        private string initvalue;
        [DataMember]
        public string  InitValue
        {
            get { return initvalue; }
            set { initvalue = value;
            NotifyPropertyChanged("InitValue");
            }
        }

        /// <summary>
        /// 过滤上限
        /// </summary>
        private string maxvalue;
        [DataMember]
        public string MaxValue
        {
            get { return maxvalue; }
            set { maxvalue = value;
            NotifyPropertyChanged("MaxValue");
            }
        }

        /// <summary>
        /// 过滤下限
        /// </summary>
        private string minvalue;
        [DataMember]
        public string MinValue
        {
            get { return minvalue; }
            set { minvalue = value;
            NotifyPropertyChanged("MinValue");
            }
        }

        /// <summary>
        /// 是否记录
        /// </summary>
        private bool isrecord;
        [DataMember]
        public bool IsRecord
        {
            get { return isrecord; }
            set
            {
                isrecord = value;
                NotifyPropertyChanged("IsRecord");
            }
        }

        /// <summary>
        /// 记录间隔
        /// </summary>
        private int recordcycle;
        [DataMember]
        public int RecordCycle
        {
            get { return recordcycle; }
            set
            {
                recordcycle = value;
                NotifyPropertyChanged("RecordCycle");
            }
        }

        /// <summary>
        /// 是否为故障
        /// </summary>
        private bool isbroken;
        [DataMember]
        public bool IsBroken
        {
            get { return isbroken; }
            set
            {
                isbroken = value;
                NotifyPropertyChanged("IsBroken");
            }
        }
    }

}


三、ViewModel层

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AutomaticConfigurationCore.Model;
using AutomaticConfigurationCore.Commons;
using AutomaticConfigurationAPP.Pages;
using System.Windows.Controls;
using System.Data;
using System.Runtime.Serialization;
using AutomaticConfigurationCore.ModelValidationRule;
using System.IO;
using System.Windows;


namespace AutomaticConfigurationAPP.ViewModel
{
    public class PageProductsModel:BaseModel
    {


        
        public DelegateCommand AddCommand { get; set; }
        public DelegateCommand DelCommand { get; set; }
        public DelegateCommand SaveCommand { get; set; }
        public DelegateCommand LoadCommand{get;set;}
        public DelegateCommand SelectionChangedCommand { get; set; }

        private List<ProductsModel> productslist;
        public List<ProductsModel> ProductsList
        {
            get { return productslist; }
            set
            {
                productslist = value;
                NotifyPropertyChanged("ProductsList");
            }
        }


        private string errormessage;
        public string ErrorMessage
        {
            get { return errormessage; }
            set
            {
                errormessage = value;
                NotifyPropertyChanged("ErrorMessage");
            }
        }

        public PageProductsModel()
        {
            //列表数据源
            string xmlDirectory = Environment.CurrentDirectory + "//Products";
            IOHelper.CreateDir(xmlDirectory);

            ProductsList = new List<ProductsModel>();
            FileInfo[] xmlFile = IOHelper.FindXmlFile("Products");
            foreach (FileInfo f in xmlFile)
            {
                ProductsList.Add(SerializeHelper.XMLDeserialize<ProductsModel>("Products", f.Name));
                ProductsValidationRule.lpm = ProductsList;
            } 

            //命令
            AddCommand = new DelegateCommand();
            AddCommand.ExecuteCommand = new Action<object>(Add);
            DelCommand = new DelegateCommand();
            DelCommand.ExecuteCommand = new Action<object>(Del);
            SaveCommand = new DelegateCommand();
            SaveCommand.ExecuteCommand = new Action<object>(Save);
            LoadCommand = new DelegateCommand();
            LoadCommand.ExecuteCommand = new Action<object>(Load);
            SelectionChangedCommand = new DelegateCommand();
            SelectionChangedCommand.ExecuteCommand = new Action<object>(SelectionChanged);
        }

        private void Load(object obj)
        {
             
        }

        private void SelectionChanged(object obj)
        {
            if (obj != null)
            {
                if (ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().TermType == "DL/T 645-1997")
                {
                    ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().Queries = "44E9 45E9 46E9 54E9 55E9 56E9 43C3 53C3 43C4 53C4 63E9 64E9 65E9 66E9 73E9 74E9 75E9 76E9 83E9 84E9 85E9 86E9";
                }
                if (ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().TermType == "DL/T 645-2007")
                {
                    ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().Queries = "33333333 33333433 33333533 33343435 33353435 33363435 33343535 33353535 33363535 33333635 33343635 33353635 33363635 33333735 33343735 33353735 33363735 33333835 33343835 33353835 33363835 33333935 33343935 33353935 33363935";
                }
                //if (ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().TermType == "ModbusRTU")
                //{
                //    ProductsList.Where(p => p.Name == obj.ToString()).FirstOrDefault().Queries = "";
                //}
            }
        }

        /// <summary>
        /// 添加新行
        /// </summary>
        /// <param name="obj"></param>
        private void Add(object obj)
        {
            DataGrid dg = obj as DataGrid;
            dg.CanUserAddRows = true;          
        }

        /// <summary>
        /// 删除行
        /// </summary>
        /// <param name="obj"></param>
        private void Del(object obj)
        {
            DataGrid dg = obj as DataGrid;
            if (dg.SelectedItem != null)
            {
                ProductsModel pm = dg.SelectedItem as ProductsModel;
                ProductsList.Remove(pm);
                ProductsValidationRule.lpm = ProductsList;
                dg.Items.Refresh();
                IOHelper.DeleteFile("Products", pm.Name + ".xml");
            }
            else
            {
                MessageBox.Show("没有选择项");
            }
        }

        /// <summary>
        /// 保存行
        /// </summary>
        /// <param name="obj"></param>
        private void Save(object obj)
        {
            
            if (string.IsNullOrEmpty(ProductsValidationRule.errormessage))
            {
                string xmlDirectory = Environment.CurrentDirectory + "//Products";
                if (IOHelper.CreateDir(xmlDirectory))
                {
                    IOHelper.deleteTmpFiles(xmlDirectory);
                    foreach (var v in ProductsList)
                    {
                        SerializeHelper.XMLSerialize(v, xmlDirectory + "//" + v.Name+".xml");
                    }
                }
            }
            else
            {
                //ErrorMessage = ProductsValidationRule.errormessage;
            }
            //DataGrid dg = obj as DataGrid;
            //dg.CanUserAddRows = false;
            //Console.WriteLine(ProductsList.First().TermType);
        }
    }
}


四、view 层 

<Page x:Class="AutomaticConfigurationAPP.Pages.Page_Products"
      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:local="clr-namespace:AutomaticConfigurationCore.ModelValidationRule;assembly=AutomaticConfigurationCore"
      xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      mc:Ignorable="d" 
      d:DesignHeight="300" d:DesignWidth="300"
	Title="终端管理">
    <Grid x:Name="GridProducts">
        <Grid.RowDefinitions>
            <RowDefinition Height="40"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <!--按钮绑定命令-->
        <StackPanel Grid.Row="0" Orientation="Horizontal">
          <Button Content="添加" Name="btnAdd" Margin="3" Width="60" Command="{Binding AddCommand}"  CommandParameter="{Binding ElementName=dataGridProducts}"/>
            <Button Content="保存" Name="btnSave" Margin="3" Width="60" Command="{Binding SaveCommand}" CommandParameter="{Binding ElementName=dataGridProducts}"/>
            <Button Content="删除" Name="btnDelete" Margin="3" Width="60" Command="{Binding DelCommand}" CommandParameter="{Binding ElementName=dataGridProducts}"/>
            <TextBlock Name="message" Height="25" Text="{Binding ErrorMessage,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Width="100"/>
        </StackPanel>
        <!--按钮绑定命令-->
        
        
        <DataGrid x:Name="dataGridProducts" RowStyle="{StaticResource RowStyle}" CanUserAddRows="False" AutoGenerateColumns="False" Grid.Row="1" ItemsSource="{Binding ProductsList}">
            <!--DataGrid加载时，绑定命令-->
            <i:Interaction.Triggers>
                <i:EventTrigger EventName="Loaded">
                    <i:InvokeCommandAction Command="{Binding LoadCommand}"/>
                </i:EventTrigger>
            </i:Interaction.Triggers>
            
            <!--DataGrid行验证-->
            <DataGrid.RowValidationRules>
                <local:ProductsValidationRule ValidationStep="UpdatedValue"/>
            </DataGrid.RowValidationRules>
            
            <DataGrid.Columns>
                <DataGridTextColumn Header="终端名称" Binding="{Binding Name}" ElementStyle="{StaticResource DataGridTextCenter}"/>
                <DataGridTemplateColumn Header="终端型号">
                    <DataGridTemplateColumn.CellTemplate>
                        <DataTemplate>
                            <ComboBox ItemsSource="{StaticResource TermTypeList}" SelectedItem="{Binding TermType, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
                                <i:Interaction.Triggers>
                                    <i:EventTrigger EventName="SelectionChanged">
                                        <i:InvokeCommandAction Command="{Binding (DataContext).SelectionChangedCommand,
                        RelativeSource={RelativeSource Mode=FindAncestor,AncestorType=Page}}" CommandParameter="{Binding Name}"/>
                                    </i:EventTrigger>
                                </i:Interaction.Triggers>
                            </ComboBox>
                        </DataTemplate>
                    </DataGridTemplateColumn.CellTemplate>
                </DataGridTemplateColumn>
                <DataGridTextColumn Header="查询帧"  Width="*" Binding="{Binding Queries}" ElementStyle="{StaticResource DataGridTextCenter}"/>
            </DataGrid.Columns>
        </DataGrid>
        
    </Grid>
</Page>


tiz198183
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
WPF MVVM 模式使用DataGrid
09-05
利用微软的MVVM开发模式，方便高效的使用DataGrid控件实现功能。
WPF MVVM DataGrid分页案例
01-23
WPF MVVM DataGrid分页案例 运用数据绑定 Command 可作为MVVM学习使用
WPF中Prism框架 MVVM知识点之 ObservableCollection动态集合，DataGrid控件
Ru_Tesla的博客
06-17 1960
需要注意的是，当 DataGrid 的 CanUserSortColumns 属性设为 True 时，默认情况下 DataGrid 控件会根据列绑定到的数据类型进行排序，即数值型数据按照数值大小排序，字符串按照字典顺序排序等。在代码中，需要先创建一个数据源对象，这个数据源对象通常是一个集合，可以是集合类、数组或DataTable等，然后将其设置为DataGrid的ItemsSource属性值。需要注意的是，DataGrid只会绑定可以公开访问的属性或字段，因此请确保数据源对象中包含所需的属性或字段。
wpf mvvm实现datagrid列中的属性进行绑定
最新发布
大黄鸭在发光的专栏
04-01 362
wpf
WPF MVVM模式DataGrid
qq_40098572的博客
04-11 1707
1.构造MVVM基本功能类 因为没有使用MVVM框架，所以要自己构造两个MVVM的基本功能类，完成属性通知和命令绑定 1.1 属性通知 /// <summary> /// INotifyPropertyChanged 用于通知属性改变（实现ViewModel向View喊话，所有绑定该属性的都会得到通知） /// </summary> public class NotificationObject : INotifyPropertyChange.
WPF MvvM框架（MvvMLight，Microsoft Toolkit Mvvm，CommunityToolkit.Mvvm；鼠标，键盘，手写等事件绑定如：抬起按下事件）
qq_48492162的博客
07-28 1489
2. 禁止自动添加行：CanUserAddRows="False"，列：AutoGenerateColumns="False"，Microsoft Toolkit Mvvm 框架被废弃之后，微软官方推荐使用CommunityToolkit.Mvvm框架，4.WeakReferenceMessenger.Default.Register()注册消息;步骤3：可以直接套用，其中 Eventname所绑定的事件，在上面已经提供了相关文章；4.读写过程中关键点：如何把PLC的数据类型转换成C#数据类型。
MVVM下DataGrid的简单应用
pan_junbiao的博客
04-03 4137
基于MVVM模式下DataGrid的简单应用，本实例将实现一个用户列表的展示和一些数据操作功能，如图1。 图1 实例要求： （1）实现用户列表的绑定。 （2）绑定性别属性时，使用Converter对性别属性的转化。 （3）绑定日期时，对日期格式的转换。 （4）点击“编辑”按钮能够获取用户信息。 （5）点击“删除”按钮能够获取用户编号。 1、实体层 在实体层中创建用户信息实体类...
三种wpf数据模板的使用（datagrid,listbox,combox）
u014194297的博客
12-30 2061
wpf里最常见的三种数据模板，绑定的方法简单介绍下，初学者可以了解下。 一、datagrid 先看下效果图 xaml部分： <DataGrid Name="gd" > <DataGrid.Columns> <DataGridTextColumn Header="姓名" Binding="{Binding Name}" Width="100"></DataGridTextCo.
DataGridMVVM.zip_WPF MVVM datagrid_datagrid_datagrid mvvm_mvvm_w
07-15
wpf控件中的datagrid功能，使用mvvm模式更好理解这个控件的功能
WPF+MVVM学习 DataGrid简单案例
11-20
1.Model:Model就是一个class，是对现实中事物的抽象，开发过程中涉及到的事物都可以抽象为Model，例如客户，客户的姓名、编号、...（通过一个例子来解释MVVM 让我使用MVVM创建一个简单的用户管理应用程序。按部就班我们
WPF初学者的福音，高效的MVVM数据绑定教程
Lowlevel01的博客
08-06 3274
简单高效地实现MVVM
WPF DataGrid SelectionChanged and SelectedCellsChanged
不是我的博客
02-23 3644
On the DataGrid I have SelectionUnit="CellOrRowHeader" and SelectionMode="Extended".
MVVM框架下，WPF实现Datagrid里的全选和选择
weixin_30398227的博客
06-29 1282
最近的一个项目是用MVVM实现，在实现功能的时候，就会有一些东西，和以前有很大的区别，项目中就用到了常用的序号，就是在Datagrid里的一个字段，用checkbox来实现。 既然是MVVM，就要用到ModleView，View和Model三层。 先看一下效果 当然，也可以确定是哪一项被选中了，这个代码里有。 实现这个全选功能，用到了三个DLL文件，分别为GalaSoft.MvvmLi...
【WPF开发备忘】使用MVVM模式开发中列表控件内的按钮事件无法触发解决方法
weixin_30872499的博客
07-26 144
实际使用MVVM进行WPF开发的时候，可能会用到列表控件中每行一个编辑或删除按钮，这时直接去绑定，发现无法响应： <DataGridTemplateColumn Header="操作"> 　　<DataGridTemplateColumn.CellTemplate> 　　<DataTemplate> ...
WPF 精修篇 DataGrid 筛选
时意
12-02 4203
DataGrid也可以分组 但是用的地方不多 就没写 筛选还是可以的 比如Datagrid数据量比较大 要做数据筛选 贴码 <DataGrid x:Name="datagrid" AutoGenerateColumns="False" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch...
WPF DataGrid实现多选、反选和不选
Dear200892的博客
09-17 4127
本篇文章数据采自https://mp.csdn.net/postedit/78849632，本篇就不在重复了。 WPF 要实现DataGrid checkbox全选和反选，方法有几种： 方法一：更改XAML代码 <Window.Resources> <local:ImagesConverter x:Key="converter"/> <...
WPF DataGrid 表头筛选
qq_36791193的博客
06-05 1774
WPF DataGrid 表头筛选 DataGridExtensions
WPF DataGrid SelectItem 和 SelectItems的用法
热门推荐
qq_37246121的博客
03-14 1万+
下午找到了一个在DataGrid中不用checkbox也可以多选的办法，简直不能太简单了。那就是了解selectitem和selectitems之间的区别在之前我做的一个多选删除操作  里面用到了checkbox  很麻烦例如可以看到 很多复选框 我用的是每次点击往集合里面添加ID的方法 而且 还要一个一个的点击 是不是很麻烦  每次都要获取  DataRowView view = (DataRo...
wpf mvvm datagrid分页
12-17
在WPF中使用MVVM架构来进行DataGrid的分页功能实现，可以遵循以下步骤： 1.创建一个ViewModel类，该类应该包含用于分页的属性和命令。例如，可以使用Pager类来存储当前页码、总页数以及每页显示的数据条数。 2.在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tiz198183

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值