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