示例#1
0
 /// <summary>
 /// 文件流写入
 /// </summary>
 /// <param name="path"></param>
 /// <param name="buffer"></param>
 public void FileStreamAppendFile(string path, MemoryMapBuffer buffer)
 {
     using (FileStream fileStream = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite, fsCacheSize))
     {
         fileStream.Write(buffer.Data, buffer.OffSet, buffer.Size);
         fileStream.Flush();
     }
 }
示例#2
0
 public MemoryMapStream()
 {
     mapPool               = new MemoryMapPool();
     mapBuffer             = new MemoryMapBuffer();
     copyBuffer            = new MemoryMapBuffer();
     mapPool.ArrayBufSize  = 5 * 1024 * 1024; //1个buffer5M;
     mapPool.MaxBufferSize = 100;             //500M缓存;
     mapPool.InitPool(10);                    //50M准备;
     mapBuffer.Data  = new byte[WriteCacheSzie];
     copyBuffer.Data = new byte[WriteCacheSzie];
 }
示例#3
0
 public MemoryMapBuffer GetMemoryMapBuffer()
 {
     lock (lock_obj)
     {
         if (lstData.Count > 0)
         {
             MemoryMapBuffer buffer = lstData[0];
             lstData.RemoveAt(0);
             return(buffer);
         }
         else
         {
             return(null);
         }
     }
 }
示例#4
0
        /// <summary>
        /// 内存映射文件写入数据
        /// </summary>
        /// <param name="path"></param>
        /// <param name="buffer"></param>
        /// <param name="mapName"></param>
        public void  MemoryMapAppendFile(string path, MemoryMapBuffer buffer, string mapName = null)
        {
            FileInfo file = new FileInfo(path);

            if (!file.Exists)
            {
                file.Create();
            }
            long len = file.Length;

            using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite, fsCacheSize))
            {
                using (MemoryMappedFile memoryFile = MemoryMappedFile.CreateFromFile(fs, mapName, len + buffer.Size, MemoryMappedFileAccess.ReadWrite, HandleInheritability.None, false))
                {
                    using (var accessor = memoryFile.CreateViewAccessor(len, buffer.Size))
                    {
                        accessor.WriteArray <byte>(0, buffer.Data, buffer.OffSet, buffer.Size);
                    }
                }
            }
        }
示例#5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="buffer"></param>
        public void FileWrite(MemoryMapBuffer buffer)
        {
            if (mapBuffer.Size + buffer.Size <= WriteCacheSzie)
            {
                Array.Copy(buffer.Data, buffer.OffSet, mapBuffer.Data, mapBuffer.Size, buffer.Size);
                mapBuffer.Size += buffer.Size;
            }
            else
            {
                autoReset.WaitOne();
                Array.Copy(mapBuffer.Data, mapBuffer.OffSet, copyBuffer.Data, 0, mapBuffer.Size);
                copyBuffer.Size = mapBuffer.Size;
                Task.Factory.StartNew(() => {
                    FileStreamAppendFile(FilePath, copyBuffer);
                    autoReset.Set();
                });

                mapBuffer.Size = 0;
                Array.Copy(buffer.Data, buffer.OffSet, mapBuffer.Data, mapBuffer.Size, buffer.Size);
                mapBuffer.Size += buffer.Size;
            }
        }
示例#6
0
        /// <summary>
        /// FileStream读取数据
        /// </summary>
        /// <param name="path"></param>
        public void FileRead(string path)
        {
            IsComplete = false;
            int r = 0;

            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, fsCacheSize))
            {
                while (true)
                {
                    MemoryMapBuffer buf = (MemoryMapBuffer)mapPool.GetBuffer();
                    r        = fs.Read(buf.Data, 0, buf.Capacity);
                    buf.Size = r;
                    lock (lock_obj)
                    {
                        lstData.Add(buf);
                    }
                    if (r < buf.Capacity)
                    {
                        break;
                    }
                }
            }
            IsComplete = true;
        }
示例#7
0
 public void FreeBuffer(MemoryMapBuffer buffer)
 {
     mapPool.Free(buffer);
 }
示例#8
0
        /// <summary>
        /// 读取文件
        /// 20M分段读取
        /// </summary>
        /// <param name="path"></param>
        /// <param name="mapName"></param>
        public async void ReadAllSegmentFileAsync(string path, string mapName = null)
        {
            IsComplete = false;
            FileInfo file = new FileInfo(path);

            if (!file.Exists)
            {
                return;
            }

            long       offset = 0;
            long       len    = 0;
            long       size   = DefaultSize;
            FileStream fs     = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, fsCacheSize);

            len = fs.Length;
            //读取文件,capacity参数不能小于文件长度;
            //但是capacity只是一个值,并不是就需要这么大内存
            //内存在下一步创建视图时确定大小
            //需要把视图部分加载到内存
            using (MemoryMappedFile memoryFile = MemoryMappedFile.CreateFromFile(fs, mapName, 0, MemoryMappedFileAccess.Read, HandleInheritability.None, true))
            {
                while (len > 0)
                {
                    //20M读取
                    //
                    size = len > DefaultSize ? DefaultSize : len;
                    //offset,size参数决定了当前访问位置及内存中大小。
                    using (var accessor = memoryFile.CreateViewAccessor(offset, size, MemoryMappedFileAccess.Read))
                    {
                        int index = 0;  //当前读取
                        int r     = 0;  //当前读取长度
                        offset += size; //设置便宜值
                        len    -= size; //剩余长度
                        while (true)
                        {
                            BaseBuffer <byte[]> item = null;
                            if (mapPool.TryGetBuffer(out item, 1000))
                            {
                                MemoryMapBuffer buf = (MemoryMapBuffer)item;
                                r        = accessor.ReadArray <byte>(index, buf.Data, buf.OffSet, buf.Capacity);
                                index   += r;
                                buf.Size = r;
                                lock (lock_obj)
                                {
                                    lstData.Add(buf);
                                }
                                if (r < buf.Size || index >= DefaultSize)
                                {
                                    //20M读取完成
                                    break;
                                }
                            }
                            else
                            {
                                Console.WriteLine("MemoryMapStream:无法获取缓存,业务处理慢");
                            }
                        }
                    }
                }
            }
            IsComplete = true;
            fs.Close();
        }