public void SunnyDayPath()
{
IObjectFactory objectFactory = (IObjectFactory)mocks.CreateMock(typeof(IObjectFactory));
IConfigurableObjectDefinition configurableObjectDefinition =
(IConfigurableObjectDefinition)mocks.CreateMock(typeof(IConfigurableObjectDefinition));
object expectedLookup = new object();
const string LookupObjectName = "foo";
Expect.Call(objectFactory.GetObject(LookupObjectName)).Return(expectedLookup);
LookupMethodOverride ovr = new LookupMethodOverride("SunnyDayPath", LookupObjectName);
MethodOverrides overrides = new MethodOverrides();
overrides.Add(ovr);
Expect.Call(configurableObjectDefinition.MethodOverrides).Return(overrides);
LookupMethodReplacer replacer = new LookupMethodReplacer(configurableObjectDefinition, objectFactory);
mocks.ReplayAll();
MethodInfo method = (MethodInfo)MethodBase.GetCurrentMethod();
object lookup = replacer.Implement(this, method, new object[] {});
Assert.AreSame(expectedLookup, lookup);
mocks.VerifyAll();
}
protected override ObjectDefinitionHolder CreateObjectDefinitionHolder(
XmlElement element,
IConfigurableObjectDefinition definition,
string objectName,
IReadOnlyList <string> aliasesArray)
{
if (definition is IWebObjectDefinition webDefinition)
{
if (definition.IsSingleton &&
element.HasAttribute(ObjectDefinitionConstants.ScopeAttribute))
{
webDefinition.Scope = GetScope(element.GetAttribute(ObjectDefinitionConstants.ScopeAttribute));
}
// force request and session scoped objects to be lazily initialized...
if (webDefinition.Scope == ObjectScope.Request ||
webDefinition.Scope == ObjectScope.Session)
{
definition.IsLazyInit = true;
}
// string typeName = element.GetAttribute(ObjectDefinitionConstants.TypeAttribute);
string typeName = definition.ObjectTypeName;
if (typeName != null &&
(typeName.EndsWith(".ascx") || typeName.EndsWith(".master")))
{
definition.IsAbstract = true;
}
}
ObjectDefinitionHolder holder = base.CreateObjectDefinitionHolder(element, definition, objectName, aliasesArray);
return(holder);
}
private IObjectDefinition ParseExceptionAction(XmlElement element, ParserContext parserContext)
{
string typeName = "Spring.Validation.Actions.ExceptionAction, Spring.Core";
string throwExpression = GetAttributeValue(element, ValidatorDefinitionConstants.ThrowAttribute);
ConstructorArgumentValues ctorArgs = new ConstructorArgumentValues();
ctorArgs.AddGenericArgumentValue(throwExpression);
string when = GetAttributeValue(element, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
IConfigurableObjectDefinition action =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
action.ConstructorArgumentValues = ctorArgs;
action.PropertyValues = properties;
return(action);
}
/// <summary>
/// Parses the RemotingConfigurer definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>RemotingConfigurer object definition.</returns>
private IConfigurableObjectDefinition ParseRemotingConfigurer(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string filename = element.GetAttribute(RemotingConfigurerConstants.FilenameAttribute);
string useConfigFile = element.GetAttribute(RemotingConfigurerConstants.UseConfigFileAttribute);
string ensureSecurity = element.GetAttribute(RemotingConfigurerConstants.EnsureSecurityAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(filename))
{
properties.Add("Filename", filename);
}
if (StringUtils.HasText(useConfigFile))
{
properties.Add("UseConfigFile", useConfigFile);
}
if (StringUtils.HasText(ensureSecurity))
{
properties.Add("EnsureSecurity", ensureSecurity);
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return(cod);
}
public void SunnyDayPath()
{
IObjectFactory mockFactory = (IObjectFactory)mocks.CreateMock(typeof(IObjectFactory));
IConfigurableObjectDefinition mockDefinition = (IConfigurableObjectDefinition)mocks.CreateMock(typeof(IConfigurableObjectDefinition));
IMethodReplacer mockReplacer = (IMethodReplacer)mocks.CreateMock(typeof(IMethodReplacer));
const string ReplacerObjectName = "replacer";
Expect.Call(mockFactory.GetObject(ReplacerObjectName)).Return(mockReplacer);
ReplacedMethodOverride ovr = new ReplacedMethodOverride("SunnyDayPath", ReplacerObjectName);
MethodOverrides overrides = new MethodOverrides();
overrides.Add(ovr);
Expect.Call(mockDefinition.MethodOverrides).Return(overrides);
Expect.Call(mockReplacer.Implement(null, null, null)).IgnoreArguments().Return(null);
mocks.ReplayAll();
DelegatingMethodReplacer replacer = new DelegatingMethodReplacer(mockDefinition, mockFactory);
MethodInfo method = (MethodInfo)MethodBase.GetCurrentMethod();
replacer.Implement(this, method, new object[] {});
mocks.VerifyAll();
}
/// <summary>
/// Creates an error message action based on the specified message element.
/// </summary>
/// <param name="message">The message element.</param>
/// <param name="parserContext">The parser helper.</param>
/// <returns>The error message action definition.</returns>
private static IObjectDefinition ParseErrorMessageAction(XmlElement message, ParserContext parserContext)
{
string messageId = GetAttributeValue(message, MessageConstants.IdAttribute);
string[] providers = GetAttributeValue(message, MessageConstants.ProvidersAttribute).Split(',');
ArrayList parameters = new ArrayList();
foreach (XmlElement param in message.ChildNodes)
{
IExpression paramExpression = Expression.Parse(GetAttributeValue(param, MessageConstants.ParameterValueAttribute));
parameters.Add(paramExpression);
}
string typeName = "Spring.Validation.Actions.ErrorMessageAction, Spring.Core";
ConstructorArgumentValues ctorArgs = new ConstructorArgumentValues();
ctorArgs.AddGenericArgumentValue(messageId);
ctorArgs.AddGenericArgumentValue(providers);
string when = GetAttributeValue(message, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
if (parameters.Count > 0)
{
properties.Add("Parameters", parameters.ToArray(typeof(IExpression)));
}
IConfigurableObjectDefinition action =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
action.ConstructorArgumentValues = ctorArgs;
action.PropertyValues = properties;
return action;
}
/// <summary>The parse inner object definition.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>The Spring.Objects.Factory.Config.IObjectDefinition.</returns>
public static IObjectDefinition ParseInnerObjectDefinition(XmlElement element, ParserContext parserContext)
{
// parses out inner object definition for concrete implementation if defined
var childElements = element.GetElementsByTagName("object");
IObjectDefinition innerComponentDefinition = null;
IConfigurableObjectDefinition inDef = null;
if (childElements != null && childElements.Count == 1)
{
var objectElement = childElements[0] as XmlElement;
// var odDelegate = parserContext.GetDelegate();
var odHolder = parserContext.ParserHelper.ParseObjectDefinitionElement(objectElement);
// odHolder = odDelegate.DecorateObjectDefinitionIfRequired(objectElement, odHolder);
inDef = odHolder.ObjectDefinition as IConfigurableObjectDefinition;
var objectName = ObjectDefinitionReaderUtils.GenerateObjectName(inDef, parserContext.Registry);
// innerComponentDefinition = new ObjectComponentDefinition(inDef, objectName);
parserContext.Registry.RegisterObjectDefinition(objectName, inDef);
}
var aRef = element.GetAttribute(REF_ATTRIBUTE);
AssertUtils.IsTrue(
!(!string.IsNullOrWhiteSpace(aRef) && inDef != null),
"Ambiguous definition. Inner object " + (inDef == null ? string.Empty : inDef.ObjectTypeName) + " declaration and \"ref\" " + aRef + " are not allowed together."
);
return(inDef);
}
/// <summary>
/// Creates object definition for the validator reference.
/// </summary>
/// <param name="element">The action definition element.</param>
/// <param name="parserContext">The parser helper.</param>
/// <returns>Generic validation action definition.</returns>
private IObjectDefinition ParseValidatorReference(XmlElement element, ParserContext parserContext)
{
string typeName = "Spring.Validation.ValidatorReference, Spring.Core";
string name = GetAttributeValue(element, ValidatorDefinitionConstants.ReferenceNameAttribute);
string context = GetAttributeValue(element, ValidatorDefinitionConstants.ReferenceContextAttribute);
string when = GetAttributeValue(element, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
properties.Add("Name", name);
if (StringUtils.HasText(context))
{
properties.Add("Context", context);
}
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
IConfigurableObjectDefinition reference =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
reference.PropertyValues = properties;
return(reference);
}
public void InstantiationWithNullFactory()
{
IConfigurableObjectDefinition mock = (IConfigurableObjectDefinition)
mocks.CreateMock(typeof(IConfigurableObjectDefinition));
new DelegatingMethodReplacer(mock, null);
}
protected override ObjectDefinitionHolder CreateObjectDefinitionHolder(XmlElement element, IConfigurableObjectDefinition definition, string objectName, string[] aliasesArray)
{
IWebObjectDefinition webDefinition = definition as IWebObjectDefinition;
if (webDefinition != null)
{
if (definition.IsSingleton
&& element.HasAttribute(ObjectDefinitionConstants.ScopeAttribute))
{
webDefinition.Scope = GetScope(element.GetAttribute(ObjectDefinitionConstants.ScopeAttribute));
}
// force request and session scoped objects to be lazily initialized...
if (webDefinition.Scope == ObjectScope.Request
|| webDefinition.Scope == ObjectScope.Session)
{
definition.IsLazyInit = true;
}
// string typeName = element.GetAttribute(ObjectDefinitionConstants.TypeAttribute);
string typeName = definition.ObjectTypeName;
if (typeName != null
&& (typeName.EndsWith(".ascx") || typeName.EndsWith(".master")))
{
definition.IsAbstract = true;
}
}
ObjectDefinitionHolder holder = base.CreateObjectDefinitionHolder(element, definition, objectName, aliasesArray);
return holder;
}
/// <summary>
/// Allows for custom modification of an application context's object definitions.
/// </summary>
/// <remarks>
/// <p>
/// If the object name matches, replaces the type by a AOP proxied type based on inheritance.
/// </p>
/// </remarks>
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
IList <string> objectDefinitionNames = factory.GetObjectDefinitionNames();
for (int i = 0; i < objectDefinitionNames.Count; ++i)
{
string name = objectDefinitionNames[i];
if (IsObjectNameMatch(name))
{
IConfigurableObjectDefinition definition =
factory.GetObjectDefinition(name) as IConfigurableObjectDefinition;
if (definition == null || IsInfrastructureType(definition.ObjectType, name))
{
continue;
}
ProxyFactory pf = CreateProxyFactory(definition.ObjectType, name);
InheritanceAopProxyTypeBuilder iaptb = new InheritanceAopProxyTypeBuilder(pf);
iaptb.ProxyDeclaredMembersOnly = this.ProxyDeclaredMembersOnly;
Type type = iaptb.BuildProxyType();
definition.ObjectType = type;
definition.ConstructorArgumentValues.AddIndexedArgumentValue(definition.ConstructorArgumentValues.ArgumentCount, pf);
}
}
}
public IObjectDefinition GetObjectDefinition(IObjectDefinitionService objectDefinitionService)
{
// parse the expression tree to create spring object definition.
IConfigurableObjectDefinition objectDefinition = CreateObjectDefinition(objectDefinitionService);
switch (_objectCreation.Body.NodeType)
{
case ExpressionType.MemberInit:
MemberInit((MemberInitExpression)_objectCreation.Body, objectDefinition);
break;
case ExpressionType.Call:
break;
case ExpressionType.New:
New((NewExpression)_objectCreation.Body, objectDefinition);
break;
case ExpressionType.Lambda:
break;
case ExpressionType.NewArrayInit:
break;
case ExpressionType.ListInit:
break;
// straight compilation of expression is required.
default:
break;
}
return(objectDefinition);
}
/// <summary>
/// Parses the CaoFactoryObject definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>CaoFactoryObject object definition.</returns>
private IConfigurableObjectDefinition ParseCaoFactoryObject(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string remoteTargetName = element.GetAttribute(CaoFactoryObjectConstants.RemoteTargetNameAttribute);
string serviceUrl = element.GetAttribute(CaoFactoryObjectConstants.ServiceUrlAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(remoteTargetName))
{
properties.Add("RemoteTargetName", remoteTargetName);
}
if (StringUtils.HasText(serviceUrl))
{
properties.Add("ServiceUrl", serviceUrl);
}
foreach (XmlElement child in element.ChildNodes)
{
switch (child.LocalName)
{
case CaoFactoryObjectConstants.ConstructorArgumentsElement:
properties.Add("ConstructorArguments", base.ParseListElement(child, name, parserContext));
break;
}
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return(cod);
}
public void ApplyConvention(string identifierName, IConfigurableObjectDefinition objectDefinition)
{
foreach (PropertyInfo propertyInfo in objectDefinition.ObjectType.GetProperties().Where(p => _typeInjections.ContainsKey(p.PropertyType)))
{
objectDefinition.PropertyValues.Add(new PropertyValue(propertyInfo.Name, _typeInjections[propertyInfo.PropertyType]));
}
}
public void InstantiationWithNullFactory()
{
IConfigurableObjectDefinition configurableObjectDefinition =
(IConfigurableObjectDefinition)mocks.CreateMock(typeof(IConfigurableObjectDefinition));
new LookupMethodReplacer(configurableObjectDefinition, null);
}
/// <summary>
/// Creates a new instance of the
/// <see cref="ArgumentNullException"/>
/// class.
/// </summary>
/// <remarks>
/// <p>
/// This is an <see lang="abstract"/> class, and as such has no
/// publicly visible constructors.
/// </p>
/// </remarks>
/// <param name="objectDefinition">
/// The object definition that is the target of the method replacement.
/// </param>
/// <param name="objectFactory">
/// The enclosing IoC container with which the above
/// <paramref name="objectDefinition"/> is associated.
/// </param>
/// <exception cref="AbstractMethodReplacer">
/// If either of the supplied arguments is <see langword="null"/>.
/// </exception>
protected AbstractMethodReplacer(
IConfigurableObjectDefinition objectDefinition, IObjectFactory objectFactory)
{
AssertUtils.ArgumentNotNull(objectDefinition, "objectDefinition");
AssertUtils.ArgumentNotNull(objectFactory, "objectFactory");
this.objectDefinition = objectDefinition;
this.objectFactory = objectFactory;
}
/// <summary>
/// Creates a new instance of the
/// <see cref="ArgumentNullException"/>
/// class.
/// </summary>
/// <remarks>
/// <p>
/// This is an <see lang="abstract"/> class, and as such has no
/// publicly visible constructors.
/// </p>
/// </remarks>
/// <param name="objectDefinition">
/// The object definition that is the target of the method replacement.
/// </param>
/// <param name="objectFactory">
/// The enclosing IoC container with which the above
/// <paramref name="objectDefinition"/> is associated.
/// </param>
/// <exception cref="AbstractMethodReplacer">
/// If either of the supplied arguments is <see langword="null"/>.
/// </exception>
protected AbstractMethodReplacer(
IConfigurableObjectDefinition objectDefinition, IObjectFactory objectFactory)
{
AssertUtils.ArgumentNotNull(objectDefinition, "objectDefinition");
AssertUtils.ArgumentNotNull(objectFactory, "objectFactory");
this.objectDefinition = objectDefinition;
this.objectFactory = objectFactory;
}
/// <summary>
/// Create an <see cref="ObjectDefinitionHolder"/> instance from the given <paramref name="definition"/> and <paramref name="objectName"/>.
/// </summary>
/// <remarks>
/// This method may be used as a last resort to post-process an object definition before it gets added to the registry.
/// </remarks>
protected virtual ObjectDefinitionHolder CreateObjectDefinitionHolder(
XmlElement element,
IConfigurableObjectDefinition definition,
string objectName,
IReadOnlyList <string> aliases)
{
return(new ObjectDefinitionHolder(definition, objectName, aliases));
}
/// <summary>
/// Generates an object name for the given object definition.
/// </summary>
/// <param name="definition">The object definition to generate a name for.</param>
/// <param name="registry">The object definitions registry that the given definition is
/// supposed to be registerd with</param>
/// <returns>the generated object name</returns>
public string GenerateObjectName(IObjectDefinition definition, IObjectDefinitionRegistry registry)
{
IConfigurableObjectDefinition objectDef = definition as IConfigurableObjectDefinition;
if (objectDef == null)
{
throw new ArgumentException(
"DefaultObjectNameGenerator is only able to handle IConfigurableObjectDefinition subclasses: " +
definition);
}
return(ObjectDefinitionReaderUtils.GenerateObjectName(objectDef, registry));
}
/// <see cref="INamespaceParser"/>
public override IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
{
string name = element.GetAttribute(ObjectDefinitionConstants.IdAttribute);
IConfigurableObjectDefinition templateDefinition = ParseTemplateDefinition(element, parserContext);
if (!StringUtils.HasText(name))
{
name = ObjectDefinitionReaderUtils.GenerateObjectName(templateDefinition, parserContext.Registry);
}
parserContext.Registry.RegisterObjectDefinition(name, templateDefinition);
return(null);
}
public void DoesNotResolveTypeNameToFullTypeInstanceIfAppDomainIsNull()
{
DefaultObjectDefinitionFactory factory = new DefaultObjectDefinitionFactory();
IConfigurableObjectDefinition definition
= factory.CreateObjectDefinition(
typeof(TestObject).FullName, null, null);
Assert.IsNotNull(definition, "CreateObjectDefinition with no parent is returning null (it must never do so).");
Assert.AreEqual(typeof(TestObject).FullName, definition.ObjectTypeName);
Assert.AreEqual(0, definition.PropertyValues.PropertyValues.Count,
"Must not have any property values as none were passed in.");
Assert.AreEqual(0, definition.ConstructorArgumentValues.ArgumentCount,
"Must not have any ctor args as none were passed in.");
}
public void CreateChildDefinition()
{
DefaultObjectDefinitionFactory factory = new DefaultObjectDefinitionFactory();
IConfigurableObjectDefinition definition
= factory.CreateObjectDefinition(
typeof(TestObject).FullName, "Aimee Mann", AppDomain.CurrentDomain);
Assert.IsNotNull(definition, "CreateObjectDefinition with no parent is returning null (it must never do so).");
Assert.AreEqual(typeof(TestObject), definition.ObjectType);
Assert.AreEqual(0, definition.PropertyValues.PropertyValues.Count,
"Must not have any property values as none were passed in.");
Assert.AreEqual(0, definition.ConstructorArgumentValues.ArgumentCount,
"Must not have any ctor args as none were passed in.");
}
/// <summary>
/// Generates an object definition name for the supplied
/// <paramref name="objectDefinition"/> that is guaranteed to be unique
/// within the scope of the supplied <paramref name="registry"/>.
/// </summary>
/// <param name="objectDefinition">The <see cref="Spring.Objects.Factory.Config.IObjectDefinition"/>
/// that requires a generated name.</param>
/// <param name="registry">The
/// <see cref="Spring.Objects.Factory.Support.IObjectDefinitionRegistry"/>
/// that the supplied <paramref name="objectDefinition"/> is to be
/// registered with (needed so that the uniqueness of any generated
/// name can be guaranteed).</param>
/// <param name="isInnerObject">if set to <c>true</c> if the given object
/// definition will be registed as an inner object or as a top level objener objects
/// verses top level objects.</param>
/// <returns>
/// An object definition name for the supplied
/// <paramref name="objectDefinition"/> that is guaranteed to be unique
/// within the scope of the supplied <paramref name="registry"/> and
/// never <cref lang="null"/>.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// If either of the <paramref name="objectDefinition"/> or
/// <paramref name="registry"/> arguments is <see langword="null"/>.
/// </exception>
/// <exception cref="Spring.Objects.Factory.ObjectDefinitionStoreException">
/// If a unique name cannot be generated.
/// </exception>
public static string GenerateObjectName(
IConfigurableObjectDefinition objectDefinition, IObjectDefinitionRegistry registry, bool isInnerObject)
{
AssertUtils.ArgumentNotNull(objectDefinition, "objectDefinition");
AssertUtils.ArgumentNotNull(registry, "registry");
string generatedObjectName = objectDefinition.ObjectTypeName;
if (StringUtils.IsNullOrEmpty(generatedObjectName))
{
if (objectDefinition is ChildObjectDefinition)
{
generatedObjectName = ((ChildObjectDefinition)objectDefinition).ParentName + "$child";
}
else if (objectDefinition.FactoryObjectName != null)
{
generatedObjectName = objectDefinition.FactoryObjectName + "$created";
}
}
if (StringUtils.IsNullOrEmpty(generatedObjectName))
{
if (!isInnerObject)
{
throw new ObjectDefinitionStoreException(
objectDefinition.ResourceDescription, String.Empty,
"Unnamed object definition specifies neither 'Type' nor 'Parent' " +
"nor 'FactoryObject' property values so a unique name cannot be generated.");
}
generatedObjectName = "$nested";
}
String id = generatedObjectName;
if (isInnerObject)
{
id = generatedObjectName + GENERATED_OBJECT_NAME_SEPARATOR + ObjectUtils.GetIdentityHexString(objectDefinition);
}
else
{
int counter = -1;
while (counter == -1 || registry.ContainsObjectDefinition(id))
{
counter++;
id = generatedObjectName + GENERATED_OBJECT_NAME_SEPARATOR + counter;
}
}
return(id);
}
/// <summary>
/// Parses the SaoExporter definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>SaoExporter object definition.</returns>
private IConfigurableObjectDefinition ParseSaoExporter(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string targetName = element.GetAttribute(SaoExporterConstants.TargetNameAttribute);
string applicationName = element.GetAttribute(SaoExporterConstants.ApplicationNameAttribute);
string serviceName = element.GetAttribute(SaoExporterConstants.ServiceNameAttribute);
string infinite = element.GetAttribute(SaoExporterConstants.InfiniteAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(targetName))
{
properties.Add("TargetName", targetName);
}
if (StringUtils.HasText(applicationName))
{
properties.Add("ApplicationName", applicationName);
}
if (StringUtils.HasText(serviceName))
{
properties.Add("ServiceName", serviceName);
}
if (StringUtils.HasText(infinite))
{
properties.Add("Infinite", infinite);
}
foreach (XmlElement child in element.ChildNodes)
{
switch (child.LocalName)
{
case LifeTimeConstants.LifeTimeElement:
ParseLifeTime(properties, child, parserContext);
break;
case InterfacesConstants.InterfacesElement:
properties.Add("Interfaces", base.ParseListElement(child, name, parserContext));
break;
}
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return(cod);
}
/// <summary>
/// Creates a generic action based on the specified element.
/// </summary>
/// <param name="element">The action definition element.</param>
/// <param name="parserContext">The parser helper.</param>
/// <returns>Generic validation action definition.</returns>
private IObjectDefinition ParseGenericAction(XmlElement element, ParserContext parserContext)
{
string typeName = GetAttributeValue(element, ObjectDefinitionConstants.TypeAttribute);
string when = GetAttributeValue(element, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = base.ParsePropertyElements("validator:action", element, parserContext);
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
IConfigurableObjectDefinition action =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
action.PropertyValues = properties;
return action;
}
private IConfigurableObjectDefinition ParseDbProviderConfigurer(XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string resource = GetAttributeValue(element, DbProviderConfigurerConstants.ResourceAttribute);
MutablePropertyValues propertyValues = new MutablePropertyValues();
if (StringUtils.HasText(resource))
{
propertyValues.Add("ProviderResource", resource);
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = propertyValues;
return(cod);
}
private void MethodCall(MethodCallExpression expression, IConfigurableObjectDefinition objectDefinition, int indexer)
{
if (expression.Method.DeclaringType.Equals(typeof(IObjectRegistry)))
{
if (expression.Arguments.Count == 1)
{
objectDefinition.ConstructorArgumentValues.AddIndexedArgumentValue(indexer, new RuntimeObjectReference((string)((ConstantExpression)expression.Arguments[0]).Value));
}
else
{
objectDefinition.ConstructorArgumentValues.AddIndexedArgumentValue(indexer, new RuntimeObjectReference(expression.Method.ReturnType.FullName));
}
}
else
{
}
}
/// <summary>
/// Creates and initialise the object definition that will be registered in your context.
/// </summary>
/// <param name="objectDefinitionService">The object definition service.</param>
/// <returns></returns>
public IObjectDefinition GetObjectDefinition(IObjectDefinitionService objectDefinitionService)
{
IConfigurableObjectDefinition objectDefinition = CreateObjectDefinition(objectDefinitionService);
foreach (var convention in _conventions)
{
if (convention is TypeNameConvention)
{
if (Identifier.Equals(DomainObjectType.FullName))
{
_identifier = ((TypeNameConvention)convention).GetIdentifierForType(DomainObjectType);
}
}
else
{
convention.ApplyConvention(_identifier, objectDefinition);
}
}
if (objectDefinition is RootWebObjectDefinition || objectDefinition is ChildWebObjectDefinition)
{
((IWebObjectDefinition)objectDefinition).Scope = _objectScope;
}
else
{
// not sure if that should really be used here.
objectDefinition.Scope = _objectScope.ToString();
}
foreach (var definitionAction in _objectDefinitionActions)
{
definitionAction(objectDefinition, objectDefinitionService);
}
// set the defaults or the one specified.
objectDefinition.DependencyCheck = _dependencyCheckMode;
objectDefinition.AutowireMode = _autoWiringMode;
if (_objectDependencies.Count > 0)
{
objectDefinition.DependsOn = _objectDependencies.ToArray();
}
return(objectDefinition);
}
public IObjectDefinition GetObjectDefinition(IObjectDefinitionService objectDefinitionService)
{
if (!objectDefinitionService.Registry.ContainsObjectDefinition(_constructorFactoryIdentifier))
{
IConfigurableObjectDefinition constructorDefinition = objectDefinitionService.Factory.CreateObjectDefinition(typeof(ConstructorFactory).FullName, null, AppDomain.CurrentDomain);
objectDefinitionService.Registry.RegisterObjectDefinition(_constructorFactoryIdentifier, constructorDefinition);
}
IConfigurableObjectDefinition objectDefinition = objectDefinitionService.Factory.CreateObjectDefinition(typeof(MethodInvokingFactoryObject).AssemblyQualifiedName, null, AppDomain.CurrentDomain);
objectDefinition.PropertyValues.Add(new PropertyValue("TargetObject", new RuntimeObjectReference(_constructorFactoryIdentifier)));
objectDefinition.PropertyValues.Add(new PropertyValue("TargetMethod", string.Format("CreateInstance<{0}>", typeof(T))));
objectDefinition.PropertyValues.Add(new PropertyValue("Arguments", new ArrayList {
_objectCreation
}));
objectDefinition.PropertyValues.Add(new PropertyValue("IsSingleton", _isSingleton));
return(objectDefinition);
}
/// <summary>
/// Creates and initialise the object definition that will be registered in your context.
/// </summary>
/// <param name="objectDefinitionService">The object definition service.</param>
/// <returns></returns>
public IObjectDefinition GetObjectDefinition(IObjectDefinitionService objectDefinitionService)
{
if (_interfaceType == null || String.IsNullOrEmpty(_interfaceType.FullName))
{
throw new ConfigurationErrorsException(string.Format("You are trying to bind a type to a null interface!"));
}
IConfigurableObjectDefinition objectDefinition;
var conditionalList = new ManagedList();
if (!objectDefinitionService.Registry.ContainsObjectDefinition(_interfaceType.FullName))
{
objectDefinition = objectDefinitionService.Factory.CreateObjectDefinition(typeof(ConstrainableDuringLoadFactoryObject).AssemblyQualifiedName, null, AppDomain.CurrentDomain);
objectDefinition.ObjectType = typeof(ConstrainableDuringLoadFactoryObject);
objectDefinition.PropertyValues.Add("IsSingleton", _isStatic);
objectDefinition.PropertyValues.Add("ConditionObjectDefinitions", conditionalList);
}
else
{
objectDefinition = (IConfigurableObjectDefinition)objectDefinitionService.Registry.GetObjectDefinition(_interfaceType.FullName);
conditionalList = (ManagedList)objectDefinition.PropertyValues.GetPropertyValue("ConditionObjectDefinitions").Value;
}
if (_constraintRegistry.ContainsKey(_interfaceType.FullName))
{
foreach (ConditionalObjectDefinition conditionalDefinition in _constraintRegistry[_interfaceType.FullName])
{
IConfigurableObjectDefinition definition = objectDefinitionService.Factory.CreateObjectDefinition(typeof(ConditionalObjectDefinition).AssemblyQualifiedName, null, AppDomain.CurrentDomain);
definition.ConstructorArgumentValues.AddIndexedArgumentValue(0, conditionalDefinition.Condition);
definition.ConstructorArgumentValues.AddIndexedArgumentValue(1, conditionalDefinition.TypeName);
definition.ConstructorArgumentValues.AddIndexedArgumentValue(2, conditionalDefinition.IsDefault);
var ro = new RuntimeObjectReference(conditionalDefinition.TypeName);
definition.PropertyValues.Add("Instance", ro);
conditionalList.Add(definition);
}
}
return(objectDefinition);
}
private void New(NewExpression body, IConfigurableObjectDefinition objectDefinition)
{
int indexer = 0;
foreach (Expression expression in body.Arguments)
{
switch (expression.NodeType)
{
case ExpressionType.Call:
MethodCall((MethodCallExpression)expression, objectDefinition, indexer);
break;
case ExpressionType.Constant:
objectDefinition.ConstructorArgumentValues.AddIndexedArgumentValue(indexer, ((ConstantExpression)expression).Value);
break;
default:
break;
}
indexer++;
}
}
private void MemberInit(MemberInitExpression body, IConfigurableObjectDefinition objectDefinition)
{
int indexer = 0;
foreach (Expression expression in body.NewExpression.Arguments)
{
switch (expression.NodeType)
{
case ExpressionType.Call:
MethodCall((MethodCallExpression)expression, objectDefinition, indexer);
break;
case ExpressionType.Constant:
objectDefinition.ConstructorArgumentValues.AddIndexedArgumentValue(indexer, ((ConstantExpression)expression).Value);
break;
default:
break;
}
indexer++;
}
foreach (MemberBinding memberBinding in body.Bindings)
{
switch (memberBinding.BindingType)
{
case MemberBindingType.Assignment:
MemberAssignment(memberBinding.Member.Name, (MemberAssignment)memberBinding, objectDefinition);
break;
case MemberBindingType.ListBinding:
break;
case MemberBindingType.MemberBinding:
break;
}
}
}
/// <summary>
/// Create an <see cref="ObjectDefinitionHolder"/> instance from the given <paramref name="definition"/> and <paramref name="objectName"/>.
/// </summary>
/// <remarks>
/// This method may be used as a last resort to post-process an object definition before it gets added to the registry.
/// </remarks>
protected virtual ObjectDefinitionHolder CreateObjectDefinitionHolder(XmlElement element, IConfigurableObjectDefinition definition, string objectName, IList<string> aliases)
{
return new ObjectDefinitionHolder(definition, objectName, aliases);
}
/// <summary>
/// Creates a new instance of the
/// <see cref="ArgumentNullException"/>
/// class.
/// </summary>
/// <param name="objectDefinition">
/// The object definition that is the target of the method replacement.
/// </param>
/// <param name="objectFactory">
/// The enclosing IoC container with which the above
/// <paramref name="objectDefinition"/> is associated.
/// </param>
/// <exception cref="DelegatingMethodReplacer">
/// If either of the supplied arguments is <see langword="null"/>.
/// </exception>
public DelegatingMethodReplacer(IConfigurableObjectDefinition objectDefinition, IObjectFactory objectFactory)
: base(objectDefinition, objectFactory)
{
}
public void ApplyConvention(string identifierName, IConfigurableObjectDefinition objectDefinition)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a new instance of the <see cref="LookupMethodReplacer"/>
/// class.
/// </summary>
/// <param name="objectDefinition">
/// The object definition that is the target of the method replacement.
/// </param>
/// <param name="objectFactory">
/// The enclosing IoC container with which the above
/// <paramref name="objectDefinition"/> is associated.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// If either of the supplied arguments is <see langword="null"/>.
/// </exception>
public LookupMethodReplacer(IConfigurableObjectDefinition objectDefinition, IObjectFactory objectFactory)
: base(objectDefinition, objectFactory)
{
}
/// <summary>
/// Wires up any exposed events in the object instance in the given
/// <see cref="Spring.Objects.IObjectWrapper"/> with any event handler
/// values from the <paramref name="definition"/>.
/// </summary>
/// <param name="name">
/// The name of the object.
/// </param>
/// <param name="definition">
/// The definition of the named object.
/// </param>
/// <param name="wrapper">
/// The <see cref="Spring.Objects.IObjectWrapper"/> wrapping the target object.
/// </param>
protected void WireEvents(string name, IConfigurableObjectDefinition definition, IObjectWrapper wrapper)
{
foreach (string eventName in definition.EventHandlerValues.Events)
{
foreach (IEventHandlerValue handlerValue
in definition.EventHandlerValues[eventName])
{
object handler = null;
if (handlerValue.Source is RuntimeObjectReference)
{
RuntimeObjectReference roref = (RuntimeObjectReference)handlerValue.Source;
handler = ResolveReference(definition, name, eventName, roref);
}
else if (handlerValue.Source is Type)
{
// a static Type event is being wired up; simply pass on the Type
handler = handlerValue.Source;
}
else if (handlerValue.Source is string)
{
// a static Type event is being wired up; we need to resolve the Type
handler = TypeResolutionUtils.ResolveType(handlerValue.Source as string);
}
else
{
throw new FatalObjectException("Currently, only references to other objects and Types are " + "supported as event sources.");
}
handlerValue.Wire(handler, wrapper.WrappedInstance);
}
}
}
///// <summary>
///// Given a property value, return a value, resolving any references to other
///// objects in the factory if necessary.
///// </summary>
///// <remarks>
///// <p>
///// The value could be :
///// <list type="bullet">
///// <item>
///// <p>
///// An <see cref="Spring.Objects.Factory.Config.IObjectDefinition"/>,
///// which leads to the creation of a corresponding new object instance.
///// Singleton flags and names of such "inner objects" are always ignored: inner objects
///// are anonymous prototypes.
///// </p>
///// </item>
///// <item>
///// <p>
///// A <see cref="Spring.Objects.Factory.Config.RuntimeObjectReference"/>, which must
///// be resolved.
///// </p>
///// </item>
///// <item>
///// <p>
///// An <see cref="Spring.Objects.Factory.Support.IManagedCollection"/>. This is a
///// special placeholder collection that may contain
///// <see cref="Spring.Objects.Factory.Config.RuntimeObjectReference"/>s or
///// collections that will need to be resolved.
///// </p>
///// </item>
///// <item>
///// <p>
///// An ordinary object or <see langword="null"/>, in which case it's left alone.
///// </p>
///// </item>
///// </list>
///// </p>
///// </remarks>
///// <param name="name">
///// The name of the object that is having the value of one of its properties resolved.
///// </param>
///// <param name="definition">
///// The definition of the named object.
///// </param>
///// <param name="argumentName">
///// The name of the property the value of which is being resolved.
///// </param>
///// <param name="argumentValue">
///// The value of the property that is being resolved.
///// </param>
// protected object ResolveValueIfNecessary(string name, RootObjectDefinition definition, string argumentName, object argumentValue)
// {
// object resolvedValue = null;
//
// AssertUtils.ArgumentNotNull(resolvedValue, "test");
//
// // we must check the argument value to see whether it requires a runtime
// // reference to another object to be resolved.
// // if it does, we'll attempt to instantiate the object and set the reference.
// if (RemotingServices.IsTransparentProxy(argumentValue))
// {
// resolvedValue = argumentValue;
// }
// else if (argumentValue is ObjectDefinitionHolder)
// {
// // contains an IObjectDefinition with name and aliases...
// ObjectDefinitionHolder holder = (ObjectDefinitionHolder)argumentValue;
// resolvedValue = ResolveInnerObjectDefinition(name, holder.ObjectName, argumentName, holder.ObjectDefinition, definition.IsSingleton);
// }
// else if (argumentValue is IObjectDefinition)
// {
// // resolve plain IObjectDefinition, without contained name: use dummy name...
// IObjectDefinition def = (IObjectDefinition)argumentValue;
// resolvedValue = ResolveInnerObjectDefinition(name, "(inner object)", argumentName, def, definition.IsSingleton);
//
// }
// else if (argumentValue is RuntimeObjectReference)
// {
// RuntimeObjectReference roref = (RuntimeObjectReference)argumentValue;
// resolvedValue = ResolveReference(definition, name, argumentName, roref);
// }
// else if (argumentValue is ExpressionHolder)
// {
// ExpressionHolder expHolder = (ExpressionHolder)argumentValue;
// object context = null;
// IDictionary variables = null;
//
// if (expHolder.Properties != null)
// {
// PropertyValue contextProperty = expHolder.Properties.GetPropertyValue("Context");
// context = contextProperty == null
// ? null
// : ResolveValueIfNecessary2(name, definition, "Context",
// contextProperty.Value);
// PropertyValue variablesProperty = expHolder.Properties.GetPropertyValue("Variables");
// object vars = (variablesProperty == null
// ? null
// : ResolveValueIfNecessary2(name, definition, "Variables",
// variablesProperty.Value));
// if (vars is IDictionary)
// {
// variables = (IDictionary)vars;
// }
// else
// {
// if (vars != null) throw new ArgumentException("'Variables' must resolve to an IDictionary");
// }
// }
//
// if (variables == null) variables = CollectionsUtil.CreateCaseInsensitiveHashtable();
// // add 'this' objectfactory reference to variables
// variables.Add(Expression.ReservedVariableNames.CurrentObjectFactory, this);
//
// resolvedValue = expHolder.Expression.GetValue(context, variables);
// }
// else if (argumentValue is IManagedCollection)
// {
// resolvedValue =
// ((IManagedCollection)argumentValue).Resolve(name, definition, argumentName,
// new ManagedCollectionElementResolver(ResolveValueIfNecessary2));
// }
// else if (argumentValue is TypedStringValue)
// {
// TypedStringValue tsv = (TypedStringValue)argumentValue;
// try
// {
// Type resolvedTargetType = ResolveTargetType(tsv);
// if (resolvedTargetType != null)
// {
// resolvedValue = TypeConversionUtils.ConvertValueIfNecessary(tsv.TargetType, tsv.Value, null);
// }
// else
// {
// resolvedValue = tsv.Value;
// }
// }
// catch (Exception ex)
// {
// throw new ObjectCreationException(definition.ResourceDescription, name,
// "Error converted typed String value for " + argumentName, ex);
// }
//
// }
// else
// {
// // no need to resolve value...
// resolvedValue = argumentValue;
// }
// return resolvedValue;
// }
///// <summary>
///// Resolve the target type of the passed <see cref="TypedStringValue"/>.
///// </summary>
///// <param name="value">The <see cref="TypedStringValue"/> who's target type is to be resolved</param>
///// <returns>The resolved target type, if any. <see lang="null" /> otherwise.</returns>
// protected virtual Type ResolveTargetType(TypedStringValue value)
// {
// if (value.HasTargetType)
// {
// return value.TargetType;
// }
// else
// {
// return null;
// }
// }
///// <summary>
///// Resolves an inner object definition.
///// </summary>
///// <param name="name">
///// The name of the object that surrounds this inner object definition.
///// </param>
///// <param name="innerObjectName">
///// The name of the inner object definition... note: this is a synthetic
///// name assigned by the factory (since it makes no sense for inner object
///// definitions to have names).
///// </param>
///// <param name="argumentName">
///// The name of the property the value of which is being resolved.
///// </param>
///// <param name="definition">
///// The definition of the inner object that is to be resolved.
///// </param>
///// <param name="singletonOwner">
///// <see langword="true"/> if the owner of the property is a singleton.
///// </param>
///// <returns>
///// The resolved object as defined by the inner object definition.
///// </returns>
// protected object ResolveInnerObjectDefinition(string name, string innerObjectName, string argumentName, IObjectDefinition definition,
// bool singletonOwner)
// {
// RootObjectDefinition mod = GetMergedObjectDefinition(innerObjectName, definition);
// mod.IsSingleton = singletonOwner;
// object instance;
// object result;
// try
// {
// instance = InstantiateObject(innerObjectName, mod, ObjectUtils.EmptyObjects, false, false);
// result = GetObjectForInstance(innerObjectName, instance);
// }
// catch (ObjectsException ex)
// {
// throw ObjectCreationException.GetObjectCreationException(ex, name, argumentName, definition.ResourceDescription, innerObjectName);
// }
// if (singletonOwner && instance is IDisposable)
// {
// // keep a reference to the inner object instance, to be able to destroy
// // it on factory shutdown...
// DisposableInnerObjects.Add(instance);
// }
// return result;
// }
/// <summary>
/// Resolve a reference to another object in the factory.
/// </summary>
/// <param name="name">
/// The name of the object that is having the value of one of its properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named object.
/// </param>
/// <param name="argumentName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="reference">
/// The runtime reference containing the value of the property.
/// </param>
/// <returns>A reference to another object in the factory.</returns>
protected object ResolveReference(IConfigurableObjectDefinition definition, string name, string argumentName, RuntimeObjectReference reference)
{
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(
string.Format(CultureInfo.InvariantCulture, "Resolving reference from property '{0}' in object '{1}' to object '{2}'.",
argumentName, name, reference.ObjectName));
}
#endregion
try
{
if (reference.IsToParent)
{
if (null == ParentObjectFactory)
{
throw new ObjectCreationException(definition.ResourceDescription, name,
string.Format(
"Can't resolve reference to '{0}' in parent factory: " + "no parent factory available.",
reference.ObjectName));
}
return ParentObjectFactory.GetObject(reference.ObjectName);
}
return GetObject(reference.ObjectName);
}
catch (ObjectsException ex)
{
throw ObjectCreationException.GetObjectCreationException(ex, name, argumentName, definition.ResourceDescription, reference.ObjectName);
}
}
/// <summary>
/// Give an object a chance to react now all its properties are set,
/// and a chance to know about its owning object factory (this object).
/// </summary>
/// <remarks>
/// <p>
/// This means checking whether the object implements
/// <see cref="Spring.Objects.Factory.IInitializingObject"/> and / or
/// <see cref="Spring.Objects.Factory.IObjectFactoryAware"/>, and invoking the
/// necessary callback(s) if it does.
/// </p>
/// <p>
/// Custom init methods are resolved in a <b>case-insensitive</b> manner.
/// </p>
/// </remarks>
/// <param name="target">
/// The new object instance we may need to initialise.
/// </param>
/// <param name="name">
/// The name the object has in the factory. Used for logging output.
/// </param>
/// <param name="definition">
/// The definition of the target object instance.
/// </param>
protected virtual void InvokeInitMethods(object target, string name, IConfigurableObjectDefinition definition)
{
if (ObjectUtils.IsAssignableAndNotTransparentProxy(typeof(IInitializingObject), target))
{
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Calling AfterPropertiesSet() on object with name '{0}'.", name));
}
#endregion
((IInitializingObject)target).AfterPropertiesSet();
}
if (StringUtils.HasText(definition.InitMethodName))
{
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(
string.Format(CultureInfo.InvariantCulture, "Calling custom init method '{0} on object with name '{1}'.",
definition.InitMethodName, name));
}
#endregion
try
{
MethodInfo targetMethod = target.GetType().GetMethod(definition.InitMethodName, MethodResolutionFlags, null, Type.EmptyTypes, null);
if (targetMethod == null)
{
throw new ObjectCreationException(definition.ResourceDescription, name,
"Could not find the named initialization method '" + definition.InitMethodName + "'.");
}
targetMethod.Invoke(target, ObjectUtils.EmptyObjects);
}
catch (TargetInvocationException ex)
{
throw new ObjectCreationException(definition.ResourceDescription, name,
"Initialization method '" + definition.InitMethodName + "' threw exception", ex.GetBaseException());
}
catch (Exception ex)
{
throw new ObjectCreationException(definition.ResourceDescription, name,
"Invocation of initialization method '" + definition.InitMethodName + "' failed", ex);
}
}
}
private void CheckDependencies(string name, IConfigurableObjectDefinition definition, PropertyInfo[] filteredPropInfo, IPropertyValues properties)
{
DependencyCheckingMode dependencyCheck = definition.DependencyCheck;
PropertyInfo[] unsatisfiedDependencies = AutowireUtils.GetUnsatisfiedDependencies(filteredPropInfo, properties, dependencyCheck);
if (unsatisfiedDependencies.Length > 0)
{
throw new UnsatisfiedDependencyException(definition.ResourceDescription, name, unsatisfiedDependencies[0].Name,
"Set this property value or disable dependency checking for this object.");
}
}
/// <summary>
/// Perform a dependency check that all properties exposed have been set, if desired.
/// </summary>
/// <remarks>
/// <p>
/// Dependency checks can be objects (collaborating objects), simple (primitives
/// and <see cref="System.String"/>), or all (both).
/// </p>
/// </remarks>
/// <param name="name">
/// The name of the object.
/// </param>
/// <param name="definition">
/// The definition of the named object.
/// </param>
/// <param name="wrapper">
/// The <see cref="Spring.Objects.IObjectWrapper"/> wrapping the target object.
/// </param>
/// <param name="properties">
/// The property values to be checked.
/// </param>
/// <exception cref="Spring.Objects.Factory.UnsatisfiedDependencyException">
/// If all of the checked dependencies were not satisfied.
/// </exception>
protected void DependencyCheck(string name, IConfigurableObjectDefinition definition, IObjectWrapper wrapper, IPropertyValues properties)
{
DependencyCheckingMode dependencyCheck = definition.DependencyCheck;
if (dependencyCheck == DependencyCheckingMode.None)
{
return;
}
PropertyInfo[] filteredPropInfo = FilterPropertyInfoForDependencyCheck(wrapper);
if (HasInstantiationAwareBeanPostProcessors)
{
foreach (IObjectPostProcessor processor in ObjectPostProcessors)
{
IInstantiationAwareObjectPostProcessor inProc = processor as IInstantiationAwareObjectPostProcessor;
if (inProc != null)
{
properties =
inProc.PostProcessPropertyValues(properties, filteredPropInfo, wrapper.WrappedInstance, name);
if (properties == null)
{
return;
}
}
}
}
CheckDependencies(name, definition, filteredPropInfo, properties);
}
/// <summary>
/// Generates an object definition name for the supplied
/// <paramref name="objectDefinition"/> that is guaranteed to be unique
/// within the scope of the supplied <paramref name="registry"/>.
/// </summary>
/// <param name="objectDefinition">The <see cref="Spring.Objects.Factory.Config.IObjectDefinition"/>
/// that requires a generated name.</param>
/// <param name="registry">The
/// <see cref="Spring.Objects.Factory.Support.IObjectDefinitionRegistry"/>
/// that the supplied <paramref name="objectDefinition"/> is to be
/// registered with (needed so that the uniqueness of any generated
/// name can be guaranteed).</param>
/// <param name="isInnerObject">if set to <c>true</c> if the given object
/// definition will be registed as an inner object or as a top level objener objects
/// verses top level objects.</param>
/// <returns>
/// An object definition name for the supplied
/// <paramref name="objectDefinition"/> that is guaranteed to be unique
/// within the scope of the supplied <paramref name="registry"/> and
/// never <cref lang="null"/>.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// If either of the <paramref name="objectDefinition"/> or
/// <paramref name="registry"/> arguments is <see langword="null"/>.
/// </exception>
/// <exception cref="Spring.Objects.Factory.ObjectDefinitionStoreException">
/// If a unique name cannot be generated.
/// </exception>
public static string GenerateObjectName(
IConfigurableObjectDefinition objectDefinition, IObjectDefinitionRegistry registry, bool isInnerObject)
{
AssertUtils.ArgumentNotNull(objectDefinition, "objectDefinition");
AssertUtils.ArgumentNotNull(registry, "registry");
string generatedObjectName = objectDefinition.ObjectTypeName;
if (StringUtils.IsNullOrEmpty(generatedObjectName))
{
if (objectDefinition is ChildObjectDefinition)
{
generatedObjectName = ((ChildObjectDefinition)objectDefinition).ParentName + "$child";
}
else if (objectDefinition.FactoryObjectName != null)
{
generatedObjectName = objectDefinition.FactoryObjectName + "$created";
}
}
if (StringUtils.IsNullOrEmpty(generatedObjectName))
{
if (!isInnerObject)
{
throw new ObjectDefinitionStoreException(
objectDefinition.ResourceDescription, String.Empty,
"Unnamed object definition specifies neither 'Type' nor 'Parent' " +
"nor 'FactoryObject' property values so a unique name cannot be generated.");
}
generatedObjectName = "$nested";
}
String id = generatedObjectName;
if (isInnerObject)
{
id = generatedObjectName + GENERATED_OBJECT_NAME_SEPARATOR + ObjectUtils.GetIdentityHexString(objectDefinition);
}
else
{
int counter = -1;
while (counter == -1 || registry.ContainsObjectDefinition(id))
{
counter++;
id = generatedObjectName + GENERATED_OBJECT_NAME_SEPARATOR + counter;
}
}
return id;
}
/// <summary>
/// Generates the name of the object for a top-level object definition unique within the given object factory.
/// </summary>
/// <param name="definition">The object definition to generate an object name for.</param>
/// <param name="registry">The registry to check for existing names.</param>
/// <returns>The generated object name</returns>
/// <exception cref="ObjectDefinitionStoreException">if no unique name can be generated for the given
/// object definition</exception>
public static string GenerateObjectName(IConfigurableObjectDefinition definition, IObjectDefinitionRegistry registry)
{
return GenerateObjectName(definition, registry, false);
}
private static void RegisterPostProcessor(IObjectDefinitionRegistry registry, IConfigurableObjectDefinition objectDefinition, string objectName)
{
objectDefinition.Role = ObjectRole.ROLE_INFRASTRUCTURE;
registry.RegisterObjectDefinition(objectName, objectDefinition);
}
