public Db4oField(IReflectField storedField)
{
internalName = storedField.GetName();
name = AutomaticPropertyUtils.TryParseName(internalName);
IReflectClass fieldType = storedField.GetFieldType();
if(fieldType!=null)
DataType = fieldType.ToString();
}
public virtual void Set(IReflectField field, object onObject, object value)
{
try
{
field.Set(onObject, value);
}
catch (Db4oException)
{
}
}
private IReflectField[] CreateDeclaredFieldsArray()
{
FieldInfo[] fields = Sharpen.Runtime.GetDeclaredFields(_type);
IReflectField[] reflectors = new IReflectField[fields.Length];
for (int i = 0; i < reflectors.Length; i++)
{
reflectors[i] = CreateField(fields[i]);
}
return reflectors;
}
internal virtual void Refresh()
{
ClassMetadata newFieldType = DetectFieldType();
if (newFieldType != null && newFieldType.Equals(_fieldType))
{
return;
}
_reflectField = null;
_state = FieldMetadataState.Unavailable;
}
public virtual object Get(IReflectField field, object onObject)
{
try
{
return field.Get(onObject);
}
catch (Db4oException)
{
return null;
}
}
private IReflectField[] CreateDeclaredFieldsArray()
{
var fields = Runtime.GetDeclaredFields(_type);
var reflectors = new IReflectField[fields.Length];
for (var i = 0; i < reflectors.Length; i++)
{
reflectors[i] = CreateField(fields[i]);
}
return(reflectors);
}
private IReflectField[] CreateFields(string[] fieldNames, Type[] fieldTypes)
{
IReflectField[] fields = new IReflectField[fieldNames.Length + 1];
for (int i = 0; i < fieldNames.Length; ++i)
{
fields[i] = new Db4objects.Db4o.Tests.Common.Reflect.Custom.CustomField(_repository
, i, fieldNames[i], fieldTypes[i]);
}
fields[fields.Length - 1] = new CustomUidField(_repository);
return fields;
}
private IReflectField[] CreateFields(string[] fieldNames, Type[] fieldTypes)
{
IReflectField[] fields = new IReflectField[fieldNames.Length + 1];
for (int i = 0; i < fieldNames.Length; ++i)
{
fields[i] = new Db4objects.Db4o.Tests.Common.Reflect.Custom.CustomField(_repository
, i, fieldNames[i], fieldTypes[i]);
}
fields[fields.Length - 1] = new CustomUidField(_repository);
return(fields);
}
public void SetField(object onObject, string fieldName, object value)
{
IReflectField field = _type.GetDeclaredField(fieldName);
if (field == null)
{
throw new ArgumentException("No field '" + fieldName + "' found in '" + FullName + "'");
}
field.Set(onObject, value);
}
private void RenderSubObject(TreeGridNode parentNode, object parentObj, IReflectField field)
{
try
{
TreeGridNode objectNode = new TreeGridNode();
parentNode.Nodes.Add(objectNode);
object value = field.Get(parentObj);
if (value != null)
{
container.Ext().Activate(value, 1);
}
objectNode.Tag = value;
IType fieldType = ResolveFieldType(field);
objectNode.Cells[0].Value = AppendIDTo(field.GetName(), GetLocalID(value), fieldType);
objectNode.Cells[1].Value = value != null?value.ToString() : BusinessConstants.DB4OBJECTS_NULL;
SetFieldType(objectNode, fieldType);
if (parentNode.Tag is DictionaryEntry && field.GetName() == BusinessConstants.DB4OBJECTS_KEY)
{
objectNode.Cells[1].ReadOnly = true;
}
else if (parentNode.Tag is DictionaryEntry && field.GetName() == BusinessConstants.DB4OBJECTS_VALUE)
{
objectNode.Cells[1].ReadOnly = checkReadonlyStatus();
}
else if (field.Get(parentObj) == null)
{
objectNode.Cells[1].ReadOnly = true;
}
else
{
objectNode.Cells[1].ReadOnly = true;
}
objectNode.ImageIndex = 0; //class
if (value != null)
{
//container = Db4oClient.Client;
//container.Ext().Activate(value, 2);
TreeGridNode treenodeDummyChildNode = new TreeGridNode();
objectNode.Nodes.Add(treenodeDummyChildNode);
treenodeDummyChildNode.Cells[0].Value = BusinessConstants.DB4OBJECTS_DUMMY;
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public virtual object Get(IReflectField field, object onObject)
{
try
{
return(field.Get(onObject));
}
catch (Db4oException)
{
return(null);
}
}
private void TraverseFields(object @object, IReflectClass claxx)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(@object);
QueueUpForTraversing(value);
}
}
public List <TreeGridViewRenderer> CreateCollectionNode(IReflectField field, object ownerObject, int count)
{
try
{
TreeGridViewRenderer TreeviewRenderer = new TreeGridViewRenderer();
TreeviewRenderer.DisplayFieldName = field.GetName() + " ( " + count + " items )";
TreeviewRenderer.FieldName = field.GetName();
TreeviewRenderer.FieldType = field.GetName();
TreeviewRenderer.QualifiedName = field.GetFieldType().GetName();
TreeviewRenderer.ObjectId = 0;
if (ownerObject != null)
{
TreeviewRenderer.FieldValue = ownerObject.ToString();
}
else
{
TreeviewRenderer.FieldValue = BusinessConstants.DB4OBJECTS_NULL;
}
if (count == 0)
{
TreeviewRenderer.HasSubNode = false;
}
else
{
TreeviewRenderer.HasSubNode = true;
long id = GetLocalID(ownerObject);
if (ownerObject is GenericObject || ownerObject is GenericArray)
{
TreeviewRenderer.ObjectId = id;
}
else
if (id != 0)
{
TreeviewRenderer.ObjectId = id;
}
else
{
TreeviewRenderer.SubObject = ownerObject;
}
}
IType type = ResolveFieldType(field);
TreeviewRenderer.FieldType = SetFieldType(type);
TreeviewRenderer.ObjectType = type;
TreeviewRenderer.ReadOnlyStatus = true;
listTreeGridViewRenderers.Add(TreeviewRenderer);
return(listTreeGridViewRenderers);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
private IReflectField[] CreateFields(string[] fieldNames, Type[] fieldTypes)
{
var fields = new IReflectField[fieldNames.Length + 1];
for (var i = 0; i < fieldNames.Length; ++i)
{
fields[i] = new CustomField(_repository
, i, fieldNames[i], fieldTypes[i]);
}
fields[fields.Length - 1] = new CustomUidField(_repository);
return(fields);
}
public void TestNullAssignmentToValueTypeField()
{
FastNetReflector reflector = new FastNetReflector();
IReflectField field = reflector.ForClass(typeof(ValueTypeContainer)).GetDeclaredField("_value");
ValueTypeContainer subject = new ValueTypeContainer(0xDb40);
field.Set(subject, null);
Assert.AreEqual(0, subject.Value);
field.Set(subject, 42);
Assert.AreEqual(42, subject.Value);
}
public void SetObject(IReflectField rfield, object containingObject, object newValue)
{
try
{
rfield.Set(containingObject, newValue);
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public static void SetObject(IReflectField rfield, object containingObject, IType fieldType, string newValue)
{
try
{
rfield.Set(containingObject, fieldType.Cast(newValue));
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public virtual IReflectField GetDeclaredField(string name)
{
for (int i = 0; i < _fields.Length; ++i)
{
IReflectField field = _fields[i];
if (field.GetName().Equals(name))
{
return(field);
}
}
return(null);
}
public object Apply(object current)
{
IReflectField field = (IReflectField)current;
try
{
return(field.Get(obj));
}
catch (Exception e)
{
throw new Db4oException(e);
}
}
private static IReflectField FieldByFieldName(object expression)
{
if (expression is string)
{
IReflectField field = ReflectorUtils.Field(((IReflectClass)_context.Value), (string
)expression);
if (field != null)
{
return(field);
}
}
throw new QLinException("expression can not be mapped to a field");
}
public static void ForEachField(IReflectClass claxx, IProcedure4 procedure)
{
while (claxx != null)
{
IReflectField[] declaredFields = claxx.GetDeclaredFields();
for (int reflectFieldIndex = 0; reflectFieldIndex < declaredFields.Length; ++reflectFieldIndex)
{
IReflectField reflectField = declaredFields[reflectFieldIndex];
procedure.Apply(reflectField);
}
claxx = claxx.GetSuperclass();
}
}
public void CreateSimplePrimitiveNode(IReflectField field, object value, IType type)
{
try
{
var treeGridViewRenderer = FillValuesInTreeGridViewRenderer(field, type, value);
treeGridViewRenderer.ReadOnlyStatus = !type.IsPrimitive || readOnly;
listTreeGridViewRenderers.Add(treeGridViewRenderer);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
private static bool TrySetField(IReflectField field, object onObject, object value
)
{
try
{
field.Set(onObject, value);
}
catch
{
return(false);
}
return(true);
}
internal FieldMetadata(ClassMetadata containingClass, IReflectField field, ClassMetadata
fieldType) : this(containingClass)
{
Init(field.GetName());
_reflectField = field;
_fieldType = fieldType;
_fieldTypeID = fieldType.GetID();
// TODO: beautify !!! possibly pull up isPrimitive to ReflectField
bool isPrimitive = field is GenericField ? ((GenericField)field).IsPrimitive() :
false;
Configure(field.GetFieldType(), isPrimitive);
CheckDb4oType();
SetAvailable();
}
public bool IsPrimitive()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
IReflectField rField = DataLayerCommon.GetDeclaredFieldInHeirarchy(rClass, m_fieldname);
return(rField.GetFieldType().IsPrimitive());
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
private TreeGridViewRenderer FillValuesInTreeGridViewRenderer(IReflectField field, IType type, object value)
{
TreeGridViewRenderer treeGridViewRenderer = new TreeGridViewRenderer();
treeGridViewRenderer.DisplayFieldName = field.GetName();
treeGridViewRenderer.FieldName = field.GetName();
treeGridViewRenderer.FieldValue = value != null?value.ToString() : BusinessConstants.DB4OBJECTS_NULL;
treeGridViewRenderer.FieldType = SetFieldType(type);
treeGridViewRenderer.ReadOnlyStatus = readOnly;
treeGridViewRenderer.ObjectType = type;
treeGridViewRenderer.ObjectId = 0;
return(treeGridViewRenderer);
}
public void CreatePrimitiveNode(IReflectField field, long id, IType type)
{
try
{
object currObj = Db4oClient.Client.Ext().GetByID(id);
object value = field.Get(currObj);
var treeGridViewRenderer = FillValuesInTreeGridViewRenderer(field, type, value);
listTreeGridViewRenderers.Add(treeGridViewRenderer);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
internal FieldMetadata(ClassMetadata containingClass, IReflectField field, ClassMetadata
fieldType) : this(containingClass)
{
Init(field.GetName());
_reflectField = field;
_fieldType = fieldType;
_fieldTypeID = fieldType.GetID();
// TODO: beautify !!! possibly pull up isPrimitive to ReflectField
bool isPrimitive = field is GenericField ? ((GenericField)field).IsPrimitive() :
false;
Configure(field.GetFieldType(), isPrimitive);
CheckDb4oType();
SetAvailable();
}
private void ScanThroughKnownClassesInfo(IObjectContainer db)
{
IReflectClass[] clazzArray = db.Ext().KnownClasses();
for (int clazzIndex = 0; clazzIndex < clazzArray.Length; ++clazzIndex)
{
IReflectClass clazz = clazzArray[clazzIndex];
IReflectField[] fieldArray = clazz.GetDeclaredFields();
for (int fieldIndex = 0; fieldIndex < fieldArray.Length; ++fieldIndex)
{
IReflectField field = fieldArray[fieldIndex];
field.GetName();
field.GetFieldType();
}
}
}
private IReflectField[] FilterTransientFields(IReflectField[] fields)
{
IList filteredFields = new ArrayList();
for (int fieldIndex = 0; fieldIndex < fields.Length; ++fieldIndex)
{
IReflectField field = fields[fieldIndex];
if (!field.IsTransient())
{
filteredFields.Add(field);
}
}
return((IReflectField[])Sharpen.Collections.ToArray(filteredFields, new IReflectField
[filteredFields.Count]));
}
private static object SetField(string attribName, object subObject, object newValue)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(subObject);
if (rclass == null)
{
return(null);
}
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield == null)
{
return(null);
}
if (rfield is GenericVirtualField || rfield.IsStatic())
{
return(null);
}
IType fieldType = Db4oClient.TypeResolver.Resolve(rfield.GetFieldType());
if (!fieldType.IsEditable)
{
if (!fieldType.IsCollection && !fieldType.IsArray)
{
subObject = rfield.Get(subObject);
Db4oClient.Client.Ext().Activate(subObject, 2);
return(subObject);
}
}
else if (subObject != null)
{
rfield.Set(subObject, fieldType.Cast(newValue));
return(subObject);
}
return(null);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
private void RenderCollection(long id, IReflectField field)
{
container = Db4oClient.Client;
object currObj = container.Ext().GetByID(id);
object value = field.Get(currObj);
if (value != null)
{
container.Ext().Activate(value, 2);
ICollection coll = (ICollection)value;
CreateCollectionNode(field, value, coll.Count);
}
else
{
CreateCollectionNode(field, value, 0);
}
}
//Db4oUtil.dumpResults(fixture().db(), results);
private object InitGenericObjects()
{
GenericClass personClass = InitGenericClass();
IReflectField surname = personClass.GetDeclaredField("surname");
IReflectField birthdate = personClass.GetDeclaredField("birthdate");
//ReflectField nArray = personClass.getDeclaredField("nArray");
object person = personClass.NewInstance();
surname.Set(person, "John");
// /int[][] arrayData = new int[2][2];
// todo: FIXME: nArray doesn't work
// nArray.set(person, arrayData);
birthdate.Set(person, new DateTime());
Fixture().Db().Store(person);
Fixture().Db().Commit();
return(person);
}
public bool Match(object candidate)
{
IReflectField field = (IReflectField)candidate;
if (field.IsStatic())
{
return(false);
}
if (field.IsTransient())
{
return(false);
}
if (Platform4.IsTransient(field.GetFieldType()))
{
return(false);
}
return(true);
}
private void RenderArray(long id, IReflectField field)
{
object currObj = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(currObj, 2);
object obj = field.Get(currObj);
if (obj != null)
{
container.Ext().Activate(obj, 2);
int length = container.Ext().Reflector().Array().GetLength(obj);
CreateCollectionNode(field, obj, length);
}
else
{
CreateCollectionNode(field, obj, 0);
}
}
private void RenderCollection(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object value = field.Get(currObj);
if (value != null)
{
container.Ext().Activate(value, 2);
ICollection coll = (ICollection)value;
CreateCollectionNode(field, value, ref rootNode, coll.Count.ToString());
}
else
{
CreateCollectionNode(field, value, ref rootNode, "0");
}
}
private FieldInfo[] MapFields(IReflectField[] fields, bool shouldStoreTransientFields
)
{
if (!shouldStoreTransientFields)
{
fields = FilterTransientFields(fields);
}
FieldInfo[] fieldsMeta = new FieldInfo[fields.Length];
for (int i = 0; i < fields.Length; ++i)
{
IReflectField field = fields[i];
bool isArray = field.GetFieldType().IsArray();
IReflectClass fieldClass = isArray ? field.GetFieldType().GetComponentType() : field
.GetFieldType();
bool isPrimitive = fieldClass.IsPrimitive();
// TODO: need to handle NArray, currently it ignores NArray and alway sets NArray flag false.
fieldsMeta[i] = new FieldInfo(field.GetName(), GetClassMeta(fieldClass), isPrimitive
, isArray, false);
}
return fieldsMeta;
}
private void RenderArray(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object obj = field.Get(currObj);
if (obj != null)
{
container.Ext().Activate(obj, 2);
int length = container.Ext().Reflector().Array().GetLength(obj);
CreateCollectionNode(field, obj, ref rootNode, length.ToString());
}
else
{
CreateCollectionNode(field, obj, ref rootNode, "0");
}
}
private void RenderCollection(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object value = field.Get(currObj);
if (value != null)
{
container.Ext().Activate(value, 2);
ICollection coll = (ICollection)value;
CreateCollectionNode(field, value, ref rootNode, coll.Count.ToString());
}
else
{
CreateCollectionNode(field, value, ref rootNode, "0");
}
}
private void RenderSubObject(TreeGridNode parentNode, object parentObj, IReflectField field)
{
try
{
TreeGridNode objectNode = new TreeGridNode();
parentNode.Nodes.Add(objectNode);
object value = field.Get(parentObj);
if (value != null)
{
container.Ext().Activate(value, 1);
}
objectNode.Tag = value;
IType fieldType = ResolveFieldType(field);
objectNode.Cells[0].Value = AppendIDTo(field.GetName(), GetLocalID(value), fieldType);
objectNode.Cells[1].Value = value != null ? value.ToString() : BusinessConstants.DB4OBJECTS_NULL;
SetFieldType(objectNode, fieldType);
if (parentNode.Tag is DictionaryEntry && field.GetName() == BusinessConstants.DB4OBJECTS_KEY)
objectNode.Cells[1].ReadOnly = true;
else if (parentNode.Tag is DictionaryEntry && field.GetName() == BusinessConstants.DB4OBJECTS_VALUE)
objectNode.Cells[1].ReadOnly = checkReadonlyStatus();
else if (field.Get(parentObj) == null)
objectNode.Cells[1].ReadOnly = true;
else
objectNode.Cells[1].ReadOnly = true;
objectNode.ImageIndex = 0; //class
if (value != null)
{
//container = Db4oClient.Client;
//container.Ext().Activate(value, 2);
TreeGridNode treenodeDummyChildNode = new TreeGridNode();
objectNode.Nodes.Add(treenodeDummyChildNode);
treenodeDummyChildNode.Cells[0].Value = BusinessConstants.DB4OBJECTS_DUMMY;
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public static void SetObject(IReflectField rfield, object containingObject, IType fieldType, string newValue)
{
try
{
rfield.Set(containingObject, fieldType.Cast(newValue));
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public _ICodeBlock_18(IReflectField field)
{
this.field = field;
}
public virtual void Set(IReflectField field, object onObject, object value)
{
field.Set(onObject, value);
}
private IReflectField[] FilterTransientFields(IReflectField[] fields)
{
IList filteredFields = new ArrayList();
for (int fieldIndex = 0; fieldIndex < fields.Length; ++fieldIndex)
{
IReflectField field = fields[fieldIndex];
if (!field.IsTransient())
{
filteredFields.Add(field);
}
}
return ((IReflectField[])Sharpen.Collections.ToArray(filteredFields, new IReflectField
[filteredFields.Count]));
}
public IType ResolveFieldType(IReflectField field)
{
IReflectClass type = field.GetFieldType();
return type != null ? ResolveType(type) : null;
}
private IReflectField[] CreateDeclaredFieldsArray()
{
var fields = Runtime.GetDeclaredFields(_type);
var reflectors = new IReflectField[fields.Length];
for (var i = 0; i < reflectors.Length; i++)
{
reflectors[i] = CreateField(fields[i]);
}
return reflectors;
}
protected virtual void UpdateExistingStaticField(Transaction trans, StaticField existingField
, IReflectField reflectField)
{
var stream = trans.Container();
var newValue = StaticReflectFieldValue(reflectField);
if (existingField.value != null && newValue != null && existingField.value.GetType
() == newValue.GetType())
{
var id = stream.GetID(trans, existingField.value);
if (id > 0)
{
if (existingField.value != newValue)
{
// This is the clue:
// Bind the current static member to it's old database identity,
// so constants and enums will work with '=='
stream.Bind(trans, newValue, id);
// This may produce unwanted side effects if the static field object
// was modified in the current session. TODO:Add documentation case.
stream.Refresh(trans, newValue, int.MaxValue);
existingField.value = newValue;
}
return;
}
}
if (newValue == null)
{
try
{
_fieldAccessor.Set(reflectField, null, existingField.value);
}
catch (Exception)
{
}
// fail silently
// TODO: why?
return;
}
existingField.value = newValue;
}
private object StaticReflectFieldValue(IReflectField reflectField)
{
return _fieldAccessor.Get(reflectField, null);
}
protected virtual StaticField ToStaticField(IReflectField reflectField)
{
return new StaticField(reflectField.GetName(), StaticReflectFieldValue(reflectField
));
}
private bool IsTransient(IReflectField field)
{
return field.IsTransient() || Platform4.IsTransient(field.GetFieldType());
}
internal virtual bool StoreField(IReflectField field)
{
if (field.IsStatic())
{
return false;
}
if (IsTransient(field))
{
if (!ShouldStoreTransientFields())
{
return false;
}
}
return Platform4.CanSetAccessible() || field.IsPublic();
}
private IReflectField[] CreateFields(string[] fieldNames, Type[] fieldTypes)
{
var fields = new IReflectField[fieldNames.Length + 1];
for (var i = 0; i < fieldNames.Length; ++i)
{
fields[i] = new CustomField(_repository
, i, fieldNames[i], fieldTypes[i]);
}
fields[fields.Length - 1] = new CustomUidField(_repository);
return fields;
}
private static bool TrySetField(IReflectField field, object onObject, object value
)
{
try
{
field.Set(onObject, value);
}
catch
{
return false;
}
return true;
}
public void CreateCollectionNode(IReflectField field, object ownerObject, ref TreeGridNode rootNode, string count)
{
try
{
TreeGridNode collNode = new TreeGridNode();
rootNode.Nodes.Add(collNode);
collNode.Cells[1].ReadOnly = true;
collNode.Cells[0].Value = field.GetName() + " ( " + count + " items )";
SetFieldType(collNode, ResolveFieldType(field));
if (ownerObject != null)
{
collNode.Cells[1].Value = ownerObject.ToString();
collNode.Tag = ownerObject;
}
else
{
collNode.Cells[1].Value = BusinessConstants.DB4OBJECTS_NULL;
}
collNode.ImageIndex = 1; //Collection
if (Convert.ToInt32(count) > 0)
{
TreeGridNode treenodeDummyChildNode = new TreeGridNode();
collNode.Nodes.Add(treenodeDummyChildNode);
treenodeDummyChildNode.Cells[0].Value = BusinessConstants.DB4OBJECTS_DUMMY;
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public virtual object Get(IReflectField field, object onObject)
{
return field.Get(onObject);
}
private static FieldProperties FieldPropertiesFor(string className, IReflectField field)
{
FieldProperties fp = new FieldProperties(field.GetName(), field.GetFieldType().GetName());
FieldDetails fd = new FieldDetails(className, fp.Field);
fp.m_isPublic = fd.GetModifier();
fp.m_isIndexed = fd.IsIndexed();
return fp;
}
public virtual void InitFields(IReflectClass clazz, IReflectField[] fields)
{
((GenericClass) clazz).InitFields((GenericField[]) fields);
}
public FieldOnObject(IReflectField field, object obj)
{
_field = field;
_object = obj;
}
private bool HasNoActivatingFields(IReflectField[] fields)
{
for (int i = 0; i < fields.Length; i++)
{
if (this.IsActivating(fields[i]))
{
return false;
}
}
return true;
}
private bool IsActivating(IReflectField field)
{
IReflectClass fieldType = field.GetFieldType();
return fieldType != null && !fieldType.IsPrimitive();
}
