private SortedDictionary <int, ISerializeDeserialize <T> > BenchmarkSerializers(IEnumerable <Type> listOfSerializers)
{
var benchmarkTimes = new SortedDictionary <int, ISerializeDeserialize <T> >();
foreach (Type type in listOfSerializers)
{
try
{
ISerializeDeserialize <T> serializer = InstantiateSerializer(type);
if (!serializer.CanSerializeType())
{
continue;
}
int count = BenchMarkSerializer(serializer);
if (count > 0)
{
benchmarkTimes.Add(count, serializer);
}
}
catch (Exception)
{
}
}
foreach (var valuePair in benchmarkTimes)
{
Trace.WriteLine(string.Format("{0} : {1}", valuePair.Key, valuePair.Value.GetType()));
}
return(benchmarkTimes);
}
private int BenchMarkSerializer(ISerializeDeserialize <T> serDeser)
{
object[] args = null;
if (typeof(T) == typeof(string))
{
args = new object[] { new[] { 'T', 'e', 's', 't', 'T', 'e', 's', 't', 'T', 'e', 's', 't' } };
}
else if (typeof(T) == typeof(byte[]))
{
byte[] test = new byte[100];
T classInstance = (T)(object)test;
Stopwatch sw = Stopwatch.StartNew();
int count = 0;
while (sw.ElapsedMilliseconds < 500)
{
byte[] bytes = serDeser.ObjectToBytes(classInstance);
serDeser.BytesToObject(bytes);
count++;
}
sw.Stop();
return(count);
}
try
{
T classInstance = (T)Activator.CreateInstance(typeof(T), args);
DataHelper.AssignEmptyData(ref classInstance);
Stopwatch sw = Stopwatch.StartNew();
int count = 0;
while (sw.ElapsedMilliseconds < 500)
{
byte[] bytes = serDeser.ObjectToBytes(classInstance);
serDeser.BytesToObject(bytes);
count++;
}
sw.Stop();
return(count);
}
catch (MissingMethodException)
{
// Missing default constructor
return(0);
}
}
public void BenchmarkSerializeMethod <T>(ISerializeDeserialize <T> serializer, object instance)
{
serializer.ObjectToBytes((T)instance);
Stopwatch timed = new Stopwatch();
timed.Start();
byte[] bytes = null;
for (int x = 0; x < Iterations; x++)
{
bytes = serializer.ObjectToBytes((T)instance);
}
timed.Stop();
Trace.WriteLine("Serialize method: " + serializer.GetType().Name);
Trace.WriteLine(timed.ElapsedMilliseconds + " ms");
Trace.WriteLine("Data size: " + bytes.Length);
Trace.WriteLine("");
}
public Array(long capacity, string path, bool autoGrow, ISerializeDeserialize <T> serializer, IViewManager viewManager)
{
ValueSerializer = serializer;
ViewManager = viewManager;
string fileName;
if (File.Exists(path) || Path.GetExtension(path).Length > 0)
{
fileName = path;
}
else
{
fileName = Path.Combine(path, "mmf-" + Guid.NewGuid() + ".bin");
}
AutoGrow = autoGrow;
InitWorkerBuffers();
ViewManager.Initialize(fileName, capacity, _dataSize);
}
public void BenchmarkDeserializeMethod <T>(ISerializeDeserialize <T> serializer, object instance)
{
var bytes = serializer.ObjectToBytes((T)instance);
serializer.BytesToObject(bytes);
Stopwatch timed = new Stopwatch();
timed.Start();
T value = default(T);
for (int x = 0; x < Iterations; x++)
{
value = serializer.BytesToObject(bytes);
}
timed.Stop();
Trace.WriteLine("Deserialize method: " + serializer.GetType().Name);
Trace.WriteLine(timed.ElapsedMilliseconds + " ms");
Trace.WriteLine(value);
Trace.WriteLine("");
}
static BackingUnknownSize()
{
_keySerializer = _keyFactory.GetSerializer();
_valueSerializer = _valueFactory.GetSerializer();
}
private void InitializeControlFile()
{
if (File.Exists(_controlFile))
{
if (!File.Exists(_hashFile))
{
throw new FileNotFoundException("Hash file is missing");
}
if (!File.Exists(_keyFile))
{
throw new FileNotFoundException("Key file is missing");
}
if (!File.Exists(_valueFile))
{
throw new FileNotFoundException("Value file is missing");
}
string[] settings = File.ReadAllLines(_controlFile);
int ctrlCapacity = int.Parse(settings[0]);
if (ctrlCapacity != _capacity)
{
throw new ArgumentException("capacity differes from existing file. " + _capacity + " != " + ctrlCapacity);
}
//TODO: iterate over serializers and compare on name - create method on the factory
_keySerializer = _keyFactory.GetSerializer(settings[1]);
if (_keySerializer == null)
{
throw new InvalidOperationException("Could not find serializer: " + settings[1]);
}
_valueSerializer = _valueFactory.GetSerializer(settings[2]);
if (_valueSerializer == null)
{
throw new InvalidOperationException("Could not find serializer: " + settings[2]);
}
}
else
{
if (File.Exists(_hashFile))
{
throw new InvalidOperationException("Hash file exists already");
}
if (File.Exists(_keyFile))
{
throw new FileNotFoundException("Key file exists already");
}
if (File.Exists(_valueFile))
{
throw new FileNotFoundException("Value file exists already");
}
using (var fileStream = File.CreateText(_controlFile))
{
fileStream.WriteLine(_capacity.ToString());
fileStream.WriteLine(_keySerializer.GetType().AssemblyQualifiedName);
fileStream.WriteLine(_valueSerializer.GetType().AssemblyQualifiedName);
}
}
}
public ByteArray(long capacity, string path, bool autoGrow, ISerializeDeserialize <byte> serializer, IViewManager viewManager)
: base(capacity, path, autoGrow, serializer, viewManager)
{
}
