Правильно копировать структуры C# с (байтовыми) массивами в них?

вам придется создать Clone способ, чтобы сделать глубокую копию членов структуры:

public struct MyStruct
{
    public byte[] data;
    public MyStruct Clone()
    {
        byte[] clonedData = new byte[this.data.Length];
        data.CopyTo(clonedData, 0);

        return new MyStruct { data = clonedData };
    }
}

вот перегрузка для вашего метода копирования структуры, которая не требует приведения результатов:

public static T RawDeserialize<T>(byte[] rawData, int position)
{
    return (T)RawDeserialize(rawData, position, typeof(T));
}

вы называете это так:

MYSTRUCT1 x = RawDeserialize<MYSTRUCT1>(...);

вы даже можете использовать var:

var x = RawDeserialize<MYSTRUCT1>(...);

Если вы хотите, чтобы структура инкапсулировала массив по значению (или, по крайней мере, вела себя так, как будто это так), так что копирование структуры будет копировать массив, у вас есть четыре варианта, которые я вижу:

1. если массив имеет фиксированный размер, объявите структуру "небезопасной" и используйте в ней "фиксированный" массив. "Фиксированный" массив хранится как часть содержащей структуры, поэтому копирование структуры будет копировать массив.
2. если массив имеет небольшой фиксированный размер, но вы не если вы хотите использовать фиксированный код, вы можете объявить поле для каждого элемента массива, а затем написать индексированное свойство, которое читает или записывает одно из полей структуры. Это, вероятно, лучший подход, если массив имеет около 4 элементов, но это будет непрактично, если он имеет сотни или тысячи.
3. структура может содержать частную ссылку на массив, который никогда не будет изменен; любая операция, которая изменит массив, должна сделать копию массива, изменить эта копия, а затем перезаписать конфиденциальную ссылку со ссылкой на новый массив (выполните шаги в таком порядке). Этот подход может быть эффективным, если структура будет широко скопирована, но массив редко будет изменен.
4. напишите класс, который ведет себя как неизменяемый массив и который содержит метод, который будет генерировать новый экземпляр, если задан старый экземпляр, индекс элемента и новое значение, которое будет храниться в этом элементе. Индексатор структуры выглядеть примерно так, как показано ниже, реальная сложность будет в классе.

byte this[int n] {
  get {return myContents[n];}
  set {myContents = myContents.WithValue(n, value);}
}

подход #4 С соответственно-объект проектирования-держатель класса может достичь o(LG с(Н)) для операций чтения и записи выполняются в произвольной последовательности, или, может быть, удастся достичь O(1) производительность для чтения и записи, выполняемых в определенной закономерности (например, "написать" способ может просто добавить каждого индекса и значением для связанного списка обновлений пока либо количество обновлений превышает размер массива или попытке чтения элемента, а затем создать новый массив со всеми обновлениями; такой класс будет работать медленно, если он был попеременно читал и писал, но общее время выполнения П обновления Далее следуют N говорится будет о(n), т. е. среднее время на обновление или чтение будет O(1).

да, но byte[] является ссылочным типом. Следовательно, в структуре хранится только ссылка (указатель) (структура является типом значения). При копировании структуры копируется только ссылка.

вам нужно создать новый byte[] и скопировать данные.

скопировать все byte[] в классе вы можете использовать отражение.

class ArrayContainer
{
    public byte[] Array1 { get; set; }
    public byte[] Array2 { get; set; }

    public ArrayContainer DeepCopy()
    {
        ArrayContainer result = new ArrayContainer();
        foreach (var property in this.GetType().GetProperties())
        {
            var oldData = property.GetValue(this, null) as byte[];
            if (oldData != null)
            {
                // Copy data with .ToArray() actually copies data.
                property.SetValue(result, oldData.ToArray(), null);
            }
        }

        return result;
    }
}

использование:

ArrayContainer container = new ArrayContainer();
container.Array1 = new byte[] { 1 };
container.Array2 = new byte[] { 2 };
ArrayContainer copy = container.DeepCopy();
copy.Array1[0] = 3;

Console.WriteLine("{0}, {1}, {2}, {3}", container.Array1[0], container.Array2[0], copy.Array1[0], copy.Array2[0]);

дает: "1, 2, 3, 2"

обратите внимание, что я использовал свойства вместо членов для массивов, но вы также можете использовать отражение для переменных-членов.

один умнее решение, заимствованные из здесь:

static public T DeepCopy<T>(T obj)
{
    BinaryFormatter s = new BinaryFormatter();
    using (MemoryStream ms = new MemoryStream())
    {
        s.Serialize(ms, obj);
        ms.Position = 0;
        T t = (T)s.Deserialize(ms);

        return t;
    }
}

помимо безопасности типа из-за использования шаблона, а также сохранения двух функций, это требует, чтобы связать SerializableAttribute на structs( или классы); CLR-aware двоичная (de) сериализация намного лучше, чем слепое копирование необработанных байтов, я думаю:

[Serializable]
struct test
{
    public int[] data;
}