C# 如何对datagridview列进行排序出现错误：未处理参数NUll异常

我使用以下linq到实体框架查询，并使用以下代码绑定数据网格视图

        private void EquipmentFinder_Load(object sender, EventArgs e)
    {
        SetupCategories();
        productgridview.RowTemplate.Height = 130;
        var products = from prods in axe.product1
                       select new
                       {
                           productid = prods.product_Id,   //0                            
                           productnam =  prods.product_Name, //1
                           productimage = prods.product_Image, //2
                           productprice = prods.product_Price,//3
                           productdescr = prods.product_Description, //4

                       };

        productbindingsource.DataSource = products;
        productgridview.DataSource = productbindingsource;          
        productgridview.Columns[0].Visible = false;
        productgridview.Columns[4].Visible = false;
    }  

我有产品id、产品图片、产品名称、产品描述、产品价格等栏

我已经做了一些列是不可见的，以供客户使用

现在我想通过单击列标题对列进行排序

注意：此处product.image存储为数据库中数组的字节

我不知道如何比较字节和排序这样

请任何人帮我做这个

非常感谢

修改代码：

          private void productgridview_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
    {
       DataGridViewColumn newcolumn =  productgridview.Columns.GetColumnCount(DataGridViewElementStates.Selected) == 1 ? productgridview.SelectedColumns[0] : null;
       DataGridViewColumn oldColumn = productgridview.SortedColumn;
       ListSortDirection direction;

       if (oldColumn != null)
       {
           // Sort the same column again, reversing the SortOrder.
           if (oldColumn == newcolumn &&
               productgridview.SortOrder == SortOrder.Ascending)
           {
               direction = ListSortDirection.Descending;
           }
           else
           {
               // Sort a new column and remove the old SortGlyph.
               direction = ListSortDirection.Ascending;
               oldColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
           }
       }
       else
       {
           direction = ListSortDirection.Ascending;
       }


           productgridview.Sort(newcolumn, direction);
           newcolumn.HeaderCell.SortGlyphDirection =
               direction == ListSortDirection.Ascending ?
               SortOrder.Ascending : SortOrder.Descending;



    }

获取错误：未处理参数NUll异常

           Value cannot be null.
           Parameter name: dataGridViewColumn

---

有人能帮我吗？…

我试过下面的代码，它可以工作，我没有图像，所以我使用了空列。代码有点长，因为我必须实现

BindingList

来实现排序。您可以在和中阅读有关

BindingList

实现的更多信息。你可以找到更多关于

