protected override void Dispose(bool disposing) { try { if (disposing) { _unmanagedStream.Close(); } } finally { base.Dispose(disposing); } }
unsafe public IHttpActionResult Unmanaged() { //使用 UnmanagedMemoryStream 类读取和写入非托管内存。 使用 Marshal 类分配和解除分配非托管内存块。 // Create some data to read and write. byte[] message = UnicodeEncoding.Unicode.GetBytes("Hello Angkor"); // Allocate a block of unmanaged memory and return an IntPtr object. IntPtr memIntPtr = Marshal.AllocHGlobal(message.Length); // Get a byte pointer from the IntPtr object. byte* memBytePtr = (byte*)memIntPtr.ToPointer(); // Create an UnmanagedMemoryStream object using a pointer to unmanaged memory. UnmanagedMemoryStream writeStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Write); // Write the data. writeStream.Write(message, 0, message.Length); // Close the stream. writeStream.Close(); // Create another UnmanagedMemoryStream object using a pointer to unmanaged memory. UnmanagedMemoryStream readStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Read); // Create a byte array to hold data from unmanaged memory. byte[] outMessage = new byte[message.Length]; // Read from unmanaged memory to the byte array. readStream.Read(outMessage, 0, message.Length); // Close the stream. readStream.Close(); // Display the data to the console. var msg = UnicodeEncoding.Unicode.GetString(outMessage); // Free the block of unmanaged memory. Marshal.FreeHGlobal(memIntPtr); return Json(msg); }
internal SessionStateStoreData DoGet(HttpContext context, String id, UnsafeNativeMethods.StateProtocolExclusive exclusiveAccess, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags) { SessionStateStoreData item = null; UnmanagedMemoryStream stream = null; int contentLength; UnsafeNativeMethods.SessionNDMakeRequestResults results; // Set default return values locked = false; lockId = null; lockAge = TimeSpan.Zero; actionFlags = 0; results.content = IntPtr.Zero; try { MakeRequest(UnsafeNativeMethods.StateProtocolVerb.GET, id, exclusiveAccess, 0, 0, 0, null, 0, s_networkTimeout, out results); switch (results.httpStatus) { case 200: /* item found, deserialize it */ contentLength = results.contentLength; if (contentLength > 0) { try { unsafe { stream = new UnmanagedMemoryStream((byte*)results.content, contentLength); } item = SessionStateUtility.DeserializeStoreData(context, stream, s_configCompressionEnabled); } finally { if(stream != null) { stream.Close(); } } lockId = results.lockCookie; actionFlags = (SessionStateActions) results.actionFlags; } break; case 423: /* state locked, return lock information */ if (0 <= results.lockAge) { if (results.lockAge < Sec.ONE_YEAR) { lockAge = new TimeSpan(0, 0, results.lockAge); } else { lockAge = TimeSpan.Zero; } } else { DateTime now = DateTime.Now; if (0 < results.lockDate && results.lockDate < now.Ticks) { lockAge = now - new DateTime(results.lockDate); } else { lockAge = TimeSpan.Zero; } } locked = true; lockId = results.lockCookie; Debug.Assert((results.actionFlags & (int)SessionStateActions.InitializeItem) == 0, "(results.actionFlags & (int)SessionStateActions.InitializeItem) == 0; uninitialized item cannot be locked"); break; } } finally { if (results.content != IntPtr.Zero) { UnsafeNativeMethods.SessionNDFreeBody(new HandleRef(this, results.content)); } } return item; }
public void Constructor2 () { UnmanagedMemoryStream ums; ums = new UnmanagedMemoryStream(mem_byteptr, length, 999, FileAccess.Read); Assert.IsTrue (ums.CanRead, "#A1"); Assert.IsTrue (ums.CanSeek, "#A2"); Assert.IsFalse (ums.CanWrite, "#A3"); Assert.AreEqual (999, ums.Capacity, "#A4"); Assert.AreEqual (length, ums.Length, "#A5"); Assert.AreEqual (0, ums.Position, "#A6"); ums.Close (); ums = new UnmanagedMemoryStream(mem_byteptr, length, 666, FileAccess.Write); Assert.IsFalse (ums.CanRead, "#B1"); Assert.IsTrue (ums.CanSeek, "#B2"); Assert.IsTrue (ums.CanWrite, "#B3"); Assert.AreEqual (666, ums.Capacity, "#B4"); Assert.AreEqual (length, ums.Length, "#B5"); Assert.AreEqual (0, ums.Position, "#B6"); ums.Close (); ums = new UnmanagedMemoryStream(mem_byteptr, 0, 0, FileAccess.ReadWrite); Assert.IsTrue (ums.CanRead, "#C1"); Assert.IsTrue (ums.CanSeek, "#C2"); Assert.IsTrue (ums.CanWrite, "#C3"); Assert.AreEqual (0, ums.Capacity, "#C4"); Assert.AreEqual (0, ums.Length, "#C5"); Assert.AreEqual (0, ums.Position, "#C6"); ums.Close (); }
public void SetLength_Negative () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); try { ums.SetLength(-1); Assert.Fail ("#1"); } catch (ArgumentOutOfRangeException ex) { // Non-negative number required Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); Assert.IsNotNull (ex.ParamName, "#5"); Assert.AreEqual ("length", ex.ParamName, "#6"); } ums.Close(); }
private Bitmap fetchImage(UnmanagedMemoryStream memStream) { int buffer; string id =""; int width; int height; int max; byte[] rgbValues = null; Bitmap bitmap; do { buffer = memStream.ReadByte(); id += (char)buffer; } while (buffer != '\n' && buffer != ' '); string dimension = ""; do { buffer = memStream.ReadByte(); dimension += (char)buffer; } while (buffer != '\n' && buffer != ' '); width = Convert.ToInt16(dimension); dimension = ""; do { buffer = memStream.ReadByte(); dimension += (char)buffer; } while (buffer != '\n' && buffer != ' '); height = Convert.ToInt16(dimension); string maxRGB = ""; do { buffer = memStream.ReadByte(); maxRGB += (char)buffer; } while (buffer != '\n' && buffer != ' '); max = Convert.ToInt16(maxRGB); rgbValues = new byte[height * width * 3]; for (int i = 0; i < rgbValues.Length; i++) { rgbValues[i] = (byte)memStream.ReadByte(); } memStream.Close(); try { bitmap = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); Rectangle rect = new Rectangle(0, 0, width, height); System.Drawing.Imaging.BitmapData bmpData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat); IntPtr ptr = bmpData.Scan0; byte[] bgrValues = new byte[rgbValues.Length]; for (int i = 0; i < rgbValues.Length; i += 3) { bgrValues[i] = rgbValues[i + 2]; bgrValues[i + 1] = rgbValues[i + 1]; bgrValues[i + 2] = rgbValues[i]; } System.Runtime.InteropServices.Marshal.Copy(bgrValues, 0, ptr, bgrValues.Length); bitmap.UnlockBits(bmpData); return bitmap; } catch (Exception ex) { Console.WriteLine("Error creating new bitmap: " + ex.ToString()); } return null; }
public void WriteByte_Capacity_Exceeded () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, 1, 2, FileAccess.ReadWrite); ums.WriteByte (0x44); ums.WriteByte (0x45); try { ums.WriteByte (0x46); Assert.Fail ("#1"); } catch (NotSupportedException ex) { // Unable to expand length of this stream beyond its capacity Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); } ums.Close(); }
public void SetLength () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); ums.SetLength (length - 1); Assert.AreEqual (capacity, ums.Capacity, "#A1"); Assert.AreEqual (length - 1, ums.Length, "#A2"); Assert.AreEqual (length - 1, ums.Position, "#A3"); ums.SetLength (length + 1); Assert.AreEqual (capacity, ums.Capacity, "#B1"); Assert.AreEqual (length + 1, ums.Length, "#B2"); Assert.AreEqual (length - 1, ums.Position, "#B3"); ums.SetLength (length); Assert.AreEqual (capacity, ums.Capacity, "#C1"); Assert.AreEqual (length, ums.Length, "#C2"); Assert.AreEqual (length - 1, ums.Position, "#C3"); ums.SetLength (0); Assert.AreEqual (capacity, ums.Capacity, "#D1"); Assert.AreEqual (0, ums.Length, "#D2"); Assert.AreEqual (0, ums.Position, "#D3"); ums.SetLength (capacity); Assert.AreEqual (capacity, ums.Capacity, "#E1"); Assert.AreEqual (capacity, ums.Length, "#E2"); Assert.AreEqual (0, ums.Position, "#E3"); ums.Close(); }
public void ReadByte () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); ums.Position = 0; Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#1"); Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#2"); ums.Close(); }
public void WriteByte () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, 3, 5, FileAccess.ReadWrite); ums.WriteByte (testStreamData [0]); Assert.AreEqual (5, ums.Capacity, "#A1"); Assert.AreEqual (1, ums.Position, "#A2"); Assert.AreEqual (3, ums.Length, "#A3"); ums.WriteByte (testStreamData [1]); Assert.AreEqual (5, ums.Capacity, "#B1"); Assert.AreEqual (2, ums.Position, "#B2"); Assert.AreEqual (3, ums.Length, "#B3"); ums.WriteByte (testStreamData [2]); Assert.AreEqual (5, ums.Capacity, "#C1"); Assert.AreEqual (3, ums.Position, "#C2"); Assert.AreEqual (3, ums.Length, "#C3"); ums.WriteByte (testStreamData [3]); Assert.AreEqual (5, ums.Capacity, "#D1"); Assert.AreEqual (4, ums.Position, "#D2"); Assert.AreEqual (4, ums.Length, "#D3"); ums.WriteByte (testStreamData [4]); Assert.AreEqual (5, ums.Capacity, "#E1"); Assert.AreEqual (5, ums.Position, "#E2"); Assert.AreEqual (5, ums.Length, "#E3"); ums.Seek (0, SeekOrigin.Begin); Assert.AreEqual (testStreamData [0], ums.ReadByte (), "#F1"); Assert.AreEqual (testStreamData [1], ums.ReadByte (), "#F2"); Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#F3"); Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#F4"); Assert.AreEqual (testStreamData [4], ums.ReadByte (), "#F5"); ums.Close (); }
public void Read () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); ums.Position = 0; Assert.AreEqual (length / 2, ums.Read (readData, 0, (length / 2)), "#1"); VerifyTestData ("#2", readData, 0, (length / 2)); Assert.AreEqual (length / 2, ums.Position, "#3"); //Seek back to begining ums.Seek (0, SeekOrigin.Begin); //Read complete stream Assert.AreEqual (length, ums.Read (readData, 0, length), "#4"); VerifyTestData ("#5", readData, 0, length); Assert.AreEqual (length, ums.Position, "#6"); //Seek to mid of the stream and read till end ums.Seek ((length / 2), SeekOrigin.Begin); ums.Read (readData, 0, (length / 2)); VerifyTestData ("#7", readData, (length / 2), (length / 2)); Assert.AreEqual (length, ums.Position, "#8"); ums.Close (); }
public void Read_EndOfStream () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, length * 2, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); Assert.AreEqual (0, ums.Read (readData, 0, 1), "#1"); ums.Seek(length + 1, SeekOrigin.Begin); Assert.AreEqual (0, ums.Read (readData, 0, 1), "#2"); ums.Seek(length - 3, SeekOrigin.Begin); Assert.AreEqual (3, ums.Read (readData, 0, 5), "#3"); ums.Seek(capacity + 1, SeekOrigin.Begin); Assert.AreEqual (0, ums.Read (readData, 0, 1), "#4"); ums.Close (); }
public void CanWrite_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); Assert.IsTrue (ums.CanWrite, "#1"); ums.Close (); Assert.IsFalse (ums.CanWrite, "#2"); }
public void CanWrite () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); Assert.IsTrue (ums.CanWrite, "#1"); ums.Seek (length, SeekOrigin.Begin); Assert.IsTrue (ums.CanWrite, "#2"); ums.Seek (capacity, SeekOrigin.Begin); Assert.IsTrue (ums.CanWrite, "#3"); ums.Seek (capacity + 1, SeekOrigin.Begin); Assert.IsTrue (ums.CanWrite, "#4"); ums.Seek (0, SeekOrigin.Begin); Assert.IsTrue (ums.CanWrite, "#5"); ums.Close (); }
public void Flush_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close(); ums.Flush(); }
public void Constructor1 () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); Assert.AreEqual ((long) length, ums.Capacity, "#1"); Assert.AreEqual ((long) length, ums.Length, "#2"); Assert.AreEqual (0L, ums.Position, "#3"); ums.Position = (length-2); Assert.AreEqual ((long)(length - 2), ums.Position, "#4"); ums.Position = 0; ums.Seek(3L, SeekOrigin.Begin); Assert.AreEqual (3L, ums.Position, "#5"); Assert.IsTrue (ums.CanRead, "#6"); Assert.IsFalse (ums.CanWrite, "#7"); ums.Close(); }
public void ReadByte_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close(); ums.ReadByte(); }
public void Write_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close(); ums.Write(testStreamData, 0, length); }
public void ReadByte_EndOfStream () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); ums.Position = 0; ums.Seek(length, SeekOrigin.Begin); Assert.AreEqual (-1, ums.ReadByte (), "#3"); ums.Seek(length + 1, SeekOrigin.Begin); Assert.AreEqual (-1, ums.ReadByte (), "#4"); ums.Seek(capacity, SeekOrigin.Begin); Assert.AreEqual (-1, ums.ReadByte (), "#5"); ums.Seek(capacity + 1, SeekOrigin.Begin); Assert.AreEqual (-1, ums.ReadByte (), "#6"); ums.Close(); }
public void WriteByte_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.Write); ums.Close(); ums.WriteByte(0x12); }
public void ReadByte_WriteOnly () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.Write); try { ums.ReadByte (); Assert.Fail ("#1"); } catch (NotSupportedException ex) { // Stream does not support reading Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); } ums.Close(); }
public void WriteByte_Stream_ReadOnly () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); try { ums.WriteByte (testStreamData [0]); Assert.Fail ("#1"); } catch (NotSupportedException ex) { // Stream does not support writing Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); } ums.Close (); }
public void Seek_Origin_Invalid () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, 5, 10, FileAccess.Read); try { ums.Seek(1, (SeekOrigin) 666); Assert.Fail ("#1"); } catch (ArgumentException ex) { // Invalid seek origin Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); Assert.IsNull (ex.ParamName, "#5"); } ums.Close(); }
public void SetLength_Capacity_Exceeded () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); try { ums.SetLength (capacity + 1); Assert.Fail ("#1"); } catch (IOException ex) { // Unable to expand length of this stream beyond its capacity Assert.AreEqual (typeof (IOException), ex.GetType (), "#2"); Assert.IsNull (ex.InnerException, "#3"); Assert.IsNotNull (ex.Message, "#4"); } ums.Close(); }
public void Seek_Offset_Invalid () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); ums.Write (testStreamData, 0, testStreamData.Length); ums.Position = 0; try { ums.Seek(-1, SeekOrigin.Begin); Assert.Fail ("#A1"); } catch (IOException ex) { // An attempt was made to move the position before the beginning // of the stream Assert.AreEqual (typeof (IOException), ex.GetType (), "#A2"); Assert.IsNull (ex.InnerException, "#A3"); Assert.IsNotNull (ex.Message, "#A4"); } ums.Position = 2; try { ums.Seek(-3, SeekOrigin.Current); Assert.Fail ("#B1"); } catch (IOException ex) { // An attempt was made to move the position before the beginning // of the stream Assert.AreEqual (typeof (IOException), ex.GetType (), "#B2"); Assert.IsNull (ex.InnerException, "#B3"); Assert.IsNotNull (ex.Message, "#B4"); } ums.Close(); }
//returns bitmap image converted from the PANGU stream public Bitmap getImage(float x, float y, float z, float yaw, float pitch, float roll , float fov) { try { unsafe { pan_protocol_set_aspect_ratio(sock, 1); //sets aspect ratio pan_protocol_set_boulder_view(sock, 1, 0); //view boulders pan_protocol_set_field_of_view(sock, fov); //set field of view ulong t = 1024; char* img; img = pan_protocol_get_viewpoint_by_angle(sock, x, y, z, yaw, pitch, roll, &t); //gets the image UnmanagedMemoryStream readStream = new UnmanagedMemoryStream((byte*)img, (long)t); Bitmap bitmap = fetchImage(readStream); readStream.Close(); readStream.Dispose(); return bitmap; } } catch { return null; //Error at PANGU end. } }
public void Position_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close(); try { long x = ums.Position; Assert.Fail ("#1: " + x); } catch (ObjectDisposedException) { } try { ums.Position = 0; Assert.Fail ("#2"); } catch (ObjectDisposedException) { } }
public override void Open(string filePath) { _content = File.ReadAllText(filePath); int i = _content.IndexOf("%!"); if (i > 0) { _content = _content.Substring(i, _content.Length - i - 1); } i = _content.IndexOf("%%EOF"); if (i > -1) { _content = _content.Substring(0, i + 5); } if (this.Viewer.EPSClip) { unsafe { fixed (char* p = _content) { UnmanagedMemoryStream ums = new UnmanagedMemoryStream((byte*)p, _content.Length); DSCTokenizer tokenizer = new DSCTokenizer(ums, true, BitConverter.IsLittleEndian); DSCToken token = null; while ((token = tokenizer.GetNextDSCKeywordToken()) != null) { if (token.Text == "%%BoundingBox:") { try { DSCToken v1 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd); DSCToken v2 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd); DSCToken v3 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd); DSCToken v4 = tokenizer.GetNextDSCValueToken(DSCTokenEnding.Whitespace | DSCTokenEnding.LineEnd); this.BoundingBox = new GhostscriptRectangle( float.Parse(v1.Text, System.Globalization.CultureInfo.InvariantCulture), float.Parse(v2.Text, System.Globalization.CultureInfo.InvariantCulture), float.Parse(v3.Text, System.Globalization.CultureInfo.InvariantCulture), float.Parse(v4.Text, System.Globalization.CultureInfo.InvariantCulture)); } catch { } break; } } tokenizer.Dispose(); tokenizer = null; ums.Close(); ums.Dispose(); ums = null; } } } this.FirstPageNumber = 1; this.LastPageNumber = 1; }
public void Write () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite); ums.Write (testStreamData, 0, length); Assert.AreEqual (capacity, ums.Capacity, "#A1"); Assert.AreEqual (length, ums.Position, "#A2"); Assert.AreEqual (length, ums.Length, "#A3"); ums.Position = 0; ums.Read (readData, 0, length); Assert.AreEqual (capacity, ums.Capacity, "#B1"); Assert.AreEqual (length, ums.Position, "#B2"); Assert.AreEqual (length, ums.Length, "#B3"); VerifyTestData ("#B4", readData, 0, length); ums.Write (testStreamData, 2, 2); Assert.AreEqual (capacity, ums.Capacity, "#C1"); Assert.AreEqual (length + 2, ums.Position, "#C1"); Assert.AreEqual (length + 2, ums.Length, "#C2"); ums.Position = length; Assert.AreEqual (testStreamData [2], ums.ReadByte (), "#D1"); Assert.AreEqual (testStreamData [3], ums.ReadByte (), "#D2"); ums.Close(); }
public void Seek_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close (); ums.Seek (0, SeekOrigin.Begin); }
public void PositionPointer_Stream_Closed () { UnmanagedMemoryStream ums = new UnmanagedMemoryStream(mem_byteptr, length); ums.Close(); try { byte* bptr = ums.PositionPointer; Assert.Fail ("#1"); } catch (ObjectDisposedException) { } try { // position pointer to somewhere within the capacity ums.PositionPointer = (byte*) (capacity - 1); Assert.Fail ("#2"); } catch (ObjectDisposedException) { } }