C# ClassMetadata.ClassReflector方法代码示例

		public virtual bool SkipClass(ClassMetadata classMetadata)
		{
			if (classMetadata.GetName() == null)
			{
				return true;
			}
			IReflectClass claxx = classMetadata.ClassReflector();
			if (Stream()._handlers.IclassInternal.IsAssignableFrom(claxx))
			{
				return true;
			}
			return false;
		}

		public void AddClassMetadata(ClassMetadata clazz)
		{
			Container().SetDirtyInSystemTransaction(this);
			_classes.Add(clazz);
			if (clazz.StateUnread())
			{
				_classMetadataByBytes.Put(clazz.i_nameBytes, clazz);
			}
			else
			{
				_classMetadataByClass.Put(clazz.ClassReflector(), clazz);
			}
			RegisterClassMetadataById(clazz);
		}

		private bool IsTAAware(ClassMetadata classMetadata)
		{
			GenericReflector reflector = classMetadata.Reflector();
			return reflector.ForClass(typeof(IActivatable)).IsAssignableFrom(classMetadata.ClassReflector
				());
		}

		public void RefreshClassCache(ClassMetadata clazz, IReflectClass oldReflector)
		{
			if (clazz.StateUnread())
			{
				_classMetadataByBytes.Put(clazz.ReadName(_systemTransaction), clazz);
			}
			else
			{
				if (oldReflector != null)
				{
					_classMetadataByClass.Remove(oldReflector);
				}
				_classMetadataByClass.Put(clazz.ClassReflector(), clazz);
			}
		}

		public ClassMetadata ReadClassMetadata(ClassMetadata classMetadata, IReflectClass
			 clazz)
		{
			if (classMetadata == null)
			{
				throw new ArgumentNullException();
			}
			if (!classMetadata.StateUnread())
			{
				return classMetadata;
			}
			_classMetadataCreationDepth++;
			try
			{
				classMetadata.CreateConfigAndConstructor(_classMetadataByBytes, clazz);
				IReflectClass claxx = classMetadata.ClassReflector();
				if (claxx != null)
				{
					_classMetadataByClass.Put(claxx, classMetadata);
					classMetadata.ReadThis();
					classMetadata.CheckChanges();
					_initClassMetadataOnUp.Add(classMetadata);
				}
			}
			finally
			{
				_classMetadataCreationDepth--;
			}
			InitClassMetadataOnUp();
			return classMetadata;
		}

		public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
			, bool isPrimitive)
		{
			return isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) : 
				classMetadata.ClassReflector();
		}

 public virtual bool IsAssignableFrom(ClassMetadata other
     )
 {
     return ClassReflector().IsAssignableFrom(other.ClassReflector());
 }

			public void OnClassRegistered(ClassMetadata clazz)
			{
				// if(Platform4.isDb4oClass(clazz.getName())) {
				// return;
				// }
				IReflectClass reflectClass = clazz.ClassReflector();
				if (this.ActivatableClass().IsAssignableFrom(reflectClass))
				{
					return;
				}
				if (this.HasNoActivatingFields(reflectClass))
				{
					return;
				}
				NotTransparentActivationEnabled diagnostic = new NotTransparentActivationEnabled(
					clazz);
				DiagnosticProcessor processor = this._container.Handlers.DiagnosticProcessor();
				processor.OnDiagnostic(diagnostic);
			}

			private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field
				)
			{
				QConClass qcc = new QConClass(this._enclosing._trans, null, field.QField(this._enclosing
					._trans), containingClass.ClassReflector());
				this._enclosing.AddConstraint(qcc);
				this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc);
			}

		internal virtual Db4objects.Db4o.Internal.ClassMetadata ReadClassMetadata()
		{
			if (_classMetadata == null)
			{
				Read();
				if (_bytes != null)
				{
					Seek(0);
					ObjectContainerBase stream = Container();
					ObjectHeader objectHeader = new ObjectHeader(stream, _bytes);
					_classMetadata = objectHeader.ClassMetadata();
					if (_classMetadata != null)
					{
						if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector
							()))
						{
							ReadThis(false);
						}
					}
				}
			}
			return _classMetadata;
		}