1

8 MB を超えるオブジェクトを Azure キャッシュに格納する方法について、何か提案はありますか? 私の場合、byte[] を使用してファイルをブロブに保存します。しかし、どうにかしてバイト[]を小さなチャンクに分割し、それを部分ファイルとして保存し、キャッシュからファイルを取得した後にマージを実行できれば.

擬似コード:

保管

bs <- split file into byte[] that are smaller than 8MB
s <- string[bs.Length]
foreach bs with index i
    s[i] <- name of bs[i]
    Add bs[i] to Azure cache using s[i] as key

Add s to cache

取得中:

s <- Get list of byte[] names
bs <- byte[s.Length]
foreach s with index i
   bs[i] <- Get byte[] using s[i]

outBs <- Join bs to one byte[]

  • ここにパフォーマンスの問題はありますか?

  • Azure キャッシュよりも優れたパフォーマンスを発揮する他の方法はありますか?

4

1 に答える 1

4

数時間の作業の後、大きなファイルを小さなファイルに分割して Azure キャッシュに保存できることがわかりました。コードを共有したいと思います。

byte[] の分割と結合のためのクラス

    public class CacheHelper
    {
        private const int kMaxFileSize = 8000000;
        private readonly int fFileSize;
        private readonly string fFileName;
        public CacheHelper(int sizeOfFile, string nameOfFile)
        {
            fFileSize = sizeOfFile;
            fFileName = nameOfFile;
        }

        public CachingObjectHolder Split(byte[] file)
        {
            var remainingSize = file.Length;
            var partialList = new List<byte[]>();
            var partial = new byte[file.Length > kMaxFileSize ? kMaxFileSize : file.Length];
            for (int i = 0; i < file.Length; i++)
            {
                if (i % kMaxFileSize == 0 && i > 0)
                {
                    partialList.Add(partial);
                    partial = new byte[remainingSize > kMaxFileSize ? kMaxFileSize : remainingSize];
                }

                partial[i % kMaxFileSize] = file[i];
                remainingSize--;
            }

            partialList.Add(partial);

            return new CachingObjectHolder(fFileName, partialList);
        }

        public static byte[] Join(CachingObjectHolder cachingObjectHolder)
        {
            var totalByteSize = cachingObjectHolder.Partials.Sum(x => x.Length);
            var output = new byte[totalByteSize];
            var globalCounter = 0;
            for (int i = 0; i < cachingObjectHolder.Partials.Count; i++)
            {
                for (int j = 0; j < cachingObjectHolder.Partials[i].Length; j++)
                {
                    output[globalCounter] = cachingObjectHolder.Partials[i][j];
                    globalCounter++;
                }
            }

            return output;
        }

        public static byte[] CreateFile(int size)
        {
            var tempFile = Path.GetTempFileName();
            using (var stream = new FileStream(tempFile, FileMode.OpenOrCreate))
            {
                using (var memStream = new MemoryStream())
                {
                    stream.SetLength(size);
                    stream.CopyTo(memStream);
                    return memStream.ToArray();
                }
            }
        }
    }

Azure Cache と通信するためのコードは次のとおりです。

    public class Cache
    {
        private const string kFileListName = "FileList";

        public static DataCacheFactory DataCacheFactory
        {
            get
            {
                return new DataCacheFactory();
            }
        }

        private static DataCache fDataCache;
        public static DataCache DataCache
        {
            get
            {
                if(fDataCache == null)
                {
                    fDataCache = DataCacheFactory.GetDefaultCache();
                }

                return fDataCache;
            }
        }

        public static byte[] Get(string name)
        {
            var dic = GetFileList();
            if (dic == null)
            {
                return (byte[])DataCache.Get(name);
            }
            if (dic.ContainsKey(name))
            {
                var list = dic[name];
                var input = new List<byte[]>();
                var cache = DataCache;
                list = list.OrderBy(x => x.Item2).ToList();
                for (int i = 0; i < list.Count; i++)
                {
                    input.Add(cache.Get(list[i].Item1) as byte[]);
                }

                var holder = new CachingObjectHolder(name, input);
                return CacheHelper.Join(holder);
            }
            else
            {
                return (byte[])DataCache.Get(name);
            }
        }

        public static void Put(string name, byte[] file)
        {
            if (file.Length > CacheHelper.kMaxFileSize)
            {
                var helper = new CacheHelper(file.Length, name);
                var output = helper.Split(file);
                var dic = GetFileList();
                if (dic == null)
                {
                    dic = new Dictionary<string, List<Tuple<string, int>>>();
                }

                var partials = new List<Tuple<string, int>>();
                for (int i = 0; i < output.CachingObjects.Count; i++)
                {
                    DataCache.Add(output.CachingObjects[i].Name, output.Partials[output.CachingObjects[i].Index]);
                    partials.Add(new Tuple<string, int>(output.CachingObjects[i].Name, 
                                               output.CachingObjects[i].Index));   
                }

                dic.Add(name, partials.OrderBy(x => x.Item2).ToList());
                PutFileList(dic);
            }
            else
            {
                DataCache.Add(name, file);
            }
        }

        public static void Remove(string name)
        {
            var dic = GetFileList();
            if (dic == null)
            {
                DataCache.Remove(name);
                return;
            }

            if (dic.ContainsKey(name))
            {
                var list = dic[name];
                for (int i = 0; i < list.Count; i++)
                {
                    DataCache.Remove(list[i].Item1);
                }

                dic.Remove(name);
                PutFileList(dic);
            }
            else
            {
                DataCache.Remove(name);
            }
        }

        private static void PutFileList(Dictionary<string, List<Tuple<string, int>>> input)
        {
            DataCache.Put(kFileListName, input);
        }

        private static Dictionary<string, List<Tuple<string, int>>> GetFileList()
        {
            return DataCache.Get(kFileListName) as Dictionary<string, List<Tuple<string, int>>>;
        }
    }

Aaaaand データホルダーに使用される 2 つのクラス

    public class CachingObjectHolder
    {
        public readonly List<byte[]> Partials;
        public readonly List<CachingObject> CachingObjects;
        public readonly string CacheName;

        public CachingObjectHolder(string name, List<byte[]> partialList)
        {
            Partials = partialList;
            CacheName = name;
            CachingObjects = new List<CachingObject>();
            CreateCachingObjects();
        }

        private void CreateCachingObjects()
        {
            for (int i = 0; i < Partials.Count; i++)
            {
                CachingObjects.Add(new CachingObject(string.Format("{0}_{1}", CacheName, i), i));
            }
        }
    }

    public class CachingObject
    {
        public int Index { get; set; }
        public string Name { get; set; }

        public CachingObject(string name, int index)
        {
            Index = index;
            Name = name;
        }
    }

クラウド上でソリューションをテストした結果は次のとおりです。R/W 時間はミリ秒単位です。 ライブテストの結果

于 2013-04-10T20:42:35.730 に答える