Как сделать эту небезопасную структуру с фиксированным массивом динамической? (или альтернатива?)

Не вдаваясь в вопрос о том, следует ли это сделать или есть ли лучшие способы сделать это, я попытаюсь ответить на желание OP создать структуры размера во время выполнения, которые можно использовать для блока памяти переменной длины. копии. Короче говоря, выполнение высокопроизводительных манипуляций с данными на уровне байтов больше подходит для C++, чем для C#, но, похоже, технически это все еще возможно.

Для этого мы можем использовать сортировку для динамического создания неуправляемой памяти переменного размера для хранения наших временных BGRn данных, а затем использовать P/Invoke для копирования блочной памяти.

public unsafe class BGRn
{
    IntPtr bgrPtr;
    int totalSize;
    const int pixelSizeBGR = 3;

    public BGRn(byte b, byte g, byte r, int size)
    {
        totalSize = pixelSizeBGR * size;
        bgrPtr = Marshal.AllocHGlobal(totalSize);

        byte* v = (byte*)bgrPtr;

        int num = 0;

        do
        {
            v[num++] = b;
            v[num++] = g;
            v[num++] = r;
        } while (num < (totalSize));
    } 

    public void CopyTo(IntPtr buffer)
    {
        CopyMemory(buffer, bgrPtr, (uint) totalSize);
    }

    [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
    private static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

}

Затем вы можете оставить другой код как есть, за исключением замены:

BGR5 np5 = new BGR5(0, 255, 255);
// ...
*((BGR5*)(row + h + Offset1)) = np5;

с:

BGRn np5 = new BGRn(0, 255, 255, 5);
// ...
np5.CopyTo((IntPtr)(row + h + Offset1));

Конечно, я пропустил Marshal.FreeHGlobal, который должен сопровождать этот класс, но пользователь должен решить, как и когда освобождать память (вероятно, реализуя операторы IDisposable и using).

На самом деле я не проверял, как работает этот код и работает ли он вообще, но он компилируется.

Использование базового класса absract может упростить работу с растровыми изображениями любой ширины, хотя вам все равно придется писать отдельный класс для каждой ширины растрового изображения. Вам не нужны структуры — вы можете писать прямо в растровую память.

using System.Drawing.Imaging;

namespace TestProject2
{
public abstract class BGRBase
{
    //init to your bitmap's BitmapData, obtained by calling Bitmap.LockBits
    protected readonly BitmapData data;

    public abstract void SetRow(int rowIndex, byte b, byte g, byte r);
}

public class BGR3 : BGRBase
{
    //use constructor to ensure that the bitmap's width is compatible

    public unsafe override void SetRow(int rowIndex, byte b, byte g, byte r)
    {
        byte* row = (byte*)data.Scan0 + rowIndex * data.Stride;
        row[0] = row[3] = row[6] = b;
        //etc
    }
}

public class BGR5 : BGRBase
{
    public override unsafe void SetRow(int rowIndex, byte b, byte g, byte r)
    {
        //code as adove
    }
}
}

Или используйте делегат, чтобы инкапсулировать соответствующий метод и вызвать его в цикле.

public static void Set5(byte* p, byte b, byte g, byte r)

public static void Set3(byte* p, byte b, byte g, byte r)

//usage
public void Draw(Rectangle rect, byte b, byte g, byte r)
{
    Action<byte*, byte, byte, byte> setRow = null;
    switch(rect.Width)
    {
        case 3: setRow = Set3; break;
        case 5: setRow = Set5; break;
        //etc
    }
    byte* p=(byte*)bmd.Scan0 + bmd.Stride * rect.Y + 3 * rect.X;
    while(p < endAddress)
    {
        setRow(p, b, g, r);
        p+=bmd.Stride;  
    }
}