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 SaveValues(object targetObject, string attribName, object newValue, int offset, IType type)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null && !(rfield is GenericVirtualField))
{
if (type.IsArray || type.IsCollection)
{
IList list = rfield.Get(targetObject) as IList;
if (null != list)
{
list[offset] = newValue;
rfield.Set(targetObject, list);
}
}
else
{
SetObject(rfield, targetObject, newValue);
}
}
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
if (dest == null)
{
throw new InvalidOperationException("Dest cannot be null: src=" + src + ", class="
+ claxx + ", source=" + sourceProvider.GetName() + ", target=" + targetProvider
.GetName());
}
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
public static void SetFieldToNull(long id, string fieldName)
{
try
{
object obj = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(obj, 1);
IReflectClass klass = DataLayerCommon.ReflectClassFor(obj);
if (klass != null)
{
IReflectField field = DataLayerCommon.GetDeclaredFieldInHeirarchy(klass, fieldName);
if (field == null)
{
return;
}
field.Set(obj, null);
Db4oClient.Client.Store(obj);
Db4oClient.Client.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
private void SetFieldsToNull(object @object, IReflectClass claxx)
{
IReflectField[] fields;
fields = claxx.GetDeclaredFields();
for (int i = 0; i < fields.Length; i++)
{
IReflectField field = fields[i];
if (field.IsStatic())
{
continue;
}
if (field.IsTransient())
{
continue;
}
field.Set(@object, null);
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
SetFieldsToNull(@object, superclass);
}
public void TestDynamicMethodsOnSecurityCriticalTypes()
{
FastNetReflector reflector = new FastNetReflector();
IReflectField sizeField = reflector.ForClass(typeof(List <NotAccessible>)).GetDeclaredField("_size");
List <NotAccessible> obj = new List <NotAccessible>();
sizeField.Set(obj, 42);
Assert.AreEqual(42, sizeField.Get(obj));
}
public virtual void Set(IReflectField field, object onObject, object value)
{
try
{
field.Set(onObject, value);
}
catch (Db4oException)
{
}
}
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);
}
public void TestNonAccessibleGenericTypeParamenterBugInReflectionEmit()
{
FastNetReflector reflector = new FastNetReflector();
IReflectField sizeField = reflector.ForClass(typeof(GenericClass <NotAccessible>)).GetDeclaredField("_size");
GenericClass <NotAccessible> obj = new GenericClass <NotAccessible>();
sizeField.Set(obj, 42);
Assert.AreEqual(42, sizeField.Get(obj));
}
public virtual void Set(IReflectField field, object onObject, object value)
{
try
{
field.Set(onObject, value);
}
catch (Db4oException)
{
}
}
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 void SetObject(IReflectField rfield, object containingObject, object newValue)
{
try
{
rfield.Set(containingObject, newValue);
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
private static bool TrySetField(IReflectField field, object onObject, object value
)
{
try
{
field.Set(onObject, value);
}
catch
{
return(false);
}
return(true);
}
public static void SaveDictionary(object targetObject, string attribName, object newValue, object key)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
if (rclass != null)
{
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null)
{
if (!(rfield is GenericVirtualField || rfield.IsStatic()))
{
object obj = rfield.Get(targetObject);
ICollection col = (ICollection)obj;
if (col is Hashtable)
{
Hashtable hash = (Hashtable)col;
hash.Remove(key);
hash.Add(key, newValue);
rfield.Set(targetObject, hash);
}
else if (col is IDictionary)
{
IDictionary dict = (IDictionary)col;
dict.Remove(key);
dict.Add(key, newValue);
rfield.Set(targetObject, dict);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
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);
}
}
//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);
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
public static void SaveValues(long id, string attribName, object newValue, int offset)
{
try
{
object targetObject = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(targetObject, 2);
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
IType type = new FieldDetails(rclass.GetName(), attribName).GetFieldType();
object obj = rfield.Get(targetObject);
if (obj is IDictionary)
{
SaveDictionary(targetObject, attribName, newValue, KeyAtIndex((IDictionary)obj, offset / 2));
}
else
{
if (rfield != null && !(rfield is GenericVirtualField || rfield.IsStatic()))
{
if (type.IsArray || type.IsCollection)
{
IList list = obj as IList;
if (null != list)
{
list[offset] = newValue;
rfield.Set(targetObject, list);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public void Run()
{
field.Set(new Item(), 42);
}
public virtual void Set(IReflectField field, object onObject, object value)
{
field.Set(onObject, value);
}
public void SetObject(IReflectField rfield, object containingObject, object newValue)
{
try
{
rfield.Set(containingObject, newValue);
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public virtual void Set(IReflectField field, object onObject, object value)
{
field.Set(onObject, value);
}
private static bool TrySetField(IReflectField field, object onObject, object value
)
{
try
{
field.Set(onObject, value);
}
catch
{
return false;
}
return true;
}
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);
}
}
