BufferAllocator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / BufferAllocator.cs / 1305376 / BufferAllocator.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Buffer Allocators with recycling 
 *
 * Copyright (c) 1999 Microsoft Corporation 
 */
namespace System.Web {

    using System.Collections; 
    using System.IO;
    using System.Globalization; 
 
    using System.Web.Util;
 
    //////////////////////////////////////////////////////////////////////////////
    // Generic buffer recycling

    /* 
     * Base class for allocator doing buffer recycling
     */ 
    internal abstract class BufferAllocator { 
        private int _maxFree;
        private int _numFree; 
        private Stack _buffers;

        private static int s_ProcsFudgeFactor;
 
        static BufferAllocator() {
            s_ProcsFudgeFactor = SystemInfo.GetNumProcessCPUs(); 
            if (s_ProcsFudgeFactor < 1) 
                s_ProcsFudgeFactor = 1;
 
            if (s_ProcsFudgeFactor > 4)
                s_ProcsFudgeFactor = 4;
        }
 

        internal BufferAllocator(int maxFree) { 
            _buffers = new Stack(); 
            _numFree = 0;
            _maxFree = maxFree * s_ProcsFudgeFactor; 
        }

        internal /*public*/ Object GetBuffer() {
            Object buffer = null; 

            if (_numFree > 0) { 
                lock(this) { 
                    if (_numFree > 0) {
                        buffer = _buffers.Pop(); 
                        _numFree--;
                    }
                }
            } 

            if (buffer == null) 
                buffer = AllocBuffer(); 

            return buffer; 
        }

        internal void ReuseBuffer(Object buffer) {
            if (_numFree < _maxFree) { 
                lock(this) {
                    if (_numFree < _maxFree) { 
                        _buffers.Push(buffer); 
                        _numFree++;
                    } 
                }
            }
        }
 
        /*
         * To be implemented by a derived class 
         */ 
        abstract protected Object AllocBuffer();
    } 

    /*
     * Concrete allocator class for ubyte[] buffer recycling
     */ 
    internal class UbyteBufferAllocator : BufferAllocator {
        private int _bufferSize; 
 
        internal UbyteBufferAllocator(int bufferSize, int maxFree) : base(maxFree) {
            _bufferSize = bufferSize; 
        }

        protected override Object AllocBuffer() {
            return new byte[_bufferSize]; 
        }
    } 
 
    /*
     * Concrete allocator class for char[] buffer recycling 
     */
    internal class CharBufferAllocator : BufferAllocator {
        private int _bufferSize;
 
        internal CharBufferAllocator(int bufferSize, int maxFree)
 
        : base(maxFree) { 
            _bufferSize = bufferSize;
        } 

        protected override Object AllocBuffer() {
            return new char[_bufferSize];
        } 
    }
 
    /* 
     * Concrete allocator class for int[] buffer recycling
     */ 
    internal class IntegerArrayAllocator : BufferAllocator {
        private int _arraySize;

        internal IntegerArrayAllocator(int arraySize, int maxFree) 

        : base(maxFree) { 
            _arraySize = arraySize; 
        }
 
        protected override Object AllocBuffer() {
            return new int[_arraySize];
        }
    } 

    /* 
     * Concrete allocator class for IntPtr[] buffer recycling 
     */
    internal class IntPtrArrayAllocator : BufferAllocator { 
        private int _arraySize;

        internal IntPtrArrayAllocator(int arraySize, int maxFree)
 
        : base(maxFree) {
            _arraySize = arraySize; 
        } 

        protected override Object AllocBuffer() { 
            return new IntPtr[_arraySize];
        }
    }
 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK