void FinalizeBindingConcrete(DiContainer container, List <Type> concreteTypes)
{
switch (BindInfo.Scope)
{
case ScopeTypes.Singleton:
{
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) => container.SingletonProviderCreator.CreateProviderForPrefabResource(
_resourcePath,
concreteType,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
BindInfo.ConcreteIdentifier));
break;
}
case ScopeTypes.Transient:
{
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) =>
CreateProviderForType(
concreteType,
new PrefabInstantiator(
container,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath))));
break;
}
case ScopeTypes.Cached:
{
var prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath)));
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) => new CachedProvider(
CreateProviderForType(concreteType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
void FinalizeBindingConcrete(DiContainer container, List <Type> concreteTypes)
{
var scope = GetScope();
switch (scope)
{
case ScopeTypes.Transient:
{
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) =>
_providerFactory(
concreteType,
new PrefabInstantiator(
container,
_gameObjectBindInfo,
concreteType,
concreteTypes,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath),
BindInfo.InstantiatedCallback)));
break;
}
case ScopeTypes.Singleton:
{
var argumentTarget = concreteTypes.OnlyOrDefault();
if (argumentTarget == null)
{
Assert.That(BindInfo.Arguments.IsEmpty(),
"Cannot provide arguments to prefab instantiator when using more than one concrete type");
}
var prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo,
argumentTarget,
concreteTypes,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath),
BindInfo.InstantiatedCallback));
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) => BindingUtil.CreateCachedProvider(
_providerFactory(concreteType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
void FinalizeBindingSelf(DiContainer container)
{
switch (BindInfo.Scope)
{
case ScopeTypes.Singleton:
{
RegisterProviderPerContract(
container,
(_, contractType) => container.SingletonProviderCreator.CreateProviderForPrefab(
_prefab,
contractType,
_gameObjectBindInfo,
BindInfo.Arguments,
BindInfo.ConcreteIdentifier));
break;
}
case ScopeTypes.Transient:
{
RegisterProviderPerContract(
container,
(_, contractType) =>
CreateProviderForType(
contractType,
new PrefabInstantiator(
container,
_gameObjectBindInfo,
BindInfo.Arguments,
new PrefabProvider(_prefab))));
break;
}
case ScopeTypes.Cached:
{
var prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo,
BindInfo.Arguments,
new PrefabProvider(_prefab)));
RegisterProviderPerContract(
container,
(_, contractType) =>
new CachedProvider(
CreateProviderForType(contractType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
void FinalizeBindingSelf(DiContainer container)
{
ScopeTypes scope = GetScope();
switch (scope)
{
case ScopeTypes.Transient:
{
RegisterProviderPerContract(
container,
(_, contractType) =>
_providerFactory(
contractType,
new PrefabInstantiator(
container,
_gameObjectBindInfo,
contractType,
BindInfo.Arguments,
new PrefabProvider(_prefab))));
break;
}
case ScopeTypes.Singleton:
{
Type argumentTarget = BindInfo.ContractTypes.OnlyOrDefault();
if (argumentTarget == null)
{
Assert.That(BindInfo.Arguments.IsEmpty(),
"Cannot provide arguments to prefab instantiator when using more than one concrete type");
}
PrefabInstantiatorCached prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo,
argumentTarget,
BindInfo.Arguments,
new PrefabProvider(_prefab)));
RegisterProviderPerContract(
container,
(_, contractType) =>
BindingUtil.CreateCachedProvider(
_providerFactory(contractType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
public IProvider CreateProvider(
string resourcePath, Type resultType, string gameObjectName, string gameObjectGroupName,
List <TypeValuePair> extraArguments, object concreteIdentifier)
{
IPrefabInstantiator creator;
_markRegistry.MarkSingleton(
resultType, concreteIdentifier, SingletonTypes.ToPrefabResource);
var prefabId = new PrefabId(concreteIdentifier, resourcePath);
if (_prefabCreators.TryGetValue(prefabId, out creator))
{
// TODO: Check the arguments are the same?
Assert.That(creator.ExtraArguments.IsEmpty() && extraArguments.IsEmpty(),
"Ambiguous creation parameters (arguments) when using ToPrefabResource with AsSingle");
Assert.IsEqual(creator.GameObjectName, gameObjectName,
"Ambiguous creation parameters (gameObjectName) when using ToPrefabResource with AsSingle");
Assert.IsEqual(creator.GameObjectGroupName, gameObjectGroupName,
"Ambiguous creation parameters (gameObjectGroupName) when using ToPrefabResource with AsSingle");
}
else
{
creator = new PrefabInstantiatorCached(
new PrefabInstantiator(
_container, gameObjectName,
gameObjectGroupName, extraArguments,
new PrefabProviderResource(resourcePath)));
_prefabCreators.Add(prefabId, creator);
}
if (resultType == typeof(GameObject))
{
return(new PrefabGameObjectProvider(creator));
}
return(new GetFromPrefabComponentProvider(resultType, creator));
}
public IProvider CreateProvider(
UnityEngine.Object prefab, Type resultType, GameObjectCreationParameters gameObjectBindInfo,
List <TypeValuePair> extraArguments, object concreteIdentifier, Func <Type, IPrefabInstantiator, IProvider> providerFactory)
{
IPrefabInstantiator creator;
var prefabId = new PrefabId(concreteIdentifier, prefab);
_markRegistry.MarkSingleton(
resultType, concreteIdentifier, SingletonTypes.FromPrefab);
if (_prefabCreators.TryGetValue(prefabId, out creator))
{
// TODO: Check the arguments are the same?
Assert.That(creator.ExtraArguments.IsEmpty() && extraArguments.IsEmpty(),
"Ambiguous creation parameters (arguments) when using ToPrefab with AsSingle");
Assert.IsEqual(creator.GameObjectCreationParameters, gameObjectBindInfo,
"Ambiguous creation parameters (game object naming/parent info) when using ToPrefab with AsSingle");
}
else
{
creator = new PrefabInstantiatorCached(
new PrefabInstantiator(
_container, gameObjectBindInfo, resultType, extraArguments, new PrefabProvider(prefab)));
_prefabCreators.Add(prefabId, creator);
}
if (resultType == typeof(GameObject))
{
return(new PrefabGameObjectProvider(creator));
}
return(providerFactory(resultType, creator));
}
void FinalizeBindingSelf(DiContainer container)
{
switch (GetScope())
{
case ScopeTypes.Singleton:
{
RegisterProviderPerContract(
container,
(_, contractType) => container.SingletonProviderCreator.CreateProviderForPrefabResource(
_resourcePath,
contractType,
_gameObjectBindInfo,
BindInfo.Arguments,
BindInfo.ConcreteIdentifier, _providerFactory));
break;
}
case ScopeTypes.Transient:
{
RegisterProviderPerContract(
container,
(_, contractType) =>
_providerFactory(
contractType,
new PrefabInstantiator(
container,
_gameObjectBindInfo,
contractType,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath))));
break;
}
case ScopeTypes.Cached:
{
var argumentTarget = BindInfo.ContractTypes.OnlyOrDefault();
if (argumentTarget == null)
{
Assert.That(BindInfo.Arguments.IsEmpty(),
"Cannot provide arguments to prefab instantiator when using more than one concrete type");
}
var prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo,
argumentTarget,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath)));
RegisterProviderPerContract(
container,
(_, contractType) =>
new CachedProvider(
_providerFactory(contractType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
void FinalizeBindingConcrete(DiContainer container, List<Type> concreteTypes)
{
switch (BindInfo.Scope)
{
case ScopeTypes.Singleton:
{
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) => container.SingletonProviderCreator.CreateProviderForPrefabResource(
_resourcePath,
concreteType,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
BindInfo.ConcreteIdentifier));
break;
}
case ScopeTypes.Transient:
{
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) =>
CreateProviderForType(
concreteType,
new PrefabInstantiator(
container,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath))));
break;
}
case ScopeTypes.Cached:
{
var prefabCreator = new PrefabInstantiatorCached(
new PrefabInstantiator(
container,
_gameObjectBindInfo.Name,
_gameObjectBindInfo.GroupName,
BindInfo.Arguments,
new PrefabProviderResource(_resourcePath)));
RegisterProvidersForAllContractsPerConcreteType(
container,
concreteTypes,
(_, concreteType) => new CachedProvider(
CreateProviderForType(concreteType, prefabCreator)));
break;
}
default:
{
throw Assert.CreateException();
}
}
}
