Esempio n. 1
0
 private void SwitchModeIfNecessary()
 {
     if (this._isolatedStorageMode)
     {
         if (this._isolatedStorageStream.Length < this._lowWaterMark)
         {
             if (this._isolatedStorageStream.Length > 0L)
             {
                 MemoryStreamBlock item = new MemoryStreamBlock(this._trackingMemoryStreamFactory.Create((int)this._isolatedStorageStream.Length), 0L);
                 this._isolatedStorageStream.Seek(0L, SeekOrigin.Begin);
                 item.Stream.Seek(0L, SeekOrigin.Begin);
                 PackagingUtilities.CopyStream(this._isolatedStorageStream, item.Stream, 0x7fffffffffffffffL, 0x80000);
                 this._memoryStreamList.Add(item);
             }
             this._isolatedStorageMode = false;
             this._isolatedStorageStream.SetLength(0L);
             this._isolatedStorageStream.Flush();
         }
     }
     else if (this._trackingMemoryStreamFactory.CurrentMemoryConsumption > this._highWaterMark)
     {
         this.EnsureIsolatedStoreStream();
         this.CopyMemoryBlocksToStream(this._isolatedStorageStream);
         this._isolatedStorageMode = true;
         foreach (MemoryStreamBlock block2 in this._memoryStreamList)
         {
             block2.Stream.Close();
         }
         this._memoryStreamList.Clear();
     }
 }
Esempio n. 2
0
        private MemoryStreamBlock ConstructMemoryStreamFromWriteRequest(byte[] buffer, long writeRequestOffset, int writeRequestSize, int bufferOffset)
        {
            MemoryStreamBlock block = new MemoryStreamBlock(this._trackingMemoryStreamFactory.Create(writeRequestSize), writeRequestOffset);

            block.Stream.Seek(0L, SeekOrigin.Begin);
            block.Stream.Write(buffer, bufferOffset, writeRequestSize);
            return(block);
        }
Esempio n. 3
0
        private bool CanCollapseWithPreviousBlock(MemoryStreamBlock memStreamBlock, long offset, long length)
        {
            if (!this._autoCloseSmallBlockGaps || (memStreamBlock == null))
            {
                return(false);
            }
            long num = offset - (memStreamBlock.Offset + memStreamBlock.Stream.Length);

            return((num <= 100L) && (((num + length) + memStreamBlock.Stream.Length) <= 0x7fffffffL));
        }
Esempio n. 4
0
 private MemoryStreamBlock GetSearchBlockForOffset(long offset)
 {
     if (this._searchBlock == null)
     {
         this._searchBlock = new MemoryStreamBlock(null, offset);
     }
     else
     {
         this._searchBlock.Offset = offset;
     }
     return(this._searchBlock);
 }
Esempio n. 5
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            int num3;

            this.CheckDisposed();
            PackagingUtilities.VerifyStreamReadArgs(this, buffer, offset, count);
            if (count == 0)
            {
                return(0);
            }
            if (this._currentStreamLength <= this._currentStreamPosition)
            {
                return(0);
            }
            int num2 = (int)Math.Min((long)count, this._currentStreamLength - this._currentStreamPosition);

            if (this._isolatedStorageMode)
            {
                this._isolatedStorageStream.Seek(this._currentStreamPosition, SeekOrigin.Begin);
                num3 = this._isolatedStorageStream.Read(buffer, offset, num2);
            }
            else
            {
                Array.Clear(buffer, offset, num2);
                int num = this._memoryStreamList.BinarySearch(this.GetSearchBlockForOffset(this._currentStreamPosition));
                if (num < 0)
                {
                    num = ~num;
                }
                while (num < this._memoryStreamList.Count)
                {
                    long num4;
                    long num5;
                    MemoryStreamBlock block = this._memoryStreamList[num];
                    PackagingUtilities.CalculateOverlap(block.Offset, (long)((int)block.Stream.Length), this._currentStreamPosition, (long)num2, out num5, out num4);
                    if (num4 <= 0L)
                    {
                        break;
                    }
                    Array.Copy(block.Stream.GetBuffer(), (int)(num5 - block.Offset), buffer, (int)((offset + num5) - this._currentStreamPosition), (int)num4);
                    num++;
                }
                num3 = num2;
            }
            this._currentStreamPosition += num3;
            return(num3);
        }
