Copy as much data as possible for a read operation. : Byte Array « File Stream « C# / C Sharp






  1. C# / C Sharp
  2. File Stream
  3. Byte Array

Copy as much data as possible for a read operation.

        

// Copyright (c) 2008 Interact Software Ltd.

// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
// and associated documentation files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

// Dynamic Bitmap Generation for Silverlight
// 
// See http://www.codeplex.com/SlDynamicBitmap for details.

using System;

namespace InteractSw.GenerateBitmap
{
    /// <summary>
    /// Helpers for copying data around.
    /// </summary>
    class CopyUtilities
    {
        /// <summary>
        /// Copy as much data as possible for a read operation.
        /// </summary>
        /// <param name="targetBuffer">Buffer to put data being read.</param>
        /// <param name="targetOffset">Position from which to start putting read data.</param>
        /// <param name="targetEnd">Offset at which no more data must be written.</param>
        /// <param name="source">Buffer from which data is being copied.</param>
        /// <param name="sourceOffset">Offset from which to start copying.</param>
        /// <returns>Number of bytes copied.</returns>
        /// <remarks>
        /// We frequently end up needing to copy data around, and the size of the source and
        /// target buffers don't necessarily match up neatly. The simple approach is to copy
        /// one byte at a time, but that has dreadful perf. This works out the largest amount
        /// that can be copied while still fitting into the remaining space, and without
        /// attempting to copy more data than there is.
        /// 
        /// The slightly peculiar bunch of arguments comes from the fact that this fell out
        /// of a refactoring exercise. It's not a wonderfully useful general-purpose method.
        /// </remarks>
        public static int WriteAsMuchDataAsPossible(byte[] targetBuffer, int targetOffset, int targetEnd, byte[] source, int sourceOffset)
        {
            int spaceInTarget = targetEnd - targetOffset;
            int spaceInSource = source.Length - sourceOffset;
            int toCopy = Math.Min(spaceInSource, spaceInTarget);
            Array.Copy(source, sourceOffset, targetBuffer, targetOffset, toCopy);
            return toCopy;
        }
    }
}








Related examples in the same category

1.Convert a byte array to string using default encoding
2.Get the byte array from a string using default encoding
3.Write a byte array to a file
4.Read byte array from file
5.Read Stream to Byte array
6.Save Byte Array To File
7.Reinitializes a byte array to the given value in an optimized way: byteArraySet
8.Bit Array To Byte Array
9.Bit Array To Byte Array (2)
10.Checks if the input byte array contains only safe values, the data does not need to be encoded for use with LDIF
11.Convert byte array into a string
12.Byte Array To String
13.Bytes To Formatted String
14.Get string from byte array
15.Reads a file into a byte array
16.Read entire stream into a byte array
17.Read Stream to fill the byte array
18.Convert to easy-to-read byte value
19.Conversions between complex types and byte arrays.
20.Search a byte array for a sub byte array
21.Append various data types to byte array
22.Convert a byte array to an Object.
23.Compares the values of two byte arrays, and returns true only if every array member is identical
24.Convert an object to a byte array.
25.Bytes Equal
26.Compare Bytes
27.Pad bytes.
28.Bytes To Comma Separated List
29.Compare Byte Array Elements
30.Byte Arrays Are Equal
31.Converts a number of bytes into a more easily read form.
32.Int to byte array converter
33.Compares up to n elements of byte array a[] against byte array b[].
34.Utility method to compare two byte arrays for equality
35.Swap Byte Order
36.Get bytes and read bytes