精华内容
下载资源
问答
  • winform loading

    2018-09-18 12:00:57
    winform loading
  • winform Loading

    2021-03-24 16:56:07
    winform 耗时方法加载loading等待
  • Winform Loading控件

    2010-12-16 23:14:03
    Winform Loading控件,类似GIF的loading效果。 解压密码:www.lwolf.cn
  • winform loading加载框效果,有渐变层,方便实用,亲测可用使用
  • winform Loading效果

    2017-12-18 16:52:00
    winform项目时,有可能用到异步耗时加载数据啥的,这个时候就需要我们封装一个正在加载的效果。下面是实现思路: 步骤一:把当前form界面使用句柄的方式截图出一个图片,这个图片会在下面用到,使用句柄获取截图...

          做winform项目时,有可能用到异步耗时加载数据啥的,这个时候就需要我们封装一个正在加载的效果。下面是实现思路:

         步骤一:把当前form界面使用句柄的方式截图出一个图片,这个图片会在下面用到,使用句柄获取截图的方式会在最后代码展示里附录上。

         步骤二:定义一个和当前form一样大小的panel,让这个panel带到当前form的Z顺序的最前面,把当前界面覆盖住,这样当前form的控件就不可点击。

         步骤三:把从步骤一获取的图片设置为步骤而定义的panel的背景,这样让这个panel看起来是和界面一样的。

         步骤四:在panel中间定义一个新的panel放置加载Loading图片和文字。

    下面是封装的代码:

      1 public partial class customForm : Form
      2     {
      3         #region properties
      4 
      5         /// <summary>
      6         /// 显示的等待框
      7         /// </summary>
      8         private System.Windows.Forms.Panel waitingBox;
      9 
     10         Panel waitingBoxInnerPanel;
     11 
     12         Label waitingBoxLab;
     13 
     14         private PictureBox _waitPicBox;
     15 
     16         private bool _IsWaitingBoxCreated = false;
     17 
     18         private bool _isOnWaiting = false;
     19 
     20         #endregion
     21 
     22         public baseLogin()
     23         {
     24             InitializeComponent();
     25 
     26             //设置程序图标
     27             Icon = Icon.FromHandle(Properties.Resources.icon.GetHicon());
     28 
     29             //Task.Delay(1000).ContinueWith((t) => { CreateWaitingBox(); });
     30         }
     31 
     32         public void ShowProgress(string message = "", int second = 60)
     33         {
     34             if (_isOnWaiting)
     35             {
     36                 return;
     37             }
     38             _isOnWaiting = true;
     39             this.Invoke(new Action(() =>
     40             {
     41                 CreateWaitingBox();
     42                 SetWaitingMessage(message);
     43                 waitingBox.Visible = true;
     44                 waitingBox.BringToFront();
     45             }));
     46         }
     47 
     48         public void ShowMessage(string message = "", int second = 2)
     49         {
     50             if (_isOnWaiting)
     51             {
     52                 return;
     53             }
     54             _isOnWaiting = true;
     55             CreateWaitingBox();
     56             SetWaitingMessage(message);
     57             if (IsHandleCreated)
     58             {
     59                 this.Invoke(new Action(() =>
     60                 {
     61                     waitingBox.Visible = true;
     62                     waitingBox.BringToFront();
     63                 }));
     64                 Task.Delay(second * 1000).ContinueWith((t) =>
     65                 {
     66                     DisMissMessage();
     67                 });
     68             }
     69         }
     70 
     71         public void DisMissMessage()
     72         {
     73             if (waitingBox == null)
     74             {
     75                 return;
     76             }
     77             if (!waitingBox.Visible)
     78             {
     79                 return;
     80             }
     81             else
     82             {
     83                 this.Invoke(new Action(() =>
     84                 {
     85                     waitingBox.Visible = false;
     86                     this._isOnWaiting = false;
     87                 }));
     88             }
     89         }
     90 
     91         #region private
     92 
     93         private void CreateWaitingBox()
     94         {
     95 
     96             if (this.IsHandleCreated)
     97             {
     98                 this.Invoke(new Action(() =>
     99                {
    100                    //Image backImg = this.CreateBacgroundImage();
    101                    Control frm = this;
    102                    Image backImg = CaptureImage(ref frm);
    103                    if (!_IsWaitingBoxCreated)
    104                    {
    105                        waitingBox = new Panel()
    106                        {
    107                            Visible = false,
    108                        };
    109                        waitingBox.BackColor = Color.FromArgb(234, 244, 252);
    110 
    111                        waitingBoxInnerPanel = new Panel();
    112                        waitingBoxInnerPanel.Width = 280;
    113                        waitingBoxInnerPanel.Height = 80;
    114                        waitingBoxInnerPanel.BackColor = Color.Gray;
    115                        waitingBoxInnerPanel.Padding = new Padding(8, 5, 5, 5);
    116 
    117                        waitingBoxLab = new Label();
    118                        waitingBoxLab.TextAlign = ContentAlignment.MiddleLeft;
    119                        waitingBoxLab.AutoEllipsis = true;
    120                        waitingBoxLab.Dock = DockStyle.Fill;
    121 
    122                        waitingBoxInnerPanel.Controls.Add(waitingBoxLab);
    123 
    124                        PictureBox pb = new PictureBox();
    125                        pb.Dock = DockStyle.Left;
    126                        pb.Size = new System.Drawing.Size(72, 70);
    127                        pb.Image = Properties.Resources.loading;
    128                        pb.Margin = new System.Windows.Forms.Padding(3, 3, 20, 3);
    129                        pb.SizeMode = PictureBoxSizeMode.StretchImage;
    130                        this._waitPicBox = pb;
    131                        waitingBoxInnerPanel.Controls.Add(pb);
    132 
    133                        waitingBox.Controls.Add(waitingBoxInnerPanel);
    134                        //waitingBox.BringToFront();
    135                        if (!this.Controls.Contains(waitingBox))
    136                        {
    137                            this.Controls.Add(waitingBox);
    138                        }
    139                        //waitingBox.Show();
    140 
    141                        this._IsWaitingBoxCreated = true;
    142 
    143                    }
    144 
    145                    Rectangle rect = this.ClientRectangle;
    146                    waitingBox.Width = rect.Width;
    147                    waitingBox.Height = rect.Height;
    148                    waitingBox.Location = new Point(rect.X, rect.Y);
    149 
    150                    waitingBox.BackgroundImage = backImg;
    151                    waitingBox.BackgroundImageLayout = ImageLayout.Stretch;
    152                }));
    153             }
    154         }
    155 
    156         /// <summary>
    157         /// 设置等待显示的信息
    158         /// </summary>
    159         /// <param name="message">The message.</param>
    160         /// User:Ryan  CreateTime:2012-8-5 16:22.
    161         private void SetWaitingMessage(string message)
    162         {
    163             if (this.IsHandleCreated)
    164             {
    165                 this.Invoke(new Action(() =>
    166                 {
    167                     message = " " + message.Trim();
    168                     if (this.waitingBoxLab != null && this.waitingBoxInnerPanel != null)
    169                     {
    170                         using (Graphics g = this.CreateGraphics())
    171                         {
    172                             int w = Convert.ToInt32(g.MeasureString(message, this.waitingBoxLab.Font).Width);
    173                             w = w >= 200 ? w : 200;
    174                             w = this.Width - 100 >= w ? w : this.Width - 100;
    175                             this.waitingBoxInnerPanel.Width = w + 60;
    176                             waitingBoxInnerPanel.Location = new Point(waitingBox.Bounds.X + waitingBox.Width / 2 - waitingBoxInnerPanel.Width / 2,
    177                                 waitingBox.Bounds.Y + waitingBox.Height / 2 - waitingBoxInnerPanel.Height);
    178                         }
    179 
    180                         this.waitingBoxLab.Text = message;
    181                     }
    182                 }));
    183             }
    184         }
    185 
    186         private Bitmap CreateBacgroundImage()
    187         {
    188             Rectangle rect = this.ClientRectangle;
    189             int w = rect.Width;
    190             int h = rect.Height;
    191             try
    192             {
    193                 Bitmap img = new Bitmap(w, h);
    194                 using (Graphics g = Graphics.FromImage(img))
    195                 {
    196                     g.CopyFromScreen(new Point(this.Location.X, this.Location.Y), new Point(0, 0), new Size(w, h));
    197                 }
    198                 //img.Save("a.jpg");
    199                 return img;
    200             }
    201             catch (Exception ex)
    202             {
    203                 return null;
    204             }
    205         }
    206 
    207 
    208         public Bitmap CaptureImage(ref Control c)
    209         {
    210             int hDC;
    211             int sh;
    212             int sw;
    213             if (c == null)
    214             {
    215                 hDC = GetDC(0);
    216                 sw = Screen.PrimaryScreen.Bounds.Width;
    217                 sh = Screen.PrimaryScreen.Bounds.Height;
    218             }
    219             else
    220             {
    221                 hDC = GetDC((int)c.Handle);
    222                 sw = c.Width;
    223                 sh = c.Height;
    224             }
    225             int hMDC = CreateCompatibleDC(hDC);
    226             int hBMP = CreateCompatibleBitmap(hDC, sw, sh);
    227             int hBMPOld = SelectObject(hMDC, hBMP);
    228             BitBlt(hMDC, 0, 0, sw, sh, hDC, 0, 0, 0xcc0020);
    229             hBMP = SelectObject(hMDC, hBMPOld);
    230             Bitmap result = Image.FromHbitmap(new IntPtr(hBMP));
    231             DeleteDC(hDC);
    232             DeleteDC(hMDC);
    233             DeleteObject(hBMP);
    234             return result;
    235         }
    236         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")]
    237         public static extern int CreateCompatibleBitmap(int hdc, int nWidth, int nHeight);
    238         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC")]
    239         public static extern int CreateCompatibleDC(int hdc);
    240         [DllImport("user32.dll", EntryPoint = "GetDC")]
    241         public static extern int GetDC(int hwnd);
    242         [DllImport("gdi32.dll", EntryPoint = "DeleteDC")]
    243         public static extern int DeleteDC(int hdc);
    244         [DllImport("gdi32.dll", EntryPoint = "SelectObject")]
    245         public static extern int SelectObject(int hdc, int hObject);
    246         [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]
    247         public static extern int DeleteObject(int hObject);
    248         [DllImport("gdi32.dll", EntryPoint = "BitBlt")]
    249         public static extern int BitBlt(int hDestDC, int x, int y, int nWidth, int nHeight, int hSrcDC, int xSrc, int ySrc, int dwRop);
    250 
    251 
    252         #endregion
    253 
    254     }
    封装代码

    下面是示例代码:

    1  public partial class Form1:customForm
    2 {
    3      private void button1_Click(object sender,EventArgs e)
    4      {
    5             ShowMessage("我是消息");
    6       }
    7 } 

     

    转载于:https://www.cnblogs.com/zuimengaitianya/p/8058440.html

    展开全文
  • winform遮罩层loading

    2014-01-14 16:11:06
    winform窗体嵌套,loading,遮罩层实现,progressbar控件。
  • Winform圆形环绕的Loading动画

    千次阅读 2014-01-20 15:57:46
    Winform中添加Loading动画

    之前写了一个WPF的圆形环绕的Loading动画,现在写一个Winform的圆形环绕的Loading动画

    1.新建Winform项目,添加一个pictureBox控件,命名为:pictureBox;

    2.引用中添加using System.Drawing.Drawing2D;

    3.Form窗体命名为:Loading,cs全部代码如下:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Collections;
    using System.Drawing.Drawing2D;
    
    namespace Circle_ProcessBar
    {
        public partial class Loading : Form
        {
            private int count = -1;
            private ArrayList images = new ArrayList();
            public Bitmap[] bitmap = new Bitmap[8];
            private int _value = 1;
            private Color _circleColor = Color.Red;
            private float _circleSize = 0.8f;
            
            public Loading()
            {
                InitializeComponent();       
            }
    
            public Color CircleColor
            {
                get { return _circleColor; }
                set
                {
                    _circleColor = value;
                    Invalidate();
                }
            }
    
            public float CircleSize
            {
                get { return _circleSize; }
                set
                {
                    if (value <= 0.0F)
                        _circleSize = 0.05F;
                    else
                        _circleSize = value > 4.0F ? 4.0F : value;
                    Invalidate();
                }
            }
    
            public Bitmap DrawCircle(int j)
            {
                const float angle = 360.0F / 8; Bitmap map = new Bitmap(150, 150);
                Graphics g = Graphics.FromImage(map);
                
                g.TranslateTransform(Width / 2.0F, Height / 2.0F);
                g.RotateTransform(angle * _value);
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                g.SmoothingMode = SmoothingMode.AntiAlias;
                int[] a = new int[8] { 25, 50, 75, 100, 125, 150, 175, 200 };
                for (int i = 1; i <= 8; i++)
                {
                    int alpha = a[(i + j - 1) % 8];
                    Color drawColor = Color.FromArgb(alpha, _circleColor);
                    using (SolidBrush brush = new SolidBrush(drawColor))
                    {
                        float sizeRate = 3.5F / _circleSize;
                        float size = Width / (6 * sizeRate);
    
                        float diff = (Width / 10.0F) - size;
    
                        float x = (Width / 80.0F) + diff;
                        float y = (Height / 80.0F) + diff;
                        g.FillEllipse(brush, x, y, size, size);
                        g.RotateTransform(angle);
                    }
                }
                return map;
            }
    
    
            public void Draw()
            {
                for (int j = 0; j < 8; j++)
                {
                    bitmap[7-j] = DrawCircle(j);
                }
            }
            protected override void OnResize(EventArgs e)
            {
                SetNewSize();
                base.OnResize(e);
            }
    
            protected override void OnSizeChanged(EventArgs e)
            {
                SetNewSize();
                base.OnSizeChanged(e);
            }
    
            private void SetNewSize()
            {
                int size = Math.Max(Width, Height);
                Size = new Size(size, size);
            }
    
            public void set()
            {
                for (int i = 0; i < 8; i++)
                {
                    Draw();
    
                    Bitmap map = new Bitmap((bitmap[i]), new Size(120, 110));
    
                    images.Add(map);
                }
                pictureBox.Image = (Image)images[0];
               pictureBox.Size = pictureBox.Image.Size;
    
            }
            private void pictureBox_Click(object sender, EventArgs e)
            {
                this.Visible = false;
                base.Dispose();
            }
    
            private void Timer_Tick(object sender, EventArgs e)
            {
                set();
                count = (count + 1) % 8;
                pictureBox.Image = (Image)images[count];
    
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                this.Visible = false;
                base.Dispose();
            }
        }
    }
    
    4.效果如图:



    展开全文
  • 在VS2008下封装WinForm自定义Loading控件。 AutoCircle.cs封装了旋转的圆形,直接在里面添加Label的话,计算圆形扇面的方法有点小复杂,所以在LoadingPanel.cs将AutoCircle和Label封装在一起。该控件中提供了当...

        在VS2008下封装WinForm自定义Loading控件。

     

         AutoCircle.cs封装了旋转的圆形,直接在里面添加Label的话,计算圆形扇面的方法有点小复杂,所以在LoadingPanel.cs将AutoCircle和Label封装在一起。该控件中提供了当LoadingPanel状态变化时的事件public event RotateStateChangedHandler OnRotateStateChanged,当打开或关闭LoadingPanel时,可以用此事件来禁用/开启页面其他控件或做其他处理。

        LoadingPanel暴露了几个属性可以对AutoCircle进行外观的设置

      

        

     1 private delegate bool DoWorkDelegate();
    2
    3
    4 public Form1()
    5 {
    6 InitializeComponent();
    7
    8 this.loadingPanel1.OnRotateStateChanged += new LoadingPanel.RotateStateChangedHandler(loadingPanel1_OnRotateStateChanged);
    9 }
    10
    11 void loadingPanel1_OnRotateStateChanged()
    12 {
    13 this.Invoke(new Action(delegate()
    14 {
    15 this.lblTip.Visible = !this.lblTip.Visible;
    16 this.btnAsync.Enabled = !this.btnAsync.Enabled;
    17 }));
    18 }
    19
    20 private bool DoWork()
    21 {
    22 System.Threading.Thread.Sleep(5000);
    23 return true;
    24 }
    25
    26 private void DoWorkCallBack(IAsyncResult ar)
    27 {
    28 AsyncResult result = (AsyncResult)ar;
    29 DoWorkDelegate caller = (DoWorkDelegate)result.AsyncDelegate;
    30 bool bResult = caller.EndInvoke(ar);
    31
    32 this.loadingPanel1.Stop();
    33 }
    34
    35 private void btnAsync_Click(object sender, EventArgs e)
    36 {
    37 DoWorkDelegate doWorkDelegate = this.DoWork;
    38 doWorkDelegate.BeginInvoke(new AsyncCallback(DoWorkCallBack), null);
    39 this.loadingPanel1.Start();
    40 }

        示例源码: 

        下载地址:http://files.cnblogs.com/lichence/CustomizedLoading.rar

        个人学习,仅供参考

    转载于:https://www.cnblogs.com/lichence/archive/2011/08/16/2140684.html

    展开全文
  • C# winform简单易用的异步加载Loading效果.rarC# winform简单易用的异步加载Loading效果.rarC# winform简单易用的异步加载Loading效果.rarC# winform简单易用的异步加载Loading效果.rarC# winform简单易用的异步加载...
  • WinForm实现Loading等待界面

    万次阅读 热门讨论 2018-11-13 10:26:13
    1,LoaderForm窗体中添加PictureBox,然后添加Loading图片 2,窗体内属性设置 StartPosition :CenterScreen在屏幕中心显示 TopMost:True置顶显示 ShowInTaskbar:False不在任务栏显示 FormBorderStyle:None不...

     

    1,LoaderForm窗体中添加PictureBox,然后添加Loading图片

    2,窗体内属性设置

    StartPosition :CenterScreen在屏幕中心显示

    TopMost:True置顶显示

    ShowInTaskbar:False不在任务栏显示

    FormBorderStyle:None不显示窗体边框和标题栏

    TransparencyKey:Control颜色为Control的部分透明

    BackColor:Control窗体背景颜色设为Control

     

    3,调用:

    LoadingHelper.ShowLoadingScreen();//显示
    LoadingHelper.CloseForm();//关闭

     

     

    4,显示效果如下:

    5,LoaderForm和LoadingHelper部分代码如下,ref:https://www.cnblogs.com/morewindows0/p/7107599.html

    LoaderForm:

     public partial class LoaderForm : Form
        {
            public LoaderForm()
            {
                InitializeComponent();
            }
    
            /// <summary>
            /// 关闭命令
            /// </summary>
            public void closeOrder()
            {
                if (this.InvokeRequired)
                {
                    //这里利用委托进行窗体的操作,避免跨线程调用时抛异常,后面给出具体定义
                    CONSTANTDEFINE.SetUISomeInfo UIinfo = new CONSTANTDEFINE.SetUISomeInfo(new Action(() =>
                    {
                        while (!this.IsHandleCreated)
                        {
                            ;
                        }
                        if (this.IsDisposed)
                            return;
                        if (!this.IsDisposed)
                        {
                            this.Dispose();
                        }
    
                    }));
                    this.Invoke(UIinfo);
                }
                else
                {
                    if (this.IsDisposed)
                        return;
                    if (!this.IsDisposed)
                    {
                        this.Dispose();
                    }
                }
            }
    
            private void LoaderForm_FormClosing(object sender, FormClosingEventArgs e)
            {
                if (!this.IsDisposed)
                {
                    this.Dispose(true);
                }
    
            }
        }
        class CONSTANTDEFINE
        {
            public delegate void SetUISomeInfo();
        }

    LoadingHelper:

      public class LoadingHelper
        {
             #region 相关变量定义
           /// <summary>
           /// 定义委托进行窗口关闭
           /// </summary>
           private delegate void CloseDelegate();
           private static LoaderForm loadingForm;
           private static readonly Object syncLock = new Object();  //加锁使用
    
            #endregion
    
            //private LoadingHelper()
            //{
    
            //}
    
            /// <summary>
            /// 显示loading框
            /// </summary>
            public static void ShowLoadingScreen()
            {
                // Make sure it is only launched once.
                if (loadingForm != null)
                    return;
                Thread thread = new Thread(new ThreadStart(LoadingHelper.ShowForm));
                thread.IsBackground = true;
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
    
            }
    
            /// <summary>
            /// 显示窗口
            /// </summary>
            private static void ShowForm()
            {
                if (loadingForm != null)
                {
                    loadingForm.closeOrder();
                    loadingForm = null;
                }
                loadingForm = new LoaderForm();
                loadingForm.TopMost = true;
                loadingForm.ShowDialog();
            }
    
            /// <summary>
            /// 关闭窗口
            /// </summary>
            public static void CloseForm()
            {
                Thread.Sleep(50); //可能到这里线程还未起来,所以进行延时,可以确保线程起来,彻底关闭窗口
                if (loadingForm != null)
                {
                    lock (syncLock)
                    {
                        Thread.Sleep(50);  
                        if (loadingForm != null)
                        {
                            Thread.Sleep(50);  //通过三次延时,确保可以彻底关闭窗口
                            loadingForm.Invoke(new CloseDelegate(LoadingHelper.CloseFormInternal));
                        }
                    }
                }
            }
    
            /// <summary>
            /// 关闭窗口,委托中使用
            /// </summary>
            private static void CloseFormInternal()
            {
    
                loadingForm.closeOrder();
                loadingForm = null;
    
            }
    
        }

     

    展开全文
  • 主要介绍了Winform圆形环绕的Loading动画实现代码,有需要的朋友可以参考一下
  • WinformLoading 美化 皮肤 控件 窗体WinformLoading 美化 皮肤 控件 窗体WinformLoading 美化 皮肤 控件 窗体WinformLoading 美化 皮肤 控件 窗体
  • WinForm下的loading框的实现

    千次阅读 2019-02-25 19:52:10
    前言:在项目使用C/S模式情况下,由于需要经常进行数据的刷新,如果直接进行刷新,会有一个等待控件重画的过程,非常的不友好,因此在这里添加一个loading框进行等待显示。 实现:在经过多方面查询资料,终于是实现...
  • winform的一个简单易用异步加载等待效果,调用方式: this.AsyncWaitDo(delegate{ //异步等待操作}, delegate{//回调操作}); this是要进行异步等待的窗体
  • Winform使用多线程loading画面

    千次阅读 2012-01-21 19:51:51
    在应用程序加载开始时新建一个线程,并将loading画面show起来,在应用程序画面弹出前将该线程终止。 代码:  private DevExpress.Utils.WaitDialogForm WaitBeforeLogin = null; //弹出登录提示画面 new Thread...
  • winform 自定义控件:半透明Loading控件 by wgscd date:2015-05-05 效果: using System;using System.Drawing;using System.Windows.Forms;using System.ComponentModel;using System.Threading; ...
  • WinForm】加载等待界面Loading

    千次阅读 2019-08-07 11:18:33
    /// Loading界面 /// private static Form frm = null; private static ILoad iLoad; /// /// 显示加载界面 /// /// <param name="frmType"></param> public static void Show(Type frmType) { if ...
  • 问题场景:Winform下常常通过订阅窗体或者用户控件的Load事件来加载各种需要一次性加载的数据(业务数据初始化),但是当加载的数据量加多或者较多时,不免会对窗体的加载显示产生影响,从而影响用户的体验。...
  • progressBar1.Style = System.Windows.Forms.ProgressBarStyle.Marquee; BackgroundWorker bgw bgw.WorkerSupportsCancellation = true;...bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);...
  • 相信经常写winform的朋友应该碰到过这种问题,就是当处理很多东西的时候界面假死的现象。 这段时间在工作的时候也碰到这情况,于是封装成一个组件方便大家使用。 其实这次发布的组件并不只这些功能,是一个自己用...
  • 在桌面程序编程中,我们经常需要执行耗时较长的代码。为了良好的用户体验,仿照win10加载动画,实现了Loading时异步处理耗时代码。
  • 如图需要执行某个方法弹出等待窗口,方法执行完成后窗体自动... public Thread Loading(LoadingForm f) { System.Threading.Thread th; th = new Thread(new ThreadStart(delegate () { f.ShowDialog(); }));
  • 为了良好的用户体验,仿照win10加载动画,实现了Loading时异步处理耗时代码。借鉴了网上两个Demo,整理后实现了较好效果,先来看效果图。 资源下载:https://download.csdn.net/download/weixin_39237340/15614132 先...
  • winform中tabcontrol控件在切换时加一个loading的界面,求大佬!!

空空如也

空空如也

1 2 3 4
收藏数 80
精华内容 32
关键字:

loadingwinform