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); }