public void TestSeekAfterEnd()
{
MemoryMappedFile mmf = MemoryMappedFile.CreateInMemoryMap();
Assert.IsNotNull(mmf);
ArgumentOutOfRangeException expected = null;
try
{
mmf.Seek(1, SeekOrigin.End);
}
catch (ArgumentOutOfRangeException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
expected = null;
try
{
mmf.Seek(MemoryMappedFile.DefaultInMemoryMapSize + 1, SeekOrigin.Begin);
}
catch (ArgumentOutOfRangeException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public void TestPositionPositive()
{
MemoryMappedFile mmf = MemoryMappedFile.CreateInMemoryMap();
Assert.IsNotNull(mmf);
mmf.Position = 100;
Assert.AreEqual(mmf.Position, 100, "Failed to set Position");
mmf.Seek(100, SeekOrigin.Current);
Assert.AreEqual(mmf.Position, 200, "Failed Seek from current");
}
private void ReadProc()
{
var lengthBuffer = new byte[4];
var dataBuffer = new byte[m_mmf.Length - 4];
while (true)
{
// use a timeout so if the app ends, this thread can exit
if (!m_dataReady.WaitOne(1000, false))
{
continue;
}
// avoid receiving our own data
if (Sending)
{
// wait long enough for the sender to reset the m_dataReady flag
Thread2.Sleep(5);
continue;
}
// grab the mutex to prevent concurrency issues
m_mutex.WaitOne(1000, false);
// read from the start
m_mmf.Seek(0, System.IO.SeekOrigin.Begin);
// get the length
m_mmf.Read(lengthBuffer, 0, 4);
var length = BitConverter.ToInt32(lengthBuffer, 0);
// get the data
m_mmf.Read(dataBuffer, 0, length);
// release the mutex so any other clients can receive
m_mutex.ReleaseMutex();
// convert to a string
var received = Encoding.ASCII.GetString(dataBuffer, 0, length);
Console.WriteLine("Received: " + received);
Debug.WriteLine("Received: " + received);
}
}
public void TestBasicReadWritePositive()
{
MemoryMappedFile mmf = MemoryMappedFile.CreateInMemoryMap();
Assert.IsNotNull(mmf);
string sourceString = "This is some test data";
byte[] outdata = Encoding.ASCII.GetBytes(sourceString);
mmf.Write(outdata, 0, outdata.Length);
mmf.Seek(-outdata.Length, SeekOrigin.Current);
byte[] indata = new byte[outdata.Length];
mmf.Read(indata, 0, indata.Length);
string targetString = Encoding.ASCII.GetString(indata, 0, indata.Length);
Assert.AreEqual(sourceString, targetString);
}
public void TestSeekPositive()
{
MemoryMappedFile mmf = MemoryMappedFile.CreateInMemoryMap();
Assert.IsNotNull(mmf);
// begin - from begin
mmf.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(mmf.Position, 0, "Failed Seek begin from begin");
// the middle - from begin
long offset = mmf.Length / 2;
mmf.Seek(offset, SeekOrigin.Begin);
Assert.AreEqual(mmf.Position, offset, "Failed Seek middle from begin");
// end - from begin
mmf.Seek(MemoryMappedFile.DefaultInMemoryMapSize, SeekOrigin.Begin);
Assert.AreEqual(mmf.Position, MemoryMappedFile.DefaultInMemoryMapSize, "Failed Seek end from begin");
// begin - from end
mmf.Seek(-MemoryMappedFile.DefaultInMemoryMapSize, SeekOrigin.End);
Assert.AreEqual(mmf.Position, 0, "Failed Seek begin from end");
// middle - from end
mmf.Seek(-offset, SeekOrigin.End);
Assert.AreEqual(mmf.Position, offset, "Failed Seek middle from end");
// end - from end
mmf.Seek(0, SeekOrigin.End);
Assert.AreEqual(mmf.Position, MemoryMappedFile.DefaultInMemoryMapSize, "Failed Seek end from end");
mmf.Seek(offset, SeekOrigin.Begin);
mmf.Seek(-offset, SeekOrigin.Current);
Assert.AreEqual(mmf.Position, 0, "Failed Seek begin from current");
mmf.Close();
}
public static string readMemFile()
{
m_mmf = MemoryMappedFile.CreateInMemoryMap(SharedMapName, MaxMapSize);
// grab the mutex to prevent concurrency issues
if (!m_mutex.WaitOne(1000, false))
{
Debug.WriteLine("Unable to acquire mutex. read Abandoned");
return "@ERROR";
}
// read from the start
m_mmf.Seek(0, System.IO.SeekOrigin.Begin);
// get the length
m_mmf.Read(dataBuffer, 0, MaxMapSize);
int i;
for (i = 0; i < MaxMapSize; ++i)
{
if (dataBuffer[i] == 0)
{
if ((dataBuffer[i + 1] | dataBuffer[i + 2] | dataBuffer[i + 3] |
dataBuffer[i + 4] | dataBuffer[i + 5] | dataBuffer[i + 6] | dataBuffer[i + 7]) == 0)
break;
}
}
string received = Encoding.UTF8.GetString(dataBuffer, 0, i);
// release the mutex so any other clients can receive
m_mutex.ReleaseMutex();
Debug.WriteLine("Received: " + received);
return received;
}
byte[] ReadFileBytes(long Position, long Size)
{
if (FileBytes != null)
{
return(FileBytes.SubArray(Position, Size));
}
#if USE_MEMORY_MAPPED_FILE
var Data = new byte[Size];
// gr: [on OSX at least] you can read past the file size, (but within capacity)
// this doesn't error, but does fill the bytes with zeros.
var BytesRead = FileView.ReadArray(Position, Data, 0, (int)Size);
if (BytesRead != Size)
{
throw new System.Exception("Memory mapped file only read " + BytesRead + "/" + Size + " bytes");
}
return(Data);
#elif USE_FILE_HANDLE
var Data = new byte[Size];
var NewPos = File.Seek(Position, System.IO.SeekOrigin.Begin);
if (NewPos != Position)
{
throw new System.Exception("Seeked to " + Position + " but stream is at " + NewPos);
}
var BytesRead = File.Read(Data, 0, (int)Size);
if (BytesRead != Size)
{
throw new System.Exception("FileStream only read " + BytesRead + "/" + Size + " bytes");
}
return(Data);
#elif USE_JAVA_FILEHANDLE
return(File.ReadBytes(Position, Size));
#else
return(FileBytes.SubArray(Position, Size));
#endif
}
public void Run()
{
var processName = Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().GetName().CodeBase);
// create the MMF
m_mmf = MemoryMappedFile.CreateInMemoryMap(SharedMapName, MaxMapSize);
// create a shared mutex
m_mutex = new NamedMutex(false, SharedMutexName);
// create a data-ready event
m_dataReady = new EventWaitHandle(false, EventResetMode.ManualReset, DataReadyEventName);
// fire up a "listener"
new System.Threading.Thread(ReadProc)
{
IsBackground = true,
Name = "MMF Peer Reader"
}
.Start();
Console.WriteLine("Memory Mapped File Created. Enter text to send to peer(s)");
// wait for user input
while (true)
{
var input = Console.ReadLine();
if (input == null)
{
Thread2.Sleep(5000);
input = GetMockInput();
Debug.WriteLine(string.Format("Platform does not have a Console installed. Sending mock data '{0}'", input));
}
if (input == "exit")
{
break;
}
// prefix our process name so we can tell who sent the data
input = processName + ":" + input;
// grab the mutex
if (!m_mutex.WaitOne(5000, false))
{
Console.WriteLine("Unable to acquire mutex. Send Abandoned");
Debug.WriteLine("Unable to acquire mutex. Send Abandoned");
continue;
}
// mark as "sending" so the listener will ignore what we send
Sending = true;
// create a "packet" (length + data)
var packet = new byte[4 + input.Length];
Buffer.BlockCopy(BitConverter.GetBytes(input.Length), 0, packet, 0, 4);
Buffer.BlockCopy(Encoding.ASCII.GetBytes(input), 0, packet, 4, input.Length);
// write the packet at the start
m_mmf.Seek(0, System.IO.SeekOrigin.Begin);
m_mmf.Write(packet, 0, packet.Length);
// notify all clients that data is ready (manual reset events will release all waiting clients)
m_dataReady.Set();
// yield to allow the receiver to unblock and check the "Sending" flag
Thread2.Sleep(1);
// reset the event
m_dataReady.Reset();
// unmark "sending"
Sending = false;
// release the mutex
m_mutex.ReleaseMutex();
}
}
