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 )
);
}
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 static void CheckValidation(ApplicationValidationResultIQ validationResult, String msg)
{
if (validationResult.HasAnyErrors())
{
throw new InvalidApplicationModelException(validationResult, msg);
}
}
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();
}
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;
}
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);
}
}
/// <summary>
/// Helper method to get enumerable of all errors of some <see cref="ApplicationValidationResultIQ"/>.
/// </summary>
/// <param name="result">The <see cref="ApplicationValidationResultIQ"/>.</param>
/// <returns>Enumerable of all errors of a single <see cref="ApplicationValidationResultIQ"/>.</returns>
/// <exception cref="NullReferenceException">If <paramref name="result"/> is <c>null</c>.</exception>
public static IEnumerable <AbstractValidationError> GetAllErrors(this ApplicationValidationResultIQ result)
{
return(result.InjectionValidationErrors
.Cast <AbstractValidationError>()
.Concat(result.StructureValidationErrors)
.Concat(result.InternalValidationErrors)
.Concat(result.CompositeValidationResults.Values.SelectMany(cResult =>
cResult.InjectionValidationErrors.Cast <AbstractValidationError>()
.Concat(cResult.StructureValidationErrors)
.Concat(cResult.InternalValidationErrors)
)));
}
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;
}
protected override LayeredApplication CreateNew(ApplicationValidationResultIQ validationResult, String name, String mode, String version, DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults)
{
return(new LayeredApplicationImpl(this, this.CompositeModelTypeModelScopeSupports.Select(kvp => Tuple.Create(kvp.Key, (CompositeModelTypeModelScopeSupport)kvp.Value)), validationResult, loadingResults, name, mode, version));
}
/// <summary>
/// Creates new instance of <see cref="InvalidApplicationModelException"/>.
/// </summary>
/// <param name="validationResult">The <see cref="ApplicationValidationResultIQ"/> which contains validation errors prohibiting some functionality.</param>
/// <param name="errorMsg">The additional error message.</param>
public InvalidApplicationModelException(ApplicationValidationResultIQ validationResult, String errorMsg)
: base(errorMsg + "\n" + validationResult)
{
this._validationResult = validationResult;
}
protected abstract TApplicationInstance CreateNew(ApplicationValidationResultIQ validationResult, String name, String mode, String version, DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults);
