WPF 自定义图片视频混播控件

最新推荐文章于 2024-11-18 12:00:00 发布
最新推荐文章于 2024-11-18 12:00:00 发布
阅读量983 收藏 5
点赞数 3
分类专栏： 笔记 C# 文章标签： wpf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wyl_tyrael/article/details/116013684
版权

水平一般，采用很简单（菜）的方式实现了图片与视频混合轮播的效果

主要通过3个 Storyboard动画 和一个Timer来控制图片和视频控件左右轮播
已满足一下情况：
1、只有一张图片
这种情况最简单 直接显示，啥也不做
2、只有一个视频
这个的话也是直接播放，在播放结束时接着播放
3、N张图片+M个视频
这种情况就用到三个Storyboard，一个是图片和图片轮播，一个是图片轮播到视频，一个是视频轮播到图片，在合适的时候启动Storyboard就可以了
原理图
在这里插入图片描述
控制Banner控件父布局中的大小

效果图：
图片与视频混合轮播

代码：

BBanner.cs实体类
 /// <summary>
    /// banner类 视频、图片
    /// </summary>
    public class BBanner
    {
        /// <summary>
        /// 类型 1 视频 ，0 图片
        /// </summary>
        public int Type { get; set; }
        /// <summary>
        /// 链接 本地链接
        /// </summary>
        public string Url { get; set; }

        /// <summary>
        /// 标题
        /// </summary>
        public string Title { get; set; }
    }
Banner.xmal 布局文件
 <Grid x:Name="gRoot" >

        <Image x:Name="image1"   Stretch="Fill"   />

        <Image x:Name="image2"     Stretch="Fill" />

        <MediaElement x:Name="meVideo" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"   LoadedBehavior="Manual" Visibility="Collapsed"  />

        <Label x:Name="cover" Background="Transparent" MouseDown="cover_MouseDown" />
    </Grid>
