/// <summary>
/// Searches for all string resources inside the <see cref="System.Resources.ResourceManager"/> whose name is prefixed with a matching tag.
/// </summary>
/// <remarks>
/// <para>
/// If a duplicate ID is found, the ID from the last ResourceManager wins.
/// </para><para>
/// Fallback:
/// <list type="number">
/// <item>
/// Resource hierarchy for current culture.
/// </item>
/// <item>
/// Resource hierarchies for less specific cultures
/// </item>
/// </list>
/// </para>
/// </remarks>
public NameValueCollection GetAllStrings(string prefix)
{
return(_cachedResourceSet.GetOrCreateValue(
Tuple.Create(CultureInfo.CurrentUICulture, prefix ?? string.Empty),
key =>
{
// Loop through all entries in the resource managers
CultureInfo[] cultureHierarchy = GetCultureHierarchy(key.Item1);
// Loop from most neutral to current UICulture
// Copy the resources into a collection
NameValueCollection result = new NameValueCollection();
for (int i = 0; i < cultureHierarchy.Length; i++)
{
CultureInfo culture = cultureHierarchy[i];
ResourceSet resourceSet = _resourceManager.GetResourceSet(culture, true, false);
if (resourceSet != null)
{
foreach (DictionaryEntry entry in resourceSet)
{
string entryKey = (string)entry.Key;
if (entryKey.StartsWith(key.Item2))
{
result[entryKey] = (string)entry.Value;
}
}
}
}
return result;
}));
}
/// <summary>
/// Returns the type arguments for the ascribed <paramref name="ascribeeType"/> as inherited or implemented by a given <paramref name="type"/>.
/// </summary>
/// <param name="type">The <see cref="Type"/> for which to return the type parameter. Must not be <see langword="null" />.</param>
/// <param name="ascribeeType">The <see cref="Type"/> to check the <paramref name="type"/> against. Must not be <see langword="null" />.</param>
/// <returns>A <see cref="Type"/> array containing the generic arguments of the <paramref name="ascribeeType"/> as it is inherited or implemented
/// by <paramref name="type"/>.</returns>
/// <exception cref="ArgumentException">
/// Thrown if the <paramref name="type"/> is not the <paramref name="ascribeeType"/> or its instantiation, its subclass or the implementation
/// of an interface in case the <paramref name="ascribeeType"/> is an interface.
/// </exception>
/// <exception cref="AmbiguousMatchException">
/// Thrown if the <paramref name="type"/> is an interface and implements the interface <paramref name="ascribeeType"/> or its instantiations
/// more than once.
/// </exception>
public static Type[] GetAscribedGenericArguments(this Type type, Type ascribeeType)
{
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("ascribeeType", ascribeeType);
return(s_ascribedGenericArgumentsCache.GetOrCreateValue(
Tuple.Create(type, ascribeeType), key => GetAscribedGenericArgumentsWithoutCache(key.Item1, key.Item2)));
}
/// <summary>
/// Returns the mapping name for the given <paramref name="propertyInformation"/>.
/// </summary>
/// <param name="propertyInformation">The property whose mapping name should be retrieved.</param>
/// <returns>The name of the given <paramref name="propertyInformation"/> as used internally by the mapping.</returns>
public string GetPropertyName(IPropertyInformation propertyInformation)
{
ArgumentUtility.CheckNotNull("propertyInformation", propertyInformation);
return(s_propertyNameCache.GetOrCreateValue(
propertyInformation,
pi => GetPropertyName(pi.GetOriginalDeclaringType(), pi.Name)));
}
private ResolvedResourceManagerResult GetResolvedResourceManagerFromCache(Type type)
{
if (type == null)
{
return(ResolvedResourceManagerResult.Null);
}
return(_resourceManagerWrappersCache.GetOrCreateValue(type, CreateResolvedResourceManagerResult));
}
public static WxeParameterDeclaration[] GetParameterDeclarations(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
if (!typeof(WxeFunction).IsAssignableFrom(type))
{
throw new ArgumentException("Type " + type.FullName + " is not derived from WxeFunction.", "type");
}
return(s_parameterDeclarations.GetOrCreateValue(type, GetParameterDeclarationsUnchecked));
}
/// <summary>
/// Use this method as a shortcut to retrieve the <see cref="BindableObjectProvider"/> for a <see cref="Type"/>
/// that has the <see cref="BindableObjectMixinBase{T}"/> applied or is derived from a bindable object base class without first retrieving the
/// matching provider.
/// </summary>
/// <param name="type">The <see cref="Type"/> to retrieve the <see cref="BindableObjectProvider"/> for.</param>
/// <returns>Returns the <see cref="BindableObjectProvider"/> for the <paramref name="type"/>.</returns>
public static BindableObjectProvider GetProviderForBindableObjectType(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
var providerAttributeType = s_providerAttributeTypeCache.GetOrCreateValue(type, FindProviderAttributeType);
var provider = (BindableObjectProvider)GetProvider(providerAttributeType);
Assertion.IsNotNull(provider, "GetProvider cannot return null (type '{0}').", type.FullName);
return(provider);
}
private static MethodInfo GetParseMethod(Type type, bool throwIfNotFound)
{
var parseMethod =
s_parseMethods.GetOrCreateValue(type, key => GetParseMethodWithFormatProviderFromType(type) ?? GetParseMethodFromType(type));
if (throwIfNotFound && parseMethod == null)
{
throw new ParseException(string.Format("Type does not have method 'public static {0} Parse (string s)'.", type.Name));
}
return(parseMethod);
}
/// <summary>
/// Gets a query for the given LINQ query, returning it from the cache if possible.
/// </summary>
/// <typeparam name="T">The <see cref="DomainObject"/> type to start the query with.</typeparam>
/// <param name="id">The ID to associate with the LINQ queryable. This ID is used as the cache key of the parsed query.</param>
/// <param name="queryGenerator">A delegate returning the LINQ queryable. The argument of this delegate is a <see cref="DomainObjectQueryable{T}"/>
/// to start the LINQ query with.</param>
/// <returns>An <see cref="IQuery"/> implementation corresponding to the LINQ query returned by <paramref name="queryGenerator"/>.</returns>
/// <remarks>
/// The <paramref name="queryGenerator"/> delegate is only evaluated if no query with the given <paramref name="id"/> is found in the cache.
/// </remarks>
public IQuery GetQuery <T> (string id, Func <IQueryable <T>, IQueryable> queryGenerator) where T : DomainObject
{
ArgumentUtility.CheckNotNullOrEmpty("id", id);
ArgumentUtility.CheckNotNull("queryGenerator", queryGenerator);
return(_cache.GetOrCreateValue(id, delegate
{
var querySource = QueryFactory.CreateLinqQuery <T> ();
var query = queryGenerator(querySource);
return QueryFactory.CreateQuery <T> (id, query);
}));
}
private XmlSerializer GetXmlSerializer(Type concreteType)
{
return(_attributeOverridesCache.GetOrCreateValue(
concreteType,
delegate(Type type)
{
return new XmlSerializer(
type,
CreateAttributeOverrides(type),
new Type[0],
AttributeUtility.GetCustomAttribute <XmlRootAttribute> (type, true),
null);
}));
}
public ClassContext GetWithInheritance(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
var exactMatch = GetExact(type);
if (exactMatch != null)
{
return(exactMatch);
}
else
{
return(_inheritedContextCache.GetOrCreateValue(type, DeriveInheritedContext));
}
}
/// <summary>
/// Evaluates whether the <paramref name="type"/> can be ascribed to the <paramref name="ascribeeType"/>.
/// </summary>
/// <param name="type">The <see cref="Type"/> to check. Must not be <see langword="null" />.</param>
/// <param name="ascribeeType">The <see cref="Type"/> to check the <paramref name="type"/> against. Must not be <see langword="null" />.</param>
/// <returns>
/// <see langword="true"/> if the <paramref name="type"/> is the <paramref name="ascribeeType"/> or its instantiation,
/// its subclass or the implementation of an interface in case the <paramref name="ascribeeType"/> is an interface.
/// </returns>
public static bool CanAscribeTo(this Type type, Type ascribeeType)
{
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("ascribeeType", ascribeeType);
return(s_canAscribeCache.GetOrCreateValue(
Tuple.Create(type, ascribeeType),
key =>
{
if (key.Item2.IsInterface)
{
if (key.Item1.IsInterface && CanAscribeInternalFromCache(key.Item1, key.Item2))
{
return true;
}
return Array.Exists(key.Item1.GetInterfaces(), current => CanAscribeInternalFromCache(current, key.Item2));
}
else
{
return CanAscribeInternalFromCache(type, ascribeeType);
}
}));
}
public static EnumMetadata GetEnumMetadata(Type enumType)
{
return(s_cache.GetOrCreateValue(enumType, t => new EnumMetadata(t)));
}
private static bool CanAscribeInternalFromCache(Type type, Type ascribeeType)
{
return(s_canAscribeInternalCache.GetOrCreateValue(Tuple.Create(type, ascribeeType), key => CanAscribeInternal(key.Item1, key.Item2)));
}
public string GetEnumName(Enum enumValue)
{
ArgumentUtility.CheckNotNull("enumValue", enumValue);
return(s_enumCache.GetOrCreateValue(enumValue, GetEnumNameInternal));
}
private static bool CanDirectlyAscribeToGenericTypeInternalFromCache(Type type, Type ascribeeType, Type ascribeeGenericTypeDefinition)
{
return(s_canDirectlyAscribeToGenericTypeInternalCache.GetOrCreateValue(
Tuple.Create(type, ascribeeType, ascribeeGenericTypeDefinition),
key => CanDirectlyAscribeToGenericTypeInternal(key.Item1, key.Item2, key.Item3)));
}
public static bool IsAssemblySigned(Assembly assembly)
{
ArgumentUtility.CheckNotNull("assembly", assembly);
return(s_isAssemblySignedCache.GetOrCreateValue(assembly, asm => IsAssemblySigned(asm.GetName())));
}
/// <summary>
/// Gets the <see cref="ExtensibleEnumDefinition{T}"/> for the given <paramref name="extensibleEnumType"/> from the cache creating a new
/// one if necessary. If a new instance is created, the <see cref="ValueDiscoveryService"/> is used to discover the values of the enum type.
/// </summary>
/// <param name="extensibleEnumType">The type of the extensible enum for which to retrieve an <see cref="ExtensibleEnumDefinition{T}"/>.</param>
/// <returns>The <see cref="ExtensibleEnumDefinition{T}"/> for the given type.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="extensibleEnumType"/> parameter is <see langword="null" />.</exception>
/// <exception cref="ArgumentException">The <paramref name="extensibleEnumType"/> parameter is not derived from
/// <see cref="ExtensibleEnumInfo{T}"/>.</exception>
public IExtensibleEnumDefinition GetDefinition(Type extensibleEnumType)
{
ArgumentUtility.CheckNotNull("extensibleEnumType", extensibleEnumType);
return(_cache.GetOrCreateValue(extensibleEnumType, CreateDefinition));
}
/// <summary>
/// Returns the mapping name for the given <paramref name="typeInformation"/>.
/// </summary>
/// <param name="typeInformation">The type whose mapping name should be retrieved.</param>
/// <returns>The name of the given <paramref name="typeInformation"/> as used internally by the mapping.</returns>
public string GetTypeName(ITypeInformation typeInformation)
{
ArgumentUtility.CheckNotNull("typeInformation", typeInformation);
return(s_typeNameCache.GetOrCreateValue(typeInformation, GetTypeNameInternal));
}
private ResourceManager GetResourceManagerFromCache(Assembly assembly, IResourcesAttribute resourcesAttribute)
{
return(_resourceManagersCache.GetOrCreateValue(
Tuple.Create(resourcesAttribute.ResourceAssembly ?? assembly, resourcesAttribute.BaseName),
GetResourceManager));
}
