[Winform]线程间操作无效，从不是创建控件的线程访问它的几个解决方案，async和await?

目录

概述

取消跨线程检查

使用委托异步调用

sync和await

总结

概述

最近在qq群里有一朋友，问起在winform中怎么通过开启线程的方式去处理耗时的操作，比如，查看某个目录下所有的文件，或者符合要求的文件。下班回来，也研究了一下。发现多线程这块有点薄弱，也算是补一补吧。

在winform开发，经常会遇到需要在控件上加载大量数据（也就是常说的耗时操作），这会导致程序出现假死状态，这个时候我们就会想到线程。

在智能客户端应用程序中，这样的线程创建并管理用户界面 (UI)，因而称为 UI 线程。

可以将 UI 线程用于所有的处理，其中包括 Web 服务调用、远程对象调用和数据库调用。然而，以这种方式使用 UI 线程通常并不是一个好主意。在大多数情况下，您不能预测调用Web 服务、远程对象或数据库会持续多久，而且在 UI 线程等待响应时，可能会导致 UI 冻结。

通过创建附加线程，应用程序可以在不使用 UI 线程的情况下执行额外的处理。当应用程序调用 Web 服务时，可以使用多线程来防止 UI 冻结或并行执行某些本地任务，以整体提高应用程序的效率。在大多数情况下，您应该坚持在单独的线程上执行任何与 UI 无关的任务。

取消跨线程检查

 案例：现在做一个这样的测试项目，我们选择一个目录通过递归的方式，遍历所有的文件，将文件信息，加载到窗体的DataGridView控件上。界面如图所示：

代码

