static ControlAccessor()
{
SafeField fldControls = null;
MethodInfo fnClear = null;
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
fnClear = GetMethod("Clear");
fldControls = new SafeField(typeof(ControlCollection).GetField("_controls", BindingFlags.Instance | BindingFlags.NonPublic));
});
s_miClear = fnClear;
ControlsArrayField = fldControls;
CreateControlCollectionDelegate fnBaseCreateControlCollection = null;
AddedControlDelegate fnBaseAddedControl = null;
RemovedControlDelegate fnBaseRemovedControl = null;
VoidMethodDelegate fnBaseClearNamingContainer = null;
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
fnBaseCreateControlCollection = (CreateControlCollectionDelegate)Delegate.CreateDelegate(typeof(CreateControlCollectionDelegate), GetMethod("CreateControlCollection"));
fnBaseAddedControl = (AddedControlDelegate)Delegate.CreateDelegate(typeof(AddedControlDelegate), GetMethod("AddedControl"));
fnBaseRemovedControl = (RemovedControlDelegate)Delegate.CreateDelegate(typeof(RemovedControlDelegate), GetMethod("RemovedControl"));
fnBaseClearNamingContainer = (VoidMethodDelegate)Delegate.CreateDelegate(typeof(VoidMethodDelegate), GetMethod("ClearNamingContainer"));
});
BaseCreateControlCollection = fnBaseCreateControlCollection;
BaseAddedControl = fnBaseAddedControl;
BaseRemovedControl = fnBaseRemovedControl;
BaseClearNamingContainer = fnBaseClearNamingContainer;
}
/// <summary>
/// Creates dynamic field instance for the specified <see cref="FieldInfo"/>.
/// </summary>
/// <param name="field">Field info to create dynamic field for.</param>
/// <returns>Dynamic field for the specified <see cref="FieldInfo"/>.</returns>
public static IDynamicField Create(FieldInfo field)
{
AssertUtils.ArgumentNotNull(field, "You cannot create a dynamic field for a null value.");
IDynamicField dynamicField = new SafeField(field);
return dynamicField;
}
/// <summary>
/// Creates dynamic field instance for the specified <see cref="FieldInfo"/>.
/// </summary>
/// <param name="field">Field info to create dynamic field for.</param>
/// <returns>Dynamic field for the specified <see cref="FieldInfo"/>.</returns>
public static IDynamicField Create(FieldInfo field)
{
AssertUtils.ArgumentNotNull(field, "You cannot create a dynamic field for a null value.");
IDynamicField dynamicField = new SafeField(field);
return(dynamicField);
}
static ControlCollectionAccessor()
{
IDynamicField owner = null;
SecurityCritical.ExecutePrivileged( new PermissionSet(PermissionState.Unrestricted), delegate
{
#if MONO_2_0
owner = new SafeField(typeof (ControlCollection).GetField("owner", BindingFlags.Instance | BindingFlags.NonPublic));
#else
owner = new SafeField(typeof (ControlCollection).GetField("_owner", BindingFlags.Instance | BindingFlags.NonPublic));
#endif
});
_owner = owner;
}
public void SafeFieldPerformanceTests()
{
int runs = 10000000;
object myClass = new MyClassWithPrivateFields(123, new object(), 456, new object());
FieldInfo fieldClassRefValue = IField(myClass.GetType(), "instanceRefValue");
FieldInfo fieldClassVtValue = IField(myClass.GetType(), "instanceVTValue");
StopWatch stopWatch = new StopWatch();
using (stopWatch.Start("Duration Class Set/Get field value: {0}"))
{
for (int i = 0; i < runs; i++)
{
SafeField instanceRefField = new SafeField(fieldClassRefValue);
SafeField instanceVtField = new SafeField(fieldClassVtValue);
int res = (int)instanceVtField.GetValue(myClass);
object ores = instanceRefField.GetValue(myClass);
}
}
object myStruct = new MyStructWithPrivateFields(123, new object(), 456, new object());
FieldInfo fieldStructRefValue = IField(myStruct.GetType(), "instanceRefValue");
FieldInfo fieldStructVtValue = IField(myStruct.GetType(), "instanceVTValue");
using (stopWatch.Start("Duration Struct Set/Get field value: {0}"))
{
for (int i = 0; i < runs; i++)
{
SafeField instanceRefField = new SafeField(fieldStructRefValue);
SafeField instanceVtField = new SafeField(fieldStructVtValue);
int res = (int)instanceVtField.GetValue(myStruct);
object ores = instanceRefField.GetValue(myStruct);
}
}
/* on my machine prints
*
* with System.Reflection.Emit.DynamicMethod generated code:
* Duration Class Set/Get field value: 00:00:03.2031250
* Duration Struct Set/Get field value: 00:00:03.5625000
*
* with standard reflection:
* Duration Class Set/Get field value: 00:00:45.4218750
* Duration Struct Set/Get field value: 00:00:44.5312500
*
*/
}
/// <summary>
/// Returns a <see cref="IDynamicField"/> implementation
/// by determining the fastest possible dynamic access strategy
/// </summary>
/// <param name="field">the field to be wrapped</param>
/// <returns>an <see cref="IDynamicField"/> instance for accessing the
/// field represented by the given <see cref="FieldInfo"/></returns>
public static IDynamicField CreateFrom(FieldInfo field)
{
AssertUtils.ArgumentNotNull(field, "You cannot create a dynamic field for a null value.");
IDynamicField dynamicField;
if (field.IsPublic &&
ReflectionUtils.IsTypeVisible(field.DeclaringType, DynamicReflectionManager.ASSEMBLY_NAME))
{
dynamicField = DynamicField.Create(field);
}
else
{
dynamicField = new SafeField(field);
}
return(dynamicField);
}
public void TestInstanceMembersOfStruct()
{
object testref1 = new object();
object testref2 = new object();
MyStructWithPrivateFields myStruct;
// ro readonly int
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyVtField = new SafeField(IField(myStruct.GetType(), "instanceReadonlyVTValue"));
Assert.AreEqual(123, instanceReadonlyVtField.GetValue(myStruct));
try { instanceReadonlyVtField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
// ro readonly object
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyRefField = new SafeField(IField(myStruct.GetType(), "instanceReadonlyRefValue"));
Assert.AreSame(testref1, instanceReadonlyRefField.GetValue(myStruct));
try { instanceReadonlyRefField.SetValue(myStruct, this); }
catch (InvalidOperationException) { }
// ro int
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceVtField = new SafeField(IField(myStruct.GetType(), "instanceVTValue"));
Assert.AreEqual(456, instanceVtField.GetValue(myStruct));
try { instanceVtField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
// ro object
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceRefField = new SafeField(IField(myStruct.GetType(), "instanceRefValue"));
Assert.AreSame(testref2, instanceRefField.GetValue(myStruct));
try { instanceRefField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
}
public void TestInstanceMembersOfClass()
{
object testref1 = new object();
object testref2 = new object();
MyClassWithPrivateFields myClass;
// ro readonly int
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyVtField = new SafeField(IField(myClass.GetType(), "instanceReadonlyVTValue"));
Assert.AreEqual(123, instanceReadonlyVtField.GetValue(myClass));
try { instanceReadonlyVtField.SetValue(myClass, 10); }
catch (InvalidOperationException) { }
// ro readonly object
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyRefField = new SafeField(IField(myClass.GetType(), "instanceReadonlyRefValue"));
Assert.AreSame(testref1, instanceReadonlyRefField.GetValue(myClass));
try { instanceReadonlyRefField.SetValue(myClass, this); }
catch (InvalidOperationException) { }
// rw int
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceVtField = new SafeField(IField(myClass.GetType(), "instanceVTValue"));
Assert.AreEqual(456, instanceVtField.GetValue(myClass));
instanceVtField.SetValue(myClass, 9182);
Assert.AreEqual(9182, instanceVtField.GetValue(myClass));
// rw object
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceRefField = new SafeField(IField(myClass.GetType(), "instanceRefValue"));
Assert.AreSame(testref2, instanceRefField.GetValue(myClass));
instanceRefField.SetValue(myClass, testref1);
Assert.AreSame(testref1, instanceRefField.GetValue(myClass));
}
private void TestStaticMembersOf(Type type, object expectedRoRefValue)
{
// ro const int
SafeField constField = new SafeField(SField(type, "constantValue"));
Assert.AreEqual(5, constField.GetValue(null));
try { constField.SetValue(null, 3); }
catch (InvalidOperationException) { }
// ro static readonly int
SafeField roVtField = new SafeField(SField(type, "staticReadonlyVTValue"));
Assert.AreEqual(11, roVtField.GetValue(null));
try { roVtField.SetValue(null, 10); }
catch (InvalidOperationException) { }
// ro static readonly object
SafeField roRefField = new SafeField(SField(type, "staticReadonlyRefValue"));
Assert.AreSame(expectedRoRefValue, roRefField.GetValue(null));
try { roRefField.SetValue(null, new object()); }
catch (InvalidOperationException) { }
// rw static int
SafeField vtField = new SafeField(SField(type, "staticVTValue"));
vtField.SetValue(null, 10);
Assert.AreEqual(10, vtField.GetValue(null));
// rw static object
SafeField refField = new SafeField(SField(type, "staticRefValue"));
object o = new object();
refField.SetValue(null, o);
Assert.AreSame(o, refField.GetValue(null));
}
public void ThrowsOnNullField()
{
SafeField field = new SafeField(null);
}
public void TestInstanceMembersOfStruct()
{
object testref1 = new object();
object testref2 = new object();
MyStructWithPrivateFields myStruct;
// ro readonly int
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyVtField = new SafeField(IField(myStruct.GetType(), "instanceReadonlyVTValue"));
Assert.AreEqual(123, instanceReadonlyVtField.GetValue(myStruct));
try { instanceReadonlyVtField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
// ro readonly object
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyRefField = new SafeField(IField(myStruct.GetType(), "instanceReadonlyRefValue"));
Assert.AreSame(testref1, instanceReadonlyRefField.GetValue(myStruct));
try { instanceReadonlyRefField.SetValue(myStruct, this); }
catch (InvalidOperationException) { }
// ro int
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceVtField = new SafeField(IField(myStruct.GetType(), "instanceVTValue"));
Assert.AreEqual(456, instanceVtField.GetValue(myStruct));
try { instanceVtField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
// ro object
myStruct = new MyStructWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceRefField = new SafeField(IField(myStruct.GetType(), "instanceRefValue"));
Assert.AreSame(testref2, instanceRefField.GetValue(myStruct));
try { instanceRefField.SetValue(myStruct, 10); }
catch (InvalidOperationException) { }
}
static NamingContainerSupportsWebDependencyInjectionOwnerProxy()
{
SafeField fld = null;
SecurityCritical.ExecutePrivileged( new PermissionSet(PermissionState.Unrestricted), delegate
{
fld = new SafeField(typeof(Control).GetField("_occasionalFields", BindingFlags.Instance | BindingFlags.NonPublic));
});
refOccasionalFields = fld;
}
/// <summary>
/// Returns a <see cref="IDynamicField"/> implementation
/// by determining the fastest possible dynamic access strategy
/// </summary>
/// <param name="field">the field to be wrapped</param>
/// <returns>an <see cref="IDynamicField"/> instance for accessing the
/// field represented by the given <see cref="FieldInfo"/></returns>
public static IDynamicField CreateFrom(FieldInfo field)
{
AssertUtils.ArgumentNotNull(field, "You cannot create a dynamic field for a null value.");
IDynamicField dynamicField;
if (field.IsPublic &&
ReflectionUtils.IsTypeVisible(field.DeclaringType, DynamicReflectionManager.ASSEMBLY_NAME))
{
dynamicField = DynamicField.Create(field);
}
else
{
dynamicField = new SafeField(field);
}
return dynamicField;
}
/// <summary>
/// For webapplications always
/// <ul>
/// <li>convert IResources using the current context.</li>
/// <li>use "web" as default resource protocol</li>
/// <li>use <see cref="HybridContextStorage"/> as default threading storage</li>
/// </ul>
/// </summary>
static WebSupportModule()
{
s_log = LogManager.GetLogger(typeof(WebSupportModule));
// required to enable accessing HttpContext.Request during IHttpModule.Init() in integrated mode
ContextHideRequestResponse = null;
try
{
fiHideRequestResponse = typeof(HttpContext).GetField("HideRequestResponse", BindingFlags.Instance|BindingFlags.NonPublic);
// fiHideRequestResponse.SetValue(HttpContext.Current, false);
ContextHideRequestResponse = (fiHideRequestResponse!=null)?new SafeField(fiHideRequestResponse):null;
}
catch(SecurityException sec)
{
s_log.Warn(string.Format("failed reflecting field HttpContext.HideRequestResponse due to security restrictions {0}", sec));
}
// register additional resource handler
ResourceHandlerRegistry.RegisterResourceHandler(WebUtils.DEFAULT_RESOURCE_PROTOCOL, typeof(WebResource));
// replace default IResource converter
TypeConverterRegistry.RegisterConverter(typeof(IResource),
new ResourceConverter(
new ConfigurableResourceLoader(WebUtils.DEFAULT_RESOURCE_PROTOCOL)));
// default to hybrid thread storage implementation
LogicalThreadContext.SetStorage(new HybridContextStorage());
s_log.Debug("Set default resource protocol to 'web' and installed HttpContext-aware HybridContextStorage");
}
public void TestInstanceMembersOfClass()
{
object testref1 = new object();
object testref2 = new object();
MyClassWithPrivateFields myClass;
// ro readonly int
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyVtField = new SafeField(IField(myClass.GetType(), "instanceReadonlyVTValue"));
Assert.AreEqual(123, instanceReadonlyVtField.GetValue(myClass));
try { instanceReadonlyVtField.SetValue(myClass, 10); }
catch (InvalidOperationException) { }
// ro readonly object
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceReadonlyRefField = new SafeField(IField(myClass.GetType(), "instanceReadonlyRefValue"));
Assert.AreSame(testref1, instanceReadonlyRefField.GetValue(myClass));
try { instanceReadonlyRefField.SetValue(myClass, this); }
catch (InvalidOperationException) { }
// rw int
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceVtField = new SafeField(IField(myClass.GetType(), "instanceVTValue"));
Assert.AreEqual(456, instanceVtField.GetValue(myClass));
instanceVtField.SetValue(myClass, 9182);
Assert.AreEqual(9182, instanceVtField.GetValue(myClass));
// rw object
myClass = new MyClassWithPrivateFields(123, testref1, 456, testref2);
SafeField instanceRefField = new SafeField(IField(myClass.GetType(), "instanceRefValue"));
Assert.AreSame(testref2, instanceRefField.GetValue(myClass));
instanceRefField.SetValue(myClass, testref1);
Assert.AreSame(testref1, instanceRefField.GetValue(myClass));
}
public void SafeFieldPerformanceTests()
{
int runs = 10000000;
object myClass = new MyClassWithPrivateFields(123, new object(), 456, new object());
FieldInfo fieldClassRefValue = IField(myClass.GetType(), "instanceRefValue");
FieldInfo fieldClassVtValue = IField(myClass.GetType(), "instanceVTValue");
StopWatch stopWatch = new StopWatch();
using (stopWatch.Start("Duration Class Set/Get field value: {0}"))
{
for(int i=0;i<runs;i++)
{
SafeField instanceRefField = new SafeField(fieldClassRefValue);
SafeField instanceVtField = new SafeField(fieldClassVtValue);
int res = (int) instanceVtField.GetValue( myClass );
object ores = instanceRefField.GetValue( myClass );
}
}
object myStruct = new MyStructWithPrivateFields(123, new object(), 456, new object());
FieldInfo fieldStructRefValue = IField(myStruct.GetType(), "instanceRefValue");
FieldInfo fieldStructVtValue = IField(myStruct.GetType(), "instanceVTValue");
using (stopWatch.Start("Duration Struct Set/Get field value: {0}"))
{
for(int i=0;i<runs;i++)
{
SafeField instanceRefField = new SafeField(fieldStructRefValue);
SafeField instanceVtField = new SafeField(fieldStructVtValue);
int res = (int) instanceVtField.GetValue( myStruct );
object ores = instanceRefField.GetValue( myStruct );
}
}
/* on my machine prints
with System.Reflection.Emit.DynamicMethod generated code:
Duration Class Set/Get field value: 00:00:03.2031250
Duration Struct Set/Get field value: 00:00:03.5625000
with standard reflection:
Duration Class Set/Get field value: 00:00:45.4218750
Duration Struct Set/Get field value: 00:00:44.5312500
*/
}
public void ThrowsOnNullField()
{
SafeField field = new SafeField(null);
}
public FieldValueAccessor(FieldInfo fieldInfo)
{
this.field = new SafeField(fieldInfo);
this.isWriteable = !(fieldInfo.IsInitOnly || fieldInfo.IsLiteral);
this.targetType = fieldInfo.FieldType;
this.contextType = fieldInfo.DeclaringType;
}
private void TestStaticMembersOf(Type type, object expectedRoRefValue)
{
// ro const int
SafeField constField = new SafeField(SField(type, "constantValue"));
Assert.AreEqual(5, constField.GetValue(null));
try { constField.SetValue(null, 3); }
catch (InvalidOperationException) { }
// ro static readonly int
SafeField roVtField = new SafeField(SField(type, "staticReadonlyVTValue"));
Assert.AreEqual(11, roVtField.GetValue(null));
try { roVtField.SetValue(null, 10); }
catch (InvalidOperationException) { }
// ro static readonly object
SafeField roRefField = new SafeField(SField(type, "staticReadonlyRefValue"));
Assert.AreSame(expectedRoRefValue, roRefField.GetValue(null));
try { roRefField.SetValue(null, new object()); }
catch (InvalidOperationException) { }
// rw static int
SafeField vtField = new SafeField(SField(type, "staticVTValue"));
vtField.SetValue(null, 10);
Assert.AreEqual(10, vtField.GetValue(null));
// rw static object
SafeField refField = new SafeField(SField(type, "staticRefValue"));
object o = new object();
refField.SetValue(null, o);
Assert.AreSame(o, refField.GetValue(null));
}
