public void SetProperty(string propertyName, string propertyValueStr) { var type = GetType(); var properties = PropertiesCache.GetFromCacheOrFetch(type, () => type.GetPropertiesEx()); var property = properties.FirstOrDefault(x => x.Name == propertyName); SetPropertyValue(property, propertyValueStr); }
/// <summary> /// Gets the member on the specified type. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <returns>MemberInfo[][].</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> public static MemberInfo[] GetMemberEx(this Type type, string name, BindingFlags bindingFlags) { Argument.IsNotNull("type", type); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Member, bindingFlags, name); return(_fieldCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetMember(name, bindingFlags))); #else return(type.GetTypeInfo().GetMember(name, bindingFlags)); #endif }
/// <summary> /// The get method ex. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <returns>MethodInfo.</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> /// <exception cref="System.ArgumentException">The <paramref name="name" /> is <c>null</c> or whitespace.</exception> public static MethodInfo GetMethodEx(this Type type, string name, BindingFlags bindingFlags) { Argument.IsNotNull("type", type); Argument.IsNotNullOrWhitespace("name", name); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Method, bindingFlags, name); return(_methodCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetMethod(name, bindingFlags))); #else return(type.GetTypeInfo().GetMethod(name, bindingFlags)); #endif }
/// <summary> /// Gets the module assembly ref overriden the version number. /// </summary> /// <param name="moduleInfo">The module info</param> /// <param name="version">The version</param> /// <returns>The module assembly ref</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="moduleInfo" /> is <c>null</c>.</exception> private ModuleAssemblyRef GetModuleAssemblyRef(ModuleInfo moduleInfo, SemanticVersion version) { Argument.IsNotNull(() => moduleInfo); var moduleInfoKey = string.Format(CultureInfo.InvariantCulture, "ModuleName:{0}; ModuleType:{1}; Ref:{2}; Version:{3}", moduleInfo.ModuleName, moduleInfo.ModuleType, moduleInfo.Ref, version); ModuleInfo moduleInfoFromCache = _moduleInfoCacheStoreCacheStorage.GetFromCacheOrFetch(moduleInfoKey, () => new ModuleInfo(moduleInfo.ModuleName, moduleInfo.ModuleType) { Ref = string.Format("{0}, {1}", moduleInfo.GetPackageName().Id, version), DependsOn = moduleInfo.DependsOn }); return(moduleInfoFromCache.GetModuleAssemblyRef(OutputDirectoryAbsoluteUri)); }
/// <summary> /// Gets the module assembly ref overriden the version number. /// </summary> /// <param name="moduleInfo">The module info</param> /// <param name="version">The version</param> /// <returns>The module assembly ref</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="moduleInfo" /> is <c>null</c>.</exception> private string GetModuleAssemblyRef(ModuleInfo moduleInfo, SemanticVersion version) { // ReSharper disable once ImplicitlyCapturedClosure Argument.IsNotNull(() => moduleInfo); var key = string.Format(CultureInfo.InvariantCulture, "ModuleName:{0}; ModuleType:{1}; Ref:{2}; Version:{3}", moduleInfo.ModuleName, moduleInfo.ModuleType, moduleInfo.Ref, version); return(GetModuleAssemblyRef(_moduleInfoCacheStoreCacheStorage.GetFromCacheOrFetch(key, () => new ModuleInfo(moduleInfo.ModuleName, moduleInfo.ModuleType) { Ref = string.Format("{0}, {1}", moduleInfo.GetPackageName().Id, version), DependsOn = moduleInfo.DependsOn }))); }
/// <summary> /// Returns whether the member value should be serialized as dictionary. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns><c>true</c> if the member value should be serialized as dictionary, <c>false</c> otherwise.</returns> protected virtual bool ShouldSerializeAsDictionary(Type memberType) { return(_shouldSerializeAsDictionaryCache.GetFromCacheOrFetch(memberType, () => { var serializerModifiers = SerializationManager.GetSerializerModifiers(memberType); if (serializerModifiers != null) { foreach (var serializerModifier in serializerModifiers) { var shouldSerializeAsDictionary = serializerModifier.ShouldSerializeAsDictionary(); if (shouldSerializeAsDictionary.HasValue) { return shouldSerializeAsDictionary.Value; } } } if (memberType.IsDictionary()) { return true; } return false; })); }
private static Tuple <XmlDocument, XmlNamespaceManager> GetResourceXmlDocument(Uri resourceDictionaryUri) { return(_resourceDictionaryCache.GetFromCacheOrFetch(resourceDictionaryUri, () => { var streamResourceInfo = Application.GetResourceStream(resourceDictionaryUri); var reader = new XmlBamlReader(streamResourceInfo.Stream); var doc = new XmlDocument(); doc.Load(reader); // Create namespace manager (all namespaces are required) var xmlNamespaceManager = new XmlNamespaceManager(doc.NameTable); foreach (XmlAttribute namespaceAttribute in doc.DocumentElement.Attributes) { // Clean up namespace (remove xmlns prefix) var xmlNamespace = namespaceAttribute.Name.Replace("xmlns", string.Empty).TrimStart(':'); xmlNamespaceManager.AddNamespace(xmlNamespace, namespaceAttribute.Value); } // Add a dummy node xmlNamespaceManager.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml"); xmlNamespaceManager.AddNamespace("ctl", "http://schemas.microsoft.com/winfx/2006/xaml/presentation"); return new Tuple <XmlDocument, XmlNamespaceManager>(doc, xmlNamespaceManager); })); }
/// <summary> /// Determines whether the specified member on the specified model should be ignored by the serialization engine. /// </summary> /// <param name="model">The model.</param> /// <param name="propertyName">Name of the member.</param> /// <returns><c>true</c> if the member should be ignored, <c>false</c> otherwise.</returns> protected override bool ShouldIgnoreMember(ModelBase model, string propertyName) { var ignoredMembers = _ignoredMembersCache.GetFromCacheOrFetch(model.GetType(), () => { var modelType = model.GetType(); var ignoredProperties = new HashSet <string>(); var properties = modelType.GetPropertiesEx(); foreach (var property in properties) { if (AttributeHelper.IsDecoratedWithAttribute <XmlIgnoreAttribute>(property)) { ignoredProperties.Add(property.Name); } } return(ignoredProperties); }); if (ignoredMembers.Contains(propertyName)) { return(true); } return(base.ShouldIgnoreMember(model, propertyName)); }
public static Color GetAccentColor(AccentColorStyle colorStyle = AccentColorStyle.AccentColor) { return(_accentColorsCache.GetFromCacheOrFetch(colorStyle, () => { var color = GetAccentColorBrush().Color; switch (colorStyle) { case AccentColorStyle.AccentColor: return Color.FromArgb(255, color.R, color.G, color.B); case AccentColorStyle.AccentColor1: return Color.FromArgb(204, color.R, color.G, color.B); case AccentColorStyle.AccentColor2: return Color.FromArgb(153, color.R, color.G, color.B); case AccentColorStyle.AccentColor3: return Color.FromArgb(102, color.R, color.G, color.B); case AccentColorStyle.AccentColor4: return Color.FromArgb(51, color.R, color.G, color.B); default: throw new ArgumentOutOfRangeException("colorStyle"); } })); }
/// <summary> /// The get property ex. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <param name="allowExplicitInterfaceProperties">if set to <c>true</c>, this method will check for explicit interface implementations when the property is not found.</param> /// <returns>PropertyInfo.</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> /// <exception cref="System.ArgumentException">The <paramref name="name" /> is <c>null</c> or whitespace.</exception> public static PropertyInfo GetPropertyEx(this Type type, string name, BindingFlags bindingFlags, bool allowExplicitInterfaceProperties = true) { Argument.IsNotNull("type", type); Argument.IsNotNullOrWhitespace("name", name); PropertyInfo propertyInfo = null; #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Property, bindingFlags, name); propertyInfo = _propertyCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetProperty(name, bindingFlags)); #else propertyInfo = type.GetTypeInfo().GetProperty(name, bindingFlags); #endif if (propertyInfo == null) { if (allowExplicitInterfaceProperties) { foreach (var iface in type.GetInterfacesEx()) { propertyInfo = iface.GetPropertyEx(name, bindingFlags, false); if (propertyInfo != null) { break; } } } } return(propertyInfo); }
/// <summary> /// Converts an <see cref="Enumerable" /> into a <see cref="IReadOnlyList{T}" /> or <see cref="IReadOnlyCollection{T}" /> /// </summary> /// <param name="instance">The enumerable</param> /// <param name="type">The type</param> /// <returns>The <see cref="IReadOnlyList{T}" /> or <see cref="IReadOnlyCollection{T}" /> as <see cref="IEnumerable" /></returns> public static IEnumerable AsReadOnly(this IEnumerable instance, Type type) { var list = instance.ToList(type); var methodInfo = AsReadOnlyGenericMethodInfoCache.GetFromCacheOrFetch(type, () => list.GetType().GetMethodEx("AsReadOnly")); return((IEnumerable)methodInfo.Invoke(list, ArrayShim.Empty <object>())); }
public static SolidColorBrush GetAccentColorBrush(AccentColorStyle colorStyle) { return(_accentColorBrushesCache.GetFromCacheOrFetch(colorStyle, () => { var color = GetAccentColor(colorStyle); return new SolidColorBrush(color); })); }
public static SolidColorBrush GetThemeColorBrush(ThemeColorStyle colorStyle = ThemeColorStyle.AccentColor) { return(_themeColorBrushesCache.GetFromCacheOrFetch(colorStyle, () => { var color = GetThemeColor(colorStyle); return GetSolidColorBrush(color); })); }
private static MethodInfo GetRegisterSimplePropertyMethodInfo(Type modelBaseType) { return(_registerSimplePropertyCache.GetFromCacheOrFetch(modelBaseType, () => { var methodInfo = modelBaseType.GetMethodEx("RegisterDynamicProperty", BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.NonPublic); return methodInfo; })); }
public SolidColorBrush GetThemeColorBrush(string resourceName) { return(_resourceBrushesCache.GetFromCacheOrFetch(resourceName, () => { var color = GetThemeColor(resourceName); return color.ToSolidColorBrush(); })); }
public static T GetOrCreateConnectedInstance <T>(this DbProvider dbProvider) { Argument.IsNotNull(() => dbProvider); var instanceCache = ConnectedInstances.GetFromCacheOrFetch(dbProvider.ProviderInvariantName, () => new CacheStorage <Type, object>()); return((T)instanceCache.GetFromCacheOrFetch(typeof(T), () => CreateConnectedInstance <T>(dbProvider))); }
/// <summary> /// Converts an <see cref="Enumerable" /> into a <see cref="IList{T}" /> /// </summary> /// <param name="instance">The enumerable</param> /// <param name="type">The type</param> /// <returns>The <see cref="IList{T}" /> as <see cref="IEnumerable" /></returns> public static IEnumerable ToList(this IEnumerable instance, Type type) { Argument.IsNotNull("instance", instance); Argument.IsNotNull("type", type); var methodInfo = ToListGenericMethodInfoCache.GetFromCacheOrFetch(type, () => ToListMethodInfo.MakeGenericMethod(type)); return((IEnumerable)methodInfo.Invoke(null, new object[] { instance })); }
private bool IsTypeBinarySerializable(Type type) { if (type == null) { return(false); } return(TypeBinarySerializableCache.GetFromCacheOrFetch(type, () => type.GetConstructor(TypeArray.From <SerializationInfo, StreamingContext>()) != null)); }
/// <summary> /// Gets the <c>ToString(IFormatProvider)</c> method. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns></returns> protected virtual MethodInfo GetObjectToStringMethod(Type memberType) { var toStringMethod = _toStringMethodCache.GetFromCacheOrFetch(memberType, () => { var method = memberType.GetMethodEx("ToString", new[] { typeof(IFormatProvider) }, BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); return(method); }); return(toStringMethod); }
/// <summary> /// The get constructors ex. /// </summary> /// <param name="type">The type.</param> /// <returns>ConstructorInfo[][].</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> public static ConstructorInfo[] GetConstructorsEx(this Type type) { Argument.IsNotNull("type", type); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Constructor, BindingFlags.Default, "allctors"); #if NETFX_CORE || PCL return(_constructorsCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().DeclaredConstructors.ToArray())); #else return(_constructorsCache.GetFromCacheOrFetch(cacheKey, type.GetConstructors)); #endif #else #if NETFX_CORE || PCL return(type.GetTypeInfo().DeclaredConstructors.ToArray()); #else return(type.GetConstructors()); #endif #endif }
/// <summary> /// The get fields ex. /// </summary> /// <param name="type">The type.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <returns>FieldInfo[][].</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> public static FieldInfo[] GetFieldsEx(this Type type, BindingFlags bindingFlags) { Argument.IsNotNull("type", type); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Field, bindingFlags); return(_fieldsCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetFields(bindingFlags))); #else return(type.GetTypeInfo().GetFields(bindingFlags)); #endif }
/// <summary> /// Gets the <c>Parse(string, IFormatProvider)</c> method. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns></returns> protected virtual MethodInfo GetObjectParseMethod(Type memberType) { var parseMethod = _parseMethodCache.GetFromCacheOrFetch(memberType, () => { var method = memberType.GetMethodEx("Parse", new[] { typeof(string), typeof(IFormatProvider) }, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); return(method); }); return(parseMethod); }
public void AddsItemToCacheAndReturnsIt() { var cache = new CacheStorage <string, int>(); var value = cache.GetFromCacheOrFetch("1", () => 1); Assert.IsTrue(cache.Contains("1")); Assert.AreEqual(1, cache["1"]); Assert.AreEqual(1, value); }
public void ReturnsCachedItem() { var cache = new CacheStorage <string, int>(); cache.Add("1", 1); var value = cache.GetFromCacheOrFetch("1", () => 2); Assert.IsTrue(cache.Contains("1")); Assert.AreEqual(1, cache["1"]); Assert.AreEqual(1, value); }
/// <summary> /// The get properties ex. /// </summary> /// <param name="type">The type.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <returns>PropertyInfo[][].</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> public static PropertyInfo[] GetPropertiesEx(this Type type, BindingFlags bindingFlags) { Argument.IsNotNull(nameof(type), type); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Property, bindingFlags); return(_propertiesCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetProperties(bindingFlags))); #else return(type.GetTypeInfo().GetProperties(bindingFlags)); #endif }
/// <summary> /// The get constructor ex. /// </summary> /// <param name="type">The type.</param> /// <param name="types">The types.</param> /// <returns>ConstructorInfo.</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> /// <exception cref="System.ArgumentNullException">The <paramref name="types" /> is <c>null</c>.</exception> public static ConstructorInfo GetConstructorEx(this Type type, Type[] types) { Argument.IsNotNull("type", type); Argument.IsNotNull("types", types); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Constructor, BindingFlags.Default, types); #if NETFX_CORE || PCL return(_constructorCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetConstructor(types, BindingFlagsHelper.GetFinalBindingFlags(false, false)))); #else return(_constructorCache.GetFromCacheOrFetch(cacheKey, () => type.GetConstructor(types))); #endif #else #if NETFX_CORE || PCL return(type.GetTypeInfo().GetConstructor(types, BindingFlagsHelper.GetFinalBindingFlags(false, false))); #else return(type.GetConstructor(types)); #endif #endif }
/// <summary> /// Gets the module assembly ref. /// </summary> /// <param name="moduleInfo">The module info</param> /// <returns>The module assembly ref</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="moduleInfo" /> is <c>null</c>.</exception> private string GetModuleAssemblyRef(ModuleInfo moduleInfo) { // ReSharper disable once ImplicitlyCapturedClosure Argument.IsNotNull(() => moduleInfo); return(_assemblyRefCacheStorage.GetFromCacheOrFetch(moduleInfo, () => { PackageName packageName = moduleInfo.GetPackageName(); string directoryName = packageName.ToString().Replace(' ', '.'); return string.Format(CultureInfo.InvariantCulture, RelativeUrlPattern, BaseUrl, directoryName, _frameworkNameIdentifier, moduleInfo.GetAssemblyName()); })); }
/// <summary> /// The get events ex. /// </summary> /// <param name="type">The type.</param> /// <param name="flattenHierarchy">The flatten Hierarchy.</param> /// <param name="allowStaticMembers">The allow Static Members.</param> /// <returns>EventInfo[][].</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> public static EventInfo[] GetEventsEx(this Type type, bool flattenHierarchy = true, bool allowStaticMembers = false) { Argument.IsNotNull("type", type); BindingFlags bindingFlags = BindingFlagsHelper.GetFinalBindingFlags(flattenHierarchy, allowStaticMembers); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Event, bindingFlags); return(_eventsCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetEvents(bindingFlags))); #else return(type.GetTypeInfo().GetEvents(bindingFlags)); #endif }
/// <summary> /// Returns whether the member value should be serialized as dictionary. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns><c>true</c> if the member value should be serialized as dictionary, <c>false</c> otherwise.</returns> protected virtual bool ShouldSerializeAsDictionary(Type memberType) { return(_shouldSerializeAsDictionaryCache.GetFromCacheOrFetch(memberType, () => { if (memberType.IsDictionary()) { return true; } return false; })); }
/// <summary> /// The get event ex. /// </summary> /// <param name="type">The type.</param> /// <param name="name">The name.</param> /// <param name="bindingFlags">The binding Flags.</param> /// <returns>EventInfo.</returns> /// <exception cref="System.ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception> /// <exception cref="System.ArgumentException">The <paramref name="name" /> is <c>null</c> or whitespace.</exception> public static EventInfo GetEventEx(this Type type, string name, BindingFlags bindingFlags) { Argument.IsNotNullOrWhitespace(nameof(name), name); Argument.IsNotNull(nameof(type), type); #if ENABLE_CACHE var cacheKey = new ReflectionCacheKey(type, ReflectionTypes.Event, bindingFlags, name); return(_eventCache.GetFromCacheOrFetch(cacheKey, () => type.GetTypeInfo().GetEvent(name, bindingFlags))); #else return(type.GetTypeInfo().GetEvent(name, bindingFlags)); #endif }
public void RunMultipleThreadsWithRandomAccessCalls() { var cacheStorage = new CacheStorage<Guid, int>(() => ExpirationPolicy.Duration(TimeSpan.FromMilliseconds(1))); var threads = new List<Thread>(); for (int i = 0; i < 25; i++) { var thread = new Thread(() => { var random = new Random(); for (int j = 0; j < 10000; j++) { var randomGuid = _randomGuids[random.Next(0, 9)]; cacheStorage.GetFromCacheOrFetch(randomGuid, () => { var threadId = Thread.CurrentThread.ManagedThreadId; Log.Info("Key '{0}' is now controlled by thread '{1}'", randomGuid, threadId); return threadId; }); ThreadHelper.Sleep(1); } }); threads.Add(thread); thread.Start(); } while (true) { bool anyThreadAlive = false; foreach (var thread in threads) { if (thread.IsAlive) { anyThreadAlive = true; break; } } if (!anyThreadAlive) { break; } ThreadHelper.Sleep(500); } }
public void ReturnsCachedItem() { var cache = new CacheStorage<string, int>(); cache.Add("1", 1); var value = cache.GetFromCacheOrFetch("1", () => 2); Assert.IsTrue(cache.Contains("1")); Assert.AreEqual(1, cache["1"]); Assert.AreEqual(1, value); }
public void AddsAndExpiresSeveralItems() { var cache = new CacheStorage<string, int>(); cache.ExpirationTimerInterval = TimeSpan.FromMilliseconds(250); for (int i = 0; i < 5; i++) { ThreadHelper.Sleep(1000); int innerI = i; var value = cache.GetFromCacheOrFetch("key", () => innerI, expiration: TimeSpan.FromMilliseconds(250)); Assert.AreEqual(i, value); } }
public void AddsAndExpiresSeveralItems() { var cache = new CacheStorage<string, int>(); for (int i = 0; i < 5; i++) { var value = cache.GetFromCacheOrFetch("key", () => i, expiration: new TimeSpan(0, 0, 1)); Assert.AreEqual(i, value); ThreadHelper.Sleep(2000); } }
public void ThrowsArgumentNullExceptionForNullFunction() { var cache = new CacheStorage<string, int>(); ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => cache.GetFromCacheOrFetch("1", null)); }
public void AddsItemToCacheWithOverrideAndReturnsIt() { var cache = new CacheStorage<string, int>(); cache.Add("1", 1); var value = cache.GetFromCacheOrFetch("1", () => 2, true); Assert.IsTrue(cache.Contains("1")); Assert.AreEqual(2, cache["1"]); Assert.AreEqual(2, value); }