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);
}
public object GetObject(IObjectDefinitionService objectDefinitionService)
{
ManagedNameValueCollection nameValueCollection = new ManagedNameValueCollection();
foreach (var nameValueCollectionAction in _nameValueCollectionActions)
{
nameValueCollectionAction(nameValueCollection, objectDefinitionService);
}
return(nameValueCollection);
}
public object GetObject(IObjectDefinitionService objectDefinitionService)
{
ManagedNameValueCollection nameValueCollection = new ManagedNameValueCollection();
foreach (var nameValueCollectionAction in _nameValueCollectionActions)
{
nameValueCollectionAction(nameValueCollection, objectDefinitionService);
}
return nameValueCollection;
}
public object GetObject(IObjectDefinitionService objectDefinitionService)
{
var managedList = new ManagedList();
managedList.ElementTypeName = _listType.FullName;
foreach (var managedListAction in _managedListActions)
{
managedListAction(managedList, objectDefinitionService);
}
return(managedList);
}
public object GetObject(IObjectDefinitionService objectDefinitionService)
{
var managedDictionary = new ManagedDictionary();
managedDictionary.KeyTypeName = _keyType.AssemblyQualifiedName;
managedDictionary.ValueTypeName = _valueType.AssemblyQualifiedName;
foreach (var action in _managedDictionaryAction)
{
action(managedDictionary, objectDefinitionService);
}
return(managedDictionary);
}
private IConfigurableObjectDefinition CreateObjectDefinition(IObjectDefinitionService objectDefinitionService)
{
IConfigurableObjectDefinition objectDefinition;
if (String.IsNullOrEmpty(_parentDefinition))
{
objectDefinition = objectDefinitionService.Factory.CreateObjectDefinition(DomainObjectType.AssemblyQualifiedName, null, AppDomain.CurrentDomain);
}
else
{
objectDefinition = objectDefinitionService.Factory.CreateObjectDefinition(DomainObjectType.AssemblyQualifiedName, _parentDefinition, AppDomain.CurrentDomain);
}
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)
{
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);
}
public object GetObject(IObjectDefinitionService objectDefinitionService)
{
return(GetObjectDefinition(objectDefinitionService));
}
