public CircularImportProblem(ConfigurationClass configClass, Stack <ConfigurationClass> importStack, Type configurationClassType) : base(String.Format("A circular [Import] has been detected: " + "Illegal attempt by [Configuration] class '{0}' to import class '{1}' as '{2}' is " + "already present in the current import stack [{3}]", importStack.Peek().SimpleName, configClass.SimpleName, configClass.SimpleName, importStack), new Location(importStack.Peek().Resource, configurationClassType) ) { }
private void LoadObjectDefinitionsForConfigurationClass(ConfigurationClass configClass) { LoadObjectDefinitionForConfigurationClassIfNecessary(configClass); foreach (ConfigurationClassMethod method in configClass.Methods) { LoadObjectDefinitionsForModelMethod(method); } LoadObjectDefinitionsFromImportedResources(configClass.ImportedResources); }
/// <summary> /// Processes the configuration class. /// </summary> /// <param name="configurationClass">The configuration class.</param> protected void ProcessConfigurationClass(ConfigurationClass configurationClass) { DoProcessConfigurationClass(configurationClass); if (ConfigurationClasses.Contains(configurationClass) && configurationClass.ObjectName != null) { // Explicit object definition found, probably replacing an import. // Let's remove the old one and go with the new one. ConfigurationClasses.Remove(configurationClass); } ConfigurationClasses.Add(configurationClass); }
private void ProcessImport(ConfigurationClass configClass, IEnumerable <Type> classesToImport) { if (_importStack.Contains(configClass)) { _problemReporter.Error(new CircularImportProblem(configClass, _importStack, configClass.ConfigurationClassType)); } else { _importStack.Push(configClass); foreach (Type classToImport in classesToImport) { ProcessConfigurationClass(new ConfigurationClass(null, classToImport)); } _importStack.Pop(); } }
private void DoProcessConfigurationClass(ConfigurationClass configurationClass) { Attribute[] importAttributes = Attribute.GetCustomAttributes(configurationClass.ConfigurationClassType, typeof(ImportAttribute)); if (importAttributes.Length > 0) { foreach (Attribute importAttribute in importAttributes) { ImportAttribute attrib = importAttribute as ImportAttribute; if (null != attrib) { ProcessImport(configurationClass, attrib.Types); } } } Attribute[] importResourceAttributes = Attribute.GetCustomAttributes(configurationClass.ConfigurationClassType, typeof(ImportResourceAttribute)); if (importResourceAttributes.Length > 0) { foreach (Attribute importResourceAttribute in importResourceAttributes) { ImportResourceAttribute attrib = importResourceAttribute as ImportResourceAttribute; if (null != attrib) { foreach (string resource in attrib.Resources) { configurationClass.AddImportedResource(resource, attrib.DefinitionReader); } } } } Collections.Generic.ISet <MethodInfo> definitionMethods = GetAllMethodsWithCustomAttributeForClass(configurationClass.ConfigurationClassType, typeof(ObjectDefAttribute)); foreach (MethodInfo definitionMethod in definitionMethods) { configurationClass.Methods.Add(new ConfigurationClassMethod(definitionMethod, configurationClass)); } }
private void LoadObjectDefinitionForConfigurationClassIfNecessary(ConfigurationClass configClass) { if (configClass.ObjectName != null) { // a Object definition already exists for this configuration class -> nothing to do return; } // no Object definition exists yet -> this must be an imported configuration class ([Import]). GenericObjectDefinition configObjectDef = new GenericObjectDefinition(); String className = configClass.ConfigurationClassType.Name; configObjectDef.ObjectTypeName = className; configObjectDef.ObjectType = configClass.ConfigurationClassType; if (CheckConfigurationClassCandidate(configClass.ConfigurationClassType)) { String configObjectName = ObjectDefinitionReaderUtils.RegisterWithGeneratedName(configObjectDef, _registry); configClass.ObjectName = configObjectName; Logger.Debug(m => m("Registered object definition for imported [Configuration] class {0}", configObjectName)); } }
/// <summary> /// Initializes a new instance of the ConfigurationClassMethod class. /// </summary> /// <param name="methodInfo"></param> /// <param name="configurationClass"></param> public ConfigurationClassMethod(MethodInfo methodInfo, ConfigurationClass configurationClass) { _methodInfo = methodInfo; _configurationClass = configurationClass; }
private void LoadObjectDefinitionsForModelMethod(ConfigurationClassMethod method) { ConfigurationClass configClass = method.ConfigurationClass; MethodInfo metadata = method.MethodMetadata; RootObjectDefinition objDef = new ConfigurationClassObjectDefinition(); objDef.FactoryObjectName = configClass.ObjectName; objDef.FactoryMethodName = metadata.Name; objDef.AutowireMode = Objects.Factory.Config.AutoWiringMode.Constructor; // consider name and any aliases //Dictionary<String, Object> ObjectAttributes = metadata.getAnnotationAttributes(Object.class.getName()); object[] objectAttributes = metadata.GetCustomAttributes(typeof(ObjectDefAttribute), true); List <string> names = new List <string>(); foreach (object t in objectAttributes) { string[] namesAndAliases = ((ObjectDefAttribute)t).NamesToArray; if (namesAndAliases != null) { names.Add(metadata.Name); } else { namesAndAliases = new[] { metadata.Name }; } names.AddRange(namesAndAliases); } string objectName = (names.Count > 0 ? names[0] : method.MethodMetadata.Name); for (int i = 1; i < names.Count; i++) { _registry.RegisterAlias(objectName, names[i]); } // has this already been overridden (e.g. via XML)? if (_registry.ContainsObjectDefinition(objectName)) { IObjectDefinition existingObjectDef = _registry.GetObjectDefinition(objectName); // is the existing Object definition one that was created from a configuration class? if (!(existingObjectDef is ConfigurationClassObjectDefinition)) { // no -> then it's an external override, probably XML // overriding is legal, return immediately Logger.Debug(m => m("Skipping loading Object definition for {0}: a definition for object " + "'{1}' already exists. This is likely due to an override in XML.", method, objectName)); return; } } //TODO: container does not presently support the concept of Primary object definition for type resolution //if (Attribute.GetCustomAttribute(metadata, typeof(PrimaryAttribute)) != null) //{ // ObjectDef.isPrimary = true; //} // is this Object to be instantiated lazily? if (Attribute.GetCustomAttribute(metadata, typeof(LazyAttribute)) != null) { objDef.IsLazyInit = (Attribute.GetCustomAttribute(metadata, typeof(LazyAttribute)) as LazyAttribute).LazyInitialize; } if (Attribute.GetCustomAttribute(metadata, typeof(DependsOnAttribute)) != null) { objDef.DependsOn = (Attribute.GetCustomAttribute(metadata, typeof(DependsOnAttribute)) as DependsOnAttribute).Name; } //TODO: container does not presently support autowiring to the degree needed to support this feature as of yet //Autowire autowire = (Autowire) ObjectAttributes.get("autowire"); //if (autowire.isAutowire()) { // ObjectDef.setAutowireMode(autowire.value()); //} if (Attribute.GetCustomAttribute(metadata, typeof(ObjectDefAttribute)) != null) { objDef.InitMethodName = (Attribute.GetCustomAttribute(metadata, typeof(ObjectDefAttribute)) as ObjectDefAttribute). InitMethod; objDef.DestroyMethodName = (Attribute.GetCustomAttribute(metadata, typeof(ObjectDefAttribute)) as ObjectDefAttribute). DestroyMethod; } // consider scoping if (Attribute.GetCustomAttribute(metadata, typeof(ScopeAttribute)) != null) { objDef.Scope = (Attribute.GetCustomAttribute(metadata, typeof(ScopeAttribute)) as ScopeAttribute).ObjectScope.ToString(); } Logger.Debug(m => m("Registering Object definition for [ObjectDef] method {0}.{1}()", configClass.ConfigurationClassType.Name, objectName)); _registry.RegisterObjectDefinition(objectName, objDef); }