Banner.xmal.cs
 /// <summary>
    /// Banner.xaml 的交互逻辑
    /// </summary>
    public partial class Banner : UserControl
    {
        /// <summary>
        /// 滚动时间
        /// </summary>
        public int ScrollTime = INIUtilBase.Instance.MediaScrollTime;

        /// <summary>
        /// 轮播间隔
        /// </summary>
        public int IntervalTime = INIUtilBase.Instance.MediaIntervalTime;

        /// <summary>
        /// 轮播timer
        /// </summary>
        DispatcherTimer mScrollTimer; //

        /// <summary>
        /// 0 n>1图片+m个视频； 1 一张图片+1个视频； 2 一张图片或一个视频
        /// </summary>
        int Type = 0;

        /// <summary>
        /// 下一个媒体是否是视频
        /// </summary>
        bool nextVideo = false;

        /// <summary>
        /// 是否开始滚动
        /// </summary>
        public bool isBegin = false;

        /// <summary>
        /// 集合图片数量
        /// </summary>
        public int ImageCount { get; set; }
        /// <summary>
        /// 集合视频数量
        /// </summary>
        public int VideoCount { get; set; }

        /// <summary>
        /// 滚动图片组
        /// </summary>
        public List<BBanner> Banners { get; set; }

        /// <summary>
        /// 滚动宽度
        /// </summary>
        public double width
        {
            get { return this.Width; }
        }

        /// <summary>
        /// 滚动高度
        /// </summary>
        public double height
        {
            get { return this.Height; }
        }

        /// <summary>
        ///   滚动索引
        /// </summary>
        private int Index = 0;

        /// <summary>
        /// 媒体目录
        /// </summary>
        public string PathMedia { get; set; }


        public Banner()
        {

            InitializeComponent();

            gRoot.Width = this.Width;
            gRoot.Height = this.Height;

            image1.Width = this.Width;
            image1.Height = this.Height;

            image2.Width = this.Width;
            image2.Height = this.Height;

            meVideo.Width = this.Width;
            meVideo.Height = this.Height;

            cover.Width = this.Width;
            cover.Height = this.Height;

            if (ScrollTime >= IntervalTime)
            {
                IntervalTime = ScrollTime + 2;
            }
            mScrollTimer = new DispatcherTimer();
            mScrollTimer.Tick += MScrollTimer_Tick;
            mScrollTimer.Interval = new TimeSpan(0, 0, (IntervalTime + ScrollTime));

            meVideo.MediaEnded += MeVideo_MediaEnded;
        }

        private void MScrollTimer_Tick(object sender, EventArgs e)
        {
            // 继续下轮动画
            if (Type == 1)
            {
                ImageVideoAnim.Begin();
            }
            else
            {
                ImageAnim.Begin();
                if (nextVideo)
                {
                    //下一个是视频，开始 图片到视频 的滚动
                    meVideo.Margin = new Thickness(width, 0, -(width), 0);
                    meVideo.Visibility = Visibility.Visible;
                    ImageVideoAnim.Begin();
                }
            }
        }

        /// <summary>
        /// 开始播放视频
        /// </summary>
        /// <param name="url"></param>
        void StartVideo(string url)
        {
            try
            {
                StopTimer();
                meVideo.Margin = new Thickness(0, 0, 0, 0);
                meVideo.Visibility = Visibility.Visible;
                meVideo.Source = new Uri(url);
                meVideo.Play();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

        }

        private void MeVideo_MediaEnded(object sender, RoutedEventArgs e)
        {
            //播放结束  判断下一个banner 
            BBanner banner = Banners[this.Index % this.Banners.Count];
            if (banner.Type == 1)
            {
                //如果是视频 继续播放
                StartVideo(banner.Url);
                Index++;
            }
            else
            {
                //展示图片
                image1.Visibility = Visibility.Visible;
                image1.Margin = new Thickness(width, 0, -(width), 0);
                image1.Source = LoadImageFreeze(banner.Url);
                VideoImageAnim.Begin();

            }
        }

        /// <summary>
        /// 开始滚动
        /// </summary>
        private void StartTimer()
        {
            image1.Visibility = Visibility.Visible;
            image2.Visibility = Visibility.Visible;
            mScrollTimer.Start();
        }


        private void StopTimer()
        {
            image1.Visibility = Visibility.Hidden;
            image2.Visibility = Visibility.Hidden;
            if (mScrollTimer != null && mScrollTimer.IsEnabled)
            {
                mScrollTimer.Stop();
            }
        }


        private Storyboard _imgAnim;
        /// <summary>
        /// 图片-->图片 滚动
        /// </summary>
        public Storyboard ImageAnim
        {
            get
            {
                if (_imgAnim == null)
                {
                    _imgAnim = new Storyboard();


                    ThicknessAnimation marginAnimation1 = new ThicknessAnimation();
                    marginAnimation1.From = new Thickness(0, 0, 0, 0);
                    marginAnimation1.To = new Thickness(-(width), 0, (width), 0);
                    marginAnimation1.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _imgAnim.Children.Add(marginAnimation1);

                    Storyboard.SetTarget(marginAnimation1, image1);
                    Storyboard.SetTargetProperty(marginAnimation1, new PropertyPath(Grid.MarginProperty));


                    ThicknessAnimation marginAnimation2 = new ThicknessAnimation();
                    marginAnimation2.From = new Thickness(width, 0, -(width), 0);
                    marginAnimation2.To = new Thickness(0, 0, -(0), 0);
                    marginAnimation2.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _imgAnim.Children.Add(marginAnimation2);

                    Storyboard.SetTarget(marginAnimation2, image2);
                    Storyboard.SetTargetProperty(marginAnimation2, new PropertyPath(Grid.MarginProperty));


                    _imgAnim.FillBehavior = FillBehavior.Stop;
                    _imgAnim.Completed += _imgAnim_Completed;

                }
                return _imgAnim;
            }
        }


        private Storyboard _imgVideoAnim;
        /// <summary>
        /// 图片 --> 视频 滚动
        /// </summary>
        public Storyboard ImageVideoAnim
        {
            get
            {
                if (_imgVideoAnim == null)
                {
                    _imgVideoAnim = new Storyboard();

                    ThicknessAnimation marginAnimation1 = new ThicknessAnimation();
                    marginAnimation1.From = new Thickness(0, 0, 0, 0);
                    marginAnimation1.To = new Thickness(-(width), 0, (width), 0);
                    marginAnimation1.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _imgVideoAnim.Children.Add(marginAnimation1);

                    Storyboard.SetTarget(marginAnimation1, image1);
                    Storyboard.SetTargetProperty(marginAnimation1, new PropertyPath(Grid.MarginProperty));


                    ThicknessAnimation marginAnimation2 = new ThicknessAnimation();
                    marginAnimation2.From = new Thickness(width, 0, -(width), 0);
                    marginAnimation2.To = new Thickness(0, 0, -(0), 0);
                    marginAnimation2.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _imgVideoAnim.Children.Add(marginAnimation2);

                    Storyboard.SetTarget(marginAnimation2, meVideo);
                    Storyboard.SetTargetProperty(marginAnimation2, new PropertyPath(Grid.MarginProperty));


                    _imgVideoAnim.FillBehavior = FillBehavior.HoldEnd;
                    _imgVideoAnim.Completed += _imgVideoAnim_Completed;

                }
                return _imgVideoAnim;
            }
        }

        private void _imgVideoAnim_Completed(object sender, EventArgs e)
        {
            BBanner banner = Banners[this.Index % this.Banners.Count];
            if (banner.Type == 1)
            {
                //如果是视频 继续播放
                StartVideo(banner.Url);
                Index++;
            }
        }

        void OneImageVideo()
        {
            this.image1.Margin = new Thickness(0, 0, 0, 0);
            this.meVideo.Margin = new Thickness(this.width, 0, -(this.width), 0);
            try
            {
                //接下来第一个为图片 还是视频
                BBanner banner = Banners[Index % Banners.Count];
                if (banner.Type == 0)
                {
                    //展示图片
                    image1.Margin = new Thickness(0, 0, 0, 0);
                    image1.Source = LoadImageFreeze(Banners[Index % Banners.Count].Url);
                    Index += 1;
                }
                else
                {
                    meVideo.Source = new Uri(Banners[Index % Banners.Count].Url);
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("OneImageVideo " + ex.ToString());
            }
        }

        private Storyboard _videoImgAnim;
        /// <summary>
        /// 视频 -->图片 滚动
        /// </summary>
        public Storyboard VideoImageAnim
        {
            get
            {
                if (_videoImgAnim == null)
                {
                    _videoImgAnim = new Storyboard();


                    ThicknessAnimation marginAnimation1 = new ThicknessAnimation();
                    marginAnimation1.From = new Thickness(0, 0, 0, 0);
                    marginAnimation1.To = new Thickness(-(width), 0, (width), 0);
                    marginAnimation1.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _videoImgAnim.Children.Add(marginAnimation1);

                    Storyboard.SetTarget(marginAnimation1, meVideo);
                    Storyboard.SetTargetProperty(marginAnimation1, new PropertyPath(Grid.MarginProperty));


                    ThicknessAnimation marginAnimation2 = new ThicknessAnimation();
                    marginAnimation2.From = new Thickness(width, 0, -(width), 0);
                    marginAnimation2.To = new Thickness(0, 0, -(0), 0);
                    marginAnimation2.Duration = TimeSpan.FromSeconds(ScrollTime);

                    _videoImgAnim.Children.Add(marginAnimation2);

                    Storyboard.SetTarget(marginAnimation2, image1);
                    Storyboard.SetTargetProperty(marginAnimation2, new PropertyPath(Grid.MarginProperty));

                    _videoImgAnim.FillBehavior = FillBehavior.Stop;
                    _videoImgAnim.Completed += _videoAnim_Completed;

                }
                return _videoImgAnim;
            }
        }


        private void _videoAnim_Completed(object sender, EventArgs e)
        {
            meVideo.Margin = new Thickness(width, 0, -(width), 0);
            ResetControl();
            StartTimer();
        }

        private void _imgAnim_Completed(object sender, EventArgs e)
        {
            //动画结束后 判断当前显示的是图片还是视频
            // 显示图片
            ResetControl();
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        /// <param name="path"></param>
        public void LoadResources(string path)
        {
            if (!Directory.Exists(path))
                return;
            string[] fileNames = Directory.GetFiles(path);
            List<BBanner> medias = new List<BBanner>();
            int imgCount = 0;

            int videoCount = 0;
            foreach (string file in fileNames)
            {
                FileInfo fi = new FileInfo(file);
                BBanner banner = null;
                Console.WriteLine(fi.Extension.ToLower());
                if (fi.Extension.ToLower() == ".jpg" || fi.Extension.ToLower() == ".png")
                {
                    banner = new BBanner { Url = file, Type = 0, Title = fi.Name };
                    imgCount++;
                }
                if (fi.Extension.ToLower().Equals(".mp4") || fi.Extension.ToLower().Equals(".avi"))
                {
                    banner = new BBanner { Url = file, Type = 1, Title = fi.Name };
                    videoCount++;
                }
                if (banner != null)
                    medias.Add(banner);
            }
            ImageCount = imgCount;
            VideoCount = videoCount;
            Banners = medias;
        }

        /// <summary>
        /// 开始滚动动画
        /// </summary>
        public void Begin()
        {
            if (!isBegin)
            {
                LoadResources(PathMedia);
                if (Banners == null || Banners.Count == 0)
                    return;
                isBegin = true;
                //只有一个媒体数据 判断是图片还是视频
                if (Banners.Count == 1)
                {
                    if (Banners[0].Type == 0)
                    {
                        //只有一张图片
                        image1.Margin = new Thickness(0, 0, 0, 0);
                        image1.Source = LoadImageFreeze(Banners[0].Url);
                        Type = 2;
                    }
                    else
                    {
                        Type = 2;
                        //只有一个视频
                        StartVideo(Banners[0].Url);
                    }

                }
                else if (ImageCount == 1)//一个图片一个视频
                {
                    Type = 1;
                    // 显示图片
                    OneImageVideo();
                    // 开始动画
                    StartTimer();

                }
                else
                {
                    Type = 0;
                    // 重置界面
                    ResetControl();
                    // 开始动画
                    StartTimer();
                }
            }
        }


        /// <summary>
        /// 初始化动画版，显示动画中的图片 重置控件界面
        /// </summary>
        void ResetControl()
        {
            nextVideo = false;
            // 复位
            // 显示图片
            try
            {
                //接下来第一个为图片 还是视频
                BBanner banner = Banners[Index % Banners.Count];
                if (banner.Type == 0)
                {
                    //展示图片
                    image1.Margin = new Thickness(0, 0, 0, 0);
                    image1.Source = LoadImageFreeze(Banners[Index % Banners.Count].Url);
                }
                else
                {
                    meVideo.Margin = new Thickness(0, 0, 0, 0);
                    image1.Visibility = Visibility.Collapsed;
                    StartVideo(banner.Url);
                }

                Index += 1;

                //判断第二个
                banner = Banners[Index % Banners.Count];
                if (banner.Type == 0)
                {
                    image2.Margin = new Thickness(width, 0, -(width), 0);
                    image2.Source = LoadImageFreeze(Banners[Index % Banners.Count].Url);
                }
                else
                {
                    nextVideo = true;
                    image2.Visibility = Visibility.Collapsed;
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("ResetControl " + ex.ToString());
            }

        }

        public static BitmapImage LoadImageFreeze(string imagePath)
        {
            try
            {
                BitmapImage bitmap = new BitmapImage();
                if (File.Exists(imagePath))
                {
                    bitmap.BeginInit();
                    bitmap.CacheOption = BitmapCacheOption.OnLoad;

                    using (Stream ms = new MemoryStream(File.ReadAllBytes(imagePath)))
                    {
                        bitmap.StreamSource = ms;
                        bitmap.EndInit();
                        bitmap.Freeze();
                    }
                }
                return bitmap;
            }
            catch (Exception ex)
            {
                Console.WriteLine("LoadImageFreeze " + ex.ToString());
                return null;
            }
        }

        private void cover_MouseDown(object sender, MouseButtonEventArgs e)
        {
        }
    }
简单使用 Window
<Window x:Class="信息展示.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" Loaded="Window_Loaded"
        xmlns:local="clr-namespace:信息展示" WindowState="Maximized" WindowStyle="None" AllowsTransparency="True" 
        Title="信息展示" >
    <Grid>
        <local:Banner  x:Name="banner" />
        <TextBlock Width="100" HorizontalAlignment="Left" VerticalAlignment="Top" MouseDown="TextBlock_MouseDown" Height="100"/>
    </Grid>
</Window>
Window.cs
 /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.Width = SystemParameters.PrimaryScreenWidth;
            this.Height = SystemParameters.PrimaryScreenHeight;
            banner.Width = SystemParameters.PrimaryScreenWidth;
            banner.Height = SystemParameters.PrimaryScreenHeight;
            //ShowUtil.init(this, SynchronizationContext.Current);
          //  SettingModel s = INIUtil.Instance;
        }

        string path = AppDomain.CurrentDomain.BaseDirectory + "/media";
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            string[] files = Directory.GetFiles(path);
            if (files != null && files.Length > 0)
            {
                banner.PathMedia = path;
                banner.Begin();
            }
            else
            {
               // ShowUtil.showTips(false, "请将图片资源拷贝到目录：" + path);
            }
        }

        private void TextBlock_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (e.ClickCount == 2)
            {
                App.Current.Shutdown(0);
            }
        }
    }

