public void FillToBrinkReceiveAndFillAgain()
{
System.Diagnostics.Debug.WriteLine("FillToBrinkReceiveAndFillAgain");
var initialSize = 24;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
// Note that each enqueue operation writes 8 bytes (4 for data and 4 for its length)
byte[] testData = { 1, 2, 3, 4 }; // 4 + 4
writeQueue.Enqueue(testData); // 8 bytes filled
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData2 = { 5, 6, 7, 8 }; // 4 + 4
writeQueue.Enqueue(testData2); // 16 bytes filled
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData3 = { 9, 10, 11, 12 }; // 4 + 4
writeQueue.Enqueue(testData3); // 24 bytes filled
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
var receivedData = readQueue.Dequeue();
Assert.Equal(testData, receivedData);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData4 = { 1, 2, 3, 4 }; // 4 + 4
writeQueue.Enqueue(testData4); // 8 bytes filled in the overflow
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
var receivedData2 = readQueue.Dequeue();
Assert.Equal(testData2, receivedData2);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData5 = { 5, 6, 7, 8 }; // 4 + 4
writeQueue.Enqueue(testData5); // 16 bytes filled in the overflow
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
var receivedData3 = readQueue.Dequeue();
Assert.Equal(testData3, receivedData3);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
}
}
}
public void TestCreateProducer1()
{
using (var queue = MemoryMappedQueue.Create("Foo"))
using (var producer = queue.CreateProducer())
{
producer.Should().NotBeNull();
}
}
public void TestCreateConsumer1()
{
using (var queue = MemoryMappedQueue.Create("Foo"))
using (var consumer = queue.CreateConsumer())
{
consumer.Should().NotBeNull();
}
}
public void TestCreateQueue1()
{
using (var queue = MemoryMappedQueue.Create("Foobar"))
{
queue.Should().NotBeNull();
new Action(() => MemoryMappedFile.CreateNew("Foobar", 123))
.ShouldThrow <IOException>("because Create() is supposed to create an underlying memor mapped file");
}
}
public void TestDequeue1()
{
using (var queue = MemoryMappedQueue.Create("Test1"))
using (var consumer = queue.CreateConsumer())
{
new Action(() => consumer.Dequeue(TimeSpan.Zero)).ShouldThrow <TimeoutException>();
byte[] unused;
consumer.TryDequeue(out unused, TimeSpan.Zero).Should().BeFalse();
}
}
[InlineData(5 * 1024 * 1024)] // 5 MB
public void InitializeTest(int initialSize)
{
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
var test = readQueue.GetHashCode();
}
}
}
public void QueueRefusesNullArray(byte[] testData)
{
var initialSize = 24;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
Assert.Throws(typeof(ArgumentNullException), () => writeQueue.Enqueue(testData));
}
}
}
private static void TestDequeue(string threadNum)
{
using (var consumer = MemoryMappedQueue.CreateConsumer("UniqueName"))
{
while (true)
{
var message = consumer.Dequeue();
var text = Encoding.UTF8.GetString(message);
Console.WriteLine($"\t\t\t\t\t\t {threadNum} read message from memory : {text}");
}
}
}
public void TestDequeue3()
{
using (var queue = MemoryMappedQueue.Create("dawawdawd"))
using (var consumer = queue.CreateConsumer())
{
consumer.Dispose();
new Action(() => consumer.Dequeue())
.ShouldThrow <ObjectDisposedException>("because the consumer has been disposed of");
byte[] unused;
new Action(() => consumer.TryDequeue(out unused))
.ShouldThrow <ObjectDisposedException>("because the consumer has been disposed of");
}
}
public void TooMuchAtOnce()
{
var initialSize = 16; // dataSize of 12 will hit the limit
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = new byte[13]; // 13(dataSize) + 4
Assert.Throws(typeof(OutOfMemoryException), () => writeQueue.Enqueue(testData));
}
}
}
public void OperationPermissionTest()
{
var initialSize = 50;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
Assert.Throws(typeof(InvalidOperationException), () => writeQueue.Dequeue());
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
Assert.Throws(typeof(InvalidOperationException), () => readQueue.Enqueue(null));
}
}
}
public void TestDequeue2()
{
using (var queue = MemoryMappedQueue.Create("Test1"))
using (var producer = queue.CreateProducer())
using (var consumer = queue.CreateConsumer())
{
byte[] message;
consumer.TryDequeue(out message, TimeSpan.FromMilliseconds(1)).Should().BeFalse();
producer.Enqueue(new byte[] { 1, 2, 3, 4 });
consumer.TryDequeue(out message).Should().BeTrue();
message.Should().Equal(new byte[] { 1, 2, 3, 4 });
}
}
public void OutOfMemory()
{
var initialSize = 16;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = new byte[5]; // 5 + 4
writeQueue.Enqueue(testData);
Assert.Throws(typeof(OutOfMemoryException), () => writeQueue.Enqueue(testData));
}
}
}
public void EmptyQueueGivesNull()
{
var initialSize = 50;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
var receivedData = readQueue.Dequeue();
Assert.Null(receivedData);
}
}
}
public void QueueRefusesEmptyString(string input)
{
var initialSize = 1000;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = new byte[input.Length * sizeof(char)];
Buffer.BlockCopy(input.ToCharArray(), 0, testData, 0, testData.Length);
Assert.Throws(typeof(ArgumentNullException), () => writeQueue.Enqueue(testData));
}
}
}
public static ExclusiveMutex TryAcquire()
{
IMemoryMappedQueue queue = null;
try
{
queue = MemoryMappedQueue.Create(QueueName);
return(new ExclusiveMutex(queue));
}
catch (Exception)
{
queue?.Dispose();
return(null);
}
}
//传入命令消息
private static void TestEnqueue(string threadNum, int num)
{
for (var i = 0; i < 100; i++)
{
var singDemo = Singleton.Instance;
var message = new MessageStructure()
{
ManagedThreadId = Thread.CurrentThread.ManagedThreadId,
CommandMessage = $"{threadNum}--{num + i + 1}",
TimeoutMillisecond = 5000
};
singDemo.SendMessage(message, out var sharedMemoryName);
var startTime = DateTime.Now;
using (var queue = MemoryMappedQueue.CreateOrOpen(sharedMemoryName))
{
while (DateTime.Now - startTime < TimeSpan.FromMilliseconds(message.TimeoutMillisecond + 1000))
{
try
{
using (var consumer = MemoryMappedQueue.CreateConsumer(sharedMemoryName))
{
if (!consumer.TryDequeue(out var resultMessage))
{
continue;
}
var text = Encoding.UTF8.GetString(resultMessage);
var messageObj = JsonConvert.DeserializeObject <MessageStructure>(text);
if (messageObj.IsTimeout)
{
Console.WriteLine($"[{threadNum}] time out :{text} ");
break;
}
Console.WriteLine($"[{threadNum}] TestEnqueue : {text}");
break;
}
}
catch (Exception)
{
continue;
}
}
}
}
}
public void EncodedStringTransfer(string input)
{
var initialSize = 1000;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = System.Text.Encoding.Unicode.GetBytes(input);
writeQueue.Enqueue(testData);
var receivedData = readQueue.Dequeue();
var receivedString = System.Text.Encoding.Unicode.GetString(receivedData);
Assert.Equal(input, receivedString);
}
}
}
public void SimpleDataTransfer()
{
var initialSize = 50;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = new byte[3];
writeQueue.Enqueue(testData);
var receivedData = readQueue.Dequeue();
Assert.Equal(testData, receivedData);
}
}
}
public void TestEnqueueDequeue1([Values(new byte[] { 1 },
new byte[] { 42, 99 },
new byte[] { 200, 91, 12 },
new byte[] { 0, 1, 44, 125, 231, 200, 100 })] byte[] message)
{
using (var queue = MemoryMappedQueue.Create("Test1"))
using (var producer = MemoryMappedQueue.CreateProducer("Test1"))
using (var consumer = queue.CreateConsumer())
{
producer.Enqueue(message);
var actualMessage = consumer.Dequeue();
actualMessage.Should().NotBeNull();
actualMessage.Should().NotBeSameAs(message);
actualMessage.Should().Equal(message);
}
}
public void QueueAcceptsZeros()
{
var initialSize = 24;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
// Note that each enqueue operation writes 8 bytes (4 for data and 4 for its length)
byte[] testData = { 0 }; // 4 + 1
writeQueue.Enqueue(testData); // 5 bytes filled
var receivedData = readQueue.Dequeue();
Assert.Equal(testData, receivedData);
}
}
}
private void Run()
{
using (var consumer = MemoryMappedQueue.CreateConsumer("UniqueName"))
{
while (true)
{
if (!consumer.TryDequeue(out var message))
{
continue;
}
var text = Encoding.UTF8.GetString(message);
var messageStructure = JsonConvert.DeserializeObject <MessageStructure>(text);
++_uId;
ResultData(messageStructure);
}
}
}
public void TestEnqueueDequeueMany()
{
using (var queue = MemoryMappedQueue.Create("Test1"))
using (var producer = queue.CreateProducer())
using (var consumer = MemoryMappedQueue.CreateConsumer("Test1"))
{
const int messageLength = 512;
const int numMessages = 1000;
for (int i = 0; i < numMessages; ++i)
{
var message = Enumerable.Range(0, messageLength).Select(n => (byte)(n % 255)).ToArray();
producer.Enqueue(message);
var actualMessage = consumer.Dequeue();
actualMessage.Should().Equal(message);
}
}
}
public void MultipleDataTransfersWithOverflow()
{
System.Diagnostics.Debug.WriteLine("MultipleDataTransfersWithOverflow");
var initialSize = 32;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = { 1, 2, 3, 4, 5, 6, 7, 8 }; // 8 + 4
writeQueue.Enqueue(testData); // 12 B filled
var receivedData = readQueue.Dequeue();
Assert.Equal(testData, receivedData);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData2 = { 9, 10, 11, 12, 13, 14, 15, 16 }; // 8 + 4
writeQueue.Enqueue(testData2); // 24 B filled
var receivedData2 = readQueue.Dequeue();
Assert.Equal(testData2, receivedData2);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData3 = { 17, 18, 19, 20 }; // 4 + 4
writeQueue.Enqueue(testData3); // 32 B filled
var receivedData3 = readQueue.Dequeue();
Assert.Equal(testData3, receivedData3);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
byte[] testData4 = { 21, 22, 23, 24 }; // 4 + 4
writeQueue.Enqueue(testData4); // 40 B filled
var receivedData4 = readQueue.Dequeue();
Assert.Equal(testData4, receivedData4);
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
}
}
}
public void MultipleDataTransfersOutOfMemory()
{
var initialSize = 24;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = { 1, 2, 3, 4 }; // 4 + 4
writeQueue.Enqueue(testData); // 8 bytes filled
byte[] testData2 = { 5, 6, 7, 8 }; // 4 + 4
writeQueue.Enqueue(testData2); // 16 bytes filled
byte[] testData3 = { 9, 10, 11, 12, 0 }; // 5 + 4
Assert.Throws(typeof(OutOfMemoryException), () => writeQueue.Enqueue(testData3)); // 25 bytes filled
}
}
}
private static void TestEnqueue(string threadNum)
{
using (var queue = MemoryMappedQueue.Create("UniqueName"))
{
using (var producer = queue.CreateProducer())
{
var num = 1;
while (true)
{
var test = $"Hello,{threadNum}!{++num}";
var message = Encoding.UTF8.GetBytes(test);
producer.Enqueue(message);
Console.WriteLine($"{threadNum} enqueue to memory : {test}");
Thread.Sleep(10);
}
}
}
}
public void StructTransfer()
{
System.Diagnostics.Debug.WriteLine("StructTransfer");
var initialSize = 1000;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
List <double> numbers = new List <double>();
List <double> receivedNumbers;
for (int i = 0; i < 5; i++)
{
numbers.Add(Math.PI * i);
}
byte[] testData;;
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
bf.Serialize(ms, numbers);
testData = ms.ToArray();
}
writeQueue.Enqueue(testData);
var receivedData = readQueue.Dequeue();
System.Diagnostics.Debug.WriteLine(writeQueue.Diagnostics());
System.Diagnostics.Debug.WriteLine(readQueue.Diagnostics());
using (MemoryStream ms = new MemoryStream())
{
ms.Write(receivedData, 0, receivedData.Length);
ms.Seek(0, SeekOrigin.Begin);
receivedNumbers = (List <double>)bf.Deserialize(ms);
}
Assert.Equal(numbers, receivedNumbers);
}
}
}
private void ResultData(MessageStructure messageStructure)
{
Task.Factory.StartNew(() =>
{
//模拟逻辑处理所用时间
{
Thread.Sleep(20);
}
_useTime = (DateTime.Now - _startTime).TotalMilliseconds;
messageStructure.ResultMessage = $"ResultData -> uId : {_uId} , useTime : {_useTime}";
messageStructure.IsTimeout = false;
}).Wait(messageStructure.TimeoutMillisecond);
var queue = MemoryMappedQueue.CreateOrOpen(messageStructure.SharedMemoryName);
var producer = queue.CreateProducer();
var message = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageStructure));
producer.Enqueue(message);
}
public void PrimitiveStringTransfer(string input)
{
var initialSize = 1000;
using (var writeQueue = new MemoryMappedQueue(initialSize, true, AccessName))
{
using (var readQueue = new MemoryMappedQueue(initialSize, false, AccessName))
{
byte[] testData = new byte[input.Length * sizeof(char)];
Buffer.BlockCopy(input.ToCharArray(), 0, testData, 0, testData.Length);
writeQueue.Enqueue(testData);
var receivedData = readQueue.Dequeue();
var receivedCharacters = new char[receivedData.Length / sizeof(char)];
Buffer.BlockCopy(receivedData, 0, receivedCharacters, 0, receivedData.Length);
var receivedString = new string(receivedCharacters);
Assert.Equal(input, receivedString);
}
}
}
