 			
 			return false;
 		}
+		
+		/**
+		 * Resolves the non-optional parameters for a constructor
+		 * @param	typeDescription The optimized description of the type
+		 * @return An array of objects to use as constructor arguments
+		 */
+		private function resolveConstructorParameters(typeDescription:Object):Array
+		{
+			var parameters:Array = [];
+			
+			for each (var parameterType:Class in typeDescription.constructorTypes)
+				parameters.push(resolve(parameterType));
+			
+			return parameters;
+		}
+		
+		/**
+		 * Resolves the properties on the instance object that are marked 'Inject'
+		 * @param	instance The object to be inspected
+		 * @param	typeDescription The optimized description of the type
+		 */
+		private function injectProperties(instance:Object, typeDescription:Object):void
+		{
+			for each (var injectableProperty:Object in typeDescription.injectableProperties)
+			{
+				instance[injectableProperty.name] = resolve(injectableProperty.type);
+			}
+		}
 	}
 }
			if (!type)
				throw new IllegalOperationError("Type cannot be null when resolving.");
			
			var description:XML = getTypeDescription(type);
			
			if (description.factory.extendsClass.length() === 0)
				throw new IllegalOperationError("Interface {0} must be registered before it can be resolved.".replace("{0}", description.@name.toString()));
			
			var parameters:Array = resolveConstructorParameters(description.factory.constructor);
			var instance:Object = createObject(type, parameters);
			injectProperties(instance, description.factory);
			
			return instance;
		}

		/**
		 * Gets the class description for the type
		 * @param	type The class to be described
		 * @return An object of constructor types and injectable properties
		 */
		private function getTypeDescription(type:Class):Object
		{
			if (_descriptions[type] !== undefined)
				return _descriptions[type];
			
			return _descriptions[type] = buildTypeDescription(type);
		}
		
		/**
		 * Builds an optimized description of the type.
		 * @param	type The type to be described.
		 * @return An optimized description of the constructor and injectable properties
		 */
		private function buildTypeDescription(type:Class):Object
		{
			var typeDescription:Object = { constructorTypes:[], injectableProperties:[] };
			var description:XML = describeType(type);
			
			if (description.factory.extendsClass.length() === 0)
				return null;
				
			for each (var parameter:XML in description.factory.constructor.parameter)
			{
				if (parameter.@optional.toString() != "false")
					break;
				
				var parameterType:Class = Class(getDefinitionByName(parameter.@type.toString()));
				typeDescription.constructorTypes.push(parameterType);
			}
			
			for each (var accessor:XML in description.factory.accessor)
			{
				if (shouldInjectAccessor(accessor))
				{
					var propertyType:Class = Class(getDefinitionByName(accessor.@type.toString()));
					typeDescription.injectableProperties.push( { name:accessor.@name.toString(), type:propertyType } ); 
				}
			}
			
			return typeDescription;
		}
		
		/**
