internal ModuleImpl( ApplicationValidationResultIQ validationResult, DictionaryQuery<CompositeModel, PublicCompositeTypeGenerationResult> loadingResults, LayerImpl layer, ModuleModel model )
{
ArgumentValidator.ValidateNotNull( "Layer instance", layer );
ArgumentValidator.ValidateNotNull( "Module model", model );
this._layer = layer;
this._moduleModel = model;
this._serviceContainer = new ThreadsafeServiceContainer();
this._modelInfoContainer = new ModelInfoContainerImpl(
layer.InternalApplication.ModelTypeSupportInternal,
model.CompositeModelsInThisContainer,
validationResult,
loadingResults,
layer.Application.CollectionsFactory,
model.LayerModel.ApplicationModel.GenericPropertyMixinType,
model.LayerModel.ApplicationModel.GenericEventMixinType
);
#if SILVERLIGHT
this._compositeTypeLookupCache = new Dictionary<CompositeModelType, IDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>>();
#else
this._compositeTypeLookupCache = new System.Collections.Concurrent.ConcurrentDictionary<CompositeModelType, System.Collections.Concurrent.ConcurrentDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>>();
#endif
this._serviceProvider = new StructureServiceProviderImpl(
this,
layer.InternalApplication.ModelTypeSupportInternal,
matcher => this.FindVisibleModels( matcher )
);
}
protected CompositeModel NewCompositeModel(DictionaryQuery <CompositeModelType, CompositeModelTypeModelScopeSupport> compositeModelSupports, ApplicationModel <ApplicationSPI> appModel, CompositeAssemblyInfo compositeInfo, String architectureContainerID)
{
var result = compositeModelSupports[compositeInfo.CompositeModelType].NewCompositeModel(appModel, compositeInfo, this.LaunchAttributeProcessingEvent, architectureContainerID);
this.CompositeModelCreatedEvent.InvokeEventIfNotNull(evt => evt(this, new CompositeModelCreatedArgs(result)));
return(result);
}
internal SingletonApplicationImpl(
SingletonApplicationModel applicationModel,
IEnumerable <Tuple <CompositeModelType, CompositeModelTypeModelScopeSupport> > compositeModelTypeSupport,
ApplicationValidationResultIQ validationResult,
DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults,
String name,
String mode,
String version
)
: base(
applicationModel,
compositeModelTypeSupport,
name,
mode,
version
)
{
this._modelInfoContainer = new ModelInfoContainerImpl(this.InternalModelSupport, applicationModel.CompositeModelsInThisContainer, validationResult, loadingResults, this.CollectionsFactory, applicationModel.GenericPropertyMixinType, applicationModel.GenericEventMixinType);
this._structureServiceProvider = new StructureServiceProviderImpl(
this,
this.ModelTypeSupport,
matcher => applicationModel.CompositeModelsInThisContainer
.Where(matcher)
.Select(model => Tuple.Create <CompositeInstanceStructureOwner, CompositeModel>(this, model))
);
this._serviceContainer = new ThreadsafeServiceContainer();
}
public CompositeStateImpl(CollectionsFactory collectionFactory, ListQuery <CompositeProperty> properties, ListQuery <CompositeEvent> events)
{
IDictionary <MethodInfo, QualifiedName> qNames = new Dictionary <MethodInfo, QualifiedName>();
IDictionary <QualifiedName, CompositeProperty> propertiesDic = new Dictionary <QualifiedName, CompositeProperty>();
IDictionary <QualifiedName, CompositeEvent> eventsDic = new Dictionary <QualifiedName, CompositeEvent>();
foreach (CompositeProperty property in properties)
{
PropertyInfo pInfo = property.ReflectionInfo;
QualifiedName qName = property.QualifiedName;
qNames.Add(pInfo.GetGetMethod(), qName);
qNames.Add(pInfo.GetSetMethod(), qName);
propertiesDic.Add(qName, property);
}
foreach (CompositeEvent evt in events)
{
EventInfo eInfo = evt.ReflectionInfo;
QualifiedName qName = evt.QualifiedName;
qNames.Add(eInfo.GetAddMethod(), qName);
qNames.Add(eInfo.GetRemoveMethod(), qName);
eventsDic.Add(qName, evt);
}
this._qNames = collectionFactory.NewDictionaryProxy(qNames).CQ;
this._properties = collectionFactory.NewDictionaryProxy(propertiesDic).CQ;
this._events = collectionFactory.NewDictionaryProxy(eventsDic).CQ;
}
public ApplicationSkeleton(
ApplicationModel <ApplicationSPI> applicationModel,
IEnumerable <Tuple <CompositeModelType, CompositeModelTypeModelScopeSupport> > compositeModelTypeSupport,
String name,
String mode,
String version
)
{
this._model = applicationModel;
this._collectionsFactory = applicationModel.CollectionsFactory;
this._name = name;
this._mode = mode;
this._version = version;
this._constraintInstancePools = new
#if SILVERLIGHT
Dictionary <Type, InstancePool <Object> >();
#else
System.Collections.Concurrent.ConcurrentDictionary <Type, InstancePool <Object> >();
#endif
this._compositeModelTypeSupport = this._model.CollectionsFactory.NewDictionaryProxy <CompositeModelType, CompositeModelTypeInstanceScopeSupport>(compositeModelTypeSupport.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2.CreateInstanceScopeSupport())).CQ;
this._activationState = (Int32)ActivationState.PASSIVE;
//this._disposedState = Convert.ToInt32( false );
this._activationInProgress = null;
this._passivationInProgress = null;
this._cancelTokenSource = new CancellationTokenSource();
}
public AttributeHolderImpl(
CollectionsFactory collectionsFactory,
IEnumerable <MemberInfo> reflectedInfos
)
{
Attribute[] attributes = reflectedInfos
.SelectMany(info => info.GetCustomAttributes(true))
.Distinct()
.Cast <Attribute>()
.ToArray();
IDictionary <Type, ListProxy <Attribute> > dic = new Dictionary <Type, ListProxy <Attribute> >();
foreach (Attribute attr in attributes)
{
ListProxy <Attribute> list;
if (!dic.TryGetValue(attr.GetType(), out list))
{
list = collectionsFactory.NewListProxy <Attribute>();
dic.Add(attr.GetType(), list);
}
list.Add(attr);
}
this._allAttributes = collectionsFactory.NewDictionary <Type, ListProxy <Attribute>, ListProxyQuery <Attribute>, ListQuery <Attribute> >(dic).MQ.IQ;
}
public PageGridData <DictionaryDto> GetDictionaryPage(DictionaryQuery query)
{
using (var dbScope = _dbScopeFactory.CreateReadOnly())
{
var db = dbScope.DbContexts.Get <FireProjDbContext>();
var data = db.Dictionary.Select(r => new DictionaryDto
{
Id = r.Id,
Name = r.Name,
Value = r.Value,
Description = r.Description,
Status = r.Status,
ParentId = r.ParentId,
});
if (!string.IsNullOrEmpty(query.Search))
{
data = data.Where(r => r.Name.Contains(query.Search));
}
var result = data.OrderBy(r => r.Id).ToList();
var total = data.Count();
return(new PageGridData <DictionaryDto> {
rows = result, total = total
});
}
}
internal LayeredApplicationImpl(
LayeredApplicationModel model,
IEnumerable <Tuple <CompositeModelType, CompositeModelTypeModelScopeSupport> > compositeModelTypeSupport,
ApplicationValidationResultIQ validationResult,
DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults,
String name,
String mode,
String version
)
: base(
model,
compositeModelTypeSupport,
name,
mode,
version
)
{
DictionaryProxy <LayerModel, LayerImpl> allLayers = model.CollectionsFactory.NewDictionaryProxy <LayerModel, LayerImpl>();
foreach (LayerModel layerModel in model.TopLevelLayers)
{
this.ProcessLayers(validationResult, loadingResults, allLayers, layerModel);
}
this._allLayers = allLayers.CQ;
}
protected ModuleModelMutable NewModuleModel(DictionaryQuery <CompositeModelType, CompositeModelTypeModelScopeSupport> compositeModelTypeSupport, DictionaryProxy <Int32, CompositeModel> models, LayerModelMutable owningLayer, ModuleArchitectureImpl module)
{
var state = new ModuleModelState(this.CollectionsFactory);
var immutable = new ModuleModelImmutable(state);
var result = new ModuleModelMutable(state, immutable);
state.ModuleName = module.Name;
state.LayerModel = owningLayer;
state.Assembler = module.LayeredCompositeAssembler;
foreach (var modelType in this.ModelTypeSupport.Keys)
{
IDictionary <CompositeModel, Visibility> visibilities = null;
if (!state.CompositeVisibilities.TryGetValue(modelType, out visibilities))
{
visibilities = new Dictionary <CompositeModel, Visibility>(ReferenceEqualityComparer <CompositeModel> .ReferenceBasedComparer);
state.CompositeVisibilities.Add(modelType, visibilities);
}
foreach (LayeredCompositeAssemblyInfo info in module.LayeredCompositeAssembler.GetInfos(modelType).Cast <LayeredCompositeAssemblyInfo>())
{
var cModel = this.NewCompositeModel(compositeModelTypeSupport, owningLayer.IQ.ApplicationModel, info, owningLayer.IQ.LayerName + "-" + module.Name);
models.Add(cModel.CompositeModelID, cModel);
state.CompositeModels.Add(cModel);
visibilities.Add(cModel, info.Visibility);
}
}
return(result);
}
internal LayerImpl(ApplicationValidationResultIQ validationResult, DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults, LayeredApplicationImpl application, LayerModel layerModel)
{
this._application = application;
this._model = layerModel;
this._modules = layerModel.ApplicationModel.CollectionsFactory.NewDictionaryProxy <ModuleModel, Module>(
layerModel.ModuleModels.ToDictionary(model => model, model => (Module) new ModuleImpl(validationResult, loadingResults, this, model))
).CQ;
}
internal DictionaryQueryOfMutablesImpl(DictionaryQuery <TKey, TValueImmutable> immutableQuery, DictionaryQueryOfQueries <TKey, TValueQuery, TValueImmutable> cmq, DictionaryWithRolesState <TKey, TValue, TValueQuery, TValueImmutable> state)
: base(state)
{
ArgumentValidator.ValidateNotNull("Immutable query", immutableQuery);
this._state = state;
this._cmq = cmq;
this._iq = immutableQuery;
}
protected ApplicationArchitectureSkeleton(IEnumerable <CompositeModelTypeAssemblyScopeSupport> modelTypeSupport)
{
ArgumentValidator.ValidateNotNull("Composite model type supports", modelTypeSupport);
this._collectionsFactory = CollectionsFactorySingleton.DEFAULT_COLLECTIONS_FACTORY;
this._modelTypeSupport = this._collectionsFactory.NewDictionaryProxy(modelTypeSupport.ToDictionary(support => support.ModelType, support => support)).CQ;
this._metaInfoContainer = UsesContainerMutableImpl.CreateEmpty();
this._additionalInjectionFunctionalities = this._collectionsFactory.NewDictionaryProxy <Type, InjectionFunctionality>();
}
//protected virtual CompositeInstanceImpl CreateNewCopy( IEnumerable<Type> publicCompositeTypes, UsesContainerQuery uses )
//{
// return new CompositeInstanceImpl( this._structureOwner, this._modelInfo.Model, publicCompositeTypes, uses );
//}
protected InstancePoolInfo <TInvocation> FindPool <TInvocation>(Type key, DictionaryQuery <Type, InstancePoolInfo <TInvocation> > dic)
{
InstancePoolInfo <TInvocation> pool = null;
if (!dic.TryFindInTypeDictionarySearchSubTypes(key, out pool))
{
throw new InternalException("Could not find invocation base type " + key + ".");
}
return(pool);
}
protected TInvocation CreateInvocationBase <TInvocation>(DictionaryQuery <Type, InstancePoolInfo <TInvocation> > dic, Type key)
{
InstancePoolInfo <TInvocation> pool = this.FindPool <TInvocation>(key, dic);
TInvocation result;
if (!pool.Pool.TryTake(out result))
{
result = (TInvocation)this._modelInfo.Types.CompositeFactory.CreateInstance(pool.TypeGenerationResult.GeneratedTypeID, this._gArgs, new Object[] { this });
}
return(result);
}
/// <summary>
/// Creates new instance of <see cref="ApplicationCodeResolveArgs"/>.
/// </summary>
/// <param name="genResults">Type generation results.</param>
/// <param name="assemblies">A dictionary containing mapping from already-existing native assemblies and generated assemblies.</param>
/// <exception cref="ArgumentNullException">If <paramref name="genResults"/> or <paramref name="assemblies"/> is <c>null</c>.</exception>
public ApplicationCodeResolveArgs(
DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> genResults,
DictionaryQuery <System.Reflection.Assembly, System.Reflection.Assembly> assemblies
)
{
ArgumentValidator.ValidateNotNull("Generation results", genResults);
ArgumentValidator.ValidateNotNull("Assemblies", assemblies);
this._genResults = genResults;
this._assemblies = assemblies;
}
public AbstractCompositeAssemblyDeclarationForExistingImpl(Assembler assembler, CompositeModelType compositeModelType, DictionaryQuery <Type, ListQuery <CompositeAssemblyInfo> > compositeAssemblyInfos)
{
ArgumentValidator.ValidateNotNull("Assembler", assembler);
ArgumentValidator.ValidateNotNull("Assembly infos", compositeAssemblyInfos);
ArgumentValidator.ValidateNotNull("Composite model type", compositeModelType);
this._assembler = assembler;
this._compositeModelType = compositeModelType;
this._composites = compositeAssemblyInfos;
this._affectedTypes = new HashSet <Type>();
}
private void ProcessLayers(ApplicationValidationResultIQ validationResult, DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults, DictionaryProxy <LayerModel, LayerImpl> layers, LayerModel layerModel)
{
if (!layers.CQ.ContainsKey(layerModel))
{
layers.Add(layerModel, new LayerImpl(validationResult, loadingResults, this, layerModel));
}
foreach (LayerModel used in layerModel.UsedLayerModels)
{
this.ProcessLayers(validationResult, loadingResults, layers, used);
}
}
static void PopulateDictionaryQuery()
{
using (DictionaryQuery <string> dic = cx.DictionaryQuery <string>("assembly"))
{
Debug.WriteLine("Adding assembly informations to 'assembly'.");
Assembly a = Assembly.GetExecutingAssembly();
dic.Add("Name", a.FullName);
dic.Add("Version", a.GetName().Version.ToString());
dic.Add("done", "");
}
}
public StructureServiceProviderImpl(
CompositeInstanceStructureOwner structure,
DictionaryQuery <CompositeModelType, CompositeModelTypeInstanceScopeSupport> modelSupport,
Func <Func <CompositeModel, Boolean>, IEnumerable <Tuple <CompositeInstanceStructureOwner, CompositeModel> > > serviceFinderFunction
)
{
ArgumentValidator.ValidateNotNull("Structure", structure);
ArgumentValidator.ValidateNotNull("Model type support", modelSupport);
ArgumentValidator.ValidateNotNull("Service finder function", serviceFinderFunction);
this._structure = structure;
this._modelSupport = modelSupport;
this._modelFinder = serviceFinderFunction;
}
public AssemblerImpl(ApplicationArchitecture <ApplicationModel <ApplicationSPI> > applicationArchitecture, Func <Int32> newCompositeIDRequestor, DictionaryQuery <CompositeModelType, CompositeModelTypeAssemblyScopeSupport> modelTypeSupport, UsesContainerMutable parentContainer, CollectionsFactory collectionsFactory)
{
ArgumentValidator.ValidateNotNull("Application architecture", applicationArchitecture);
ArgumentValidator.ValidateNotNull("ID requestor function", newCompositeIDRequestor);
ArgumentValidator.ValidateNotNull("Model type support", modelTypeSupport);
ArgumentValidator.ValidateNotNull("Parent uses container", parentContainer);
ArgumentValidator.ValidateNotNull("Collections factory", collectionsFactory);
this._applicationArchitecture = applicationArchitecture;
this._newCompositeIDRequestor = newCompositeIDRequestor;
this._collectionsFactory = collectionsFactory;
this._compositeInfos = this._collectionsFactory.NewDictionaryProxy <CompositeModelType, DictionaryWithRoles <Type, ListProxy <CompositeAssemblyInfo>, ListProxyQuery <CompositeAssemblyInfo>, ListQuery <CompositeAssemblyInfo> > >();
this._assemblyScopeSupport = modelTypeSupport;
this._parentContainer = parentContainer;
}
static void TestParallelModifications()
{
using (DictionaryQuery <string> dic = cx.DictionaryQuery <string>("parallel"))
{
dic.Add("hello", "world");
dic["hello"].ShouldBe("world");
using (DictionaryQuery <string> pdic = cx.DictionaryQuery <string>("parallel"))
{
pdic["hello"] = "you";
}
dic.ShouldContainKey("hello");
dic["hello"].ShouldBe("you");
dic.Clear();
}
}
internal ModuleArchitectureImpl(
String moduleName,
LayerArchitecture layer,
UsesContainerQuery parentContainer,
Func <Int32> compositeIDGenerator,
DictionaryQuery <CompositeModelType, CompositeModelTypeAssemblyScopeSupport> modelTypeSupport
)
{
ArgumentValidator.ValidateNotNull("Layer", layer);
ArgumentValidator.ValidateNotNull("Parent meta-info container", parentContainer);
this._moduleName = moduleName;
this._layer = layer;
this._metaInfo = UsesContainerMutableImpl.CreateWithParent(parentContainer);
this._assembler = new LayeredCompositeAssemblerImpl(this, compositeIDGenerator, modelTypeSupport, this._metaInfo, layer.Architecture.CollectionsFactory);
this._domainSpecificAssemblers = new DomainSpecificAssemblerAggregatorImpl <LayeredCompositeAssembler>(layer.Architecture.CollectionsFactory);
}
internal LayeredApplicationModelImmutable(
LayeredArchitecture architecture,
Type genericCompositePropertyMixin,
Type genericCompositeEventMixin,
Type genericFragmentBaseType,
DictionaryQuery <CompositeModelType, CompositeModelTypeAssemblyScopeSupport> modelTypeAssemblyScopeSupport,
out DictionaryQuery <CompositeModelType, CompositeModelTypeModelScopeSupport> compositeModelTypeSupport,
out DictionaryProxy <Int32, CompositeModel> models,
out ListProxy <LayerModelMutable> topLevelLayers,
out ListProxy <LayerModelMutable> allLayers
)
: base(architecture, genericCompositePropertyMixin, genericCompositeEventMixin, genericFragmentBaseType, modelTypeAssemblyScopeSupport, out compositeModelTypeSupport, out models)
{
this._topLevelLayers = this.CollectionsFactory.NewListProxy <LayerModelMutable>();
this._allLayers = this.CollectionsFactory.NewListProxy <LayerModelMutable>();
topLevelLayers = this._topLevelLayers;
allLayers = this._allLayers;
}
static void TestDictionaryQuery()
{
using (DictionaryQuery <string> dic = cx.DictionaryQuery <string>("assembly"))
{
dic.ShouldSatisfyAllConditions(
() => dic.ShouldContainKey("done"),
() => dic.ShouldContainKey("Name"),
() => dic["Name"].ShouldBe(Assembly.GetExecutingAssembly().FullName)
);
dynamic dyn = dic.AsDynamic();
(dyn.Name as object).ShouldBe(dic["Name"]);
dyn.Name = Assembly.GetExecutingAssembly().GetName().Name;
dic["Name"].ShouldBe(Assembly.GetExecutingAssembly().GetName().Name);
dic["Name"] = Assembly.GetExecutingAssembly().FullName;
}
}
static async Task TestMultithreading()
{
Random rand = new Random();
using (DictionaryQuery <string> dic = cx.DictionaryQuery <string>("async"))
{
for (int i = 0; i < 15; i++)
{
if (!dic.ContainsKey("nb" + i))
{
await Task.Delay(rand.Next(1000));
dic["nb" + i % 2] = "whatever" + i;
}
}
dic.Clear();
}
}
protected ApplicationModelSkeletonImmutable(
ApplicationArchitecture <ApplicationModel <ApplicationSPI> > architecture,
Type genericCompositePropertyMixin,
Type genericCompositeEventMixin,
Type genericFragmentBaseType,
DictionaryQuery <CompositeModelType, CompositeModelTypeAssemblyScopeSupport> modelTypeAssemblyScopeSupport,
out DictionaryQuery <CompositeModelType, CompositeModelTypeModelScopeSupport> compositeModelTypeSupport,
out DictionaryProxy <Int32, CompositeModel> models
)
{
ArgumentValidator.ValidateNotNull("Application architecture", architecture);
ArgumentValidator.ValidateNotNull("Generic composite property mixin", genericCompositePropertyMixin);
ArgumentValidator.ValidateNotNull("Generic composite event mixin", genericCompositeEventMixin);
ArgumentValidator.ValidateNotNull("Generic fragment base type", genericFragmentBaseType);
this._injectionService = new InjectionServiceImpl();
this._genericCompositePropertyMixin = genericCompositePropertyMixin;
this._genericCompositeEventMixin = genericCompositeEventMixin;
this._genericFragmentBaseType = genericFragmentBaseType;
this._collectionsFactory = architecture.CollectionsFactory;
this._compositeModelTypeSupport = this._collectionsFactory.NewDictionaryProxy <CompositeModelType, CompositeModelTypeModelScopeSupport>(modelTypeAssemblyScopeSupport.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.CreateModelScopeSupport())).CQ;
this._models = this._collectionsFactory.NewDictionaryProxy <Int32, CompositeModel>();
this._validationResult = new Lazy <ApplicationValidationResultIQ>(this.DoValidate, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
compositeModelTypeSupport = this._compositeModelTypeSupport;
models = this._models;
this._typeModelDic = new Lazy <DictionaryQuery <CompositeModel, CompositeTypeModel> >(() =>
this._collectionsFactory.NewDictionaryProxy(this.CompositeModels.Values
.Select(cModel => Tuple.Create(cModel, ((CompositeValidationResultImmutable)this._validationResult.Value.CompositeValidationResults[cModel]).TypeModel))
.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2, ReferenceEqualityComparer <CompositeModel> .ReferenceBasedComparer)).CQ
, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
this._affectedAssemblies = new Lazy <SetQuery <Assembly> >(() =>
this._collectionsFactory.NewSetProxy(new HashSet <Assembly>(
this._typeModelDic.Value
.SelectMany(tModel => tModel.Key.PublicTypes
.Concat(tModel.Value.PrivateCompositeTypeInfos.Keys)
.Concat(tModel.Value.FragmentTypeInfos.Keys)
.Concat(tModel.Value.ConcernInvocationTypeInfos.Keys)
.Concat(tModel.Value.SideEffectInvocationTypeInfos.Keys))
.Select(type => type.GetAssembly())
)).CQ
, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
}
internal SingletonApplicationModelImmutable(
SingletonArchitecture architecture,
Type genericCompositePropertyMixin,
Type genericCompositeEventMixin,
Type genericFragmentBaseType,
DictionaryQuery <CompositeModelType, CompositeModelTypeAssemblyScopeSupport> modelTypeAssemblyScopeSupport,
out DictionaryQuery <CompositeModelType, CompositeModelTypeModelScopeSupport> compositeModelTypeSupport,
out DictionaryProxy <Int32, CompositeModel> models,
out SetProxy <CompositeModel> modelsForContainer,
Assembler assembler
)
: base(architecture, genericCompositePropertyMixin, genericCompositeEventMixin, genericFragmentBaseType, modelTypeAssemblyScopeSupport, out compositeModelTypeSupport, out models)
{
ArgumentValidator.ValidateNotNull("Assembler", assembler);
this._assembler = assembler;
this._compositeModels = this.CollectionsFactory.NewSetProxy <CompositeModel>();
modelsForContainer = this._compositeModels;
}
/// <summary>
/// Tries to find a value from <paramref name="dictionary"/> with types as keys. If direct lookup fails, this method will accept value of the key which will return <c>true</c> for <see cref="E_CommonUtils.IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes"/> with <paramref name="type"/> as first argument and current key as second argument.
/// </summary>
/// <typeparam name="TValue">The type of the values of the <paramref name="dictionary"/>.</typeparam>
/// <param name="type">The type to search value for.</param>
/// <param name="dictionary">The dictionary to search from.</param>
/// <param name="result">This will contain result if return value is <c>true</c>; otherwise <c>default(TValue)</c>.</param>
/// <returns>If the dictionary contains key <paramref name="type"/> or any of its parent types, <c>true</c>; otherwise, <c>false</c>.</returns>
internal static Boolean TryFindInTypeDictionarySearchSubTypes <TValue>(this DictionaryQuery <Type, TValue> dictionary, Type type, out TValue result)
{
// First try to find directly
var found = dictionary.TryGetValue(type, out result);
if (!found)
{
// Then iterate all value until found
foreach (var kvp in dictionary)
{
found = type.IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(kvp.Key);
if (found)
{
result = kvp.Value;
break;
}
}
}
return(found);
}
/// <summary>
/// Tries to find a value from <paramref name="dictionary"/> with types as keys. If direct lookup fails, this method will accept value of bottom-most type of <paramref name="type"/>'s inheritance hierarchy found in <paramref name="dictionary"/>.
/// </summary>
/// <typeparam name="TValue">The type of the values of the <paramref name="dictionary"/>.</typeparam>
/// <param name="type">The type to search value for.</param>
/// <param name="dictionary">The dictionary to search from.</param>
/// <param name="result">This will contain result if return value is <c>true</c>; otherwise <c>default(TValue)</c>.</param>
/// <returns>If the dictionary contains key <paramref name="type"/> or any of the keys has <paramref name="type"/> as its parent type, <c>true</c>; otherwise, <c>false</c>.</returns>
internal static Boolean TryFindInTypeDictionarySearchBottommostType <TValue>(this DictionaryQuery <Type, TValue> dictionary, Type type, out TValue result)
{
var found = dictionary.TryGetValue(type, out result);
if (!found)
{
// Search for bottom-most type
var current = type;
var currentOK = false;
foreach (var kvp in dictionary)
{
currentOK = current.IsAssignableFrom(kvp.Key);
found = currentOK || found;
if (currentOK)
{
result = kvp.Value;
current = kvp.Key;
}
}
}
return(found);
}
public ModelInfoContainerImpl(
DictionaryQuery <CompositeModelType, CompositeModelTypeInstanceScopeSupport> modelSupport,
SetQuery <CompositeModel> models,
ApplicationValidationResultIQ validationResult,
DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults,
CollectionsFactory collectionsFactory,
Type genericPropertyMixinType,
Type genericEventMixinType
)
{
ArgumentValidator.ValidateNotNull("Model support", modelSupport);
ArgumentValidator.ValidateNotNull("Models", models);
ArgumentValidator.ValidateNotNull("Validation result", validationResult);
PublicCompositeTypeGenerationResult[] typeGenResults = new PublicCompositeTypeGenerationResult[models.Count];
Int32 gIdx = 0;
foreach (CompositeModel model in models)
{
typeGenResults[gIdx] = loadingResults[model];
++gIdx;
}
this._compositeModels = collectionsFactory.NewDictionaryProxy <CompositeModelType, SetQuery <CompositeModelInfo> >(
models
.Select(model => model.ModelType)
.Distinct()
.ToDictionary(
modelType => modelType,
modelType2 =>
collectionsFactory.NewSetProxy <CompositeModelInfo>(new HashSet <CompositeModelInfo>(models
.Select((modelInner, idx) => new KeyValuePair <CompositeModel, PublicCompositeTypeGenerationResult>(modelInner, typeGenResults[idx]))
.Where(kvp => kvp.Key.ModelType.Equals(modelType2))
.Select(kvp => new ModelInfoImpl(kvp.Key, kvp.Value, collectionsFactory)),
ReferenceEqualityComparer <CompositeModelInfo> .ReferenceBasedComparer)).CQ
)
).CQ;
}