使用AutoPoco.Engine；
使用AutoPoco；
使用AutoPoco.DataSources；
命名空间GridViewSorting
{
公共部分类TestForm:Form
{
公共测试表单（）
{
初始化组件（）；
}
私有void TestForm_加载（对象发送方，事件参数e）
{
LoadGridData（）；
}
私有void gv_ColumnHeaderMouseClick（对象发送者，DataGridViewCellMouseEventArgs e）
{
var newcolumn=gv.Columns[e.ColumnIndex]；
var showColumn=newcolumn；
列表方向；
var sortedColumn=gv.sortedColumn；
var sd=sortedColumn==null？排序器。无：sortedColumn.HeaderCell.SortGlyphDirection；
if（sortedColumn==newcolumn&&sd==gv.SortOrder）
返回；
if（sd==SortOrder.Descending | | sd==SortOrder.None）
{
sd=升序排序器；
方向=列表或方向。升序；
}
其他的
{
sd=排序器下降；
方向=列表或方向。下降；
}
//现在有趣的事情开始了，假设这是图像列，您想
//产品图像列标题时基于产品名称排序
//单击。
if（newcolumn.HeaderText==“ProductImage”）//检查图像列是否
{
newcolumn=gv.Columns[“ProductName”]；//按产品名称排序
}
gv.排序（新列、方向）；
newcolumn.HeaderCell.SortGlyphDirection=SortOrder.None；
showColumn.HeaderCell.SortGlyphDirection=sd；//更改单击列上的排序指示符
}
私有void LoadGridData（）
{
IGenerationSessionFactory工厂=autopocContainer.Configure（x=>
{
x、 约定（c=>{c.UseDefaultConventions（）；}）；
x、 AddFromAssemblyContainingType（）；
x、 包括（）
.Setup（c=>c.ProductName）。使用（）
.Setup（c=>c.Id）.Use（）
.设置（c=>c.ProductDescription）.使用（5,20）；
});
var session=factory.CreateSession（）；
var r=新随机变量（234234）；
var rn=r.Next（5100）；
IList产品=会话列表（25）
.pressure（x=>x.Price，r.Next（）*rn）
.Get（）；
var bl=新产品列表（）；
foreach（产品中的var i）
{
bl.Add（i）；
}
gv.DataSource=bl；
}
}
公共类ProductList:SortableProductList
{
受保护的覆盖比较GetComparer（PropertyDescriptor prop）
{
比较比较器；
开关（道具名称）
{
案例“Id”：
比较器=新比较（委托（SimpleProduct x、SimpleProduct y）
{
如果（x！=null）
如果（y！=null）
返回（x.Id.CompareTo（y.Id））；
其他的
返回1；
如果（y！=null），则为else
返回-1；
其他的
返回0；
});
打破
案例“ProductName”：
比较器=新比较（委托（SimpleProduct x、SimpleProduct y）
{
如果（x！=null）
如果（y！=null）
返回（x.ProductName.CompareTo（y.ProductName））；
其他的
返回1；
如果（y！=null），则为else
返回-1；
其他的
返回0；
});
打破
案例“ProductDescription”：
比较器=新比较（委托（SimpleProduct x、SimpleProduct y）
{
如果（x！=null）
如果（y！=null）
返回（x.ProductDescription.CompareTo（y.ProductDescription））；
其他的
返回1；
如果（y！=null），则为else
返回-1；
其他的
返回0；
});
打破
案例“价格”：
比较器=新比较（委托（SimpleProduct x、SimpleProduct y）
{
如果（x！=null）
如果（y！=null）
using AutoPoco.Engine;
using AutoPoco;
using AutoPoco.DataSources;

namespace GridViewSorting
{
    public partial class TestForm : Form
    {
        public TestForm()
        {
            InitializeComponent();
        }

        private void TestForm_Load(object sender, EventArgs e)
        {
            LoadGridData();
        }

        private void gv_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            var newcolumn = gv.Columns[e.ColumnIndex];
            var showColumn = newcolumn;

            ListSortDirection direction;
            var sortedColumn = gv.SortedColumn;

            var sd = sortedColumn==null? SortOrder.None:sortedColumn.HeaderCell.SortGlyphDirection;

            if (sortedColumn == newcolumn && sd == gv.SortOrder)
                return;

            if (sd == SortOrder.Descending || sd == SortOrder.None)
            {
                sd = SortOrder.Ascending;
                direction = ListSortDirection.Ascending;
            }
            else
            {
                sd = SortOrder.Descending;
                direction = ListSortDirection.Descending;
            }

            //now the fun begins, suppose this is image column and you want to 
            //sort based on product name when product image column header
            //is clicked.

            if (newcolumn.HeaderText == "ProductImage")//check if image column
            {
                newcolumn = gv.Columns["ProductName"];//sort on product names
            }

            gv.Sort(newcolumn, direction);
            newcolumn.HeaderCell.SortGlyphDirection = SortOrder.None;
            showColumn.HeaderCell.SortGlyphDirection = sd;//change sort indicator on clicked column
        }

        private void LoadGridData()
        {
            IGenerationSessionFactory factory = AutoPocoContainer.Configure(x =>
            {
                x.Conventions(c => { c.UseDefaultConventions(); });
                x.AddFromAssemblyContainingType<SimpleProduct>();

                x.Include<SimpleProduct>()
                    .Setup(c => c.ProductName).Use<FirstNameSource>()
                    .Setup(c => c.Id).Use<IntegerIdSource>()
                    .Setup(c => c.ProductDescription).Use<RandomStringSource>(5, 20);
            });

            var session = factory.CreateSession();
            var r = new Random(234234);
            var rn = r.Next(5, 100);
            IList<SimpleProduct> products = session.List<SimpleProduct>(25)
                .Impose(x => x.Price, r.Next() * rn)
                .Get();
            var bl = new ProductList();

            foreach (var i in products)
            {
                bl.Add(i);
            }

            gv.DataSource = bl;
        }
    }

    public class ProductList : SortableProductList<SimpleProduct>
    {
        protected override Comparison<SimpleProduct> GetComparer(PropertyDescriptor prop)
        {
            Comparison<SimpleProduct> comparer;
            switch (prop.Name)
            {
                case "Id":
                    comparer = new Comparison<SimpleProduct>(delegate(SimpleProduct x, SimpleProduct y)
                    {
                        if (x != null)
                            if (y != null)
                                return (x.Id.CompareTo(y.Id));
                            else
                                return 1;
                        else if (y != null)
                            return -1;
                        else
                            return 0;
                    });
                    break;
                case "ProductName":
                    comparer = new Comparison<SimpleProduct>(delegate(SimpleProduct x, SimpleProduct y)
                    {
                        if (x != null)
                            if (y != null)
                                return (x.ProductName.CompareTo(y.ProductName));
                            else
                                return 1;
                        else if (y != null)
                            return -1;
                        else
                            return 0;
                    });
                    break;
                case "ProductDescription":
                    comparer = new Comparison<SimpleProduct>(delegate(SimpleProduct x, SimpleProduct y)
                    {
                        if (x != null)
                            if (y != null)
                                return (x.ProductDescription.CompareTo(y.ProductDescription));
                            else
                                return 1;
                        else if (y != null)
                            return -1;
                        else
                            return 0;
                    });
                    break;
                case "Price":
                    comparer = new Comparison<SimpleProduct>(delegate(SimpleProduct x, SimpleProduct y)
                    {
                        if (x != null)
                            if (y != null)
                                return (x.Price.CompareTo(y.Price));
                            else
                                return 1;
                        else if (y != null)
                            return -1;
                        else
                            return 0;
                    });
                    break;
                default:
                    comparer = new Comparison<SimpleProduct>((x, y) =>
                    {
                        if (x != null && y != null)
                            return x.GetHashCode().CompareTo(y.GetHashCode());
                        return 0;
                    });
                    break;
            }
            return comparer;
        }
    }

    public abstract class SortableProductList<T> : BindingList<T>
    {
        protected override bool SupportsSortingCore{get{return true;}}

        protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
        {
            if (prop.PropertyType.GetInterface("IComparable") == null)return;
            var itemsList = (List<T>)this.Items;

            Comparison<T> comparer = GetComparer(prop);
            itemsList.Sort(comparer);
            if (direction == ListSortDirection.Descending) itemsList.Reverse();
        }

        protected abstract Comparison<T> GetComparer(PropertyDescriptor prop);
    }

    public class SimpleProduct
    {
        public int Id { get; set; }
        public string ProductName { get; set; }
        public decimal Price { get; set; }
        public string ProductImage { get; set; }
        public string ProductDescription { get; set; }
    }
}