Provides extension methods for copying streams More...

Static Public Member Functions
static MemoryStream	CopyToMemoryStream (Stream s)
	Copies the remaining data in the current stream to a new MemoryStream instance. More...

static MemoryStream	CopyToMemoryStream (Stream s, bool entireStream)
	Copies the current stream into a new MemoryStream instance. More...

static MemoryStream	CopyToMemoryStream (Stream s, bool entireStream, int chunkSize)
	Copies the current stream into a new MemoryStream instance. More...

static byte[]	CopyToBytes (Stream s)
	Copies the remaining data in the current stream to a byte[] array of exact size. More...

static byte[]	CopyToBytes (Stream s, bool entireStream)
	Copies the current stream into a byte[] array of exact size. More...

static void	CopyToStream (Stream s, Stream other)
	Copies the remaining data from the this stream into the given stream. More...

static void	CopyToStream (Stream s, Stream other, bool entireStream)
	Copies this stream into the given stream More...

static void	CopyToStream (Stream src, Stream dest, bool entireStream, int chunkSize)
	Copies this stream into the given stream More...

static byte[]	CopyToBytes (Stream src, bool entireStream, int chunkSize)
	Copies the current stream into a byte[] array of exact size More...

static byte[]	CopyOrReturnBuffer (Stream src, out long length, bool entireStream, int chunkSize)
	Attempts to return a byte[] array containing the remaining portion of the stream. Unlike CopyToBytes(), does not return a byte[] array of exact length, and may re-use the actual Stream's byte array, making it unsafe to write to in the future. More...

Detailed Description

Provides extension methods for copying streams

Definition at line 12 of file Stream.cs.

Member Function Documentation

static byte [] ImageResizer.ExtensionMethods.StreamExtensions.CopyOrReturnBuffer	(	Stream	src,
		out long	length,
		bool	entireStream,
		int	chunkSize
	)

inlinestatic

Attempts to return a byte[] array containing the remaining portion of the stream. Unlike CopyToBytes(), does not return a byte[] array of exact length, and may re-use the actual Stream's byte array, making it unsafe to write to in the future.

Parameters

src
length
chunkSize

Returns

Definition at line 189 of file Stream.cs.

Referenced by ImageResizer.Plugins.WicBuilder.WicBuilderPlugin.BuildJob().

                                                                                                                {
             if (src is MemoryStream) {
                 if (entireStream || src.Position == 0) {
                     length = src.Length;
                     //Slice from 
                     MemoryStream ms = src as MemoryStream;
                     try {
                         return ms.GetBuffer();
                     } catch (UnauthorizedAccessException) //If we can't slice it, then we read it like a normal stream
                     {
                         return ms.ToArray();
                     }
                 } else {
                     byte[] buf = CopyToBytes(src, entireStream, chunkSize);
                     length = buf.Length;
                     return buf;
                 }
             }else{
                 MemoryStream ms = CopyToMemoryStream(src, entireStream, chunkSize);
                 return CopyOrReturnBuffer(ms, out length, true, chunkSize);
             }
         }

static byte [] ImageResizer.ExtensionMethods.StreamExtensions.CopyToBytes ( Stream s )

inlinestatic

Copies the remaining data in the current stream to a byte[] array of exact size.

Parameters

s

Returns

Definition at line 51 of file Stream.cs.

                                                    {
             return CopyToBytes(s, false);
         }

static byte [] ImageResizer.ExtensionMethods.StreamExtensions.CopyToBytes	(	Stream	s,
		bool	entireStream
	)

inlinestatic

Copies the current stream into a byte[] array of exact size.

Parameters

s
entireStream	True to copy entire stream if seeakable, false to only copy remaining data

Returns

Definition at line 60 of file Stream.cs.

                                                                       {
             return CopyToBytes(s, entireStream, 0x1000);
         }

static byte [] ImageResizer.ExtensionMethods.StreamExtensions.CopyToBytes	(	Stream	src,
		bool	entireStream,
		int	chunkSize
	)

inlinestatic

Copies the current stream into a byte[] array of exact size

Parameters

src
entireStream	True to copy entire stream if seeakable, false to only copy remaining data.
chunkSize	The buffer size to use (in bytes) if a buffer is required. Default: 4KiB

Returns

Definition at line 134 of file Stream.cs.

                                                                                        {
             byte[] bytes;
             if (src is MemoryStream) {
                 //Slice from 
                 MemoryStream ms = src as MemoryStream;
                 try {
                     byte[] buffer = ms.GetBuffer();
                     long pos = entireStream ? 0 : src.Position;
                     long count = src.Length - pos;
                     bytes = new byte[count];
                     Array.Copy(buffer, pos, bytes, 0, count);
                     return bytes;
                 } catch (UnauthorizedAccessException) //If we can't slice it, then we read it like a normal stream
                 { }
                 if (entireStream || src.Position == 0) return ms.ToArray(); //Uses InternalBlockCopy, quite fast...
             }
 
             if (src.CanSeek) {
                 long pos = entireStream ? 0 : src.Position;
                 if (entireStream) src.Seek(0, SeekOrigin.Begin);
 
                 // Read the source file into a byte array.
                 int numBytesToRead = (int)(src.Length - pos);
                 bytes = new byte[numBytesToRead];
                 int numBytesRead = 0;
                 while (numBytesToRead > 0) {
                     // Read may return anything from 0 to numBytesToRead.
                     int n = src.Read(bytes, numBytesRead, numBytesToRead);
 
                     // Break when the end of the file is reached.
                     if (n == 0)
                         break;
 
                     numBytesRead += n;
                     numBytesToRead -= n;
                 }
                 Debug.Assert(numBytesRead == bytes.Length);
                 return bytes;
             } else {
                 //No seeking, so we have to buffer to an intermediate memory stream
                 var ms = new MemoryStream();
                 CopyToStream(src, ms, entireStream, chunkSize);
                 return CopyToBytes(ms, true, chunkSize);
             }
         }

