/// <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);
}
