private static ClassCache CreateCacheEntry(Type clazz) { ClassCache cachedInfo; long shallowInstanceSize = NUM_BYTES_OBJECT_HEADER; JCG.List <FieldInfo> referenceFields = new JCG.List <FieldInfo>(32); for (Type c = clazz; c != null; c = c.BaseType) { FieldInfo[] fields = c.GetFields( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static); foreach (FieldInfo f in fields) { // LUCENENET specific - exclude fields that are marked with the ExcludeFromRamUsageEstimationAttribute if (!f.IsStatic && f.GetCustomAttribute <ExcludeFromRamUsageEstimationAttribute>(inherit: false) is null) { shallowInstanceSize = AdjustForField(shallowInstanceSize, f); if (!f.FieldType.IsPrimitive) { referenceFields.Add(f); } } } } cachedInfo = new ClassCache(AlignObjectSize(shallowInstanceSize), referenceFields.ToArray()); return(cachedInfo); }
// Returns true if this node is automatically invoked public bool IsAutoInvoked(bool ignoreException) { if (TraceUtil.If(this, TraceLevel.Verbose)) { TraceUtil.WriteLineVerbose(this, "IsAutoInvoked: " + this); } if (_objInfo.ObjMemberInfo == null) { return(false); } if (_objInfo.ObjMemberInfo is FieldInfo) { return(true); } if (_objInfo.ObjMemberInfo is PropertyInfo) { // We pay attention to the Auto Invoke property // only on the implicit invocation where an exception // is not reported. We do allow the property to be // gotten by explicitly selecting the node. if (!ignoreException || ComponentInspectorProperties.AutoInvokeProperties) { if (_objInfo.CalcParams(ignoreException) && !_objInfo.NeedsParamValues(false) && ClassCache.ShouldAutoInvokeProp(this)) { return(true); } } } return(false); }
/// <summary> /// 获取指定分类 /// 不存在或已删除时返回null /// </summary> /// <param name="classId">分类Id</param> /// <returns></returns> public virtual Database.GenericClass GetClass(long classId) { return(ClassCache.GetOrCreate(classId, () => UnitOfWork.ReadData <Database.GenericClass, Database.GenericClass>(r => { return r.GetByIdWhereNotDeleted(classId); }), ClassCacheTime)); }
/// <summary> /// Create a cached information about shallow size and reference fields for /// a given class. /// </summary> private static ClassCache CreateCacheEntry(Type clazz) { ClassCache cachedInfo; long shallowInstanceSize = NUM_BYTES_OBJECT_HEADER; List <FieldInfo> referenceFields = new List <FieldInfo>(32); for (Type c = clazz; c != null; c = c.BaseType) { FieldInfo[] fields = c.GetFields( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static); foreach (FieldInfo f in fields) { if (!f.IsStatic) { shallowInstanceSize = AdjustForField(shallowInstanceSize, f); if (!f.FieldType.IsPrimitive) { referenceFields.Add(f); } } } } cachedInfo = new ClassCache(AlignObjectSize(shallowInstanceSize), referenceFields.ToArray()); return(cachedInfo); }
public void ThrowsIfClassesNotLoadedTest() { var schema = Schema.Parse(BaseClassSchema); var cache = new ClassCache(); Assert.Throws <AvroException>(() => new ReflectWriter <BaseClass>(schema, cache)); }
public void HeterogeneousTest() { var heterogeneousSchema = @" [ ""string"", ""null"", { ""type"" : ""record"", ""name"" : ""Dervied2"", ""fields"" : [ { ""name"" : ""A"", ""type"" : ""string""}, { ""name"" : ""C"", ""type"" : ""double""} ] }, ] "; var schema = Schema.Parse(heterogeneousSchema); var derived2write = new Derived2() { A = "derived2", C = 3.14 }; // union types (except for [null, type]) need to be manually registered var unionSchema = schema as UnionSchema; var cache = new ClassCache(); cache.LoadClassCache(typeof(Derived2), unionSchema[2]); var writer = new ReflectWriter <object>(schema, cache); var reader = new ReflectReader <object>(schema, schema, cache); using (var stream = new MemoryStream(256)) { var encoder = new BinaryEncoder(stream); writer.Write(derived2write, encoder); writer.Write("string value", encoder); writer.Write(null, encoder); stream.Seek(0, SeekOrigin.Begin); var decoder = new BinaryDecoder(stream); var derived2read = (Derived2)reader.Read(decoder); var stringRead = (string)reader.Read(decoder); var nullRead = reader.Read(decoder); Assert.AreEqual(derived2read.A, derived2write.A); Assert.AreEqual(derived2read.C, derived2write.C); Assert.AreEqual(stringRead, "string value"); Assert.IsNull(nullRead); } }
protected override Class loadClass(string name, bool resolve) { //Console.WriteLine(".loadClass: " + name); var c = default(Class); try { if (ClassCache.ContainsKey(name)) { var LoadedClass = (Class)ClassCache[name]; c = LoadedClass; } else if (ClassBytes.ContainsKey(name)) { var Bytes = (sbyte[])ClassBytes[name]; var DefineName = name; var LoadedClass = this.defineClass(DefineName, Bytes, 0, Bytes.Length); ClassCache[name] = LoadedClass; c = LoadedClass; } else { c = base.loadClass(name, resolve); } } catch (System.Exception cc) { Console.WriteLine("InternalURLClassLoader.loadClass error, check TypeDefinitionCache, " + new { name, cc.Message }); // what should we do with the missing types? // we can only return null as it is going to gail anyhow //throw new InvalidOperationException(); } //Console.WriteLine(".loadClass: " + c.GetDeclaringFile()); return(c); }
public void CompileAndInstantiate() { string className; var compileUnit = ClassCache.createCompileUnit <ISource>(out className); //save to file var provider = new CSharpCodeProvider(new Dictionary <String, String> { { "CompilerVersion", "v4.0" } }); var firstTypeName = compileUnit.Namespaces[0].Types[0].Name; string sourceFile = $"..\\..\\Examples\\Generated\\{firstTypeName}{(provider.FileExtension[0] == '.' ? string.Empty : ".")}{provider.FileExtension}"; using (var sw = new StreamWriter(sourceFile, false)) { var tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions()); tw.Close(); } }
public void BaseClassTest() { var schema = Schema.Parse(BaseClassSchema); var derived1write = new Derived1() { A = "derived1", B = 7 }; var derived2write = new Derived2() { A = "derived2", C = 3.14 }; // union types (except for [null, type]) need to be manually registered var unionSchema = schema as UnionSchema; var cache = new ClassCache(); cache.LoadClassCache(typeof(Derived1), unionSchema[0]); cache.LoadClassCache(typeof(Derived2), unionSchema[1]); var x = schema as RecordSchema; var writer = new ReflectWriter <BaseClass>(schema, cache); var reader = new ReflectReader <BaseClass>(schema, schema, cache); using (var stream = new MemoryStream(256)) { var encoder = new BinaryEncoder(stream); writer.Write(derived1write, encoder); writer.Write(derived2write, encoder); stream.Seek(0, SeekOrigin.Begin); var decoder = new BinaryDecoder(stream); var derived1read = (Derived1)reader.Read(decoder); var derived2read = (Derived2)reader.Read(decoder); Assert.AreEqual(derived1read.A, derived1write.A); Assert.AreEqual(derived1read.B, derived1write.B); Assert.AreEqual(derived2read.A, derived2write.A); Assert.AreEqual(derived2read.C, derived2write.C); } }
public void GenericFixedDefaultConverter() { var schema = Schema.Parse(_fixedSchema); var rs = schema as RecordSchema; FixedSchema fs = null; foreach (var f in rs.Fields) { if (f.Name == "myFixed") { fs = f.Schema as FixedSchema; } } var fixedRecWrite = new GenericFixedRec() { myFixed = new GenericFixed(fs) { Value = new byte[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6 } } }; GenericFixedRec fixedRecRead = null; ClassCache.AddDefaultConverter <byte[], GenericFixed>((a, s) => new GenericFixed(s as FixedSchema, a), (p, s) => p.Value); var writer = new ReflectWriter <GenericFixedRec>(schema); var reader = new ReflectReader <GenericFixedRec>(schema, schema); using (var stream = new MemoryStream(256)) { writer.Write(fixedRecWrite, new BinaryEncoder(stream)); stream.Seek(0, SeekOrigin.Begin); fixedRecRead = reader.Read(null, new BinaryDecoder(stream)); Assert.IsTrue(fixedRecRead.myFixed.Value.Length == 16); Assert.IsTrue(fixedRecWrite.myFixed.Value.SequenceEqual(fixedRecRead.myFixed.Value)); } }
static ThemeInfo() { var assembly = Assembly.GetExecutingAssembly(); foreach (var definedType in assembly.DefinedTypes) { if (!definedType.IsEnum) { continue; } var attribs = definedType.GetCustomAttributes <VisualClassAttribute>().ToList(); if (attribs.Count == 0) { continue; } var @class = new ClassCache(definedType); foreach (var attrib in attribs) { PartMap[attrib.ClassName] = @class; } } }
public void TestAll() { var instance = ClassCache.Create <ISource, Source>(new Source(), "name of cache"); }
/// <summary> /// 获取分类,不存在或已删除时返回null /// </summary> /// <param name="classId">分类Id</param> /// <returns></returns> public virtual Entities.GenericClass GetWithCache(Guid classId) { return(ClassCache.GetOrCreate(classId, () => Get(classId), ClassCacheTime)); }
// Gets the objects to iterate over to make the child nodes protected override ICollection GetChildren() { if (_typeHandler != null && _typeHandler.Enabled) { return(_typeHandler.GetChildren()); } bool showFields = ComponentInspectorProperties.ShowFields; bool showProps = ComponentInspectorProperties.ShowProperties; bool showMethods = ComponentInspectorProperties.ShowMethods; bool showEvents = ComponentInspectorProperties.ShowEvents; bool showPublicOnly = ComponentInspectorProperties.ShowPublicMembersOnly; bool showBase = ComponentInspectorProperties.ShowBaseClasses; bool showPropMeth = ComponentInspectorProperties.ShowPropertyAccessorMethods; Type objType = ObjType; bool comObject = objType.IsCOMObject; ArrayList members = ClassCache.GetMembers(objType); ArrayList membersOut = new ArrayList(); foreach (MemberInfo member in members) { // Get rid of these (types are inner classes) if (member is ConstructorInfo || member is Type) { continue; } if (member is FieldInfo && !showFields) { continue; } if (member is PropertyInfo && !showProps) { continue; } if (member is MethodInfo && !showMethods) { continue; } if (member is EventInfo && !showEvents) { continue; } if (showPublicOnly) { // Sigh, seems that the property visiblity is not shown in // reflection and the visbility is in each type of member // rather than the superclass if ((member is MethodInfo && !((MethodInfo)member).IsPublic) || (member is FieldInfo && !((FieldInfo)member).IsPublic)) { continue; } } if (!showBase) { if (!objType.Equals(member.DeclaringType)) { continue; } } // Ignore property accessors/event adders if specified if (!showPropMeth && member.MemberType == MemberTypes.Method) { if (member.Name.StartsWith("get_") || member.Name.StartsWith("set_") || member.Name.StartsWith("add_") || member.Name.StartsWith("remove_")) { continue; } if (comObject) { if (member.Name.IndexOf("_Event_add_") != -1 || member.Name.IndexOf("_Event_remove_") != -1 || member.Name.IndexOf("_get_") != -1 || member.Name.IndexOf("_set_") != -1) { continue; } } } membersOut.Add(member); } return(membersOut); }
/// <summary> /// Constructor for the <c>RegistryBinder</c> object. This /// is used to create bindings between classes and the converters /// that should be used to serialize and deserialize the instances. /// All converters are instantiated once and cached for reuse. /// </summary> public RegistryBinder() { this.factory = new ConverterFactory(); this.cache = new ClassCache(); }
/* * Non-recursive version of object descend. this consumes more memory than recursive in-depth * traversal but prevents stack overflows on long chains of objects * or complex graphs (a max. recursion depth on my machine was ~5000 objects linked in a chain * so not too much). */ private static long MeasureObjectSize(object root) { // Objects seen so far. IdentityHashSet <object> seen = new IdentityHashSet <object>(); // Class cache with reference Field and precalculated shallow size. HashMap <Type, ClassCache> classCache = new IdentityHashMap <Type, ClassCache>(); // Stack of objects pending traversal. Recursion caused stack overflows. Stack <object> stack = new Stack <object>(); stack.Push(root); long totalSize = 0; while (stack.Count > 0) { object ob = stack.Pop(); if (ob == null || seen.Contains(ob)) { continue; } seen.Add(ob); Type obClazz = ob.GetType(); if (obClazz.Equals(typeof(string))) { // LUCENENET specific - we can get a closer estimate of a string // by using simple math. Reference: http://stackoverflow.com/a/8171099. // This fixes the TestSanity test. totalSize += (2 * (((string)ob).Length + 1)); } if (obClazz.IsArray) { /* * Consider an array, possibly of primitive types. Push any of its references to * the processing stack and accumulate this array's shallow size. */ long size = NUM_BYTES_ARRAY_HEADER; Array array = (Array)ob; int len = array.Length; if (len > 0) { Type componentClazz = obClazz.GetElementType(); if (componentClazz.GetTypeInfo().IsPrimitive) { size += (long)len * primitiveSizes[componentClazz]; } else { size += (long)NUM_BYTES_OBJECT_REF * len; // Push refs for traversal later. for (int i = len; --i >= 0;) { object o = array.GetValue(i); if (o != null && !seen.Contains(o)) { stack.Push(o); } } } } totalSize += AlignObjectSize(size); } else { /* * Consider an object. Push any references it has to the processing stack * and accumulate this object's shallow size. */ try { ClassCache cachedInfo = classCache[obClazz]; if (cachedInfo == null) { classCache[obClazz] = cachedInfo = CreateCacheEntry(obClazz); } foreach (FieldInfo f in cachedInfo.ReferenceFields) { // Fast path to eliminate redundancies. object o = f.GetValue(ob); if (o != null && !seen.Contains(o)) { stack.Push(o); } } totalSize += cachedInfo.AlignedShallowInstanceSize; } catch (Exception e) { // this should never happen as we enabled setAccessible(). throw new Exception("Reflective field access failed?", e); } } } // Help the GC (?). seen.Clear(); stack.Clear(); classCache.Clear(); return(totalSize); }
private static void AssertReflectRecordEqual(Schema schema1, object rec1, Schema schema2, object rec2, ClassCache cache) { var recordSchema = (RecordSchema)schema1; foreach (var f in recordSchema.Fields) { var rec1Val = cache.GetClass(recordSchema).GetValue(rec1, f); var rec2Val = cache.GetClass(recordSchema).GetValue(rec2, f); if (rec1Val.GetType().IsClass) { AssertReflectRecordEqual(f.Schema, rec1Val, f.Schema, rec2Val, cache); } else if (rec1Val is IList) { var schema1List = f.Schema as ArraySchema; var rec1List = (IList)rec1Val; if (rec1List.Count > 0) { var rec2List = (IList)rec2Val; Assert.AreEqual(rec1List.Count, rec2List.Count); for (int j = 0; j < rec1List.Count; j++) { AssertReflectRecordEqual(schema1List.ItemSchema, rec1List[j], schema1List.ItemSchema, rec2List[j], cache); } } else { Assert.AreEqual(rec1Val, rec2Val); } } else if (rec1Val is IDictionary) { var schema1Map = f.Schema as MapSchema; var rec1Dict = (IDictionary)rec1Val; var rec2Dict = (IDictionary)rec2Val; Assert.AreEqual(rec2Dict.Count, rec2Dict.Count); foreach (var key in rec1Dict.Keys) { var val1 = rec1Dict[key]; var val2 = rec2Dict[key]; if (f.Schema is RecordSchema) { AssertReflectRecordEqual(f.Schema as RecordSchema, val1, f.Schema as RecordSchema, val2, cache); } else { Assert.AreEqual(val1, val2); } } } else { Assert.AreEqual(rec1Val, rec2Val); } } }
public static T CreateInstance <T>(params object[] Params) { return(ClassCache.CreateInstance <T>(Params)); }
public static void DestroyInstance(IReusableClass obj) { ClassCache.DestroyInstance(obj); }
/// <summary> /// 清理缓存 /// </summary> public virtual void ClearCache() { ClassCache.Clear(); ClassListCache.Clear(); ClassTreeCache.Clear(); }
public static void Initialize() { ThreadCache.Initialize(); ClassCache.Initialize(); }