C# 窗口加载

1，在winform窗口中加入一个label控件，将属性AutoSie改为false。

导入一张后缀名为.gif

2，窗体内属性设置

StartPosition :CenterScreen在屏幕中心显示

TopMost:True置顶显示

ShowInTaskbar:False不在任务栏显示

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

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

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

 

3，调用：

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

代码：

 public   class LoadingHelper
    {
        #region 相关变量定义
        /// <summary>
        /// 定义委托进行窗口关闭
        /// </summary>
        private delegate void CloseDelegate();
        private static LoaderForm loadingForm;
        private static readonly Object syncLock = new Object();  //加锁使用

        #endregion
       /* LoadingHelper.ShowLoadingScreen();//显示
LoadingHelper.CloseForm();//关闭*/
        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;

        }

    }

  /// <summary>
        /// 提供序列化和反序列化对象的相关静态方法。
        /// </summary>
        public class SerializerHelper
        {
        #region 将指定的对象序列化为XML文件或二进制文件并返回执行状态。
        /// <summary>
        /// 将指定的对象序列化为XML文件或二进制文件并返回执行状态。
        /// </summary>
        /// <param name="o">要序列化的对象</param>
        /// <param name="path">保存路径</param>
        /// <param name="isBinaryFile">序列化后生成的文件类型是否为二进制文件，true为二进制文件，否则为xml文件或文本文件</param>
        /// <returns>返回执行状态</returns>
        public static bool Serialize(Object o, string path, bool isBinaryFile)
        {
            bool flag = false;
            try
            {
                if (isBinaryFile)
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    using (FileStream stream = new FileStream(path, FileMode.Create))
                    {
                        formatter.Serialize(stream, o);
                        flag = true;
                    }
                }
                else
                {
                    XmlSerializer serializer = new XmlSerializer(o.GetType());
                    using (XmlTextWriter writer = new XmlTextWriter(path, Encoding.UTF8))
                    {
                        writer.Formatting = Formatting.Indented;
                        XmlSerializerNamespaces n = new XmlSerializerNamespaces();
                        n.Add("", "");
                        serializer.Serialize(writer, o, n);
                        flag = true;
                    }
                }
            }
            catch { flag = false; }
            return flag;
        }
        #endregion
        #region 将指定的对象序列化为XML格式的字符串并返回。
        /// <summary>
        /// 将指定的对象序列化为XML格式的字符串并返回。
        /// </summary>
        /// <param name="o">待序列化的对象</param>
        /// <returns>返回序列化后的字符串</returns>
        public static string Serialize(Object o)
        {
            string xml = "";
            try
            {
                XmlSerializer serializer = new XmlSerializer(o.GetType());
                using (MemoryStream mem = new MemoryStream())
                {
                    using (XmlTextWriter writer = new XmlTextWriter(mem, Encoding.UTF8))
                    {
                        writer.Formatting = Formatting.Indented;
                        XmlSerializerNamespaces n = new XmlSerializerNamespaces();
                        n.Add("", "");
                        serializer.Serialize(writer, o, n);

                        mem.Seek(0, SeekOrigin.Begin);
                        using (StreamReader reader = new StreamReader(mem))
                        {
                            xml = reader.ReadToEnd();
                        }
                    }
                }
            }
            catch { xml = ""; }
            return xml;
        }
        #endregion
        #region 从指定的文件中反序列化出对应的对象并返回。
        /// <summary>
        /// 从指定的文件中反序列化出对应的对象并返回。
        /// </summary>
        /// <param name="t">要反序列化的对象类型</param>
        /// <param name="path">文件路径</param>
        /// <param name="isBinaryFile">反序列化的文件类型是否为二进制文件，true为二进制文件，否则为xml文件或文本文件</param>
        /// <returns>返回Object</returns>
        public static object Deserialize(Type t, string path, bool isBinaryFile)
        {
            Object o = null;
            try
            {
                if (!isBinaryFile)
                {
                    XmlSerializer serializer = new XmlSerializer(t);
                    using (XmlTextReader reader = new XmlTextReader(path))
                    {
                        o = serializer.Deserialize(reader);
                    }
                }
                else
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
                    {
                        o = formatter.Deserialize(stream);
                    }
                }
            }
            catch { o = null; }
            return o;
        }
        #endregion
        #region 将指定的xml格式的字符反序列化为对应的对象并返回。
        /// <summary>
        /// 将指定的xml格式的字符反序列化为对应的对象并返回。
        /// </summary>
        /// <param name="t">对象的类型</param>
        /// <param name="xml">待反序列化的xml格式的字符的内容</param>
        /// <returns>返回对应的对象</returns>
        public static Object Deserialize(Type t, string xml)
        {
            Object o = null;
            try
            {
                XmlSerializer serializer = new XmlSerializer(t);
                using (MemoryStream mem = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
                {
                    o = serializer.Deserialize(mem);
                }
            }
            catch { o = null; }
            return o;
        }
        #endregion
        #region 将指定的对象序列化为XML文件，并返回执行状态。
        /// <summary>
        /// 将指定的对象序列化为XML文件，并返回执行状态。
        /// </summary>
        /// <param name="o">要序列化的对象</param>
        /// <param name="path">生成的文件名称</param>
        /// <returns>返回执行状态</returns>
        public static bool XmlSerialize(Object o, string path)
        {
            return SerializerHelper.Serialize(o, path, false);
        }
        #endregion
        #region 将指定XML文件，反序列化为对应的对象并返回。
        /// <summary>
        /// 将指定XML文件，反序列化为对应的对象并返回。
        /// </summary>
        /// <param name="t">对象的类型</param>
        /// <param name="path">XML文件路径</param>
        /// <returns>返回对象</returns>
        public static Object XmlDeserialize(Type t, string path)
        {
            return SerializerHelper.Deserialize(t, path, false);
        }
        #endregion
        #region 将指定的对象序列化为二进制文件，并返回执行状态
        /// <summary>
        /// 将指定的对象序列化为二进制文件，并返回执行状态。
        /// </summary>
        /// <param name="o">要序列化的对象</param>
        /// <param name="path">生成的文件名称</param>
        /// <returns>返回执行状态</returns>
        public static bool BinarySerialize(Object o, string path)
        {
            return SerializerHelper.Serialize(o, path, true);
        }
        #endregion
        #region  将指定二进制文件，反序列化为对应的对象并返回。
        /// <summary>
        /// 将指定二进制文件，反序列化为对应的对象并返回。
        /// </summary>
        /// <param name="t">对象的类型</param>
        /// <param name="path">XML文件路径</param>
        /// <returns>返回对象</returns>
        public static Object BinaryDeserialize(Type t, string path)
        {
            return SerializerHelper.Deserialize(t, path, true);
        }
        #endregion
    }