protected override void ParseTransformer(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { ManagedDictionary headers = new ManagedDictionary(); XmlAttributeCollection attributes = element.Attributes; for (int i = 0; i < attributes.Count; i++) { XmlNode node = attributes.Item(i); String name = node.LocalName; if (IsEligibleHeaderName(name)) { name = Conventions.AttributeNameToPropertyName(name); object value; if (ReferenceAttributesContains(name)) { value = new RuntimeObjectReference(node.Value); } else { value = node.Value; } if (_prefix != null) { name = _prefix + name; } headers.Add(name, value); } } PostProcessHeaders(element, headers, parserContext); builder.AddConstructorArg(headers); builder.AddPropertyValue("overwrite", ShouldOverwrite(element)); }
/// <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); }
/// <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 virtual object ResolveReference(IObjectDefinition 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 == objectFactory.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(objectFactory.ParentObjectFactory.GetObject(reference.ObjectName)); } return(objectFactory.GetObject(reference.ObjectName)); } catch (ObjectsException ex) { throw ObjectCreationException.GetObjectCreationException(ex, name, argumentName, definition.ResourceDescription, reference.ObjectName); } }
/// <summary> /// TODO /// </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="argumentValue"> /// The value of the property that is being resolved. /// </param> private object ResolvePropertyValue(string name, IObjectDefinition definition, string argumentName, object argumentValue) { object resolvedValue = null; // 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 ICustomValueReferenceHolder) { resolvedValue = ((ICustomValueReferenceHolder)argumentValue).Resolve(objectFactory, name, definition, argumentName, 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 <string, object> variables = null; if (expHolder.Properties != null) { PropertyValue contextProperty = expHolder.Properties.GetPropertyValue("Context"); context = contextProperty == null ? null : ResolveValueIfNecessary(name, definition, "Context", contextProperty.Value); PropertyValue variablesProperty = expHolder.Properties.GetPropertyValue("Variables"); object vars = (variablesProperty == null ? null : ResolveValueIfNecessary(name, definition, "Variables", variablesProperty.Value)); if (vars is IDictionary <string, object> ) { variables = (IDictionary <string, object>)vars; } if (vars is IDictionary) { IDictionary temp = (IDictionary)vars; variables = new Dictionary <string, object>(temp.Count); foreach (DictionaryEntry entry in temp) { variables.Add((string)entry.Key, entry.Value); } } else { if (vars != null) { throw new ArgumentException("'Variables' must resolve to an IDictionary"); } } } if (variables == null) { variables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); } // add 'this' objectfactory reference to variables variables.Add(Expression.ReservedVariableNames.CurrentObjectFactory, objectFactory); resolvedValue = expHolder.Expression.GetValue(context, variables); } else if (argumentValue is IManagedCollection) { resolvedValue = ((IManagedCollection)argumentValue).Resolve(name, definition, argumentName, ResolveValueIfNecessary); } 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); }
public override void Inject(Object target, string objectName, IPropertyValues pvs) { MethodInfo method = _member as MethodInfo; try { Object[] arguments; if (_cached) { arguments = ResolveCachedArguments(objectName); } else { Type[] paramTypes = method.GetParameters().Select(p => p.ParameterType).ToArray(); arguments = new Object[paramTypes.Length]; var descriptors = new DependencyDescriptor[paramTypes.Length]; IList autowiredBeanNames = new ArrayList(); for (int i = 0; i < arguments.Length; i++) { MethodParameter methodParam = new MethodParameter(method, i); descriptors[i] = new DependencyDescriptor(methodParam, _required); arguments[i] = _objectFactory.ResolveDependency(descriptors[i], objectName, autowiredBeanNames); if (arguments[i] == null && !_required) { arguments = null; break; } } lock (this) { if (!_cached) { if (arguments != null) { _cachedMethodArguments = new Object[arguments.Length]; for (int i = 0; i < arguments.Length; i++) { _cachedMethodArguments[i] = descriptors[i]; } RegisterDependentObjects(objectName, autowiredBeanNames); if (autowiredBeanNames.Count == paramTypes.Length) { for (int i = 0; i < paramTypes.Length; i++) { string autowiredBeanName = autowiredBeanNames[i] as string; if (_objectFactory.ContainsObject(autowiredBeanName)) { if (_objectFactory.IsTypeMatch(autowiredBeanName, paramTypes[i])) { _cachedMethodArguments[i] = new RuntimeObjectReference(autowiredBeanName); } } } } } else { _cachedMethodArguments = null; } _cached = true; } } } if (arguments != null) { method.Invoke(target, arguments); } } catch (Exception ex) { throw new ObjectCreationException("Could not autowire method: " + method, ex); } }
/// <summary> /// Get all property values, given a prefix (which will be stripped) /// and add the object they define to the factory with the given name /// </summary> /// <param name="name">The name of the object to define.</param> /// <param name="id"> /// The <see cref="System.Collections.IDictionary"/> containing string pairs. /// </param> /// <param name="prefix">The prefix of each entry, which will be stripped.</param> /// <param name="resourceDescription"> /// The description of the resource that the /// <see cref="System.Collections.IDictionary"/> came from (for logging purposes). /// </param> /// <exception cref="Oragon.Spring.Objects.ObjectsException"> /// In case of loading or parsing errors. /// </exception> protected void RegisterObjectDefinition( string name, IDictionary id, string prefix, string resourceDescription) { string typeName = null; string parent = null; bool singleton = true; bool lazyInit = false; MutablePropertyValues pvs = new MutablePropertyValues(); foreach (string key in id.Keys) { if (key.StartsWith(prefix + Separator)) { string property = key.Substring(prefix.Length + Separator.Length); if (property.Equals(ClassKey)) { typeName = (string)id[key]; } else if (property.Equals(SingletonKey)) { string val = (string)id[key]; singleton = (val == null) || val.Equals(TrueValue); } else if (property.Equals(LazyInitKey)) { string val = (string)id[key]; lazyInit = val.Equals(TrueValue); } else if (property.Equals(ParentKey)) { parent = (string)id[key]; } else if (property.EndsWith(RefSuffix)) { // This isn't a real property, but a reference to another prototype // Extract property name: property is of form dog(ref) property = property.Substring(0, property.Length - RefSuffix.Length); string reference = (String)id[key]; // It doesn't matter if the referenced object hasn't yet been registered: // this will ensure that the reference is resolved at runtime // Default is not to use singleton object val = new RuntimeObjectReference(reference); pvs.Add(new PropertyValue(property, val)); } else { // normal object property object val = id[key]; if (val is String) { string strVal = (string)val; // if it starts with a reference prefix... if (strVal.StartsWith(RefPrefix)) { // expand reference string targetName = strVal.Substring(1); if (targetName.StartsWith(RefPrefix)) { // escaped prefix -> use plain value val = targetName; } else { val = new RuntimeObjectReference(targetName); } } } pvs.Add(new PropertyValue(property, val)); } } } if (log.IsDebugEnabled) { log.Debug(pvs.ToString()); } if (parent == null) { log.Debug(this.DefaultParentObject); parent = this.DefaultParentObject; } if (typeName == null && parent == null) { throw new ObjectDefinitionStoreException(resourceDescription, name, "Either 'type' or 'parent' is required"); } try { IConfigurableObjectDefinition objectDefinition = ObjectDefinitionFactory.CreateObjectDefinition(typeName, parent, Domain); objectDefinition.PropertyValues = pvs; objectDefinition.IsSingleton = singleton; objectDefinition.IsLazyInit = lazyInit; Registry.RegisterObjectDefinition(name, objectDefinition); } catch (Exception ex) { throw new ObjectDefinitionStoreException( resourceDescription, name, "Unable to load type [" + typeName + "]", ex); } }
public void Add <T>(Func <IObjectDefinitionService, object> keyObjectReference, RuntimeObjectReference actualValue) { _managedDictionaryAction.Add((d, f) => d.Add(keyObjectReference(f), actualValue)); }
public void Add(RuntimeObjectReference keyObjectReference, Func <IObjectDefinitionService, object> runtimeObjectReference) { _managedDictionaryAction.Add((d, f) => d.Add(keyObjectReference, runtimeObjectReference(f))); }
public void Add <V>(RuntimeObjectReference keyObjectReference, V actualValue) { _managedDictionaryAction.Add((d, f) => d.Add(keyObjectReference, actualValue)); }
public void Add <T>(T keyValue, RuntimeObjectReference runtimeObjectReference) { _managedDictionaryAction.Add((d, f) => d.Add(keyValue, runtimeObjectReference)); }
public void Add(RuntimeObjectReference keyObjectReference, RuntimeObjectReference valueObjectReference) { _managedDictionaryAction.Add((d, f) => d.Add(keyObjectReference, valueObjectReference)); }
public void AddInjectedTypeIdentifierName(Type injectedPropertyType, string injectedIdentifierName) { _typeInjections[injectedPropertyType] = new RuntimeObjectReference(injectedIdentifierName); }
/// <summary>The parse map element.</summary> /// <param name="mapEle">The map ele.</param> /// <param name="bd">The bd.</param> /// <returns>The System.Collections.IDictionary.</returns> public IDictionary ParseMapElement(XmlElement mapEle, IObjectDefinition bd) { string defaultKeyType = mapEle.GetAttribute(KEY_TYPE_ATTRIBUTE); string defaultValueType = mapEle.GetAttribute(VALUE_TYPE_ATTRIBUTE); XmlNodeList entryEles = mapEle.GetElementsByTagName(ENTRY_ELEMENT, OBJECTS_NAMESPACE_URI); var map = new ManagedDictionary(entryEles.Count); map.KeyTypeName = defaultKeyType; map.ValueTypeName = defaultValueType; map.MergeEnabled = this.ParseMergeAttribute(mapEle); foreach (XmlNode entryEle in entryEles) { // Should only have one value child element: ref, value, list, etc. // Optionally, there might be a key child element. XmlNodeList entrySubNodes = entryEle.ChildNodes; XmlElement keyEle = null; XmlElement valueEle = null; for (int j = 0; j < entrySubNodes.Count; j++) { XmlNode node = entrySubNodes.Item(j); if (node is XmlElement) { var candidateEle = (XmlElement)node; if (this.NodeNameEquals(candidateEle, KEY_ELEMENT)) { if (keyEle != null) { this.Error("<entry> element is only allowed to contain one <key> sub-element", entryEle); } else { keyEle = candidateEle; } } else { // Child element is what we're looking for. if (valueEle != null) { this.Error("<entry> element must not contain more than one value sub-element", entryEle); } else { valueEle = candidateEle; } } } } // Extract key from attribute or sub-element. object key = null; bool hasKeyAttribute = this.HasAttribute(entryEle, KEY_ATTRIBUTE); bool hasKeyRefAttribute = this.HasAttribute(entryEle, KEY_REF_ATTRIBUTE); if ((hasKeyAttribute && hasKeyRefAttribute) || (hasKeyAttribute || hasKeyRefAttribute) && keyEle != null) { this.Error( "<entry> element is only allowed to contain either " + "a 'key' attribute OR a 'key-ref' attribute OR a <key> sub-element", entryEle); } if (hasKeyAttribute) { key = this.buildTypedStringValueForMap(entryEle.Attributes[KEY_ATTRIBUTE].Value, defaultKeyType); } else if (hasKeyRefAttribute) { string refName = entryEle.Attributes[KEY_REF_ATTRIBUTE].Value; if (!StringUtils.HasText(refName)) { this.Error("<entry> element contains empty 'key-ref' attribute", entryEle); } var reference = new RuntimeObjectReference(refName); key = reference; } else if (keyEle != null) { key = this.parseKeyElement(keyEle, bd, defaultKeyType); } else { this.Error("<entry> element must specify a key", entryEle); } // Extract value from attribute or sub-element. object value = null; bool hasValueAttribute = this.HasAttribute(entryEle, VALUE_ATTRIBUTE); bool hasValueRefAttribute = this.HasAttribute(entryEle, VALUE_REF_ATTRIBUTE); if ((hasValueAttribute && hasValueRefAttribute) || (hasValueAttribute || hasValueRefAttribute) && valueEle != null) { this.Error( "<entry> element is only allowed to contain either " + "'value' attribute OR 'value-ref' attribute OR <value> sub-element", entryEle); } if (hasValueAttribute) { value = this.buildTypedStringValueForMap(entryEle.Attributes[VALUE_ATTRIBUTE].Value, defaultValueType); } else if (hasValueRefAttribute) { string refName = entryEle.Attributes[VALUE_REF_ATTRIBUTE].Value; if (!StringUtils.HasText(refName)) { this.Error("<entry> element contains empty 'value-ref' attribute", entryEle); } var reference = new RuntimeObjectReference(refName); value = reference; } else if (valueEle != null) { value = this.parsePropertySubElement(valueEle, bd, defaultValueType); } else { this.Error("<entry> element must specify a value", entryEle); } // Add final key and value to the Map. map.Add(key, value); } return(map); }
private object parsePropertySubElement(XmlElement ele, IObjectDefinition bd, string defaultValueType) { if (!isDefaultNamespace(ele)) { return(this.parseNestedCustomElement(ele, bd)); } else if (this.NodeNameEquals(ele, OBJECT_ELEMENT)) { ObjectDefinitionHolder nestedBd = this.parserContext.ParserHelper.ParseObjectDefinitionElement(ele, bd); // if (nestedBd != null) // { // nestedBd = decorateObjectDefinitionIfRequired(ele, nestedBd, bd); // } return(nestedBd); } else if (this.NodeNameEquals(ele, REF_ELEMENT)) { // A generic reference to any name of any object. string refName = ele.GetAttribute(OBJECT_REF_ATTRIBUTE); bool toParent = false; if (!StringUtils.HasLength(refName)) { // A reference to the id of another object in the same XML file. refName = ele.GetAttribute(LOCAL_REF_ATTRIBUTE); if (!StringUtils.HasLength(refName)) { // A reference to the id of another object in a parent context. refName = ele.GetAttribute(PARENT_REF_ATTRIBUTE); toParent = true; if (!StringUtils.HasLength(refName)) { this.Error("'object', 'local' or 'parent' is required for <ref> element", ele); return(null); } } } if (!StringUtils.HasText(refName)) { this.Error("<ref> element contains empty target attribute", ele); return(null); } var reference = new RuntimeObjectReference(refName, toParent); return(reference); } // else if (NodeNameEquals(ele, IDREF_ELEMENT)) { // return parseIdRefElement(ele); // } else if (this.NodeNameEquals(ele, VALUE_ELEMENT)) { return(this.parseValueElement(ele, defaultValueType)); } else if (this.NodeNameEquals(ele, NULL_ELEMENT)) { // It's a distinguished null value. Let's wrap it in a TypedStringValue // object in order to preserve the source location. var nullHolder = new TypedStringValue(null); return(nullHolder); } else if (this.NodeNameEquals(ele, ARRAY_ELEMENT)) { return(this.parseArrayElement(ele, bd)); } else if (this.NodeNameEquals(ele, LIST_ELEMENT)) { return(this.parseListElement(ele, bd)); } else if (this.NodeNameEquals(ele, SET_ELEMENT)) { return(this.parseSetElement(ele, bd)); } else if (this.NodeNameEquals(ele, MAP_ELEMENT)) { return(this.ParseMapElement(ele, bd)); } // else if (NodeNameEquals(ele, PROPS_ELEMENT)) // { // return parsePropsElement(ele); // } else { this.Error("Unknown property sub-element: [" + ele.Name + "]", ele); return(null); } }