快速图片合并（BitmapData操作）

        public static Bitmap Merge(Bitmap left, Bitmap right)
        {
            Bitmap bmpOut = new Bitmap(left.Width + right.Width, left.Height);
            unsafe
            {
                BitmapData leftData = left.LockBits(new Rectangle(0, 0, left.Width, left.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                byte* leftPtr = (byte*)(void*)leftData.Scan0;

                BitmapData rightData = right.LockBits(new Rectangle(0, 0, right.Width, left.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                byte* rightPtr = (byte*)(void*)rightData.Scan0;

                BitmapData outData = bmpOut.LockBits(new Rectangle(0, 0, bmpOut.Width, bmpOut.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                byte* outPtr = (byte*)(void*)outData.Scan0;

                int outStride = outData.Stride;
                int offL = leftData.Stride - 3 * left.Width;
                int offR = rightData.Stride - 3 * right.Width;
                for (int y = 0; y < left.Height; ++y)
                {
                    for (int x = 0; x < leftData.Width * 3; ++x)
                    {
                        outPtr[outStride * y + x] = leftPtr[0];
                        ++leftPtr;
                    }
                    leftPtr += offL;

                    for (int x = 0; x < rightData.Width * 3; ++x)
                    {
                        outPtr[outStride * y + 3 * left.Width + x] = rightPtr[0];
                        ++rightPtr;
                    }
                    rightPtr += offR;
                }

                left.UnlockBits(leftData);
                right.UnlockBits(rightData);
                bmpOut.UnlockBits(outData);
                return bmpOut;
            }
        }
        public static Bitmap Merge(Bitmap[] bitmaps)
        {
            int count = bitmaps.Length;
            int height = bitmaps[0].Height;
            int outWidth = bitmaps.Select(b => b.Width).Sum();
            Bitmap bmpOut = new Bitmap(outWidth, bitmaps[0].Height);
            unsafe
            {
                BitmapData[] imgData = new BitmapData[count];
                byte*[] imgPtr = new byte*[count];
                int[] imgOffset = new int[count];
                int[] imgStart = new int[count];
                imgStart[0] = 0;
                for (int i = 0; i < count; i++)
                {
                    imgData[i] = bitmaps[i].LockBits(new Rectangle(0, 0, bitmaps[i].Width, height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                    imgPtr[i] = (byte*)imgData[i].Scan0;
                    imgOffset[i] = imgData[i].Stride - 3 * bitmaps[i].Width;
                    if (i > 0) imgStart[i] = imgStart[i - 1] + imgData[i - 1].Width * 3;
                }

                BitmapData outData = bmpOut.LockBits(new Rectangle(0, 0, bmpOut.Width, bmpOut.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                byte* outPtr = (byte*)(void*)outData.Scan0;
                int outStride = outData.Stride;

                for (int y = 0; y < height; ++y)
                {
                    for (int idx = 0; idx < count; idx++)
                    {
                        for (int x = 0; x < imgData[idx].Width * 3; ++x)
                        {
                            outPtr[outStride * y + imgStart[idx] + x] = imgPtr[idx][0];
                            ++imgPtr[idx];
                        }
                        imgPtr[idx] += imgOffset[idx];
                    }
                }
                for (int i = 0; i < count; i++)
                {
                    bitmaps[i].UnlockBits(imgData[i]);
                }
                bmpOut.UnlockBits(outData);
                return bmpOut;
            }
        }