| private Write ( byte buffer, int offset, int count ) : void | ||
| buffer | byte | |
| offset | int | |
| count | int | |
| Résultat | void | |
public unsafe void Write(Stream value)
{
if (value.Length > _availableLength)
throw new ArgumentException("Value is too long.");
var buffer = new byte[4096];
var lengthToWrite = value.Length;
while (lengthToWrite > 0)
{
using (var stream = new UnmanagedMemoryStream(_currentPointer.Value.Ptr, _currentPointer.Value.AvailableLength, _currentPointer.Value.AvailableLength, FileAccess.ReadWrite))
{
do
{
var read = value.Read(buffer, 0, Math.Min(buffer.Length, _currentPointer.Value.AvailableLength));
stream.Write(buffer, 0, read);
lengthToWrite -= read;
_currentPointer.Value.AvailableLength -= read;
}
while (_currentPointer.Value.AvailableLength > 0 && lengthToWrite > 0);
_currentPointer = _currentPointer.Next;
}
}
}
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);
}
public void Write_Count_Overflow ()
{
using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, capacity, FileAccess.ReadWrite)) {
try {
ums.Write (testStreamData, 1, Int32.MaxValue);
Assert.Fail ("#1");
}
catch (ArgumentException ex) {
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNull (ex.ParamName, "#5");
}
}
}
public void Write_Offset_Negative ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, capacity, FileAccess.ReadWrite);
try {
ums.Write (testStreamData, -1, testStreamData.Length);
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 ("offset", ex.ParamName, "#6");
}
ums.Close();
}
unsafe void SaveMessage(byte[] message)
{
// 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();
}
private static unsafe void ThreadFunc()
{
try
{
int size = 65536;
bool createdMain = false;
var hFile = WinAPI.OpenFileMapping(
WinAPI.FileMapAccess.FileMapAllAccess,
false,
"ulHelper_fm");
if (hFile == IntPtr.Zero)
{
hFile = WinAPI.CreateFileMapping(
new IntPtr(-1),
IntPtr.Zero,
WinAPI.FileMapProtection.PageReadWrite,
(uint)0, (uint)size,
"ulHelper_fm");
createdMain = true;
}
var lpBaseAddress = WinAPI.MapViewOfFile(
hFile,
WinAPI.FileMapAccess.FileMapAllAccess,
0, 0, 0);
Mutex = new Mutex(false, "ulHelper_mutex");
Stream = new UnmanagedMemoryStream((byte*)lpBaseAddress.ToPointer(), size, size, FileAccess.ReadWrite);
eventWH = new EventWaitHandle(false, EventResetMode.AutoReset, "ulHelper_event");
int accCount;
byte[] buf = new byte[size];
if (createdMain)
{
Mutex.WaitOne();
try
{
buf[0] = buf[1] = buf[2] = buf[3] = 0;
Stream.Position = 0;
Stream.Write(buf, 0, 4);
}
finally
{
Mutex.ReleaseMutex();
}
}
eventWH.Set();
while (true)
{
eventWH.WaitOne();
if (MainForm.NeedTerminate)
break;
Mutex.WaitOne();
try
{
Stream.Position = 0;
accCount = Stream.ReadByte();
lock (Accounts.List)
if (Accounts.List.Count != accCount)
{
foreach (var acc in Accounts.List)
acc.Active = false;
for (int i = 0; i < accCount; i++)
{
string accountName = "";
int index = 0;
Stream.Position = 8 + i * 128;
Stream.Read(buf, 0, 128);
while (buf[index] != 0)
accountName += (char)buf[index++];
if (!Accounts.List.Any(acc => acc.Name == accountName))
{
var accData = new AccountData(accountName);
Accounts.List.Add(accData);
}
Accounts.List.First(acc => acc.Name == accountName).Active = true;
}
PerformNewAccount();
}
}
finally
{
Mutex.ReleaseMutex();
}
}
WinAPI.UnmapViewOfFile(lpBaseAddress);
WinAPI.CloseHandle(hFile);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception ex)
{
var f = new ExceptionForm(ex);
f.ShowDialog();
}
}
private void BuildCacheArray()
{
var workItem = GetReaderWorkItem();
try
{
if (workItem.IsMemory)
throw new InvalidOperationException("When trying to build cache, reader worker is already in-memory reader.");
var dataSize = _isReadOnly ? _physicalDataSize + ChunkFooter.MapSize : _chunkHeader.ChunkSize;
_cachedLength = ChunkHeader.Size + dataSize + ChunkFooter.Size;
var cachedData = Marshal.AllocHGlobal(_cachedLength);
try
{
using (var unmanagedStream = new UnmanagedMemoryStream((byte*)cachedData, _cachedLength, _cachedLength, FileAccess.ReadWrite))
{
workItem.Stream.Seek(0, SeekOrigin.Begin);
var buffer = new byte[65536];
// in ongoing chunk there is no need to read everything, it's enough to read just actual data written
int toRead = _isReadOnly ? _cachedLength : ChunkHeader.Size + _physicalDataSize;
while (toRead > 0)
{
int read = workItem.Stream.Read(buffer, 0, Math.Min(toRead, buffer.Length));
if (read == 0)
break;
toRead -= read;
unmanagedStream.Write(buffer, 0, read);
}
}
}
catch
{
Marshal.FreeHGlobal(cachedData);
throw;
}
_cachedData = cachedData;
}
finally
{
ReturnReaderWorkItem(workItem);
}
}
internal UnmanagedMemoryStream ResourceValueAsStream (string name, int index)
{
ResourceInfo ri = infos [index];
if ((PredefinedResourceType)ri.TypeIndex != PredefinedResourceType.Stream)
throw new InvalidOperationException (String.Format ("Resource '{0}' was not a Stream. Use GetObject() instead.", name));
lock (readerLock) {
reader.BaseStream.Seek (ri.ValuePosition, SeekOrigin.Begin);
// here we return a Stream from exactly
// current position so that the returned
// Stream represents a single object stream.
long slen = reader.ReadInt32();
UnmanagedMemoryStream basePtrStream = reader.BaseStream as UnmanagedMemoryStream;
unsafe {
if (basePtrStream != null) {
return new UnmanagedMemoryStream (basePtrStream.PositionPointer, slen);
} else {
IntPtr ptr = Marshal.AllocHGlobal ((int) slen);
byte* addr = (byte*) ptr.ToPointer ();
UnmanagedMemoryStream ms = new UnmanagedMemoryStream (addr, slen, slen, FileAccess.ReadWrite);
// The memory resource must be freed
// when the stream is disposed.
ms.Closed += delegate (object o, EventArgs e) {
Marshal.FreeHGlobal (ptr);
};
byte [] bytes = new byte [slen < 1024 ? slen : 1024];
while (slen > 0 ) {
int x = reader.Read (bytes, 0, (int)Math.Min (bytes.Length, slen));
if (x == 0)
throw new FormatException ("The resource data is corrupt. Resource stream ended");
ms.Write (bytes, 0, x);
slen -= x;
}
ms.Seek (0, SeekOrigin.Begin);
return ms;
}
}
}
}
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 Read_Offset_Overflow ()
{
using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream (mem_byteptr, length, length, FileAccess.ReadWrite)) {
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
try {
ums.Read (readData, Int32.MaxValue, 0);
Assert.Fail ("#1");
}
catch (ArgumentException ex) {
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNull (ex.ParamName, "#5");
}
}
}
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 Read_Count_Overlow ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
try {
ums.Read (readData, 1, readData.Length);
Assert.Fail ("#1");
} catch (ArgumentException ex) {
// Offset and length were out of bounds for the array or count
// is greater than the number of elements from index to the end
// of the source collection
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNull (ex.ParamName, "#5");
}
}
public void Read_Count_Negative ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, length, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, testStreamData.Length);
ums.Position = 0;
try {
ums.Read (readData, 0, -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 ("count", ex.ParamName, "#6");
}
}
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 ATAreadDMA8Mem(UnmanagedMemoryStream pMem, int size)
{
if (((xferMode & 0xF0) == 0x40) &&
(dev9.Dev9Ru16((int)DEV9Header.SPD_R_IF_CTRL) & DEV9Header.SPD_IF_DMA_ENABLE) != 0)
{
//size >>= 1;
Log_Verb("DMA read, size " + size + ", transferred " + rdTransferred + ", total size " + nsector * 512);
Log_Info("rATA");
//read
byte[] temp = new byte[size];
hddImage.Read(temp, 0, size);
pMem.Write(temp, 0, size);
rdTransferred += size;
if (rdTransferred >= nsector * 512)
{
//Set Sector
long currSect = HDD_GetLBA();
currSect += nsector;
HDD_SetLBA(currSect);
nsector = 0;
status = DEV9Header.ATA_STAT_READY | DEV9Header.ATA_STAT_SEEK;
if (sendIRQ) dev9.DEV9irq(3, 1); //0x6c
rdTransferred = 0;
//dev9.Dev9Wu16((int)DEV9Header.SPD_R_IF_CTRL, (UInt16)(dev9.Dev9Ru16((int)DEV9Header.SPD_R_IF_CTRL) & ~DEV9Header.SPD_IF_DMA_ENABLE));
}
}
}
public void Write_Stream_Closed ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
ums.Close();
ums.Write(testStreamData, 0, length);
}
public void Write_Stream_ReadOnly ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length);
try {
ums.Write(testStreamData, 0, length);
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 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 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 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();
}
public override int Read(ObjectId oid, out UnmanagedMemoryStream data, out ObjectType objectType)
{
data = null;
objectType = default(ObjectType);
MockGitObject gitObject;
if (!m_objectIdToContent.TryGetValue(oid, out gitObject))
{
return (int) ReturnCode.GIT_ENOTFOUND;
}
data = Allocate(gitObject.Length);
foreach (var chunk in gitObject.Data)
{
data.Write(chunk, 0, chunk.Length);
}
objectType = gitObject.ObjectType;
return (int)ReturnCode.GIT_OK;
}
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();
}
private void BuildCacheArray()
{
var workItem = GetReaderWorkItem();
if (workItem.IsMemory)
throw new InvalidOperationException("When trying to build cache, reader worker is already in-memory reader.");
try
{
_cachedDataLength = _isReadonly ? _chunkFooter.ActualChunkSize + _chunkFooter.MapSize : _chunkHeader.ChunkSize;
var cachedData = (byte*) Marshal.AllocHGlobal(_cachedDataLength);
try
{
using (var unmanagedStream = new UnmanagedMemoryStream(cachedData,
_cachedDataLength,
_cachedDataLength,
FileAccess.ReadWrite))
{
workItem.Stream.Seek(GetRealPosition(0, inMemory: false), SeekOrigin.Begin);
var buffer = new byte[4096];
int toRead = _cachedDataLength;
while (toRead > 0)
{
int read = workItem.Stream.Read(buffer, 0, Math.Min(toRead, buffer.Length));
if (read == 0)
break;
toRead -= read;
unmanagedStream.Write(buffer, 0, read);
}
}
}
catch
{
Marshal.FreeHGlobal((IntPtr) cachedData);
throw;
}
_cachedData = cachedData;
}
finally
{
ReturnReaderWorkItem(workItem);
}
}
public void Write_Capacity_Exceeded ()
{
UnmanagedMemoryStream ums = new
UnmanagedMemoryStream(mem_byteptr, length, length + 2, FileAccess.ReadWrite);
ums.Write (testStreamData, 0, length);
ums.Write (testStreamData, 0, 2);
try {
ums.Write (testStreamData, 0, 1);
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 override void Write(byte[] buffer, int offset, int count)
{
_unmanagedStream.Write(buffer, offset, count);
}
/// <summary>
/// Writes a sequence of bytes
/// </summary>
/// <param name="Buffer"></param>
/// <param name="BytesToWrite"></param>
/// <param name="AtOffset"></param>
public unsafe void Write(byte[] Buffer, int BytesToWrite, Int64 AtOffset)
{
IntPtr hMVF = IntPtr.Zero;
try
{
Int64 FileMapStart = (AtOffset / _AllocationGranularity) * _AllocationGranularity;
Int64 MapViewSize = (AtOffset % _AllocationGranularity) + _AllocationGranularity;
Int64 iViewDelta = AtOffset - FileMapStart;
hMVF = Win32API.MapViewOfFile(_hMMF, Win32API.FileMapAccess.FileMapWrite, FileMapStart, (Int32)MapViewSize);
if (hMVF == IntPtr.Zero)
throw new Win32Exception();
byte* p = (byte*)hMVF.ToPointer() + iViewDelta;
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(p, MapViewSize, MapViewSize, FileAccess.Write);
ums.Write(Buffer, 0, BytesToWrite);
Win32API.FlushViewOfFile(hMVF, (Int32)MapViewSize);
}
finally
{
if (hMVF != IntPtr.Zero)
Win32API.UnmapViewOfFile(hMVF);
}
}