事件参数和委托：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Wofy.ThreadDemo
{

    /// <summary>
    ///功能描述    :    事件参数
    ///开发者      :    wolfy
    ///建立时间    :    2014年07月19日
    ///修订描述    :    
    ///进度描述    :    
    ///版本号      :    1.0
    ///最后修改时间:    2014年07月19日
    /// </summary>
    public class FileMessageEventArgs:EventArgs
    {
        public FileMessage fileMessage{set;get;}
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Wofy.ThreadDemo
{

    /// <summary>
    ///功能描述    :    文件信息委托
    ///开发者      :    wolfy
    ///建立时间    :    2014年07月19日
    ///修订描述    :    
    ///进度描述    :    
    ///版本号      :    1.0
    ///最后修改时间:    2014年07月19日
    /// </summary>
    public delegate void FileMessageEventHandler(object sender, FileMessageEventArgs e);

}

文件信息类：

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

namespace Wofy.ThreadDemo
{
    /// <summary>
    /// 文件信息
    /// </summary>
    public class FileMessage
    {
        /// <summary>
        /// 序号
        /// </summary>
        [Description("序号")]
        public int intCount { get; set; }
        /// <summary>
        /// 文件路径
        /// </summary>
        [Description("文件路径")]
        public string strFilePath { set; get; }
        /// <summary>
        /// 文件名
        /// </summary>
        [Description("文件名")]
        public string strFileName { set; get; }
        /// <summary>
        /// 文件类型
        /// </summary>
        [Description("文件类型")]
        public string strFileType { set; get; }
    }
}

窗体代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Threading;
namespace Wofy.ThreadDemo
{
    /// <summary>
    ///功能描述    :    文件浏览器主窗口
    ///开发者      :    wolfy
    ///建立时间    :    2014年07月19日
    ///修订描述    :    
    ///进度描述    :    
    ///版本号      :    1.0
    ///最后修改时间:    2014年07月19日
    /// </summary>
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
            //取消跨线程检查
           // Form.CheckForIllegalCrossThreadCalls = false;
        }
        private event FileMessageEventHandler fileMessageEventHandler;
        private void btnSelectPath_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
            if (folderBrowserDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //目录路径
                this.txtPath.Text = folderBrowserDialog.SelectedPath;
                fileMessageEventHandler += MainForm_fileMessageEventHandler;
                Thread thread = new Thread(new ParameterizedThreadStart(GetFiles));
                thread.IsBackground = true;
                thread.Start(this.txtPath.Text);
            }

        }
        /// <summary>
        /// 文件信息事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void MainForm_fileMessageEventHandler(object sender, FileMessageEventArgs e)
        {
            FileMessage fileMessage = e.fileMessage;
            this.dgViewFiles.Rows.Add(new object[] { fileMessage.intCount, fileMessage.strFilePath, fileMessage.strFileName, fileMessage.strFileType });
        }
     
        private List<string> lstTypes = null;
        static object _objLock = new object();
        int intFileCount = 1;
        /// <summary>
        /// 递归获得文件信息
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        public void GetFiles(object obj)
        {
            string strPath = obj.ToString();
            List<FileMessage> lstFiles = new List<FileMessage>();

            //单例创建集合
            if (lstTypes == null)
            {
                lock (_objLock)
                {
                    if (lstTypes == null)
                    {
                        lstTypes = GetCheckedFileType();
                    }
                }
            }
            string[] files = new string[0];
            if (lstTypes.Count > 0)
            {
                foreach (string strType in lstTypes)
                {
                    files = Directory.GetFiles(strPath, "*" + strType);
                    AddFileMessage(files);
                }
            }
            else
            {
                files = Directory.GetFiles(strPath);
                AddFileMessage(files);
            }
            string[] strDirs = Directory.GetDirectories(strPath);
            for (int i = 0; i < strDirs.Length; i++)
            {
                GetFiles(strDirs[i]);
            }
        }
        /// <summary>
        /// 将信息添加到集合
        /// </summary>
        /// <param name="files"></param>
        private void AddFileMessage(string[] files)
        {
            for (int i = 0; i < files.Length; i++)
            {
                FileInfo fileInfo = new FileInfo(files[i]);
                FileMessage fileMessage = new FileMessage();
                fileMessage.intCount = intFileCount++;
                fileMessage.strFileName = Path.GetFileName(fileInfo.FullName);
                fileMessage.strFilePath = fileInfo.FullName;
                fileMessage.strFileType = fileInfo.Extension;
                FileMessageEventArgs e = new FileMessageEventArgs();
                e.fileMessage = fileMessage;
                this.fileMessageEventHandler(null, e);
            }
        }
        /// <summary>
        /// 获得选择的文件类型
        /// </summary>
        /// <returns></returns>
        private List<string> GetCheckedFileType()
        {
            List<string> lstFileTypes = new List<string>();
            foreach (Control control in this.Controls)
            {
                if (control is CheckBox)
                {
                    CheckBox checkBox = control as CheckBox;
                    if (checkBox != null && checkBox.Checked)
                    {
                        lstFileTypes.Add(checkBox.Text);
                    }
                }
            }
            return lstFileTypes;
        }
        /// <summary>
        /// 窗体加载
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_Load(object sender, EventArgs e)
        {
            //通过反射的方式添加列
            Type type = typeof(FileMessage);
            PropertyInfo[] propertyInfos = type.GetProperties();
            foreach (PropertyInfo propertyInfo in propertyInfos)
            {
                object[] objs = propertyInfo.GetCustomAttributes(typeof(DescriptionAttribute), true);
                if (objs.Length > 0)
                {
                    DescriptionAttribute attr = objs[0] as DescriptionAttribute;
                    string result = attr.Description;
                    this.dgViewFiles.Columns.Add(result, result);
                }
            }
            //调整列宽
            AutoSizeColumn(dgViewFiles);


        }
        /// <summary>
        /// 使DataGridView的列自适应宽度
        /// </summary>
        /// <param name="dgViewFiles"></param>
        private void AutoSizeColumn(DataGridView dgViewFiles)
        {
            int width = 0;
            //使列自使用宽度
            //对于DataGridView的每一个列都调整
            for (int i = 0; i < dgViewFiles.Columns.Count; i++)
            {
                //将每一列都调整为自动适应模式
                dgViewFiles.AutoResizeColumn(i, DataGridViewAutoSizeColumnMode.AllCells);
                //记录整个DataGridView的宽度
                width += dgViewFiles.Columns[i].Width;
            }
            //判断调整后的宽度与原来设定的宽度的关系，如果是调整后的宽度大于原来设定的宽度，
            //则将DataGridView的列自动调整模式设置为显示的列即可，
            //如果是小于原来设定的宽度，将模式改为填充。
            if (width > dgViewFiles.Size.Width)
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
            }
            else
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            }
            //冻结某列 从左开始 0，1，2
            dgViewFiles.Columns[1].Frozen = true;
        }
    }
}

