692 lines
24 KiB
C#
692 lines
24 KiB
C#
|
//------------------------------------------------------------------------------
|
||
|
|
// <copyright file="DbBuffer.cs" company="Microsoft">
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
// </copyright>
|
||
|
|
// <owner current="true" primary="true">[....]</owner>
|
||
|
|
//------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
namespace System.Data.ProviderBase
|
||
|
|
{
|
||
|
|
using System;
|
||
|
|
using System.Data.Common;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Runtime.CompilerServices;
|
||
|
|
using System.Runtime.ConstrainedExecution;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
using System.Security;
|
||
|
|
using System.Security.Permissions;
|
||
|
|
using System.Threading;
|
||
|
|
|
||
|
|
// DbBuffer is abstract to require derived class to exist
|
||
|
|
// so that when debugging, we can tell the difference between one DbBuffer and another
|
||
|
|
internal abstract class DbBuffer : SafeHandle {
|
||
|
|
|
||
|
|
internal const int LMEM_FIXED = 0x0000;
|
||
|
|
internal const int LMEM_MOVEABLE = 0x0002;
|
||
|
|
internal const int LMEM_ZEROINIT = 0x0040;
|
||
|
|
|
||
|
|
private readonly int _bufferLength;
|
||
|
|
|
||
|
|
private DbBuffer(int initialSize, bool zeroBuffer) : base(IntPtr.Zero, true) {
|
||
|
|
if (0 < initialSize) {
|
||
|
|
int flags = ((zeroBuffer) ? LMEM_ZEROINIT : LMEM_FIXED);
|
||
|
|
|
||
|
|
_bufferLength = initialSize;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {} finally {
|
||
|
|
base.handle = SafeNativeMethods.LocalAlloc(flags, (IntPtr)initialSize);
|
||
|
|
}
|
||
|
|
if (IntPtr.Zero == base.handle) {
|
||
|
|
throw new OutOfMemoryException();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected DbBuffer(int initialSize) : this(initialSize, true) {
|
||
|
|
}
|
||
|
|
|
||
|
|
protected DbBuffer(IntPtr invalidHandleValue, bool ownsHandle) : base(invalidHandleValue, ownsHandle) {
|
||
|
|
}
|
||
|
|
|
||
|
|
private int BaseOffset { get { return 0; } }
|
||
|
|
|
||
|
|
public override bool IsInvalid {
|
||
|
|
get {
|
||
|
|
return (IntPtr.Zero == base.handle);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal int Length {
|
||
|
|
get {
|
||
|
|
return _bufferLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal string PtrToStringUni(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
|
||
|
|
string value = null;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
int length = UnsafeNativeMethods.lstrlenW(ptr);
|
||
|
|
Validate(offset, (2*(length+1)));
|
||
|
|
value = Marshal.PtrToStringUni(ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal String PtrToStringUni(int offset, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
|
||
|
|
string value = null;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
value = Marshal.PtrToStringUni(ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal byte ReadByte(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 1);
|
||
|
|
Debug.Assert(0 == offset%4, "invalid alignment");
|
||
|
|
|
||
|
|
byte value;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
value = Marshal.ReadByte(ptr, offset);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal byte[] ReadBytes(int offset, int length) {
|
||
|
|
byte[] value = new byte[length];
|
||
|
|
return ReadBytes(offset, value, 0, length);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal byte[] ReadBytes(int offset, byte[] destination, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != destination, "null destination");
|
||
|
|
Debug.Assert(startIndex + length <= destination.Length, "destination too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(ptr, destination, startIndex, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return destination;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Char ReadChar(int offset) {
|
||
|
|
short value = ReadInt16(offset);
|
||
|
|
return unchecked((char)value);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal char[] ReadChars(int offset, char[] destination, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != destination, "null destination");
|
||
|
|
Debug.Assert(startIndex + length <= destination.Length, "destination too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(ptr, destination, startIndex, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return destination;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Double ReadDouble(int offset) {
|
||
|
|
Int64 value = ReadInt64(offset);
|
||
|
|
return BitConverter.Int64BitsToDouble(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Int16 ReadInt16(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 2);
|
||
|
|
Debug.Assert(0 == offset%2, "invalid alignment");
|
||
|
|
|
||
|
|
short value;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
value = Marshal.ReadInt16(ptr, offset);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ReadInt16Array(int offset, short[] destination, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != destination, "null destination");
|
||
|
|
Debug.Assert(startIndex + length <= destination.Length, "destination too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(ptr, destination, startIndex, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Int32 ReadInt32(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 4);
|
||
|
|
Debug.Assert(0 == offset%4, "invalid alignment");
|
||
|
|
|
||
|
|
int value;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
value = Marshal.ReadInt32(ptr, offset);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ReadInt32Array(int offset, int[] destination, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 4*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != destination, "null destination");
|
||
|
|
Debug.Assert(startIndex + length <= destination.Length, "destination too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(ptr, destination, startIndex, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Int64 ReadInt64(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 8);
|
||
|
|
Debug.Assert(0 == offset%IntPtr.Size, "invalid alignment");
|
||
|
|
|
||
|
|
long value;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
value = Marshal.ReadInt64(ptr, offset);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal IntPtr ReadIntPtr(int offset) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, IntPtr.Size);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
|
||
|
|
IntPtr value;
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
value = Marshal.ReadIntPtr(ptr, offset);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal unsafe Single ReadSingle(int offset) {
|
||
|
|
Int32 value = ReadInt32(offset);
|
||
|
|
return *(Single*)&value;
|
||
|
|
}
|
||
|
|
|
||
|
|
override protected bool ReleaseHandle() {
|
||
|
|
// NOTE: The SafeHandle class guarantees this will be called exactly once.
|
||
|
|
IntPtr ptr = base.handle;
|
||
|
|
base.handle = IntPtr.Zero;
|
||
|
|
if (IntPtr.Zero != ptr) {
|
||
|
|
SafeNativeMethods.LocalFree(ptr);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void StructureToPtr(int offset, object structure) {
|
||
|
|
Debug.Assert(null != structure, "null structure");
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, Marshal.SizeOf(structure.GetType()));
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.StructureToPtr(structure, ptr, false/*fDeleteOld*/);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteByte(int offset, byte value) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 1);
|
||
|
|
Debug.Assert(0 == offset%4, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
Marshal.WriteByte(ptr, offset, value);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteBytes(int offset, byte[] source, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != source, "null source");
|
||
|
|
Debug.Assert(startIndex + length <= source.Length, "source too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(source, startIndex, ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteCharArray(int offset, char[] source, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != source, "null source");
|
||
|
|
Debug.Assert(startIndex + length <= source.Length, "source too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(source, startIndex, ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteDouble(int offset, Double value) {
|
||
|
|
WriteInt64(offset, BitConverter.DoubleToInt64Bits(value));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteInt16(int offset, short value) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 2);
|
||
|
|
Debug.Assert(0 == offset%2, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
Marshal.WriteInt16(ptr, offset, value);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteInt16Array(int offset, short[] source, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 2*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != source, "null source");
|
||
|
|
Debug.Assert(startIndex + length <= source.Length, "source too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(source, startIndex, ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteInt32(int offset, int value) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 4);
|
||
|
|
Debug.Assert(0 == offset%4, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
Marshal.WriteInt32(ptr, offset, value);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteInt32Array(int offset, int[] source, int startIndex, int length) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
Validate(offset, 4*length);
|
||
|
|
Debug.Assert(0 == offset%ADP.PtrSize, "invalid alignment");
|
||
|
|
Debug.Assert(null != source, "null source");
|
||
|
|
Debug.Assert(startIndex + length <= source.Length, "source too small");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = ADP.IntPtrOffset(DangerousGetHandle(), offset);
|
||
|
|
Marshal.Copy(source, startIndex, ptr, length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteInt64(int offset, long value) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, 8);
|
||
|
|
Debug.Assert(0 == offset%IntPtr.Size, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
Marshal.WriteInt64(ptr, offset, value);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteIntPtr(int offset, IntPtr value) {
|
||
|
|
offset += BaseOffset;
|
||
|
|
ValidateCheck(offset, IntPtr.Size);
|
||
|
|
Debug.Assert(0 == offset%IntPtr.Size, "invalid alignment");
|
||
|
|
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
Marshal.WriteIntPtr(ptr, offset, value);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal unsafe void WriteSingle(int offset, Single value) {
|
||
|
|
WriteInt32(offset, *(Int32*)&value);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void ZeroMemory() {
|
||
|
|
bool mustRelease = false;
|
||
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
||
|
|
try {
|
||
|
|
DangerousAddRef(ref mustRelease);
|
||
|
|
|
||
|
|
IntPtr ptr = DangerousGetHandle();
|
||
|
|
SafeNativeMethods.ZeroMemory(ptr, (IntPtr)Length);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
if (mustRelease) {
|
||
|
|
DangerousRelease();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Guid ReadGuid(int offset) {
|
||
|
|
// faster than Marshal.PtrToStructure(offset, typeof(Guid))
|
||
|
|
byte[] buffer = new byte[16];
|
||
|
|
ReadBytes(offset, buffer, 0, 16);
|
||
|
|
return new Guid(buffer);
|
||
|
|
}
|
||
|
|
internal void WriteGuid(int offset, Guid value) {
|
||
|
|
// faster than Marshal.Copy(value.GetByteArray()
|
||
|
|
StructureToPtr(offset, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal DateTime ReadDate(int offset) {
|
||
|
|
short[] buffer = new short[3];
|
||
|
|
ReadInt16Array(offset, buffer, 0, 3);
|
||
|
|
return new DateTime(
|
||
|
|
unchecked((ushort)buffer[0]), // Year
|
||
|
|
unchecked((ushort)buffer[1]), // Month
|
||
|
|
unchecked((ushort)buffer[2])); // Day
|
||
|
|
}
|
||
|
|
internal void WriteDate(int offset, DateTime value) {
|
||
|
|
short[] buffer = new short[3] {
|
||
|
|
unchecked((short)value.Year),
|
||
|
|
unchecked((short)value.Month),
|
||
|
|
unchecked((short)value.Day),
|
||
|
|
};
|
||
|
|
WriteInt16Array(offset, buffer, 0, 3);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal TimeSpan ReadTime(int offset) {
|
||
|
|
short[] buffer = new short[3];
|
||
|
|
ReadInt16Array(offset, buffer, 0, 3);
|
||
|
|
return new TimeSpan(
|
||
|
|
unchecked((ushort)buffer[0]), // Hours
|
||
|
|
unchecked((ushort)buffer[1]), // Minutes
|
||
|
|
unchecked((ushort)buffer[2])); // Seconds
|
||
|
|
}
|
||
|
|
internal void WriteTime(int offset, TimeSpan value) {
|
||
|
|
short[] buffer = new short[3] {
|
||
|
|
unchecked((short)value.Hours),
|
||
|
|
unchecked((short)value.Minutes),
|
||
|
|
unchecked((short)value.Seconds),
|
||
|
|
};
|
||
|
|
WriteInt16Array(offset, buffer, 0, 3);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal DateTime ReadDateTime(int offset) {
|
||
|
|
short[] buffer = new short[6];
|
||
|
|
ReadInt16Array(offset, buffer, 0, 6);
|
||
|
|
int ticks = ReadInt32(offset + 12);
|
||
|
|
DateTime value = new DateTime(
|
||
|
|
unchecked((ushort)buffer[0]), // Year
|
||
|
|
unchecked((ushort)buffer[1]), // Month
|
||
|
|
unchecked((ushort)buffer[2]), // Day
|
||
|
|
unchecked((ushort)buffer[3]), // Hours
|
||
|
|
unchecked((ushort)buffer[4]), // Minutes
|
||
|
|
unchecked((ushort)buffer[5])); // Seconds
|
||
|
|
return value.AddTicks(ticks / 100);
|
||
|
|
}
|
||
|
|
internal void WriteDateTime(int offset, DateTime value) {
|
||
|
|
int ticks = (int)(value.Ticks % 10000000L)*100;
|
||
|
|
short[] buffer = new short[6] {
|
||
|
|
unchecked((short)value.Year),
|
||
|
|
unchecked((short)value.Month),
|
||
|
|
unchecked((short)value.Day),
|
||
|
|
unchecked((short)value.Hour),
|
||
|
|
unchecked((short)value.Minute),
|
||
|
|
unchecked((short)value.Second),
|
||
|
|
};
|
||
|
|
WriteInt16Array(offset, buffer, 0, 6);
|
||
|
|
WriteInt32(offset + 12, ticks);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal Decimal ReadNumeric(int offset) {
|
||
|
|
byte[] bits = new byte[20];
|
||
|
|
ReadBytes(offset, bits, 1, 19);
|
||
|
|
|
||
|
|
int[] buffer = new int[4];
|
||
|
|
buffer[3] = ((int) bits[2]) << 16; // scale
|
||
|
|
if (0 == bits[3]) {
|
||
|
|
buffer[3] |= unchecked((int)0x80000000); //sign
|
||
|
|
}
|
||
|
|
buffer[0] = BitConverter.ToInt32(bits, 4); // low
|
||
|
|
buffer[1] = BitConverter.ToInt32(bits, 8); // mid
|
||
|
|
buffer[2] = BitConverter.ToInt32(bits, 12); // high
|
||
|
|
if (0 != BitConverter.ToInt32(bits, 16)) {
|
||
|
|
throw ADP.NumericToDecimalOverflow();
|
||
|
|
}
|
||
|
|
return new Decimal(buffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void WriteNumeric(int offset, Decimal value, byte precision) {
|
||
|
|
int[] tmp = Decimal.GetBits(value);
|
||
|
|
byte[] buffer = new byte[20];
|
||
|
|
|
||
|
|
buffer[1] = precision;
|
||
|
|
Buffer.BlockCopy(tmp, 14, buffer, 2, 2); // copy sign and scale
|
||
|
|
buffer[3] = (Byte) ((0 == buffer[3]) ? 1 : 0); // flip sign for native
|
||
|
|
Buffer.BlockCopy(tmp, 0, buffer, 4, 12);
|
||
|
|
buffer[16] = 0;
|
||
|
|
buffer[17] = 0;
|
||
|
|
buffer[18] = 0;
|
||
|
|
buffer[19] = 0;
|
||
|
|
WriteBytes(offset, buffer, 1, 19);
|
||
|
|
}
|
||
|
|
|
||
|
|
[ConditionalAttribute("DEBUG")]
|
||
|
|
protected void ValidateCheck(int offset, int count) {
|
||
|
|
Validate(offset, count);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void Validate(int offset, int count) {
|
||
|
|
if ((offset < 0) || (count < 0) || (Length < checked(offset + count))) {
|
||
|
|
throw ADP.InternalError(ADP.InternalErrorCode.InvalidBuffer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|