/// <summary>
/// Gets the name of the table as it is mapped in the database.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityType">Type of the entity.</param>
/// <returns>
/// The table name including the schema.
/// </returns>
public static string GetTableName(this DbContext context, Type entityType)
{
Argument.IsNotNull("context", context);
Argument.IsNotNull("entityType", entityType);
return(_tableNameCache.GetFromCacheOrFetch(entityType, () =>
{
var objectContext = context.GetObjectContext();
return GetTableName(objectContext, entityType);
}));
}
public ImageSource ResolveImageFromUri(Uri uri, string defaultUrl = null)
{
if (uri == null)
{
return(GetDefaultImage(defaultUrl));
}
lock (_lockObject)
{
return(_packageDetailsCache.GetFromCacheOrFetch(uri.AbsoluteUri, () => CreateImage(uri, defaultUrl)));
}
}
/// <summary>
/// Gets the string with the specified culture.
/// </summary>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="cultureInfo">The culture information.</param>
/// <returns>The string or <c>null</c> if the resource cannot be found.</returns>
/// <exception cref="ArgumentException">The <paramref name="resourceName" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="cultureInfo" /> is <c>null</c>.</exception>
public string GetString(string resourceName, CultureInfo cultureInfo)
{
Argument.IsNotNullOrWhitespace("resourceName", resourceName);
Argument.IsNotNull("cultureInfo", cultureInfo);
var resourceKey = new LanguageResourceKey(resourceName, cultureInfo);
return(_stringCache.GetFromCacheOrFetch(resourceKey, () =>
{
foreach (var resourceFile in _languageSources)
{
try
{
var value = GetString(resourceFile, resourceName, cultureInfo);
if (!string.IsNullOrWhiteSpace(value))
{
return value;
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to get string for resource name '{0}' from resource file '{1}'", resourceName, resourceFile);
}
}
return null;
}));
}
/// <summary>
/// Gets the property info from the cache.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="property">The property.</param>
/// <param name="ignoreCase">if set to <c>true</c>, ignore case.</param>
/// <returns>PropertyInfo.</returns>
public static PropertyInfo GetPropertyInfo(object obj, string property, bool ignoreCase = false)
{
string cacheKey = $"{obj.GetType().FullName}_{property}_{ignoreCase}";
return(_availableProperties.GetFromCacheOrFetch(cacheKey, () =>
{
var objectType = obj.GetType();
if (!ignoreCase)
{
// Use old mechanism to ensure no breaking changes / performance hite
return objectType.GetPropertyEx(property);
}
var allProperties = objectType.GetPropertiesEx();
foreach (var propertyInfo in allProperties)
{
if (string.Equals(propertyInfo.Name, property, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
{
return propertyInfo;
}
}
return null;
}));
}
/// <summary>
/// Gets the name of the entity set in the <see cref="DbContext" /> for the specified entity type.
/// </summary>
/// <param name="dbContext">The db context.</param>
/// <param name="entityType">Type of the entity.</param>
/// <returns>The name of the entity set.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="dbContext" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="entityType" /> is <c>null</c>.</exception>
public static string GetEntitySetName(this DbContext dbContext, Type entityType)
{
Argument.IsNotNull("dbContext", dbContext);
Argument.IsNotNull("entityType", entityType);
var entitySetName = _entitySetNameCache.GetFromCacheOrFetch(new Tuple <Type, Type>(dbContext.GetType(), entityType), () =>
{
var objectContext = dbContext.GetObjectContext();
var entitySet = objectContext.MetadataWorkspace.GetEntityContainer(objectContext.DefaultContainerName, DataSpace.CSpace)
.BaseEntitySets.FirstOrDefault(bes => bes.ElementType.Name == entityType.Name);
if (entitySet == null && entityType.BaseType != null)
{
// recursive method call, should be no problem as the compiler wont allow circular base class dependencies
return(dbContext.GetEntitySetName(entityType.BaseType));
}
if (entitySet == null)
{
throw new InstanceNotFoundException(String.Format("No EntitySet has been found for the provided Type '{0}'", entityType));
}
return(entitySet.Name);
});
return(entitySetName);
}
/// <summary>
/// Gets the fields
/// </summary>
/// <param name="type">Type of the model.</param>
/// <returns>A hash set containing the fields.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public Dictionary <string, MemberMetadata> GetFields(Type type)
{
Argument.IsNotNull("type", type);
return(_fieldsCache.GetFromCacheOrFetch(type, () =>
{
var dictionary = new Dictionary <string, MemberMetadata>();
var fields = type.GetFieldsEx();
foreach (var fieldInfo in fields)
{
if (fieldInfo.Name.Contains("__BackingField") ||
fieldInfo.DeclaringType == typeof(ModelBase))
{
continue;
}
var memberMetadata = new MemberMetadata(type, fieldInfo.FieldType, SerializationMemberGroup.Field, fieldInfo.Name)
{
Tag = fieldInfo
};
var nameOverride = GetNameOverrideForSerialization(fieldInfo);
if (!string.IsNullOrWhiteSpace(nameOverride))
{
memberMetadata.MemberNameForSerialization = nameOverride;
}
dictionary[fieldInfo.Name] = memberMetadata;
}
return dictionary;
}));
}
/// <summary>
/// Determines the interesting dependency properties.
/// </summary>
/// <returns>A list of names with dependency properties to subscribe to.</returns>
private List <DependencyPropertyInfo> DetermineInterestingDependencyProperties()
{
var targetControlType = TargetControlType;
return(_dependencyPropertiesToSubscribe.GetFromCacheOrFetch(targetControlType, () =>
{
var controlDependencyProperties = TargetControl.GetDependencyProperties();
var dependencyProperties = new List <DependencyPropertyInfo>();
if ((_dependencyPropertySelector == null) || (_dependencyPropertySelector.MustSubscribeToAllDependencyProperties(targetControlType)))
{
dependencyProperties.AddRange(controlDependencyProperties);
}
else
{
var dependencyPropertiesToSubscribe = _dependencyPropertySelector.GetDependencyPropertiesToSubscribeTo(targetControlType);
if (!dependencyPropertiesToSubscribe.Contains("DataContext"))
{
dependencyPropertiesToSubscribe.Add("DataContext");
}
foreach (var gatheredDependencyProperty in controlDependencyProperties)
{
if (dependencyPropertiesToSubscribe.Contains(gatheredDependencyProperty.PropertyName))
{
dependencyProperties.Add(gatheredDependencyProperty);
}
}
}
return dependencyProperties;
}));
}
/// <summary>
/// Gets the resource manager.
/// </summary>
/// <param name="source">The source.</param>
private ResourceManager GetResourceManager(string source)
{
return(_resourceFileCache.GetFromCacheOrFetch(source, () =>
{
try
{
#if NETFX_CORE && !WIN81
var resourceLoader = new ResourceManager(source);
#elif WIN81
var resourceLoader = ResourceManager.GetForCurrentView(source);
#else
var splittedString = source.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var assemblyName = splittedString[1].Trim();
var containingAssemblyName = string.Format("{0},", assemblyName);
var assembly = AssemblyHelper.GetLoadedAssemblies().FirstOrDefault(x => x.FullName.Contains(containingAssemblyName));
if (assembly == null)
{
return null;
}
string resourceFile = splittedString[0];
var resourceLoader = new ResourceManager(resourceFile, assembly);
#endif
return resourceLoader;
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to get the resource manager for source '{0}'", source);
return null;
}
}));
}
/// <summary>
/// Gets the entity key of the specified entity type in the <see cref="DbContext" />.
/// </summary>
/// <param name="dbContext">The db context.</param>
/// <param name="dbEntityEntry">Type of the entity.</param>
/// <returns>The entity key.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="dbContext"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="dbEntityEntry"/> is <c>null</c>.</exception>
public static EntityKey GetEntityKey(this DbContext dbContext, DbEntityEntry dbEntityEntry)
{
Argument.IsNotNull("dbContext", dbContext);
Argument.IsNotNull("dbEntityEntry", dbEntityEntry);
var entityType = dbEntityEntry.GetEntityType();
var keySet = _entityKeyCache.GetFromCacheOrFetch(new Tuple <Type, Type>(dbContext.GetType(), entityType), () =>
{
var entitySet = dbContext.GetEntitySet(entityType);
return((from keyMember in entitySet.ElementType.KeyMembers
select keyMember.Name).ToList());
});
var entitySetName = dbContext.GetFullEntitySetName(entityType);
var currentValues = dbEntityEntry.CurrentValues;
var keys = new List <EntityKeyMember>();
foreach (var keySetItem in keySet)
{
keys.Add(new EntityKeyMember
{
Key = keySetItem,
Value = currentValues[keySetItem]
});
}
var entityKey = new EntityKey(entitySetName, keys.ToArray());
return(entityKey);
}
/// <summary>
/// Gets the dependency property cache key prefix.
/// </summary>
/// <param name="frameworkElement">The framework element.</param>
/// <returns>The dependency property cache key prefix based on the framework element..</returns>
/// <exception cref="ArgumentNullException">The <paramref name="frameworkElement"/> is <c>null</c>.</exception>
public static string GetDependencyPropertyCacheKeyPrefix(FrameworkElement frameworkElement)
{
Argument.IsNotNull("frameworkElement", frameworkElement);
var frameworkElementType = frameworkElement.GetType();
return(_cacheKeyCache.GetFromCacheOrFetch(frameworkElementType, () => frameworkElement.GetType().FullName.Replace(".", "_")));
}
/// <summary>
/// Gets the properties to serialize for the specified object.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of properties to serialize.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public virtual HashSet <string> GetPropertiesToSerialize(Type type)
{
Argument.IsNotNull("type", type);
return(_propertiesToSerializeCache.GetFromCacheOrFetch(type, () =>
{
var properties = new HashSet <string>();
var propertyDataManager = PropertyDataManager.Default;
var catelTypeInfo = propertyDataManager.GetCatelTypeInfo(type);
var catelProperties = catelTypeInfo.GetCatelProperties();
var catelPropertyNames = new HashSet <string>(catelProperties.Keys);
foreach (var modelProperty in catelProperties)
{
var propertyData = modelProperty.Value;
if (!typeof(ModelBase).IsAssignableFromEx(propertyData.Type) && !propertyData.IsSerializable)
{
Log.Warning("Property '{0}' is not serializable, so will be excluded from the serialization", propertyData.Name);
continue;
}
if (!propertyData.IncludeInSerialization)
{
Log.Debug("Property '{0}' is flagged to be excluded from serialization", propertyData.Name);
continue;
}
var propertyInfo = propertyData.GetPropertyInfo(type);
if (propertyInfo != null)
{
if (!AttributeHelper.IsDecoratedWithAttribute <ExcludeFromSerializationAttribute>(propertyInfo.PropertyInfo))
{
properties.Add(modelProperty.Key);
}
}
else
{
// Dynamic property, always include
properties.Add(modelProperty.Key);
}
}
var typeProperties = type.GetPropertiesEx();
foreach (var typeProperty in typeProperties)
{
if (!catelPropertyNames.Contains(typeProperty.Name))
{
if (AttributeHelper.IsDecoratedWithAttribute <IncludeInSerializationAttribute>(typeProperty))
{
properties.Add(typeProperty.Name);
}
}
}
return properties;
}));
}
/// <summary>
/// Determines whether the property is decorated with the specified attribute.
/// </summary>
/// <param name="attributeType">Type of the attribute.</param>
/// <returns><c>true</c> if the property is decorated with the specified attribute.; otherwise, <c>false</c>.</returns>
public bool IsDecoratedWithAttribute(Type attributeType)
{
Argument.IsNotNull("attributeType", attributeType);
return(_decoratedWithAttributeCache.GetFromCacheOrFetch(attributeType, () =>
{
return AttributeHelper.IsDecoratedWithAttribute(PropertyInfo, attributeType);
}));
}
/// <summary>
/// Gets the catel properties to serialize.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of properties to serialize.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public virtual Dictionary <string, MemberMetadata> GetCatelPropertiesToSerialize(Type type)
{
Argument.IsNotNull("type", type);
return(_catelPropertiesToSerializeCache.GetFromCacheOrFetch(type, () =>
{
var serializableMembers = new Dictionary <string, MemberMetadata>();
var properties = GetCatelProperties(type);
foreach (var modelProperty in properties)
{
var memberMetadata = modelProperty.Value;
var propertyData = (PropertyData)memberMetadata.Tag;
bool isSerializable = propertyData.IsSerializable || propertyData.Type.IsModelBase();
if (!isSerializable)
{
// CTL-550
var cachedPropertyInfo = propertyData.GetPropertyInfo(type);
if (cachedPropertyInfo.IsDecoratedWithAttribute <IncludeInSerializationAttribute>())
{
isSerializable = true;
}
}
if (!isSerializable)
{
Log.Warning("Property '{0}' is not serializable, so will be excluded from the serialization. If this property needs to be included, use the 'IncludeInSerializationAttribute'", propertyData.Name);
continue;
}
if (!propertyData.IncludeInSerialization)
{
Log.Debug("Property '{0}' is flagged to be excluded from serialization", propertyData.Name);
continue;
}
var propertyInfo = propertyData.GetPropertyInfo(type);
if (propertyInfo != null)
{
if (!propertyInfo.IsDecoratedWithAttribute <ExcludeFromSerializationAttribute>())
{
serializableMembers.Add(modelProperty.Key, memberMetadata);
}
}
else
{
// Dynamic property, always include
serializableMembers.Add(modelProperty.Key, memberMetadata);
}
}
return serializableMembers;
}));
}
/// <summary>
/// Gets the name of the property based on the expression.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="allowNested">If set to <c>true</c>, nested properties are allowed.</param>
/// <param name="nested">If set to <c>true</c>, this is a nested call.</param>
/// <returns>The string representing the property name or <see cref="string.Empty"/> if no property can be found.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="propertyExpression"/> is <c>null</c>.</exception>
/// <exception cref="NotSupportedException">The specified expression is not a member access expression.</exception>
private static string GetPropertyName(Expression propertyExpression, bool allowNested = false, bool nested = false)
{
Argument.IsNotNull("propertyExpression", propertyExpression);
const string NoMemberExpression = "The expression is not a member access expression";
string cacheKey = string.Format("{0}_{1}_{2}", propertyExpression, allowNested, nested);
return(_expressionNameCache.GetFromCacheOrFetch(cacheKey, () =>
{
MemberExpression memberExpression;
var unaryExpression = propertyExpression as UnaryExpression;
if (unaryExpression != null)
{
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = propertyExpression as MemberExpression;
}
if (memberExpression == null)
{
if (nested)
{
return string.Empty;
}
Log.Error(NoMemberExpression);
throw new NotSupportedException(NoMemberExpression);
}
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo == null)
{
if (nested)
{
return string.Empty;
}
Log.Error(NoMemberExpression);
throw new NotSupportedException(NoMemberExpression);
}
if (allowNested && (memberExpression.Expression != null) && (memberExpression.Expression.NodeType == ExpressionType.MemberAccess))
{
var propertyName = GetPropertyName(memberExpression.Expression, true, true);
return propertyName + (!string.IsNullOrEmpty(propertyName) ? "." : string.Empty) + propertyInfo.Name;
}
return propertyInfo.Name;
}));
}
public IPropertyCollection GetInstanceProperties(Type targetType)
{
Argument.IsNotNull(() => targetType);
return(_cache.GetFromCacheOrFetch(targetType, () =>
{
var instanceProperties = new InstanceProperties(targetType);
_filterCustomizationService.CustomizeInstanceProperties(instanceProperties);
return instanceProperties;
}));
}
/// <summary>
/// Gets the string with the specified culture.
/// </summary>
/// <param name="resourceName">Name of the resource.</param>
/// <param name="cultureInfo">The culture information.</param>
/// <returns>The string or <c>null</c> if the resource cannot be found.</returns>
/// <exception cref="ArgumentException">The <paramref name="resourceName" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="cultureInfo" /> is <c>null</c>.</exception>
public string GetString(string resourceName, CultureInfo cultureInfo)
{
Argument.IsNotNullOrWhitespace("resourceName", resourceName);
Argument.IsNotNull("cultureInfo", cultureInfo);
if (CacheResults)
{
var resourceKey = new LanguageResourceKey(resourceName, cultureInfo);
return(_stringCache.GetFromCacheOrFetch(resourceKey, () => GetStringInternal(resourceName, cultureInfo)));
}
return(GetStringInternal(resourceName, cultureInfo));
}
/// <summary>
/// Gets the name of the entity set in the <see cref="DbContext" /> for the specified entity type.
/// </summary>
/// <param name="dbContext">The db context.</param>
/// <param name="entityType">Type of the entity.</param>
/// <returns>The name of the entity set.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="dbContext" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="entityType" /> is <c>null</c>.</exception>
public static string GetEntitySetName(this DbContext dbContext, Type entityType)
{
Argument.IsNotNull("dbContext", dbContext);
Argument.IsNotNull("entityType", entityType);
var entitySetName = _entitySetNameCache.GetFromCacheOrFetch(new Tuple <Type, Type>(dbContext.GetType(), entityType), () =>
{
var objectContext = dbContext.GetObjectContext();
return(objectContext.MetadataWorkspace.GetEntityContainer(objectContext.DefaultContainerName, DataSpace.CSpace).BaseEntitySets.First(bes => bes.ElementType.Name == entityType.Name).Name);
});
return(entitySetName);
}
/// <summary>
/// Ensures that the specified theme is loaded.
/// </summary>
/// <param name="resourceUri">The resource URI.</param>
public static void EnsureThemeIsLoaded(Uri resourceUri)
{
EnsureThemeIsLoaded(resourceUri, () =>
{
var application = Application.Current;
if (application == null)
{
return(false);
}
return(ThemeLoadedCache.GetFromCacheOrFetch(resourceUri, () => ContainsDictionary(application.Resources, resourceUri)));
});
}
public List <ConstructorInfo> GetConstructors(int parameterCount, bool mustMatchExactCount)
{
string key = string.Format("{0}_{1}", parameterCount, mustMatchExactCount);
return(_callCache.GetFromCacheOrFetch(key, () =>
{
var constructors = new List <ConstructorInfo>();
constructors.AddRange(GetConstructors(parameterCount, mustMatchExactCount, true));
constructors.AddRange(GetConstructors(parameterCount, mustMatchExactCount, false));
return constructors;
}));
}
/// <summary>
/// Provides an access point to allow a custom implementation in order to retrieve the available validator for the specified type.
/// </summary>
/// <param name="targetType">The target type.</param>
/// <returns>The <see cref="IValidator" /> for the specified type or <c>null</c> if no validator is available for the specified type.</returns>
protected override IValidator GetValidator(Type targetType)
{
return(_validatorPerType.GetFromCacheOrFetch(targetType, () =>
{
ValidateModelAttribute attribute;
if (AttributeHelper.TryGetAttribute(targetType, out attribute))
{
var validator = TypeFactory.Default.CreateInstance(attribute.ValidatorType) as IValidator;
return validator;
}
return null;
}));
}
/// <summary>
/// Gets the catel property names.
/// </summary>
/// <param name="type">Type of the model.</param>
/// <returns>A hash set containing the Catel property names.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public HashSet <string> GetCatelPropertyNames(Type type)
{
Argument.IsNotNull("type", type);
return(_catelPropertyNamesCache.GetFromCacheOrFetch(type, () =>
{
var propertyDataManager = PropertyDataManager.Default;
var catelTypeInfo = propertyDataManager.GetCatelTypeInfo(type);
var properties = (from property in catelTypeInfo.GetCatelProperties()
where !property.Value.IsModelBaseProperty
select property.Key);
return new HashSet <string>(properties);
}));
}
/// <summary>
/// Gets the property information.
/// </summary>
/// <param name="containingType">Type of the containing.</param>
/// <returns>CachedPropertyInfo.</returns>
public CachedPropertyInfo GetPropertyInfo(Type containingType)
{
Argument.IsNotNull("containingType", containingType);
return(_cachedPropertyInfo.GetFromCacheOrFetch(containingType, () =>
{
var propertyInfo = containingType.GetPropertyEx(Name, BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (propertyInfo == null)
{
return null;
}
return new CachedPropertyInfo(propertyInfo);
}));
}
/// <summary>
/// Gets the properties to serialize for the specified object.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of properties to serialize.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public virtual Dictionary <string, MemberMetadata> GetRegularPropertiesToSerialize(Type type)
{
Argument.IsNotNull("type", type);
return(_regularPropertiesToSerializeCache.GetFromCacheOrFetch(type, () =>
{
var serializableMembers = new Dictionary <string, MemberMetadata>();
var catelPropertyNames = new HashSet <string>();
var isModelBase = type.IsModelBase();
if (isModelBase)
{
catelPropertyNames = GetCatelPropertyNames(type, true);
}
var regularProperties = GetRegularProperties(type);
foreach (var typeProperty in regularProperties)
{
var memberMetadata = typeProperty.Value;
var propertyInfo = (PropertyInfo)memberMetadata.Tag;
if (!catelPropertyNames.Contains(memberMetadata.MemberName))
{
// If not a ModelBase, include by default
var include = !isModelBase;
if (propertyInfo.IsDecoratedWithAttribute <IncludeInSerializationAttribute>())
{
include = true;
}
if (propertyInfo.IsDecoratedWithAttribute <ExcludeFromSerializationAttribute>())
{
include = false;
}
if (include)
{
serializableMembers.Add(typeProperty.Key, memberMetadata);
}
}
}
return serializableMembers;
}));
}
/// <summary>
/// Gets the resource manager.
/// </summary>
/// <param name="source">The source.</param>
private ResourceManager GetResourceManager(string source)
{
Func <ResourceManager> retrievalFunc = () =>
{
try
{
#if NETFX_CORE && WIN80
var resourceLoader = new ResourceManager(source);
#elif NETFX_CORE
var resourceLoader = ResourceManager.GetForCurrentView(source);
#else
var splittedString = source.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var assemblyName = splittedString[1].Trim();
var containingAssemblyName = string.Format("{0},", assemblyName);
var loadedAssemblies = AssemblyHelper.GetLoadedAssemblies();
// Invert so design-time will always pick the latest version
loadedAssemblies.Reverse();
var assembly = loadedAssemblies.FirstOrDefault(x => x.FullName.StartsWith(containingAssemblyName));
if (assembly == null)
{
return(null);
}
string resourceFile = splittedString[0];
var resourceLoader = new ResourceManager(resourceFile, assembly);
#endif
return(resourceLoader);
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to get the resource manager for source '{0}'", source);
return(null);
}
};
if (CacheResults)
{
return(_resourceFileCache.GetFromCacheOrFetch(source, retrievalFunc));
}
return(retrievalFunc());
}
public virtual string GetMachineId(string separator = "-", bool hashCombination = true)
{
Argument.IsNotNull(() => separator);
var key = string.Format("machineid_{0}_{1}", separator, hashCombination);
return(_cacheStorage.GetFromCacheOrFetch(key, () =>
{
Log.Debug("Retrieving machine id");
var cpuId = string.Empty;
var motherboardId = string.Empty;
var hddId = string.Empty;
var gpuId = string.Empty;
TaskHelper.RunAndWait(new Action[]
{
() => cpuId = "CPU >> " + GetCpuId(),
() => motherboardId = "BASE >> " + GetMotherboardId(),
() => hddId = "HDD >> " + GetHardDriveId(),
() => gpuId = "GPU >> " + GetGpuId(),
//() => gpuId = "MAC >> " + _systemIdentificationService.GetMacId(),
});
var values = new List <string>(new[]
{
cpuId,
motherboardId,
hddId,
gpuId
});
var hashedValues = new List <string>();
foreach (var value in values)
{
var hashedValue = CalculateMd5Hash(value);
hashedValues.Add(hashedValue);
Log.Debug("* {0} => {1}", value, hashedValue);
}
var machineId = string.Join(separator, hashedValues);
Log.Debug("Hashed machine id '{0}'", machineId);
if (hashCombination)
{
machineId = CalculateMd5Hash(machineId);
}
return machineId;
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewModelPropertyDescriptor" /> class.
/// </summary>
/// <param name="viewModel">The view model. Can be <c>null</c> for generic property definitions.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <param name="attributes">The attributes.</param>
/// <exception cref="ArgumentException">The <paramref name="propertyName" /> is <c>null</c> or whitespace.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="propertyType" /> is <c>null</c>.</exception>
/// <remarks>Must be kept internal because it contains special generic options such as a null view model.</remarks>
internal ViewModelPropertyDescriptor(ViewModelBase viewModel, string propertyName, Type propertyType, Attribute[] attributes)
: base(propertyName, attributes)
{
Argument.IsNotNullOrWhitespace("propertyName", propertyName);
Argument.IsNotNull("propertyType", propertyType);
_viewModel = viewModel;
_viewModelType = (viewModel != null) ? viewModel.GetType() : null;
_propertyName = propertyName;
_propertyType = propertyType;
if (_viewModelType != null)
{
string cacheKey = string.Format("{0}_{1}", _viewModelType.FullName, propertyName);
_propertyInfo = _propertyInfoCache.GetFromCacheOrFetch(cacheKey, () => _viewModelType.GetPropertyEx(propertyName));
}
}
/// <summary>
/// Gets the signature of a method.
/// </summary>
/// <param name="constructorInfo">The member info.</param>
/// <returns>The signature of the member info.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="constructorInfo"/> is <c>null</c>.</exception>
public static string GetSignature(this ConstructorInfo constructorInfo)
{
Argument.IsNotNull("constructorInfo", constructorInfo);
return(_constructorSignatureCache.GetFromCacheOrFetch(constructorInfo, () =>
{
var stringBuilder = new StringBuilder();
stringBuilder.Append(GetMethodBaseSignaturePrefix(constructorInfo));
stringBuilder.Append("ctor(");
var param = constructorInfo.GetParameters().Select(p => String.Format("{0} {1}", p.ParameterType.Name, p.Name)).ToArray();
stringBuilder.Append(String.Join(", ", param));
stringBuilder.Append(")");
return stringBuilder.ToString();
}));
}
/// <summary>
/// Gets the field names.
/// </summary>
/// <param name="type">Type of the model.</param>
/// <returns>A hash set containing the field names.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public HashSet <string> GetFieldNames(Type type)
{
Argument.IsNotNull("type", type);
return(_fieldNamesCache.GetFromCacheOrFetch(type, () =>
{
var fieldNames = GetFieldsToSerialize(type);
var finalFields = new HashSet <string>();
foreach (var fieldName in fieldNames)
{
finalFields.Add(fieldName);
}
return finalFields;
}));
}
/// <summary>
/// Gets the regular property names.
/// </summary>
/// <param name="type">Type of the model.</param>
/// <returns>A hash set containing the regular property names.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public HashSet <string> GetRegularPropertyNames(Type type)
{
Argument.IsNotNull("type", type);
return(_regularPropertyNamesCache.GetFromCacheOrFetch(type, () =>
{
var regularPropertyNames = GetRegularProperties(type);
var finalProperties = new HashSet <string>();
foreach (var propertyName in regularPropertyNames)
{
finalProperties.Add(propertyName.Key);
}
return finalProperties;
}));
}
/// <summary>
/// Gets the entity key of the specified entity type in the <see cref="DbContext" />.
/// </summary>
/// <param name="dbContext">The db context.</param>
/// <param name="entityType">Type of the entity.</param>
/// <param name="keyValue">The key value.</param>
/// <returns>The entity key.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="dbContext"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="entityType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="keyValue"/> is <c>null</c>.</exception>
public static EntityKey GetEntityKey(this DbContext dbContext, Type entityType, object keyValue)
{
Argument.IsNotNull("dbContext", dbContext);
Argument.IsNotNull("entityType", entityType);
Argument.IsNotNull("keyValue", keyValue);
var keyPropertyName = _entityKeyPropertyNameCache.GetFromCacheOrFetch(new Tuple <Type, Type>(dbContext.GetType(), entityType), () =>
{
var entitySet = GetEntitySet(dbContext, entityType);
return(entitySet.ElementType.KeyMembers[0].ToString());
});
var entitySetName = GetFullEntitySetName(dbContext, entityType);
var entityKey = new EntityKey(entitySetName, new[] { new EntityKeyMember(keyPropertyName, keyValue) });
return(entityKey);
}
