NativeContainerを自作したい

    using System;
    using System.Diagnostics;
    using Unity.Collections.LowLevel.Unsafe;
    using Unity.Collections;
    using Unity.Burst;

    [NativeContainer]
    [NativeContainerSupportsMinMaxWriteRestriction]
    [DebuggerDisplay("Length = {Length}")]
    [DebuggerTypeProxy(typeof(NativeArray2DDebugView<>))]
    public unsafe struct NativeArray2D<T> : IDisposable where T : unmanaged
    {
        [NativeDisableUnsafePtrRestriction]
        // 変数名は「m_Buffer」で固定
        internal void* m_Buffer;

        // 変数名は「m_Length」で固定
        internal int m_Length;

#if ENABLE_UNITY_COLLECTIONS_CHECKS

        // 変数名は「m_MinIndex」で固定
        internal int m_MinIndex;
        // 変数名は「m_MaxIndex」で固定
        internal int m_MaxIndex;

        // 変数名は「m_Safety」で固定
        internal AtomicSafetyHandle m_Safety;

        internal static readonly SharedStatic<int> s_staticSafetyId =
            SharedStatic<int>.GetOrCreate<NativeArray2D<T>>();

#endif

        // 変数名は「m_AllocatorLabel」で固定
        internal Allocator m_AllocatorLabel;

        public NativeArray2D(int height, int width, Allocator allocator)
        {
            long size = UnsafeUtility.SizeOf<T>() * width * height;

#if ENABLE_UNITY_COLLECTIONS_CHECKS

            if (allocator <= Allocator.None)
                throw new ArgumentException("Allocator must be Temp, TempJob or Persistent", nameof(allocator));

            if (!UnsafeUtility.IsBlittable<T>())
                throw new ArgumentException(string.Format("{0} used in NativeCustomArray<{0}> must be blittable", typeof(T)));

            if (width < 0)
                throw new ArgumentOutOfRangeException(nameof(width), "Width must be >= 0");
            if (height < 0)
                throw new ArgumentOutOfRangeException(nameof(height), "Height must be >= 0");

#endif

            m_Buffer = UnsafeUtility.Malloc(size, UnsafeUtility.AlignOf<T>(), allocator);
            UnsafeUtility.MemClear(m_Buffer, size);

            Width = width;
            Height = height;
            m_Length = width * height;
            m_AllocatorLabel = allocator;

#if ENABLE_UNITY_COLLECTIONS_CHECKS

            m_MinIndex = 0;
            m_MaxIndex = m_Length - 1;

            m_Safety = CollectionHelper.CreateSafetyHandle(allocator);
            CollectionHelper.SetStaticSafetyId<NativeArray2D<T>>(ref m_Safety, ref s_staticSafetyId.Data);

#endif
        }

        public int Length { get { return m_Length; } }

        // NativeArray2D独自のプロパティ
        public int Width { get; }
        // NativeArray2D独自のプロパティ
        public int Height { get; }

        public unsafe T this[int y, int x]
        {
            get
            {
#if ENABLE_UNITY_COLLECTIONS_CHECKS

                AtomicSafetyHandle.CheckReadAndThrow(m_Safety);

                if (y * Width + x < m_MinIndex || y * Width + x > m_MaxIndex) OutOfRangeError(y * Width + x);

#endif

                return UnsafeUtility.ReadArrayElement<T>(m_Buffer, y * Width + x);
            }

            set
            {
#if ENABLE_UNITY_COLLECTIONS_CHECKS

                AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);

                if (y * Width + x < m_MinIndex || y * Width + x > m_MaxIndex) OutOfRangeError(y * Width + x);

#endif

                UnsafeUtility.WriteArrayElement(m_Buffer, y * Width + x, value);
            }
        }

        public T[,] ToArray()
        {
#if ENABLE_UNITY_COLLECTIONS_CHECKS

            AtomicSafetyHandle.CheckReadAndThrow(m_Safety);

#endif

            T[,] array = new T[Height, Width];
            for (int i = 0; i < Height; ++i)
            {
                for (int j = 0; j < Width; ++j)
                {
                    array[i, j] = UnsafeUtility.ReadArrayElement<T>(m_Buffer, i * Width + j);
                }
            }

            return array;
        }

        public bool IsCreated
        {
            get { return m_Buffer != null; }
        }

        public void Dispose()
        {
#if ENABLE_UNITY_COLLECTIONS_CHECKS

            CollectionHelper.DisposeSafetyHandle(ref m_Safety);

#endif

            UnsafeUtility.FreeTracked(m_Buffer, m_AllocatorLabel);
            m_Buffer = null;
            m_Length = 0;

            Width = 0;
            Height = 0;
        }

#if ENABLE_UNITY_COLLECTIONS_CHECKS

        private void OutOfRangeError(int index)
        {
            if (index < m_Length && (m_MinIndex != 0 || m_MaxIndex != m_Length - 1))
                throw new IndexOutOfRangeException(string.Format(
                "Index {0} is out of restricted IJobParallelFor range [{1}...{2}] in ReadWriteBuffer.\n" +
                "ReadWriteBuffers are restricted to only read & write the element at the job index. " +
                "You can use double buffering strategies to avoid race conditions due to " +
                "reading & writing in parallel to the same elements from a job.",
                index, m_MinIndex, m_MaxIndex));

            throw new IndexOutOfRangeException(string.Format("Index {0} is out of range of '{1}' Length.", index, Length));
        }

#endif
    }

    internal sealed class NativeArray2DDebugView<T> where T : unmanaged
    {
        private NativeArray2D<T> m_Array;

        public NativeArray2DDebugView(NativeArray2D<T> array)
        {
            m_Array = array;
        }

        public T[,] Items
        {
            get { return m_Array.ToArray(); }
        }
    }

JobsUtility.PatchBufferMinMaxRanges(bufferRangePatchData, UnsafeUtility.AddressOf(ref jobData), begin, end - begin);

public unsafe static extern void PatchBufferMinMaxRanges(IntPtr bufferRangePatchData, void* jobdata, int startIndex, int rangeSize);