static MemoryStream ImageResizer.ExtensionMethods.StreamExtensions.CopyToMemoryStream ( Stream s )

inlinestatic

Copies the remaining data in the current stream to a new MemoryStream instance.

Parameters

s

Returns

Definition at line 19 of file Stream.cs.

                                                                 {
             return CopyToMemoryStream(s, false);
         }

static MemoryStream ImageResizer.ExtensionMethods.StreamExtensions.CopyToMemoryStream	(	Stream	s,
		bool	entireStream
	)

inlinestatic

Copies the current stream into a new MemoryStream instance.

Parameters

s
entireStream	True to copy entire stream if seeakable, false to only copy remaining data

Returns

Definition at line 28 of file Stream.cs.

                                                                                    {
             return CopyToMemoryStream(s, entireStream,0x1000);
         }

static MemoryStream ImageResizer.ExtensionMethods.StreamExtensions.CopyToMemoryStream	(	Stream	s,
		bool	entireStream,
		int	chunkSize
	)

inlinestatic

Copies the current stream into a new MemoryStream instance.

Parameters

s
entireStream	True to copy entire stream if seeakable, false to only copy remaining data
chunkSize	The buffer size to use (in bytes) if a buffer is required. Default: 4KiB

Returns

Definition at line 39 of file Stream.cs.

                                                                                                   {
             MemoryStream ms = new MemoryStream(s.CanSeek ? ((int)s.Length + 8 - (entireStream ? 0 : (int)s.Position)) : chunkSize);
             CopyToStream(s, ms, entireStream, chunkSize);
             ms.Position = 0;
             return ms;
         }

static void ImageResizer.ExtensionMethods.StreamExtensions.CopyToStream	(	Stream	s,
		Stream	other
	)

inlinestatic

Copies the remaining data from the this stream into the given stream.

Parameters

s
other	The stream to write to

Definition at line 68 of file Stream.cs.

                                                                 {
             CopyToStream(s, other, false);
         }

static void ImageResizer.ExtensionMethods.StreamExtensions.CopyToStream	(	Stream	s,
		Stream	other,
		bool	entireStream
	)

inlinestatic

Copies this stream into the given stream

Parameters

s
other	The stream to write to
entireStream	True to copy entire stream if seeakable, false to only copy remaining data

Definition at line 77 of file Stream.cs.

                                                                                    {
             CopyToStream(s, other, entireStream, 0x1000);
         }

static void ImageResizer.ExtensionMethods.StreamExtensions.CopyToStream	(	Stream	src,
		Stream	dest,
		bool	entireStream,
		int	chunkSize
	)

inlinestatic

Copies this stream into the given stream

Parameters

src
dest	The stream to write to
entireStream	True to copy entire stream if seeakable, false to only copy remaining data
chunkSize	True to copy entire stream if seeakable, false to only copy remaining data

Definition at line 92 of file Stream.cs.

                                                                                                    {
             if (entireStream && src.CanSeek) src.Seek(0, SeekOrigin.Begin);
 
             if (src is MemoryStream && src.CanSeek) {
                 try {
                     int pos = (int)src.Position;
                     dest.Write(((MemoryStream)src).GetBuffer(), pos, (int)(src.Length - pos));
                     return;
                 } catch (UnauthorizedAccessException) //If we can't slice it, then we read it like a normal stream
                 { }
             }
             if (dest is MemoryStream && src.CanSeek) {
                 try {
                     int srcPos = (int)src.Position;
                     int pos = (int)dest.Position;
                     int length = (int)(src.Length - srcPos) + pos;
                     dest.SetLength(length);
 
                     var data = ((MemoryStream)dest).GetBuffer();
                     while (pos < length) {
                         pos += src.Read(data, pos, length - pos);
                     }
                     return;
                 } catch (UnauthorizedAccessException) //If we can't write directly, fall back
                 { }
             }
             int size = (src.CanSeek) ? Math.Min((int)(src.Length - src.Position), chunkSize) : chunkSize;
             byte[] buffer = new byte[size];
             int n;
             do {
                 n = src.Read(buffer, 0, buffer.Length);
                 dest.Write(buffer, 0, n);
             } while (n != 0);
         }

The documentation for this class was generated from the following file:

C:/Users/nathanael/Documents/resizer/Core/ExtensionMethods/Stream.cs

Static Public Member Functions

Detailed Description

Member Function Documentation