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); }
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 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 FieldValueAccessor(FieldInfo fieldInfo) { this.field = new SafeField(fieldInfo); this.isWriteable = !(fieldInfo.IsInitOnly || fieldInfo.IsLiteral); this.targetType = fieldInfo.FieldType; this.contextType = fieldInfo.DeclaringType; }