public void On_interfaces() { var options = new ProxyGenerationOptions(); options.AdditionalAttributes.Add(AttributeUtil.CreateBuilder <__Protect>()); var proxy = generator.CreateInterfaceProxyWithoutTarget(typeof(IDisposable), new Type[0], options); Assert.IsTrue(proxy.GetType().IsDefined(typeof(__Protect), false)); }
public void On_class() { var options = new ProxyGenerationOptions(); options.AdditionalAttributes.Add(AttributeUtil.CreateBuilder <__Protect>()); var proxy = generator.CreateClassProxy(typeof(CanDefineAdditionalCustomAttributes), options); Assert.IsTrue(proxy.GetType().IsDefined(typeof(__Protect), false)); }
public void DefineCustomAttributeFor <TAttribute>(FieldReference field) where TAttribute : Attribute, new() { var customAttributeBuilder = AttributeUtil.CreateBuilder <TAttribute>(); var fieldbuilder = field.Fieldbuilder; if (fieldbuilder == null) { throw new ArgumentException("Invalid field reference.This reference does not point to field on type being generated", "field"); } fieldbuilder.SetCustomAttribute(customAttributeBuilder); }
public void AddCustomAttributes(ProxyGenerationOptions proxyGenerationOptions) { foreach (var attr in proxyGenerationOptions.attributesToAddToGeneratedTypes) { var customAttributeBuilder = AttributeUtil.CreateBuilder(attr); if (customAttributeBuilder != null) { typebuilder.SetCustomAttribute(customAttributeBuilder); } } foreach (var attribute in proxyGenerationOptions.AdditionalAttributes) { typebuilder.SetCustomAttribute(attribute); } }
/// <summary> /// Constructs an instance of the Mock Repository. /// </summary> /// <remarks> /// There is very little reason to instantiate an instance of MockRepository. /// This is intended for internal use only. /// </remarks> public MockRepository() { delegateRepository = new RepositoryForDelegates(); generatorOptions = new ProxyGenerationOptions { Selector = new RhinoSelector(), }; generatorOptions.AdditionalAttributes .Add(AttributeUtil.CreateBuilder <__ProtectAttribute>()); defaultOptions = new ProxyGenerationOptions { Selector = new RhinoSelector(), }; ArgumentManager.Clear(); }
protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseConstructor, params FieldReference[] fields) { ArgumentReference[] args; ParameterInfo[] baseConstructorParams = null; if (baseConstructor != null) { baseConstructorParams = baseConstructor.GetParameters(); } if (baseConstructorParams != null && baseConstructorParams.Length != 0) { args = new ArgumentReference[fields.Length + baseConstructorParams.Length]; var offset = fields.Length; for (var i = offset; i < offset + baseConstructorParams.Length; i++) { var paramInfo = baseConstructorParams[i - offset]; args[i] = new ArgumentReference(paramInfo.ParameterType); } } else { args = new ArgumentReference[fields.Length]; } for (var i = 0; i < fields.Length; i++) { args[i] = new ArgumentReference(fields[i].Reference.FieldType); } var constructor = emitter.CreateConstructor(args); if (baseConstructorParams != null && baseConstructorParams.Length != 0) { var last = baseConstructorParams.Last(); if (last.ParameterType.GetTypeInfo().IsArray&& last.IsDefined(typeof(ParamArrayAttribute))) { var parameter = constructor.ConstructorBuilder.DefineParameter(args.Length, ParameterAttributes.None, last.Name); var builder = AttributeUtil.CreateBuilder <ParamArrayAttribute>(); parameter.SetCustomAttribute(builder); } } for (var i = 0; i < fields.Length; i++) { constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression())); } // Invoke base constructor if (baseConstructor != null) { Debug.Assert(baseConstructorParams != null); var slice = new ArgumentReference[baseConstructorParams.Length]; Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length); constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice); } else { constructor.CodeBuilder.InvokeBaseConstructor(); } constructor.CodeBuilder.AddStatement(new ReturnStatement()); }
public void DefineCustomAttribute <TAttribute>() where TAttribute : Attribute, new() { var customAttributeBuilder = AttributeUtil.CreateBuilder <TAttribute>(); typebuilder.SetCustomAttribute(customAttributeBuilder); }
public void DefineCustomAttribute <TAttribute>(object[] constructorArguments) where TAttribute : Attribute { var customAttributeBuilder = AttributeUtil.CreateBuilder(typeof(TAttribute), constructorArguments); typebuilder.SetCustomAttribute(customAttributeBuilder); }
public object Create(object some = null, Type typeToTrack = null, ObjectChangeTracker reusedTracker = null, object parentObject = null, PropertyInfo propertyToSet = null, object[] constructorArguments = null) { typeToTrack = typeToTrack ?? some.GetType(); ITrackableType interfaceTrackableType = null; if ((Configuration.CanTrackType(typeToTrack) || Configuration.ImplementsBaseType(typeToTrack, out interfaceTrackableType)) && !typeToTrack.IsTrackable()) { if (interfaceTrackableType != null) { Configuration.TrackThisTypeRecursive ( typeToTrack, trackableType => { if (trackableType.Type == typeToTrack) { trackableType.IncludeProperties(interfaceTrackableType.IncludedProperties.ToArray()); } } ); } Contract.Assert(typeToTrack.IsClass && !typeToTrack.IsAbstract && !typeToTrack.IsSealed, $"The object type to track '{typeToTrack.AssemblyQualifiedName}' must be a non-abstract, non-sealed class"); ProxyGenerationOptions options = new ProxyGenerationOptions(new SimplePropertyInterceptionHook(Configuration)); options.AddMixinInstance(new ChangeTrackableObjectMixin(Configuration, this)); options.AdditionalAttributes.Add(AttributeUtil.CreateBuilder(typeof(DebuggerDisplayAttribute), new[] { $"{typeToTrack.FullName}Proxy" })); List <IInterceptor> interceptors = new List <IInterceptor> { new SimplePropertyInterceptor() }; if (typeToTrack.IsDynamicObject()) { interceptors.Add(new DynamicObjectInterceptor(Configuration, this)); } object proxy; if (some != null) { proxy = ProxyGenerator.CreateClassProxyWithTarget ( classToProxy: typeToTrack, additionalInterfacesToProxy: new[] { typeof(IChangeTrackableObject) }, target: some, options: options, interceptors: interceptors.ToArray() ); } else { proxy = ProxyGenerator.CreateClassProxy ( classToProxy: typeToTrack, additionalInterfacesToProxy: new[] { typeof(IChangeTrackableObject) }, options: options, constructorArguments: constructorArguments, interceptors: interceptors.ToArray() ); } IChangeTrackableObject trackableObject = (IChangeTrackableObject)proxy; ObjectChangeTrackingContext trackingContext = trackableObject.GetChangeTrackingContext(); trackingContext.State = ChangeTrackableObjectState.Constructing; trackableObject.StartTracking(trackableObject, reusedTracker); trackingContext.State = ChangeTrackableObjectState.Ready; HashSet <PropertyInfo> propertiesToTrack = new HashSet <PropertyInfo>(Configuration.GetTrackableType(typeToTrack).IncludedProperties); if (propertiesToTrack.Count() == 0) { foreach (PropertyInfo property in typeToTrack.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { propertiesToTrack.Add(property); } } foreach (PropertyInfo property in propertiesToTrack) { if (!property.IsIndexer() && property.CanReadAndWrite()) { object propertyValue = property.GetValue(trackableObject); if (propertyValue != null) { Create(propertyValue, trackableObject.GetChangeTrackingContext().ChangeTracker, proxy, property); } else { Create(property.PropertyType, trackableObject.GetChangeTrackingContext().ChangeTracker, proxy, property); } } } if (propertyToSet != null) { propertyToSet.SetValue(parentObject ?? proxy, proxy); } trackableObject.AcceptChanges(); return(proxy); } else { return(some); } }