 		public function getInstance(type : Class, name : String = '', targetType : Class = null) : *
 		{
 			const mappingId : String = getQualifiedClassName(type) + '|' + name;
-			var provider : DependencyProvider = getProvider(mappingId, false);
-			if (!provider)
-			{
-				provider = getDefaultProvider(mappingId);
+			var provider : DependencyProvider = getProvider(mappingId);
+			if (!provider && (name.length == 0))
+			{
+				provider = getDefaultProvider(type);
 			}
 			if(provider)
 			{

			}
			
			//No meaningful way to automatically create base types without names
			const baseTypes:Array = ["Array|", "Boolean|", "Class|", "Function|", "int|", "Number|", "Object|", "String|", "uint|"];
			if(baseTypes.indexOf(mappingId) > -1)
			{
				return null;
			}
			
			const parts : Array = mappingId.split('|');
			const name : String = parts.pop();
			
			// No names around here partner (as keeping 'satisfies' and actual responses consistent would
			// mean you'd have to be updating strings in multiple places, which is the road to madness)
			if(name.length > 0)
			{
				return null;
			}

			const typeName : String = parts.pop();
			
			try
			{
				const definition : Object = _applicationDomain.hasDefinition(typeName)
					? _applicationDomain.getDefinition(typeName)
					: getDefinitionByName(typeName);
			}
			catch (e : Error)
			{
				return null;
			}
			if (!definition || !(definition is Class))
			{
				return null;
			}
			const type : Class = Class(definition);
			
			return getNearestDefaultProviderForType(type, consultParents);
		}

			{
				return softProvider;
			}
			return null;
		}

		SsInternal function getDefaultProvider(type : Class, consultParents : Boolean = true) : DependencyProvider
		{
			if((!_fallbackProvider) && (_blockParentFallbackProvider || (!(consultParents && _parentInjector))))
			{
