/// <summary> /// Tries to get model definition for identifier <paramref name="modelIdentifier"/>. /// </summary> /// <param name="modelIdentifier">Identifier of requested model definition.</param> /// <param name="modelDefinition">Model definition.</param> /// <returns><c>true</c> if model was found; <c>false</c> otherwise.</returns> public bool TryGet(string modelIdentifier, out IModelDefinition modelDefinition) { Ensure.NotNullOrEmpty(modelIdentifier, "modelIdentifier"); // Search in singletons. if (singletons.TryGetValue(modelIdentifier, out modelDefinition)) { return(true); } lock (storageLock) { // Search in builders. IFactory <IModelDefinition> builder; if (builders.TryGetValue(modelIdentifier, out builder)) { singletons[modelIdentifier] = modelDefinition = builder.Create(); return(true); } // Search using search handlers. if (onSearchDefinition.TryExecute(modelIdentifier, out modelDefinition)) { singletons[modelIdentifier] = modelDefinition; return(true); } } // Unnable to find model definition. modelDefinition = null; return(true); }
public bool TryGet(string modelIdentifier, string fieldIdentifier, string metadataKey, out IFieldMetadataValidator validator) { foreach (FieldMetadataValidatorKey key in LazyEnumerateKeys(modelIdentifier, fieldIdentifier, metadataKey)) { if (singletons.TryGetValue(key, out validator)) { return(true); } IFactory <IFieldMetadataValidator> builder; if (builders.TryGetValue(key, out builder)) { validator = builder.Create(); return(true); } if (onSearchValidator.TryExecute(key, out validator)) { return(true); } } validator = null; return(false); }
public object TryCreate(IReflectionBehaviorFactoryContext context, Type behaviorType) { IReflectionBehaviorFactory provider; if (!storage.TryGetValue(behaviorType, out provider)) { onSearchFactory.TryExecute(behaviorType, out provider); } return(provider.TryCreate(context, behaviorType)); }
public CodeExpression TryGenerate(ICodeDomContext context, Type behaviorType) { ICodeDomBehaviorGenerator generator; if (!storage.TryGetValue(behaviorType, out generator)) { onSearchGenerator.TryExecute(behaviorType, out generator); } return(generator.TryGenerate(context, behaviorType)); }
public bool TryGet <TModel>(out IValidationHandler <TModel> handler) { Type modelType = typeof(TModel); DefaultValidationHandlerDefinition definition; if (storage.TryGetValue(modelType, out definition)) { handler = (IValidationHandler <TModel>)definition.ValidationHandler; return(true); } object rawHandler; if (onSearchHandler.TryExecute(modelType, out rawHandler)) { handler = definition.ValidationHandler as IValidationHandler <TModel>; return(handler != null); } handler = null; return(false); }
/// <summary> /// Tries to find mapping from <paramref name="type"/> to <paramref name="targetTypeName"/> /// when converting .NET type to XML type name. /// </summary> /// <param name="type">.NET type.</param> /// <param name="targetTypeName">Mapped XML type name.</param> /// <returns><c>true</c> when mapping does exist; <c>false</c> otherwise.</returns> public bool TryGetXmlName(Type type, out string targetTypeName) { Ensure.NotNull(type, "type"); if (typeStorage.TryGetValue(type, out targetTypeName)) { return(true); } if (onSearchName.TryExecute(type, out targetTypeName)) { return(true); } targetTypeName = null; return(false); }
/// <summary> /// Tries to find mapping from <paramref name="typeName"/> to <paramref name="targetType"/> /// when converting XML type name to .NET type. /// </summary> /// <param name="typeName">XML type name.</param> /// <param name="targetType">Mapped .NET type.</param> /// <returns><c>true</c> when mapping does exist; <c>false</c> otherwise.</returns> public bool TryGetMappedType(string typeName, out Type targetType) { Ensure.NotNullOrEmpty(typeName, "typeName"); if (nameStorage.TryGetValue(typeName, out targetType)) { return(true); } if (onSearchType.TryExecute(typeName, out targetType)) { return(true); } targetType = null; return(false); }
public Task <IDeleteContext> PrepareContextAsync(IKey key) { Ensure.NotNull(key, "key"); IDeleteHandler handler; if (handlers.TryGetValue(key.Type, out handler)) { return(handler.HandleAsync(key)); } if (onSearchHandler.TryExecute(key.Type, out handler)) { return(handler.HandleAsync(key)); } return(Task.FromResult <IDeleteContext>(new MissingHandlerContext(key))); }
public IDeleteContext PrepareContext(IKey key) { Ensure.NotNull(key, "key"); IDeleteHandler handler; if (handlers.TryGetValue(key.Type, out handler)) { return(handler.Handle(key)); } if (onSearchHandler.TryExecute(key.Type, out handler)) { return(handler.Handle(key)); } return(new MissingHandlerContext(key)); }
public bool TryGet(IModelDefinition modelDefinition, out IModelView <T> modelView) { Ensure.NotNull(modelDefinition, "modelDefinition"); IFactory <IModelView <T> > modelViewActivator; if (storage.TryGetValue(modelDefinition.Identifier, out modelViewActivator)) { modelView = modelViewActivator.Create(); return(true); } if (onSearchView.TryExecute(modelDefinition, out modelViewActivator)) { modelView = modelViewActivator.Create(); return(true); } modelView = null; return(false); }
public bool TryWith <TFeature>(out TFeature feature) { Type featureType = typeof(TFeature); object featureBase; if (features.TryGetValue(featureType, out featureBase)) { feature = (TFeature)featureBase; return(true); } Func <object> featureGetter; if (featureGetters.TryGetValue(featureType, out featureGetter)) { feature = (TFeature)featureGetter(); return(true); } foreach (IFeatureModel featureModel in featureModels) { if (featureModel.TryWith(out feature)) { return(true); } } if (onSearchFeature.TryExecute(featureType, out featureBase)) { feature = (TFeature)featureBase; return(true); } feature = default(TFeature); return(false); }
/// <summary> /// Tries to get model definition for type <paramref name="modelType"/>. /// </summary> /// <param name="modelType">Type of requested model definition.</param> /// <param name="modelDefinition">Model definition.</param> /// <returns><c>true</c> if model was found; <c>false</c> otherwise.</returns> public bool TryGet(Type modelType, out IModelDefinition modelDefinition) { Ensure.NotNull(modelType, "modelType"); // Search in singletons. if (singletons.TryGetValue(modelType, out modelDefinition)) { return(true); } lock (storageLock) { // Search using search handlers. if (onSearchDefinition.TryExecute(modelType, out modelDefinition)) { singletons[modelType] = modelDefinition; return(true); } } // Unnable to find model definition. modelDefinition = null; return(false); }
public bool TryConvert <TSource, TTarget>(TSource sourceValue, out TTarget targetValue) { Type sourceType = typeof(TSource); Type targetType = typeof(TTarget); // If target value is assignable from source, no conversion is needed. if (targetType.IsAssignableFrom(sourceType)) { targetValue = (TTarget)(object)sourceValue; return(true); } // If source value is null, return default value. if (sourceValue == null) { targetValue = default(TTarget); return(true); } // Find converter, look in storage or find using search handler. IConverter converter = null; Dictionary <Type, IConverter> sourceStorage; if (!storage.TryGetValue(sourceType, out sourceStorage) || !sourceStorage.TryGetValue(targetType, out converter)) { onSearchConverter.TryExecute(new ConverterSearchContext(sourceType, targetType), out converter); } // If no converter was found, try context converters. if (converter == null && !IsConverterContextType(sourceType)) { return(TryConvert <IConverterContext <TSource>, TTarget>(new DefaultConverterContext <TSource>(sourceValue, this), out targetValue)); } // If no converter was found, conversion is not possible. if (converter == null) { targetValue = default(TTarget); return(false); } // Try cast to generic converter. IConverter <TSource, TTarget> genericConverter = converter as IConverter <TSource, TTarget>; if (genericConverter != null) { return(genericConverter.TryConvert(sourceValue, out targetValue)); } // Convert using general converter. object targetObject; if (converter.TryConvert(sourceType, targetType, sourceValue, out targetObject)) { targetValue = (TTarget)targetObject; return(true); } // No other options for conversion. targetValue = default(TTarget); return(false); }