/// <summary> /// Initializes a new instance of the <see cref="ObjectDefinitionParser"/> class. /// </summary> /// <param name="domainObjectType">Type of the domain object you are going to configure for DI.</param> /// <param name="identifier">An identifier to use when declaring several configuration for the same domain type.</param> public ObjectDefinitionParser(Type domainObjectType, string identifier) { _domainObjectType = domainObjectType; _identifier = identifier; _autoWiringMode = FluentStaticConfiguration.DefaultWiringMode; _dependencyCheckMode = FluentStaticConfiguration.DefaultDependencyCheckingMode; }
protected AbstractObjectDefinition(SerializationInfo info, StreamingContext context) { constructorArgumentValues = (ConstructorArgumentValues)info.GetValue("constructorArgumentValues", typeof(ConstructorArgumentValues)); propertyValues = (MutablePropertyValues)info.GetValue("propertyValues", typeof(MutablePropertyValues)); eventHandlerValues = (EventValues)info.GetValue("eventHandlerValues", typeof(EventValues)); methodOverrides = (MethodOverrides)info.GetValue("methodOverrides", typeof(MethodOverrides)); resourceDescription = info.GetString("resourceDescription"); isSingleton = info.GetBoolean("isSingleton"); isPrototype = info.GetBoolean("isPrototype"); isLazyInit = info.GetBoolean("isLazyInit"); isAbstract = info.GetBoolean("isAbstract"); scope = info.GetString("scope"); role = (ObjectRole)info.GetValue("role", typeof(ObjectRole)); var objectTypeName = info.GetString("objectTypeName"); objectType = objectTypeName != null?Type.GetType(objectTypeName) : null; autowireMode = (AutoWiringMode)info.GetValue("autowireMode", typeof(AutoWiringMode)); dependencyCheck = (DependencyCheckingMode)info.GetValue("dependencyCheck", typeof(DependencyCheckingMode)); dependsOn = (IList <string>)info.GetValue("dependsOn", typeof(IList <string>)); autowireCandidate = info.GetBoolean("autowireCandidate"); primary = info.GetBoolean("primary"); qualifiers = (IDictionary <string, AutowireCandidateQualifier>)info.GetValue("qualifiers", typeof(IDictionary <string, AutowireCandidateQualifier>)); initMethodName = info.GetString("initMethodName"); destroyMethodName = info.GetString("destroyMethodName"); factoryMethodName = info.GetString("factoryMethodName"); factoryObjectName = info.GetString("factoryObjectName"); }
/// <summary> /// Creates a new instance of the /// <see cref="Oragon.Spring.Objects.Factory.Support.RootObjectDefinition"/> class /// for a singleton using the supplied /// <see cref="Oragon.Spring.Objects.Factory.Config.AutoWiringMode"/>. /// </summary> /// <param name="type"> /// The <see cref="System.Type"/> of the object to instantiate. /// </param> /// <param name="autowireMode"> /// The autowiring mode. /// </param> /// <param name="dependencyCheck"> /// Whether to perform a dependency check for objects (not /// applicable to autowiring a constructor, thus ignored there) /// </param> public RootObjectDefinition( Type type, AutoWiringMode autowireMode, bool dependencyCheck) { ObjectType = type; AutowireMode = autowireMode; if (dependencyCheck && ResolvedAutowireMode != AutoWiringMode.Constructor) { DependencyCheck = DependencyCheckingMode.Objects; } }
/// <summary> /// Creates a new instance of the /// <see cref="Oragon.Spring.Objects.Factory.Support.RootObjectDefinition"/> class /// for a singleton using the supplied /// <see cref="Oragon.Spring.Objects.Factory.Config.AutoWiringMode"/>. /// </summary> /// <param name="type"> /// The <see cref="System.Type"/> of the object to instantiate. /// </param> /// <param name="autowireMode"> /// The autowiring mode. /// </param> public RootObjectDefinition(Type type, AutoWiringMode autowireMode) { ObjectType = type; AutowireMode = autowireMode; }
/// <summary> /// Sets the autowire mode for this definition. /// </summary> /// <param name="autowireMode">The autowire mode.</param> /// <returns>The current <code>ObjectDefinitionBuilder</code>.</returns> public ObjectDefinitionBuilder SetAutowireMode(AutoWiringMode autowireMode) { objectDefinition.AutowireMode = autowireMode; return(this); }
/// <summary> /// Sets the autowire mode for this definition. /// </summary> /// <param name="autowireMode">The autowire mode.</param> /// <returns>The current <code>ObjectDefinitionBuilder</code>.</returns> public ObjectDefinitionBuilder SetAutowireMode(AutoWiringMode autowireMode) { objectDefinition.AutowireMode = autowireMode; return this; }
/// <summary> /// Autowire the object properties of the given object instance by name or /// <see cref="System.Type"/>. /// </summary> /// <param name="instance"> /// The existing object instance. /// </param> /// <param name="autowireMode"> /// The desired autowiring mode. /// </param> /// <param name="dependencyCheck"> /// Whether to perform a dependency check for the object. /// </param> /// <exception cref="Spring.Objects.ObjectsException"> /// If the wiring fails. /// </exception> /// <exception cref="System.ArgumentException"> /// If the supplied <paramref name="autowireMode"/> is not one of the /// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode.ByName"/> or /// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode.ByType"/> /// values. /// </exception> /// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode"/> public virtual void AutowireObjectProperties(object instance, AutoWiringMode autowireMode, bool dependencyCheck) { if (autowireMode != AutoWiringMode.ByName && autowireMode != AutoWiringMode.ByType) { throw new ArgumentException("Just AutoWiringMode.ByName and AutoWiringMode.ByType allowed."); } RootObjectDefinition rod = new RootObjectDefinition(instance.GetType(), autowireMode, dependencyCheck); PopulateObject(instance.GetType().Name, rod, new ObjectWrapper(instance)); }
/// <summary> /// Create a new object instance of the given class with the specified /// autowire strategy. /// </summary> /// <param name="type"> /// The <see cref="System.Type"/> of the object to instantiate. /// </param> /// <param name="autowireMode"> /// The desired autowiring mode. /// </param> /// <param name="dependencyCheck"> /// Whether to perform a dependency check for objects (not applicable to /// autowiring a constructor, thus ignored there). /// </param> /// <returns>The new object instance.</returns> /// <exception cref="Spring.Objects.ObjectsException"> /// If the wiring fails. /// </exception> /// <seealso cref="Spring.Objects.Factory.Config.AutoWiringMode"/> public virtual object Autowire(Type type, AutoWiringMode autowireMode, bool dependencyCheck) { RootObjectDefinition rod = new RootObjectDefinition(type, autowireMode, dependencyCheck); if (rod.ResolvedAutowireMode == AutoWiringMode.Constructor) { return AutowireConstructor(type.Name, rod, null, null).WrappedInstance; } object obj = InstantiationStrategy.Instantiate(rod, string.Empty, this); PopulateObject(obj.GetType().Name, rod, new ObjectWrapper(obj)); return obj; }
/// <summary> /// 如果某个类型未在容器注册,则注册该类型 /// </summary> /// <param name="container"></param> /// <param name="alias"></param> /// <param name="registerType"></param> /// <param name="registerAsSingleton"></param> /// <param name="autoWiringMode"></param> public static void RegisterTypeIfMissing(this IApplicationContext container, string alias, Type registerType, bool registerAsSingleton, AutoWiringMode autoWiringMode, bool lazyInit = false) { Type typeToRegister = registerType; if (!container.ContainsObjectDefinition(alias)) { DefaultObjectDefinitionFactory definitionFactory = new DefaultObjectDefinitionFactory(); ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.RootObjectDefinition(definitionFactory, typeToRegister); builder.SetSingleton(registerAsSingleton); builder.SetAutowireMode(autoWiringMode); builder.SetLazyInit(lazyInit); IConfigurableApplicationContext configurableContext = container as IConfigurableApplicationContext; IObjectDefinitionRegistry definitionRegistry = container as IObjectDefinitionRegistry; if (definitionRegistry != null) { definitionRegistry.RegisterObjectDefinition(alias, builder.ObjectDefinition); //if (configurableContext != null) //{ // configurableContext.Refresh(); //} } } }
/// <summary> /// 如果某个类型未在容器注册,则注册该类型 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="alias"></param> /// <param name="registerAsSingleton"></param> /// <param name="autoWiringMode"></param> public static void RegisterTypeIfMissing <T>(this IApplicationContext container, string alias, bool registerAsSingleton, AutoWiringMode autoWiringMode) where T : class { Type typeToRegister = typeof(T); RegisterTypeIfMissing(container, alias, typeToRegister, registerAsSingleton, autoWiringMode); }
public IObjectConfigurationBuildStage <TObject> Autowire(AutoWiringMode mode) { _definition.AutowireMode = mode; return(this); }
public ICanConfigureObject <T> AutoWire(AutoWiringMode wiringMode) { _configurationParser.AutoWire(wiringMode); return(this); }
public void AutoWire(AutoWiringMode wiringMode) { _autoWiringMode = wiringMode; }
public static void SetSpringDefault(AutoWiringMode wiringMode, DependencyCheckingMode dependencyCheckMode) { FluentStaticConfiguration.DefaultWiringMode = wiringMode; FluentStaticConfiguration.DefaultDependencyCheckingMode = dependencyCheckMode; }
/// <summary> /// Creates a new instance of the /// <see cref="Spring.Objects.Factory.Support.RootObjectDefinition"/> class /// for a singleton using the supplied /// <see cref="Spring.Objects.Factory.Config.AutoWiringMode"/>. /// </summary> /// <param name="type"> /// The <see cref="System.Type"/> of the object to instantiate. /// </param> /// <param name="autowireMode"> /// The autowiring mode. /// </param> /// <param name="dependencyCheck"> /// Whether to perform a dependency check for objects (not /// applicable to autowiring a constructor, thus ignored there) /// </param> public RootObjectDefinition( Type type, AutoWiringMode autowireMode, bool dependencyCheck) { ObjectType = type; AutowireMode = autowireMode; if (dependencyCheck && ResolvedAutowireMode != AutoWiringMode.Constructor) { DependencyCheck = DependencyCheckingMode.Objects; } }
/// <summary> /// Creates a new instance of the /// <see cref="Spring.Objects.Factory.Support.RootObjectDefinition"/> class /// for a singleton using the supplied /// <see cref="Spring.Objects.Factory.Config.AutoWiringMode"/>. /// </summary> /// <param name="type"> /// The <see cref="System.Type"/> of the object to instantiate. /// </param> /// <param name="autowireMode"> /// The autowiring mode. /// </param> public RootObjectDefinition(Type type, AutoWiringMode autowireMode) { ObjectType = type; AutowireMode = autowireMode; }