c# - 存储二维数组

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yuxuac/article/details/89401218

using System;
using System.IO;
using System.IO.Compression;

namespace ArrayTest
{
    class Program
    {
        static void Main(string[] args)
        {
            ushort[,] orignalArray = new ushort[1024, 128];

            var r = new Random();
            for (int i = 0; i < orignalArray.GetLength(0); i++)
            {
                for (int j = 0; j < orignalArray.GetLength(1); j++)
                {
                    orignalArray[i, j] = (ushort)(r.Next(1, 10));
                }
            }

            // Write
            ushort[] array = _2DArrayToArray(orignalArray);
            byte[] byteArray = UshortArrayToByteArray(array);
            byte[] compressedbyteArray = Compress(byteArray);
            File.WriteAllBytes("output.dat", compressedbyteArray);

            // Read
            var readBytes = File.ReadAllBytes("output.dat");
            var decompressBytes = Decompress(readBytes);
            var readData = ByteArrayToUshortArray(decompressBytes);
            var readResult = ArrayTo2DArray(readData);

        }

        /// <summary>
        /// 压缩byte[]
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Compress(byte[] data)
        {
            MemoryStream output = new MemoryStream();
            using (DeflateStream dstream = new DeflateStream(output, CompressionLevel.Optimal))
            {
                dstream.Write(data, 0, data.Length);
            }
            return output.ToArray();
        }

        /// <summary>
        /// 解压缩byte[]
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Decompress(byte[] data)
        {
            MemoryStream input = new MemoryStream(data);
            MemoryStream output = new MemoryStream();
            using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
            {
                dstream.CopyTo(output);
            }
            return output.ToArray();
        }

        /// <summary>
        /// 二维数组转化为一维数组
        /// </summary>
        /// <param name="_2DArray"></param>
        /// <returns></returns>
        public static ushort[] _2DArrayToArray(ushort[,] _2DArray)
        {
            ushort colCnt = (ushort)_2DArray.GetLength(0);
            ushort rowCnt = (ushort)_2DArray.GetLength(1);

            ushort[] result = new ushort[colCnt * rowCnt + 2];

            result[0] = colCnt;
            result[1] = rowCnt;

            int index = 2;

            for (int i = 0; i < _2DArray.GetLength(0); i++)
            {
                for (int j = 0; j < _2DArray.GetLength(1); j++)
                {
                    result[index] = _2DArray[i, j];
                    index++;
                }
            }
            return result;
        }

        /// <summary>
        /// 一维数组转化为二维数组
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static ushort[,] ArrayTo2DArray(ushort[] array)
        {
            ushort colCnt = array[0];
            ushort rowCnt = array[1];

            ushort[,] result = new ushort[colCnt, rowCnt];
            int index = 2;
            for (int i = 0; i < colCnt; i++)
            {
                for (int j = 0; j < rowCnt; j++)
                {
                    result[i, j] = array[index];
                    index++;
                }
            }

            return result;
        }

        /// <summary>
        /// byte[]转化为ushort[]
        /// </summary>
        /// <param name="byteArray"></param>
        /// <returns></returns>
        public static ushort[] ByteArrayToUshortArray(byte[] byteArray)
        {
            ushort[] result = new ushort[byteArray.Length / 2];
            Buffer.BlockCopy(byteArray, 0, result, 0, byteArray.Length);
            return result;
        }

        /// <summary>
        /// ushort[]转化为byte[]
        /// </summary>
        /// <param name="ushortArray"></param>
        /// <returns></returns>
        public static byte[] UshortArrayToByteArray(ushort[] ushortArray)
        {
            byte[] bytes = new byte[ushortArray.Length * 2];
            Buffer.BlockCopy(ushortArray, 0, bytes, 0, ushortArray.Length * 2);
            return bytes;
        }
    }
}