如果上面的代码会报错：

出现这个错误，是因为新开的线程操作UI主线程上的控件导致的。也就有了第一种解决方案，添加如下代码即可解决问题：

 //取消跨线程检查
 Control.CheckForIllegalCrossThreadCalls = false;

取消跨线程检测，总感觉心里不爽，它们是线程安全的，这里非得强制去取消，总感觉有什么隐患似的。虽然解决了问题，但是对DataGridView滚动条却无法使用了。这里就有了常规使用的第二种方案，通过委托来实现。

使用委托异步调用

使用委托修改原来的代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Threading;
namespace Wofy.ThreadDemo
{
    /// <summary>
    ///功能描述    :    文件浏览器主窗口
    ///开发者      :    wolfy
    ///建立时间    :    2014年07月19日
    ///修订描述    :    
    ///进度描述    :    
    ///版本号      :    1.0
    ///最后修改时间:    2014年07月19日
    /// </summary>
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }
        private event FileMessageEventHandler fileMessageEventHandler;
        Thread thread;
        private void btnSelectPath_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
            if (folderBrowserDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //目录路径
                this.txtPath.Text = folderBrowserDialog.SelectedPath;
                fileMessageEventHandler += MainForm_fileMessageEventHandler;
                thread = new Thread(new ParameterizedThreadStart(GetFiles));
                thread.IsBackground = true;
                thread.Start(this.txtPath.Text);
            }

        }
        //委托
        private delegate void DelegateSetDataGridView(FileMessage fileMessage);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileMessage"></param>
        private void SetDataGridView(FileMessage fileMessage)
        {
            //获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。
            if (this.dgViewFiles.InvokeRequired)
            {
                Invoke(new DelegateSetDataGridView(SetDataGridView), new object[] { fileMessage });
            }
            else
            {
                this.dgViewFiles.Rows.Add(new object[] { fileMessage.intCount, fileMessage.strFilePath, fileMessage.strFileName, fileMessage.strFileType });
            }

        }
       
        /// <summary>
        /// 文件信息事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void MainForm_fileMessageEventHandler(object sender, FileMessageEventArgs e)
        {
            FileMessage fileMessage = e.fileMessage;
            SetDataGridView(fileMessage);
        }

        private List<string> lstTypes = null;
        static object _objLock = new object();
        int intFileCount = 1;
        /// <summary>
        /// 递归获得文件信息
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        public void GetFiles(object obj)
        {
            string strPath = obj.ToString();
            List<FileMessage> lstFiles = new List<FileMessage>();

            //单例创建集合
            if (lstTypes == null)
            {
                lock (_objLock)
                {
                    if (lstTypes == null)
                    {
                        lstTypes = GetCheckedFileType();
                    }
                }
            }
            string[] files = new string[0];
            if (lstTypes.Count > 0)
            {
                foreach (string strType in lstTypes)
                {
                    files = Directory.GetFiles(strPath, "*" + strType);
                    AddFileMessage(files);
                }
            }
            else
            {
                files = Directory.GetFiles(strPath);
                AddFileMessage(files);
            }
            string[] strDirs = Directory.GetDirectories(strPath);
            for (int i = 0; i < strDirs.Length; i++)
            {
                GetFiles(strDirs[i]);
            }
        }
        /// <summary>
        /// 将信息添加到集合
        /// </summary>
        /// <param name="files"></param>
        private void AddFileMessage(string[] files)
        {
            for (int i = 0; i < files.Length; i++)
            {
                FileInfo fileInfo = new FileInfo(files[i]);
                FileMessage fileMessage = new FileMessage();
                fileMessage.intCount = intFileCount++;
                fileMessage.strFileName = Path.GetFileName(fileInfo.FullName);
                fileMessage.strFilePath = fileInfo.FullName;
                fileMessage.strFileType = fileInfo.Extension;
                FileMessageEventArgs e = new FileMessageEventArgs();
                e.fileMessage = fileMessage;
                this.fileMessageEventHandler(null, e);
            }
        }
        /// <summary>
        /// 获得选择的文件类型
        /// </summary>
        /// <returns></returns>
        private List<string> GetCheckedFileType()
        {
            List<string> lstFileTypes = new List<string>();
            foreach (Control control in this.Controls)
            {
                if (control is CheckBox)
                {
                    CheckBox checkBox = control as CheckBox;
                    if (checkBox != null && checkBox.Checked)
                    {
                        lstFileTypes.Add(checkBox.Text);
                    }
                }
            }
            return lstFileTypes;
        }
        /// <summary>
        /// 窗体加载
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_Load(object sender, EventArgs e)
        {
            //通过反射的方式添加列
            Type type = typeof(FileMessage);
            PropertyInfo[] propertyInfos = type.GetProperties();
            foreach (PropertyInfo propertyInfo in propertyInfos)
            {
                object[] objs = propertyInfo.GetCustomAttributes(typeof(DescriptionAttribute), true);
                if (objs.Length > 0)
                {
                    DescriptionAttribute attr = objs[0] as DescriptionAttribute;
                    string result = attr.Description;
                    this.dgViewFiles.Columns.Add(result, result);
                }
            }
            //调整列宽
            AutoSizeColumn(dgViewFiles);


        }
        /// <summary>
        /// 使DataGridView的列自适应宽度
        /// </summary>
        /// <param name="dgViewFiles"></param>
        private void AutoSizeColumn(DataGridView dgViewFiles)
        {
            int width = 0;
            //使列自使用宽度
            //对于DataGridView的每一个列都调整
            for (int i = 0; i < dgViewFiles.Columns.Count; i++)
            {
                //将每一列都调整为自动适应模式
                dgViewFiles.AutoResizeColumn(i, DataGridViewAutoSizeColumnMode.AllCells);
                //记录整个DataGridView的宽度
                width += dgViewFiles.Columns[i].Width;
            }
            //判断调整后的宽度与原来设定的宽度的关系，如果是调整后的宽度大于原来设定的宽度，
            //则将DataGridView的列自动调整模式设置为显示的列即可，
            //如果是小于原来设定的宽度，将模式改为填充。
            if (width > dgViewFiles.Size.Width)
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
            }
            else
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            }
            //冻结某列 从左开始 0，1，2
            dgViewFiles.Columns[1].Frozen = true;
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            //窗体关闭是停止线程
            thread.Abort();
        }
    }
}

