// /// <summary> // /// Create an object instance for the given object definition. // /// </summary> // /// <param name="name">The name of the object.</param> // /// <param name="definition"> // /// The object definition for the object that is to be instantiated. // /// </param> // /// <param name="arguments"> // /// The arguments to use if creating a prototype using explicit arguments to // /// a static factory method. It is invalid to use a non-<see langword="null"/> arguments value // /// in any other case. // /// </param> // /// <returns> // /// A new instance of the object. // /// </returns> // /// <exception cref="Spring.Objects.ObjectsException"> // /// In case of errors. // /// </exception> // /// <remarks> // /// <p> // /// Delegates to the // /// <see cref="Spring.Objects.Factory.Support.AbstractAutowireCapableObjectFactory.CreateObject (string,RootObjectDefinition,object[],bool)"/> // /// method version with the <c>allowEagerCaching</c> parameter set to <b>true</b>. // /// </p> // /// <p> // /// The object definition will already have been merged with the parent // /// definition in case of a child definition. // /// </p> // /// <p> // /// All the other methods in this class invoke this method, although objects // /// may be cached after being instantiated by this method. All object // /// instantiation within this class is performed by this method. // /// </p> // /// </remarks> // protected internal override object CreateObject(string name, RootObjectDefinition definition, object[] arguments) // { // return CreateObject(name, definition, arguments, true, false); // } /// <summary> /// Create an object instance for the given object definition. /// </summary> /// <param name="name">The name of the object.</param> /// <param name="definition"> /// The object definition for the object that is to be instantiated. /// </param> /// <param name="arguments"> /// The arguments to use if creating a prototype using explicit arguments to /// a static factory method. It is invalid to use a non-<see langword="null"/> arguments value /// in any other case. /// </param> /// <param name="allowEagerCaching"> /// Whether eager caching of singletons is allowed... typically true for /// singlton objects, but never true for inner object definitions. /// </param> /// <param name="suppressConfigure"> /// Suppress injecting dependencies yet. /// </param> /// <returns> /// A new instance of the object. /// </returns> /// <exception cref="Spring.Objects.ObjectsException"> /// In case of errors. /// </exception> /// <remarks> /// <p> /// The object definition will already have been merged with the parent /// definition in case of a child definition. /// </p> /// <p> /// All the other methods in this class invoke this method, although objects /// may be cached after being instantiated by this method. All object /// instantiation within this class is performed by this method. /// </p> /// </remarks> protected internal override object InstantiateObject(string name, RootObjectDefinition definition, object[] arguments, bool allowEagerCaching, bool suppressConfigure) { // guarantee the initialization of objects that the current one depends on.. if (definition.DependsOn != null && definition.DependsOn.Length > 0) { foreach (string dependant in definition.DependsOn) { GetObject(dependant); } } #region Instrumentation if (log.IsDebugEnabled) { log.Debug(string.Format(CultureInfo.InvariantCulture, "Creating instance of Object '{0}' with merged definition [{1}].", name, definition)); } #endregion // Make sure object type is actually resolved at this point. ResolveObjectType(definition, name); try { definition.PrepareMethodOverrides(); } catch (ObjectDefinitionValidationException ex) { throw new ObjectDefinitionStoreException(definition.ResourceDescription, name, "Validation of method overrides failed. " + ex.Message, ex); } // return IObjectDefinition instance itself for an abstract object-definition if (definition.IsTemplate) { return definition; } object instance = null; IObjectWrapper instanceWrapper = null; bool eagerlyCached = false; try { // Give IInstantiationAwareObjectPostProcessors a chance to return a proxy instead of the target instance.... if (definition.HasObjectType) { instance = ApplyObjectPostProcessorsBeforeInstantiation(definition.ObjectType, name); if (instance != null) { return instance; } } instanceWrapper = CreateObjectInstance(name, definition, arguments); instance = instanceWrapper.WrappedInstance; // eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like IObjectFactoryAware. if (allowEagerCaching && definition.IsSingleton) { if (log.IsDebugEnabled) { log.Debug("Eagerly caching object '" + name + "' to allow for resolving potential circular references"); } AddEagerlyCachedSingleton(name, definition, instance); eagerlyCached = true; } if (!suppressConfigure) { instance = ConfigureObject(name, definition, instanceWrapper); } } catch (ObjectCreationException) { if (eagerlyCached) { RemoveEagerlyCachedSingleton(name, definition); } throw; } catch (Exception ex) { if (eagerlyCached) { RemoveEagerlyCachedSingleton(name, definition); } throw new ObjectCreationException(definition.ResourceDescription, name, "Initialization of object failed : " + ex.Message, ex); } return instance; }