private void _Implement(FluentTypeBuilder <TAbstract> typeBuilder, Type interfaceType) { foreach (var method in interfaceType.GetMethods()) { if (method.IsAbstract) { ImplementAnyMethod(typeBuilder, method); } } foreach (var property in interfaceType.GetProperties()) { if (_IsAbstract(property)) { ImplementAnyProperty(typeBuilder, property); } } foreach (var eventInfo in interfaceType.GetEvents()) { if (eventInfo.GetAddMethod().IsAbstract) { ImplementEventUntyped(typeBuilder, eventInfo); } } }
/// <summary> /// This method is invoked to implement any method, be it a normal method, a property getter, setter etc. /// If you want to implement only normal methods, inherit the ImplementMethod method. /// </summary> protected virtual void ImplementAnyMethod(FluentTypeBuilder <TAbstract> typeBuilder, MethodInfo method) { if (!method.IsSpecialName) { ImplementMethod(typeBuilder, method); } }
private FluentTypeBuilder <TAbstract> _GetTypeBuilder() { if (_typeBuilder != null) { return(_typeBuilder); } var typeBuilder = CreateTypeBuilder(_additionalInterfaces); _Implement(typeBuilder, typeof(TAbstract)); if (typeof(TAbstract).IsInterface) { var baseInterfaces = typeof(TAbstract).GetInterfaces(); foreach (var baseInterface in baseInterfaces) { _Implement(typeBuilder, baseInterface); } } if (_additionalInterfaces != null) { foreach (var additionalInterface in _additionalInterfaces) { if (!additionalInterface.IsAssignableFrom(typeof(TAbstract))) { _Implement(typeBuilder, additionalInterface); } } } _typeBuilder = typeBuilder; return(typeBuilder); }
/// <summary> /// This method is invoked to implement any property, be it a normal property or an indexer. /// If you want to generate only properties, override the ImplementPropertyUntyped or the ImplementProperty generic method. /// </summary> protected virtual void ImplementAnyProperty(FluentTypeBuilder <TAbstract> typeBuilder, PropertyInfo property) { if (property.GetIndexParameters().Length > 0) { ImplementIndexerUntyped(typeBuilder, property); } else { ImplementPropertyUntyped(typeBuilder, property); } }
/// <summary> /// Creates a new NotifyPropertyChangedGenerator that will work with the given typeBuilder /// and also let you tell where is the field that stores the PropertyChanged delegates. /// </summary> public static NotifyPropertyChangedGenerator <TBase> Create <TBase>(FluentTypeBuilder <TBase> typeBuilder, Expression <Func <PropertyChangedEventHandler> > eventHandlerFieldExpression) { return(new NotifyPropertyChangedGenerator <TBase>(typeBuilder, eventHandlerFieldExpression)); }
/// <summary> /// Creates a new NotifyPropertyChangedGenerator that will work with the given typeBuilder. /// </summary> public static NotifyPropertyChangedGenerator <TBase> Create <TBase>(FluentTypeBuilder <TBase> typeBuilder) { return(new NotifyPropertyChangedGenerator <TBase>(typeBuilder)); }
/// <summary> /// Method invoked to implement events. /// </summary> protected abstract void ImplementEvent <T>(FluentTypeBuilder <TAbstract> typeBuilder, EventInfo eventInfo);
/// <summary> /// Method invoked to implement indexers. /// </summary> protected abstract void ImplementIndexerUntyped(FluentTypeBuilder <TAbstract> typeBuilder, PropertyInfo indexer);
/// <summary> /// Method invoked to implement properties. /// </summary> protected abstract void ImplementProperty <T>(FluentTypeBuilder <TAbstract> typeBuilder, PropertyInfo property);
/// <summary> /// Method invoked to implement methods. /// </summary> protected abstract void ImplementMethod(FluentTypeBuilder <TAbstract> typeBuilder, MethodInfo method);
/// <summary> /// This method is invoked to implement events, but it is not typed. It is usually better to only override the /// ImplementEvent generic method. /// </summary> protected virtual void ImplementEventUntyped(FluentTypeBuilder <TAbstract> typeBuilder, EventInfo eventInfo) { var implementEvent = _implementEvent.MakeGenericMethod(eventInfo.EventHandlerType); implementEvent.Invoke(this, new object[] { typeBuilder, eventInfo }); }
/// <summary> /// This method is invoked to implement normal properties (that is, excluding indexers), but it does not have the /// parameters rightly typed, which can make it hard to build the expression. You will probably prefer to inherit /// the ImplementProperty generic method. /// </summary> protected virtual void ImplementPropertyUntyped(FluentTypeBuilder <TAbstract> typeBuilder, PropertyInfo property) { var implementProperty = _implementProperty.MakeGenericMethod(property.PropertyType); implementProperty.Invoke(this, new object[] { typeBuilder, property }); }