自定义CircularPicturebox拖放图片失效，如何解决禁止拖放问题？

问题描述 #

我给自定义的CircularPicturebox添加了以下事件：

this.DragEnter += CircularPicturebox_DragEnter;
this.DragDrop += CircularPicturebox_DragDrop;

我从Form1设计器工具箱中拖入该控件，但运行时尝试拖放图片到控件上时，出现禁止进入的图标。请问是否需要用鼠标事件模拟拖放，而非仅依赖DragEnter和DragDrop事件？

自定义CircularPicturebox完整代码 #

using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Drawing.Imaging;

namespace ColorAnalyzer
{
    class CircularPicturebox : PictureBox
    {
        private int borderSize = 2;
        private Color borderColor = Color.RoyalBlue;
        private Color borderColor2 = Color.HotPink;
        private DashStyle borderLineStyle = DashStyle.Solid;
        private DashCap borderCapStyle = DashCap.Flat;
        private float gradientAngle = 50F;
        // 存储提取的颜色，用于持久化绘制
        private List<Color> _extractedColors = new List<Color>();

        public CircularPicturebox()
        {
            this.DragEnter += CircularPicturebox_DragEnter;
            this.DragDrop += CircularPicturebox_DragDrop;
            // 关键：开启控件拖放允许
            this.AllowDrop = true;

            this.Size = new Size(300, 300);
            this.SizeMode = PictureBoxSizeMode.StretchImage;
        }

        private void CircularPicturebox_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);

                if (files.Length > 0)
                {
                    string imagePath = files[0];
                    if (File.Exists(imagePath))
                    {
                        using (Bitmap image = new Bitmap(imagePath))
                        {
                            _extractedColors = ExtractUniqueColors(image);
                        }
                        // 触发重绘，显示提取的颜色
                        this.Invalidate();
                    }
                }
            }
        }

        private List<Color> ExtractUniqueColors(Bitmap image)
        {
            List<Color> uniqueColors = new List<Color>();

            BitmapData bmpData = image.LockBits(
                new Rectangle(0, 0, image.Width, image.Height),
                ImageLockMode.ReadOnly, image.PixelFormat);

            int bytesPerPixel = Image.GetPixelFormatSize(image.PixelFormat) / 8;
            Dictionary<Color, bool> uniqueColorDict = new Dictionary<Color, bool>();

            unsafe
            {
                byte* ptr = (byte*)bmpData.Scan0;

                for (int y = 0; y < image.Height; y++)
                {
                    for (int x = 0; x < image.Width; x++)
                    {
                        int position = (y * bmpData.Stride) + (x * bytesPerPixel);
                        Color pixelColor = Color.FromArgb(
                            ptr[position + 2],
                            ptr[position + 1],
                            ptr[position]);

                        if (!uniqueColorDict.ContainsKey(pixelColor))
                        {
                            uniqueColors.Add(pixelColor);
                            uniqueColorDict.Add(pixelColor, true);
                        }
                    }
                }
            }

            image.UnlockBits(bmpData);
            return uniqueColors;
        }

        protected override void OnPaint(PaintEventArgs pe)
        {
            base.OnPaint(pe);
            var graph = pe.Graphics;
            var rectContourSmooth = Rectangle.Inflate(this.ClientRectangle, -1, -1);
            var rectBorder = Rectangle.Inflate(rectContourSmooth, -borderSize, -borderSize);
            var smoothSize = borderSize > 0 ? borderSize * 3 : 1;

            using (var borderGColor = new LinearGradientBrush(rectBorder, borderColor, borderColor2, gradientAngle))
            using (var pathRegion = new GraphicsPath())
            using (var penSmooth = new Pen(this.Parent.BackColor, smoothSize))
            using (var penBorder = new Pen(borderGColor, borderSize))
            {
                graph.SmoothingMode = SmoothingMode.AntiAlias;
                penBorder.DashStyle = borderLineStyle;
                penBorder.DashCap = borderCapStyle;
                pathRegion.AddEllipse(rectContourSmooth);
                this.Region = new Region(pathRegion);

                graph.DrawEllipse(penSmooth, rectContourSmooth);
                if (borderSize > 0)
                    graph.DrawEllipse(penBorder, rectBorder);
            }

            // 绘制提取的颜色
            if (_extractedColors.Count > 0)
            {
                int circleSize = 30;
                int spacing = 10;
                int centerX = this.Width / 2;
                int centerY = this.Height / 2;
                int currentX = centerX - (_extractedColors.Count * (circleSize + spacing)) / 2;

                foreach (Color color in _extractedColors)
                {
                    using (SolidBrush brush = new SolidBrush(color))
                    {
                        graph.FillEllipse(brush, currentX, centerY - circleSize / 2, circleSize, circleSize);
                    }
                    currentX += circleSize + spacing;
                }
            }
        }

        private void CircularPicturebox_DragEnter(object sender, DragEventArgs e)
        {
            // 转换鼠标位置到控件本地坐标
            Point clientPoint = this.PointToClient(new Point(e.X, e.Y));
            // 同时验证数据格式和鼠标是否在圆形区域内
            if (e.Data.GetDataPresent(DataFormats.FileDrop) && this.Region.IsVisible(clientPoint))
                e.Effect = DragDropEffects.Copy;
            else
                e.Effect = DragDropEffects.None;
        }

        [Category("RJ Code Advance")]
        public int BorderSize
        {
            get { return borderSize; }
            set
            {
                borderSize = value;
                this.Invalidate();
            }
        }

        [Category("RJ Code Advance")]
        public Color BorderColor
        {
            get { return borderColor; }
            set
            {
                borderColor = value;
                this.Invalidate();
            }
        }

        [Category("RJ Code Advance")]
        public Color BorderColor2
        {
            get { return borderColor2; }
            set
            {
                borderColor2 = value;
                this.Invalidate();
            }
        }

        [Category("RJ Code Advance")]
        public DashStyle BorderLineStyle
        {
            get { return borderLineStyle; }
            set
            {
                borderLineStyle = value;
                this.Invalidate();
            }
        }

        [Category("RJ Code Advance")]
        public DashCap BorderCapStyle
        {
            get { return borderCapStyle; }
            set
            {
                borderCapStyle = value;
                this.Invalidate();
            }
        }

        [Category("RJ Code Advance")]
        public float GradientAngle
        {
            get { return gradientAngle; }
            set
            {
                gradientAngle = value;
                this.Invalidate();
            }
        }

        protected override void OnResize(EventArgs e)
        {
            this.Invalidate();
        }
    }
}

问题原因及解决步骤 #

核心问题 #

1. 未开启拖放权限：WinForms控件默认AllowDrop属性为false，即使绑定了拖放事件，功能也不会激活。
2. 自定义区域的命中测试偏差：你设置了圆形Region，但默认拖放事件的触发判断基于控件矩形边界，鼠标在圆形外、矩形内时会触发事件但不允许操作，导致显示禁止图标。

解决方法 #

1. 开启AllowDrop：在控件构造函数中添加this.AllowDrop = true;，这是拖放功能生效的前提。
2. 精准判断拖放区域：在DragEnter事件中，将鼠标位置转换为控件本地坐标，通过Region.IsVisible()判断是否在圆形区域内，仅允许区域内的拖放操作。
3. 修复绘制持久化问题：原代码用CreateGraphics()绘制颜色是临时的，窗口重绘后会消失，改为存储颜色数据并在OnPaint中绘制，保证内容持久显示。

不需要用鼠标事件模拟拖放，调整上述三点即可解决禁止图标问题。

内容的提问来源于stack exchange，提问作者Daniel Lip