目前来说只是实现了功能，对于性能这块没做什么优化，相信还有更优雅的实现方式。

WPF视频播放控件
01-04
WPF视频播放控件，有前进、后退、暂停、停止、拖动进度、拖动静音等
WPF 视频播放控件
12-19
C# WPF 视频播放控件，支持播放、暂停、拖拽进度、调节音量大小等功能；
一款高效视频播放控件的设计思路（c# WPF版）
09-24 1284
　　因工作的需要，开发了一款视频播放程序。期间也经历许多曲折，查阅了大量资料，经过了反复测试，终于圆满完成了任务。 我把开发过程中的一些思路、想法写下来，以期对后来者有所帮助。 视频播放的本质 　　就是连续的图片。当每秒播放的图片超过一定数量，人眼就很难觉察到每帧图像播放间隔，看到的就是连续的视频流。 视频播放的过程 　　必须有数据源，数据源一般是摄像头采集后，再经过压缩传送到程序。摄像...
用于（海康、大华等）录像机的WPF视频播放控件
08-27
WPF视频播放控件，可用于海康、大华等录像机的上位机开发。
干货来袭！C#WPF使用MediaElement控件进行视频播放
weixin_50236846的博客
04-24 2313
创作背景：工控项目，如果能加入设备的视频介绍，那将是锦上添花的效果。所以小编进行了代码测试，并且简单的实现了视频播放功能。闲话少叙，接下来就看主要代码。
WPF 自定义控件库 常用控件封装&常用控件样式重写
03-26
在Windows Presentation Foundation（WPF）框架中，自定义控件库是开发人员为了增强应用程序界面交互性和美观性的重要工具。本资源"GenUI.WPF-master"似乎是一个包含自定义控件和样式重写的项目，旨在提供对常用WPF...
WPF自定义时间控件，可选择日期、时间
04-13
在Windows Presentation Foundation (WPF) 中，开发人员经常需要创建自定义控件以满足特定的用户界面需求。本文将深入探讨如何使用C#语言在WPF中构建一个自定义的时间选择控件，该控件允许用户同时选择日期和时间。...
wpf自定义图片控件，可画框，图片浏览
07-05
在本文中，我们将深入探讨如何在WPF（Windows Presentation Foundation）中自定义一个图片控件，使其具备图像浏览和画框功能。WPF是.NET Framework的一部分，提供了丰富的UI设计和图形渲染能力，使得开发出这样的...
WPF 自定义虚拟键盘控件
12-28
WPF .net Framework 4.6.2 虚拟键盘自定义控件；适合新手借鉴、程序应急使用；直接上源码，可自行修改； 虚拟键盘(支持英文，数字输入，及部分特殊字符(特殊字符都为英文字符)) 1.0版本；后续慢慢增加其他功能及其他...
WPF自定义exe进程嵌入控件
12-18
本篇将详细讲解如何在WPF应用中自定义exe进程嵌入控件，并提供相关的技术细节和步骤。 首先，我们需要了解WPF的基本概念。WPF是.NET Framework的一部分，用于构建富客户端应用程序。它提供了丰富的UI设计工具，如...
原生WPF的VLC视频播放控件
02-01
原生WPF的VLC视频播放控件，不存在winform空域问题，demo里是播放RTSP的视频，可以替换为其他路径，直接播放其他视频文件，支持截图，录像，直接修改录像文件后缀可以保存为不同编码类型的视频文件 使用.net4，支持anycpu
wpfMediaelement非常好的播放控件
07-29
请看仔细介绍，以免下错了，本资源是介绍MediaElement的实例，有播放功能，在播放的同时产生水中播放的效果。
WPF视频播放器
04-06
完全可以直接套用的视频播放器，有快进、后退、全屏等功能。
WPF的媒体播放器控件，几乎可以播放任何媒体
04-11
WPF的媒体播放器控件，基于MPV播放器，可以播放几乎所有媒体文件。
探秘WpfVLC：一款强大的WPF视频播放器组件
gitblog_00049的博客
04-05 1477
探秘WpfVLC：一款强大的WPF视频播放器组件 项目地址:https://gitcode.com/gh_mirrors/wp/WpfVLC 在数字化媒体日益普及的时代，高质量的视频播放体验是各种应用程序不可或缺的一部分。对于Windows Presentation Foundation（WPF）开发者来说，找到一个既简单易用又功能丰富的视频播放解决方案并不总是那么容易。然而，项目的出现，正是为了...
wpf图片轮播
qq_38643387的博客
08-20 684
百度云盘地址：链接：https://pan.baidu.com/s/1FdTL1k9BV7LcXDF_rEes-A 提取码：a5k9 注：此代码可直接运行，开发时.netframework版本为4.5.2 注：此核心源码来源于GIT上WPFEFFECTS，非本人创作，如有侵权可联系，立即删除。 附：本地百度云wpfeffect源码（非最新版）：链接：https://pan.baidu.com/s/1yDsxQ79_MZk8UkCQFwA6gA 提取码：a5k9 GIT源码地址：https://g..
WPF 下的 VlcControl 控件，播放视频过程中，闪黑屏问题的排查与解决方法
weixin_48466684的博客
09-16 3718
在Wpf 下，使用VlcControl 控件，可以实现很多强大的播放功能和解码功能。但是在使用过程中发现当视频播放时，会有预加载时间，导致出现闪黑屏的情况。
基于WPF开发视频播放器
最新发布
绳锯木断，水滴石穿，专心写文，无问西东！！！
11-18 1506
在实际应用中，视频播放功能在很多软件中都会用到，将音频和视频集成到应用程序中不仅可以增强用户体验，还能起到事半功倍的效果。今天本文以一个简单的小例子，简述如何通过WPF中的MediaElement开发视频播放器，仅供学习分享使用，如有不足之处，还请指正！
WPF自定义字体设置对话框控件开发教程
WPF不仅提供了丰富的界面控件，还支持高度自定义，使得开发者可以根据需求设计和实现定制化的用户界面。 在传统桌面应用程序开发中，WinForms（Windows Forms）和VC++（Visual C++）等技术通常提供了内置的对话框...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值