Esempio n. 6
0
 public override void SetLength(long newLength)
 {
     this.CheckDisposed();
     if (newLength < 0L)
     {
         throw new ArgumentOutOfRangeException("newLength");
     }
     if (this._currentStreamLength != newLength)
     {
         if (this._isolatedStorageMode)
         {
             this._isolatedStorageStream.SetLength(newLength);
         }
         else if (this._currentStreamLength > newLength)
         {
             int index = this._memoryStreamList.BinarySearch(this.GetSearchBlockForOffset(newLength));
             if (index < 0)
             {
                 index = ~index;
             }
             else
             {
                 MemoryStreamBlock block = this._memoryStreamList[index];
                 long num3 = newLength - block.Offset;
                 if (num3 > 0L)
                 {
                     block.Stream.SetLength(num3);
                     index++;
                 }
             }
             for (int i = index; i < this._memoryStreamList.Count; i++)
             {
                 this._memoryStreamList[i].Stream.Close();
             }
             this._memoryStreamList.RemoveRange(index, this._memoryStreamList.Count - index);
         }
         this._currentStreamLength = newLength;
         if (this._currentStreamPosition > this._currentStreamLength)
         {
             this._currentStreamPosition = this._currentStreamLength;
         }
     }
     this.SwitchModeIfNecessary();
 }
Esempio n. 7
0
        private void WriteAndCollapseBlocks(byte[] buffer, int offset, int count)
        {
            int  index                       = this._memoryStreamList.BinarySearch(this.GetSearchBlockForOffset(this._currentStreamPosition));
            bool flag                        = false;
            MemoryStreamBlock item           = null;
            MemoryStreamBlock memStreamBlock = null;

            if (index < 0)
            {
                index = ~index;
                if (index != 0)
                {
                    memStreamBlock = this._memoryStreamList[index - 1];
                }
                if (this.CanCollapseWithPreviousBlock(memStreamBlock, this._currentStreamPosition, (long)count))
                {
                    memStreamBlock.Stream.Seek(0L, SeekOrigin.End);
                    this.SkipWrite(memStreamBlock.Stream, memStreamBlock.EndOffset, this._currentStreamPosition);
                    memStreamBlock.Stream.Write(buffer, offset, count);
                    flag = true;
                }
            }
            else
            {
                memStreamBlock = this._memoryStreamList[index];
                if ((memStreamBlock.Stream.Length + count) <= 0x7fffffffL)
                {
                    memStreamBlock.Stream.Seek(this._currentStreamPosition - memStreamBlock.Offset, SeekOrigin.Begin);
                    memStreamBlock.Stream.Write(buffer, offset, count);
                    flag = true;
                    index++;
                }
                else
                {
                    memStreamBlock.Stream.SetLength(this._currentStreamPosition - item.Offset);
                }
            }
            if (!flag)
            {
                memStreamBlock = this.ConstructMemoryStreamFromWriteRequest(buffer, this._currentStreamPosition, count, offset);
                this._memoryStreamList.Insert(index, memStreamBlock);
                index++;
            }
            this._currentStreamPosition += count;
            int num2 = index;

            while (num2 < this._memoryStreamList.Count)
            {
                if (this._memoryStreamList[num2].EndOffset > this._currentStreamPosition)
                {
                    break;
                }
                this._memoryStreamList[num2].Stream.Close();
                num2++;
            }
            if ((num2 - index) > 0)
            {
                this._memoryStreamList.RemoveRange(index, num2 - index);
            }
            long num3 = -1L;

            if (index < this._memoryStreamList.Count)
            {
                item = this._memoryStreamList[index];
                num3 = this._currentStreamPosition - item.Offset;
            }
            else
            {
                item = null;
            }
            if (num3 <= 0L)
            {
                if ((item != null) && this.CanCollapseWithPreviousBlock(memStreamBlock, item.Offset, item.Stream.Length))
                {
                    this._memoryStreamList.RemoveAt(index);
                    memStreamBlock.Stream.Seek(0L, SeekOrigin.End);
                    this.SkipWrite(memStreamBlock.Stream, this._currentStreamPosition, item.Offset);
                    memStreamBlock.Stream.Write(item.Stream.GetBuffer(), 0, (int)item.Stream.Length);
                }
            }
            else
            {
                this._memoryStreamList.RemoveAt(index);
                int num4 = (int)(item.Stream.Length - num3);
                if ((memStreamBlock.Stream.Length + num4) <= 0x7fffffffL)
                {
                    memStreamBlock.Stream.Seek(0L, SeekOrigin.End);
                    memStreamBlock.Stream.Write(item.Stream.GetBuffer(), (int)num3, num4);
                }
                else
                {
                    item = this.ConstructMemoryStreamFromWriteRequest(item.Stream.GetBuffer(), this._currentStreamPosition, num4, (int)num3);
                    this._memoryStreamList.Insert(index, item);
                }
            }
        }