static LoadedAssembly TryReadFromCache(string cacheFileName, DateTime lastWriteTime)
{
if (cacheFileName == null || !File.Exists(cacheFileName))
{
return(null);
}
//LoggingService.Debug("Deserializing " + cacheFileName);
try {
using (FileStream fs = new FileStream(cacheFileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete, 4096, FileOptions.SequentialScan)) {
using (BinaryReader reader = new BinaryReaderWith7BitEncodedInts(fs)) {
if (reader.ReadInt64() != lastWriteTime.Ticks)
{
LoggingService.Debug("Timestamp mismatch, deserialization aborted. (" + cacheFileName + ")");
return(null);
}
FastSerializer s = new FastSerializer();
return(s.Deserialize(reader) as LoadedAssembly);
}
}
} catch (IOException ex) {
LoggingService.Warn(ex);
return(null);
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn(ex);
return(null);
} catch (SerializationException ex) {
LoggingService.Warn(ex);
return(null);
}
}
void SaveToCache(string cacheFileName, DateTime lastWriteTime, LoadedAssembly asm)
{
if (cacheFileName == null)
{
return;
}
LoggingService.Debug("Serializing to " + cacheFileName);
try {
Directory.CreateDirectory(DomPersistencePath);
using (FileStream fs = new FileStream(cacheFileName, FileMode.Create, FileAccess.Write)) {
using (BinaryWriter writer = new BinaryWriterWith7BitEncodedInts(fs)) {
writer.Write(lastWriteTime.Ticks);
FastSerializer s = new FastSerializer();
s.Serialize(writer, asm);
}
}
} catch (IOException ex) {
LoggingService.Warn(ex);
// Can happen if two SD instances are trying to access the file at the same time.
// We'll just let one of them win, and instance that got the exception won't write to the cache at all.
// Similarly, we also ignore the other kinds of IO exceptions.
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn(ex);
}
}
//[UnityEditor.MenuItem("Tools/Vexe/CompileAsm")]
//public static void CompileAsm()
//{
//var types = ReflectionHelper.CachedGetRuntimeTypes().Concat(ReflectionHelper.GetUnityEngineTypes()).ToList();
//var types = ReflectionHelper.CachedGetRuntimeTypes().ToList();
//var serializer = new FastSerializer();
//var adapters = new IBaseSerializer[] { new UnityObjectSerializer() };
//serializer.CompileAssembly(types, adapters, new VFWPredicates(), "SerTest", "Assets", "SERIALIZER");
//UnityEditor.AssetDatabase.ImportAsset("Assets/SerTest.dll", UnityEditor.ImportAssetOptions.ForceUpdate);
//}
#endif
static ALPHA_FastSerializerBackend()
{
var types = ReflectionHelper.CachedGetRuntimeTypes().ToList();
var serializsers = new IBaseSerializer[] { new UnityObjectSerializer() };
Serializer = FastSerializer.CompileDynamic(types, serializsers, new VFWPredicates());
}
public void FixtureSetUp()
{
FastSerializer serializer = new FastSerializer();
using (MemoryStream ms = new MemoryStream()) {
serializer.Serialize(ms, TypeSystemConvertVisitorTests.ParseTestCase());
ms.Position = 0;
testCasePC = (IProjectContent)serializer.Deserialize(ms);
}
}
public void FixtureSetUp()
{
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true
};
IProjectContent pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
FastSerializer serializer = new FastSerializer();
using (MemoryStream ms = new MemoryStream()) {
serializer.Serialize(ms, pc);
ms.Position = 0;
testCasePC = (IProjectContent)serializer.Deserialize(ms);
}
}
public bool IsSerializableType(Type type)
{
if (FastSerializer.IsNotQualified(type))
{
return(false);
}
// a type is serializable if there's no attributes requirements
// otherwise it must have one of the SerializeType attributes
var serializeType = attributes.SerializeType;
return(serializeType == null ||
serializeType.Length == 0 ||
serializeType.Any(type.IsDefined));
}
public void FixtureSetUp()
{
CecilLoader loader = new CecilLoader()
{
IncludeInternalMembers = true
};
IUnresolvedAssembly pc = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
FastSerializer serializer = new FastSerializer();
using (MemoryStream ms = new MemoryStream()) {
serializer.Serialize(ms, pc);
ms.Position = 0;
var asm = (IUnresolvedAssembly)serializer.Deserialize(ms);
base.compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib);
}
}
static void SaveToCache(string cacheFileName, IProjectContent pc)
{
try {
Directory.CreateDirectory(Path.GetDirectoryName(cacheFileName));
using (FileStream fs = new FileStream(cacheFileName, FileMode.Create, FileAccess.Write)) {
using (BinaryWriter writer = new BinaryWriterWith7BitEncodedInts(fs)) {
writer.Write(cacheMagicNumber);
FastSerializer s = new FastSerializer();
s.Serialize(writer, pc);
}
}
} catch (IOException ex) {
LoggingService.Warn(ex);
// Can happen if two SD instances are trying to access the file at the same time.
// We'll just let one of them win, and the instance that got the exception won't write to the cache at all.
// Similarly, we also ignore the other kinds of IO exceptions.
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn(ex);
}
}
static string GetTypeName(Type type)
{
if (type == null)
{
return(string.Empty);
}
FastSerializer.Log("Getting type name for type: {0}", type.FullName);
if (_getTypeName == null)
{
_getTypeName = new Func <Type, string>(x =>
{
if (x.IsArray)
{
return(GetTypeName(x.GetElementType()) + "Array" + x.GetArrayRank());
}
if (x.IsGenericParameter || !x.IsGenericType)
{
return(x.Name);
}
var builder = new StringBuilder();
var name = x.Name;
var index = name.IndexOf("`");
builder.Append(name.Substring(0, index));
builder.Append("Of");
var args = x.GetGenericArguments();
for (int i = 0; i < args.Length; i++)
{
var arg = args[i];
builder.Append(GetTypeName(arg));
}
return(builder.ToString());
}).Memoize();
}
return(_getTypeName(type));
}
static IProjectContent TryReadFromCache(string cacheFileName)
{
if (cacheFileName == null || !File.Exists(cacheFileName))
{
return(null);
}
LoggingService.Debug("Deserializing " + cacheFileName);
try {
using (FileStream fs = new FileStream(cacheFileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete, 4096, FileOptions.SequentialScan)) {
using (BinaryReader reader = new BinaryReaderWith7BitEncodedInts(fs)) {
if (reader.ReadInt32() != cacheMagicNumber)
{
LoggingService.Warn("Incorrect magic number");
return(null);
}
FastSerializer s = new FastSerializer();
return((IProjectContent)s.Deserialize(reader));
}
}
} catch (IOException ex) {
LoggingService.Warn(ex);
return(null);
} catch (UnauthorizedAccessException ex) {
LoggingService.Warn(ex);
return(null);
} catch (SerializationException ex) {
LoggingService.Warn(ex);
return(null);
} catch (InvalidCastException ex) {
// can happen if serialized types are incompatible to expected types
LoggingService.Warn(ex);
return(null);
} catch (FormatException ex) {
// e.g. invalid 7-bit-encoded int
LoggingService.Warn(ex);
return(null);
}
}
public void Serialize(FastSerializer.SerializationWriter writer)
{
// nothing to do
}
public void Deserialize(FastSerializer.SerializationReader reader)
{
// nothing to do
}
internal static void EmitDbgAsm(FastSerializer serializer, List <Type> types, string assemblyName, string assemblyDir, string typeName, EmitContext ctx)
{
var asmName = new AssemblyName(assemblyName);
var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave, assemblyDir);
var modBuilder = asmBuilder.DefineDynamicModule(assemblyName, assemblyName + ".dll");
var typeBuilder = modBuilder.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract | TypeAttributes.Class);
// serialization
{
var serializationBase = typeBuilder.DefineMethod("Serialize",
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard, typeof(void),
new Type[] { typeof(Stream), typeof(object), typeof(SerializationContext) });
serializationBase.DefineParameter(1, ParameterAttributes.None, "stream");
serializationBase.DefineParameter(2, ParameterAttributes.None, "value");
serializationBase.DefineParameter(3, ParameterAttributes.None, "ctx");
ctx.SerializationBase = serializationBase;
EmitSerializationCode(ctx, (n, t) => CreateAssemblySerializeStub(n, t, typeBuilder));
emit.il = serializationBase.GetILGenerator();
EmitDynamicSerializationBase(ctx);
var writeNull = typeBuilder.DefineMethod("Delegate_Write_Null",
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard, typeof(void), SerializationParameters);
{
emit.il = writeNull.GetILGenerator();
emit.ret();
}
for (int i = 0; i < ctx.Types.Count; i++)
{
var type = ctx.Types[i];
var writer = ctx.GetWriteStub(type);
EmitHelper.EmitAssemblySerializeDelegator(type, writer, typeBuilder);
}
}
// deserialization code
{
var deserializationBase = typeBuilder.DefineMethod("Deserialize",
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard, typeof(object), DeserializationParameters);
deserializationBase.DefineParameter(1, ParameterAttributes.None, "stream");
deserializationBase.DefineParameter(2, ParameterAttributes.None, "ctx");
ctx.DeserializationBase = deserializationBase;
EmitDeserializationCode(ctx, (n, t) => CreateAssemblyDeserializeStub(n, t, typeBuilder));
emit.il = deserializationBase.GetILGenerator();
EmitDeserializationBase(ctx);
var readNull = typeBuilder.DefineMethod("Delegate_Read_Null",
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard, typeof(object), DeserializationParameters);
{
emit.il = readNull.GetILGenerator();
emit.retnull();
}
for (int i = 0; i < ctx.Types.Count; i++)
{
var type = ctx.Types[i];
var reader = ctx.GetReadStub(type);
EmitHelper.EmitAssemblyDeserializeDelegator(type, reader, typeBuilder);
}
}
typeBuilder.CreateType();
asmBuilder.Save(assemblyName + ".dll");
}
public void CompileAsm()
{
FastSerializer.CompileAssembly(types, null, null, "SerTest", null, "TestSerializer");
}
private void CompileDynamic()
{
serializer = FastSerializer.CompileDynamic(types, null, null, null);
}
public void CompileWithPredicates(ISerializationPredicates p)
{
FastSerializer.CompileDynamic(types, null, p, onTypeGenerated: null);
}