关于Control.Invoke可以参考下面的文章：
http://msdn.microsoft.com/zh-CN/library/system.windows.forms.control.invoke.aspx

http://msdn.microsoft.com/zh-cn/library/zyzhdc6b.aspx

关于Control.InvokeRequire可以参考下面的文章：

http://msdn.microsoft.com/zh-cn/library/system.windows.forms.control.invokerequired.aspx

Windows 窗体中的控件被绑定到特定的线程，不具备线程安全性。 因此，如果从另一个线程调用控件的方法，那么必须使用控件的一个 Invoke 方法来将调用封送到适当的线程。 该属性可用于确定是否必须调用 Invoke 方法，当不知道什么线程拥有控件时这很有用。

窗体上的控件只允许创建它们的线程访问，也就是主线程，如果非主线程访问则会发生异常。我们可以借助于控件的InvokeRequired属性来判断该控件目前是否被主线程访问，如果是，返回false。如果不是，再利用Invoke方法找到主线程，让主线程执行访问控件的方法。 

async和await

之前在博客园看到async和await方面的文章，就想着使用一下，发现异步加载变得如此简单。

关于async和await可参考

http://www.cnblogs.com/jesse2013/p/async-and-await.html

使用async和await改写上面的代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Threading;
namespace Wofy.ThreadDemo
{
    /// <summary>
    ///功能描述    :    文件浏览器主窗口
    ///开发者      :    wolfy
    ///建立时间    :    2014年07月19日
    ///修订描述    :    
    ///进度描述    :    
    ///版本号      :    1.0
    ///最后修改时间:    2014年07月19日
    /// </summary>
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }
        private event FileMessageEventHandler fileMessageEventHandler;
        //Thread thread;
        //注意加上async
        private async void btnSelectPath_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
            if (folderBrowserDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //目录路径
                this.txtPath.Text = folderBrowserDialog.SelectedPath;
                fileMessageEventHandler += MainForm_fileMessageEventHandler;
                await GetFiles(this.txtPath.Text);

                //thread = new Thread(new ParameterizedThreadStart(GetFiles));
                //thread.IsBackground = true;
                //thread.Start(this.txtPath.Text);

            }

        }
        //委托
        private delegate void DelegateSetDataGridView(FileMessage fileMessage);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileMessage"></param>
        private void SetDataGridView(FileMessage fileMessage)
        {
            //获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。
            if (this.dgViewFiles.InvokeRequired)
            {
                Invoke(new DelegateSetDataGridView(SetDataGridView), new object[] { fileMessage });
            }
            else
            {
                this.dgViewFiles.Rows.Add(new object[] { fileMessage.intCount, fileMessage.strFilePath, fileMessage.strFileName, fileMessage.strFileType });
            }

        }

        /// <summary>
        /// 文件信息事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void MainForm_fileMessageEventHandler(object sender, FileMessageEventArgs e)
        {
            FileMessage fileMessage = e.fileMessage;
            // SetDataGridView(fileMessage);
            this.dgViewFiles.Rows.Add(new object[] { fileMessage.intCount, fileMessage.strFilePath, fileMessage.strFileName, fileMessage.strFileType });
        }

        private List<string> lstTypes = null;
        static object _objLock = new object();
        int intFileCount = 1;
        /// <summary>
        /// 递归获得文件信息
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        public async Task<List<FileMessage>> GetFiles(object obj)
        {
            string strPath = obj.ToString();
            List<FileMessage> lstFiles = new List<FileMessage>();

            //单例创建集合
            if (lstTypes == null)
            {
                lock (_objLock)
                {
                    if (lstTypes == null)
                    {
                        lstTypes = GetCheckedFileType();
                    }
                }
            }
            string[] files = new string[0];
            if (lstTypes.Count > 0)
            {
                foreach (string strType in lstTypes)
                {
                    files = Directory.GetFiles(strPath, "*" + strType);
                    AddFileMessage(files);
                }
            }
            else
            {
                files = Directory.GetFiles(strPath);
                AddFileMessage(files);
            }
            string[] strDirs = Directory.GetDirectories(strPath);
            for (int i = 0; i < strDirs.Length; i++)
            {
                await GetFiles(strDirs[i]);
            }
            //创建Task，创建一个新的线程，不然还会出现UI假死的现象
            return await Task.Run(() => { return lstFiles; });
             
        }
        /// <summary>
        /// 将信息添加到集合
        /// </summary>
        /// <param name="files"></param>
        private void AddFileMessage(string[] files)
        {
            for (int i = 0; i < files.Length; i++)
            {
                FileInfo fileInfo = new FileInfo(files[i]);
                FileMessage fileMessage = new FileMessage();
                fileMessage.intCount = intFileCount++;
                fileMessage.strFileName = Path.GetFileName(fileInfo.FullName);
                fileMessage.strFilePath = fileInfo.FullName;
                fileMessage.strFileType = fileInfo.Extension;
                FileMessageEventArgs e = new FileMessageEventArgs();
                e.fileMessage = fileMessage;
                this.fileMessageEventHandler(null, e);
            }
        }
        /// <summary>
        /// 获得选择的文件类型
        /// </summary>
        /// <returns></returns>
        private List<string> GetCheckedFileType()
        {
            List<string> lstFileTypes = new List<string>();
            foreach (Control control in this.Controls)
            {
                if (control is CheckBox)
                {
                    CheckBox checkBox = control as CheckBox;
                    if (checkBox != null && checkBox.Checked)
                    {
                        lstFileTypes.Add(checkBox.Text);
                    }
                }
            }
            return lstFileTypes;
        }
        /// <summary>
        /// 窗体加载
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_Load(object sender, EventArgs e)
        {
            //通过反射的方式添加列
            Type type = typeof(FileMessage);
            PropertyInfo[] propertyInfos = type.GetProperties();
            foreach (PropertyInfo propertyInfo in propertyInfos)
            {
                object[] objs = propertyInfo.GetCustomAttributes(typeof(DescriptionAttribute), true);
                if (objs.Length > 0)
                {
                    DescriptionAttribute attr = objs[0] as DescriptionAttribute;
                    string result = attr.Description;
                    this.dgViewFiles.Columns.Add(result, result);
                }
            }
            //调整列宽
            AutoSizeColumn(dgViewFiles);


        }
        /// <summary>
        /// 使DataGridView的列自适应宽度
        /// </summary>
        /// <param name="dgViewFiles"></param>
        private void AutoSizeColumn(DataGridView dgViewFiles)
        {
            int width = 0;
            //使列自使用宽度
            //对于DataGridView的每一个列都调整
            for (int i = 0; i < dgViewFiles.Columns.Count; i++)
            {
                //将每一列都调整为自动适应模式
                dgViewFiles.AutoResizeColumn(i, DataGridViewAutoSizeColumnMode.AllCells);
                //记录整个DataGridView的宽度
                width += dgViewFiles.Columns[i].Width;
            }
            //判断调整后的宽度与原来设定的宽度的关系，如果是调整后的宽度大于原来设定的宽度，
            //则将DataGridView的列自动调整模式设置为显示的列即可，
            //如果是小于原来设定的宽度，将模式改为填充。
            if (width > dgViewFiles.Size.Width)
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
            }
            else
            {
                dgViewFiles.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            }
            //冻结某列 从左开始 0，1，2
            dgViewFiles.Columns[1].Frozen = true;
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            //窗体关闭是停止线程
            // thread.Abort();
        }
    }
}

结果

总结

第一种方式虽然一个属性可以解决跨线程的问题，但是并不完美，造成DataGridView滚动条无法使用。第二种是最常见的解决线程间操作的解决办法。第三种方式如果直接返回List<FileMessage> ，则界面仍然会有假死，无法移动的现象，应该是await之后并没有创建新的线程造成的，可以通过下面代码方式解决，如果数据量非常大，仍然会瞬间有卡顿的现象(只是看了一篇文章，出于好奇把这种方式列出来了，也算是提供一个跨线程操作UI控件的一个思路吧，不过从代码量看其实实现变的更简单了)。

 //创建Task，创建一个新的线程，不然还会出现UI假死的现象
 return await Task.Run(() => { return lstFiles; });

具体细节可参考：

http://www.cnblogs.com/jesse2013/p/async-and-await.html

代码：链接：http://pan.baidu.com/s/1pJK5RJl 密码：avx1