/// <summary>
/// Finds the fields that represent a <see cref="PropertyData"/>.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of <see cref="PropertyData"/> elements found as fields.</returns>
/// <exception cref="InvalidOperationException">One ore more fields are not declared correctly.</exception>
private IEnumerable <PropertyData> FindCatelFields(Type type)
{
// CTL-212: Generic types are not supported for FieldInfo.GetValue
if (type.ContainsGenericParametersEx())
{
return(ArrayShim.Empty <PropertyData>());
}
PreventWrongDeclaredFields(type);
// Fields - actual addition
var foundFields = new List <PropertyData>();
var fields = new List <FieldInfo>();
fields.AddRange(type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, false)));
foreach (var field in fields)
{
if (field.FieldType == typeof(PropertyData))
{
var propertyValue = (field.IsStatic ? field.GetValue(null) : field.GetValue(this)) as PropertyData;
if (propertyValue != null)
{
foundFields.Add(propertyValue);
}
}
}
return(foundFields);
}
public static Type[] GetKnownTypes()
{
var assembly = AppDomain.CurrentDomain.GetLoadedAssemblies(false).FirstOrDefault(a => a.FullName.StartsWith("DynamicClasses", StringComparison.Ordinal));
var types = new List <Type>(assembly == null ? ArrayShim.Empty <Type>() : assembly.GetTypes().Where(t => t.Name.StartsWith("DynamicClass", StringComparison.Ordinal)).ToArray());
return(types.ToArray());
}
/// <summary>
/// Finds the properties that represent a <see cref="PropertyData"/>.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of <see cref="PropertyData"/> elements found as properties.</returns>
/// <exception cref="InvalidOperationException">One ore more properties are not declared correctly.</exception>
private IEnumerable <PropertyData> FindCatelProperties(Type type)
{
// CTL-212: Generic types are not supported for FieldInfo.GetValue
if (type.ContainsGenericParametersEx())
{
return(ArrayShim.Empty <PropertyData>());
}
PreventWrongDeclaredProperties(type);
// Properties - actual addition
var foundProperties = new List <PropertyData>();
var properties = new List <PropertyInfo>();
properties.AddRange(type.GetPropertiesEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, true), true));
foreach (var property in properties)
{
if (property.PropertyType == typeof(PropertyData))
{
var propertyValue = property.GetValue(null, null) as PropertyData;
if (propertyValue != null)
{
foundProperties.Add(propertyValue);
}
}
}
return(foundProperties);
}
/// <summary>
/// Creates the exception with the message and inner exception. If the exception does not support creation with
/// inner exceptions, it will use the message only.
/// </summary>
/// <param name="exceptionType">Type of the exception.</param>
/// <param name="message">The message.</param>
/// <param name="innerException">The inner exception.</param>
/// <returns>The created exception or <c>null</c> if there was no valid constructor available.</returns>
public static Exception CreateException(Type exceptionType, string message, Exception innerException = null)
{
// Try 1: with inner exception
if (innerException != null)
{
var argsWithInnerException = new object[] { message, innerException };
var exceptionWithInnerException = CreateException(exceptionType, argsWithInnerException);
if (exceptionWithInnerException != null)
{
return(exceptionWithInnerException);
}
}
// try 2: without inner exception
var args = new object[] { message };
var exception = CreateException(exceptionType, args);
if (exception != null)
{
return(exception);
}
// try 3: without anything
exception = CreateException(exceptionType, ArrayShim.Empty <object>());
if (exception != null)
{
return(exception);
}
return(null);
}
/// <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>()));
}
/// <summary>
/// Resolves the specified types with the specified tag.
/// </summary>
/// <param name="types">The types.</param>
/// <param name="tag">The tag.</param>
/// <returns>A list of resolved types. If one of the types cannot be resolved, that location in the array will be <c>null</c>.</returns>
public object[] ResolveMultiple(Type[] types, object tag = null)
{
Argument.IsNotNull("types", types);
if (types.Length == 0)
{
return(ArrayShim.Empty <object>());
}
int typeCount = types.Length;
var resolvedTypes = new object[typeCount];
lock (_serviceLocator)
{
for (int i = 0; i < typeCount; i++)
{
try
{
resolvedTypes[i] = Resolve(types[i], tag);
}
catch (TypeNotRegisteredException ex)
{
Log.Debug(ex, "Failed to resolve type '{0}', returning null", ex.RequestedType.GetSafeFullName(false));
}
}
}
return(resolvedTypes);
}
/// <summary>
/// Gets the types prefiltered by assembly. If types must be retrieved from a single assembly only, this method is very fast.
/// </summary>
/// <param name="assembly">Name of the assembly.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="allowInitialization">If set to <c>true</c>, allow initialization of the AppDomain if it hasn't happened yet. If <c>false</c>, deal with the types currently in the cache.</param>
/// <returns>System.Type[].</returns>
private static Type[] GetTypesPrefilteredByAssembly(Assembly assembly, Func <Type, bool> predicate, bool allowInitialization)
{
if (allowInitialization)
{
InitializeTypes(assembly);
}
var assemblyName = (assembly != null) ? TypeHelper.GetAssemblyNameWithoutOverhead(assembly.FullName) : string.Empty;
// IMPORTANT NOTE!!!! DON'T USE LOGGING IN THE CODE BELOW BECAUSE IT MIGHT CAUSE DEADLOCK (BatchLogListener will load
// async stuff which can deadlock). Keep it simple without calls to other code. Do any type initialization *outside*
// the lock and make sure not to make calls to other methods
Dictionary <string, Type> typeSource = null;
lock (_lockObject)
{
if (!string.IsNullOrWhiteSpace(assemblyName))
{
_typesByAssembly.TryGetValue(assemblyName, out typeSource);
}
else
{
typeSource = _typesWithAssembly;
}
}
if (typeSource == null)
{
return(ArrayShim.Empty <Type>());
}
var retryCount = 3;
while (retryCount > 0)
{
retryCount--;
try
{
if (predicate != null)
{
return(typeSource.Values.Where(predicate).ToArray());
}
return(typeSource.Values.ToArray());
}
catch (Exception)
{
// Ignore
}
}
return(ArrayShim.Empty <Type>());
// IMPORTANT NOTE: READ NOTE ABOVE BEFORE EDITING THIS METHOD!!!!
}
/// <summary>
/// Converts the list of objects to an array of attributes, very easy to use during GetCustomAttribute reflection.
/// </summary>
/// <param name="objects">The object array, can be <c>null</c>.</param>
/// <returns>Attribute array or empty array if <paramref name="objects"/> is <c>null</c>.</returns>
public static Attribute[] ToAttributeArray(this object[] objects)
{
if (objects == null)
{
return(ArrayShim.Empty <Attribute>());
}
return(objects.Cast <Attribute>().ToArray());
}
/// <summary>
/// Converts a string to a byte array.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>The byte array value of the string.</returns>
public static byte[] ToByteArray(string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return(ArrayShim.Empty <byte>());
}
var encoding = new UTF8Encoding();
return(encoding.GetBytes(value));
}
/// <summary>
/// Gets the properties of the view.
/// </summary>
/// <param name="view">The view.</param>
/// <returns>List of properties.</returns>
public static string[] GetProperties(this IView view)
{
Argument.IsNotNull("view", view);
#if !XAMARIN
var viewProperties = ((FrameworkElement)view).GetDependencyProperties();
return(viewProperties.Select(x => x.PropertyName).ToArray());
#else
return(ArrayShim.Empty <string>());
#endif
}
public Assembly[] GetAssemblies()
{
lock (_lock)
{
if (_loadedAssemblies == null)
{
var loadedAssemblies = new List <Assembly>();
#if NETFX_CORE
var folder = Package.Current.InstalledLocation;
// Note: normally it's bad practice to use task.Wait(), but GetAssemblies must be blocking to cache it all
var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new[] { ".dll", ".exe", ".winmd" });
queryOptions.FolderDepth = FolderDepth.Shallow;
var queryResult = folder.CreateFileQueryWithOptions(queryOptions);
var task = queryResult.GetFilesAsync().AsTask();
task.Wait();
var files = task.Result.ToList();
var arrayToIgnore = KnownPrefixesToIgnore.ToArray();
foreach (var file in files)
{
if (file.Name.StartsWithAnyIgnoreCase(arrayToIgnore))
{
continue;
}
var assembly = LoadAssemblyFromFile(file);
if (assembly != null)
{
loadedAssemblies.Add(assembly);
}
}
#else
var currentdomain = typeof(string).GetTypeInfo().Assembly.GetType("System.AppDomain").GetRuntimeProperty("CurrentDomain").GetMethod.Invoke(null, ArrayShim.Empty <object>());
var method = currentdomain.GetType().GetRuntimeMethod("GetAssemblies", ArrayShim.Empty <Type>());
var assemblies = method.Invoke(currentdomain, ArrayShim.Empty <object>()) as Assembly[];
loadedAssemblies.AddRange(assemblies);
#endif
_loadedAssemblies = loadedAssemblies.ToArray();
}
return(_loadedAssemblies);
}
}
/// <summary>
/// Constructs the view with the view model. First, this method tries to inject the specified DataContext into the
/// view. If the view does not contain a constructor with this parameter type, it will try to use the default constructor
/// and set the DataContext manually.
/// </summary>
/// <param name="viewType">Type of the view to instantiate.</param>
/// <param name="dataContext">The data context to inject into the view. In most cases, this will be a view model.</param>
/// <returns>
/// The constructed view or <c>null</c> if it was not possible to construct the view.
/// </returns>
/// <exception cref="ArgumentNullException">The <paramref name="viewType" /> is <c>null</c>.</exception>
public static FrameworkElement ConstructViewWithViewModel(Type viewType, object dataContext)
{
Argument.IsNotNull("viewType", viewType);
Log.Debug("Constructing view for view type '{0}'", viewType.Name);
FrameworkElement view;
// First, try to constructor directly with the data context
if (dataContext != null)
{
var injectionConstructor = viewType.GetConstructorEx(new[] { dataContext.GetType() });
if (injectionConstructor != null)
{
view = (FrameworkElement)injectionConstructor.Invoke(new[] { dataContext });
Log.Debug("Constructed view using injection constructor");
return(view);
}
}
Log.Debug("No constructor with data (of type '{0}') injection found, trying default constructor", ObjectToStringHelper.ToTypeString(dataContext));
// Try default constructor
var defaultConstructor = viewType.GetConstructorEx(ArrayShim.Empty <Type>());
if (defaultConstructor is null)
{
Log.Error("View '{0}' does not have an injection or default constructor thus cannot be constructed", viewType.Name);
return(null);
}
try
{
view = (FrameworkElement)defaultConstructor.Invoke(null);
}
catch (Exception ex)
{
throw Log.ErrorAndCreateException <InvalidOperationException>(ex, "Failed to construct view '{0}' with both injection and empty constructor", viewType.Name);
}
view.DataContext = dataContext;
Log.Debug("Constructed view using default constructor and setting DataContext afterwards");
return(view);
}
/// <summary>
/// Gets the auto complete values.
/// </summary>
/// <param name="property">The property.</param>
/// <param name="filter">The filter.</param>
/// <param name="source">The source.</param>
/// <returns>System.String[].</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is <c>null</c>.</exception>
public virtual string[] GetAutoCompleteValues(string property, string filter, IEnumerable source)
{
Argument.IsNotNull("source", source);
if (source is string)
{
return(ArrayShim.Empty <string>());
}
var propertyValues = new List <string>();
if (string.IsNullOrWhiteSpace(property))
{
try
{
// Filter items directly
propertyValues.AddRange(from x in source.OfType <string>()
select x);
}
catch (Exception)
{
// Swallow
}
}
else
{
propertyValues.AddRange(from x in source.Cast <object>()
select GetPropertyValue(x, property));
}
propertyValues = propertyValues.Where(x => !string.Equals(x, "null")).Distinct().ToList();
var filteredValues = propertyValues;
if (!string.IsNullOrEmpty(filter))
{
filteredValues = filteredValues.Where(x => x.Contains(filter)).ToList();
}
var orderedPropertyValues = filteredValues.GroupBy(x => x).Select(g => new
{
Value = g.Key,
Count = g.Select(x => x).Distinct().Count()
}).OrderBy(x => x.Count).Select(x => x.Value).Take(10);
return(orderedPropertyValues.OrderBy(x => x).ToArray());
}
/// <summary>
/// Gets the known types via attributes.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of known types via the <see cref="KnownTypeAttribute"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
protected virtual Type[] GetKnownTypesViaAttributes(Type type)
{
Argument.IsNotNull("type", type);
string typeName = type.AssemblyQualifiedName;
if (string.IsNullOrWhiteSpace(typeName))
{
return(ArrayShim.Empty <Type>());
}
return(_knownTypesByAttributesCache.GetFromCacheOrFetch(typeName, () =>
{
var additionalTypes = new List <Type>();
var knownTypeAttributes = type.GetCustomAttributesEx(typeof(KnownTypeAttribute), true);
foreach (var attr in knownTypeAttributes)
{
var ktattr = attr as KnownTypeAttribute;
if (ktattr != null)
{
if (ktattr.MethodName != null)
{
var mi = type.GetMethodEx(ktattr.MethodName, BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
// this can be null because we are also getting here through the recursive behaviour
// of GetCustomAttributesEx. We are getting at this point once per class derived from a
// base class having a KnownType() with a method. This can be ignored
if (mi != null)
{
var types = mi.Invoke(null, null) as IEnumerable <Type>;
if (types != null)
{
additionalTypes.AddRange(types);
}
}
}
else
{
additionalTypes.Add(ktattr.Type);
}
}
}
return additionalTypes.ToArray();
}));
}
/// <summary>
/// Gets hidden property value.
/// </summary>
/// <typeparam name="TValue">The type of the T value.</typeparam>
/// <param name="obj">The obj.</param>
/// <param name="property">The property.</param>
/// <param name="baseType">The base Type.</param>
/// <returns>``0.</returns>
/// <exception cref="PropertyNotFoundException"></exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="obj" /> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentException">The <paramref name="property" /> is <c>null</c> or whitespace.</exception>
/// <exception cref="System.ArgumentException">The <paramref name="property" /> is <c>null</c> or whitespace.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="obj" /> is <c>null</c>.</exception>
public static TValue GetHiddenPropertyValue <TValue>(object obj, string property, Type baseType)
{
Argument.IsNotNull("obj", obj);
Argument.IsNotNullOrWhitespace("property", property);
Argument.IsNotNull("baseType", baseType);
Argument.IsOfType("obj", obj, baseType);
var bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var propertyInfo = baseType.GetPropertyEx(property, bindingFlags);
if (propertyInfo == null)
{
throw Log.ErrorAndCreateException(s => new PropertyNotFoundException(property),
"Hidden property '{0}' is not found on the base type '{1}'", property, baseType.GetType().Name);
}
return((TValue)propertyInfo.GetValue(obj, bindingFlags, null, ArrayShim.Empty <object>(), CultureInfo.InvariantCulture));
}
/// <summary>
/// Converters the stream to a byte array.
/// </summary>
/// <param name="stream">The stream to convert to a byte array.</param>
/// <returns>The byte array representing the stream.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is <c>null</c>.</exception>
public static byte[] ToByteArray(this Stream stream)
{
Argument.IsNotNull("stream", stream);
stream.Position = 0L;
var length = (int)stream.Length;
if (length == 0)
{
return(ArrayShim.Empty <byte>());
}
var buffer = new byte[length];
stream.Read(buffer, 0, length);
return(buffer);
}
/// <summary>
/// Gets all types from the assembly safely. Sometimes, the <see cref="ReflectionTypeLoadException"/> is thrown,
/// and no types are returned. In that case the user must manually get the successfully loaded types from the
/// <see cref="ReflectionTypeLoadException.Types"/>.
/// <para/>
/// This method automatically loads the types. If the <see cref="ReflectionTypeLoadException"/> occurs, this method
/// will return the types that were loaded successfully.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <param name="logLoaderExceptions">If set to <c>true</c>, the loader exceptions will be logged.</param>
/// <returns>The array of successfully loaded types.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="assembly"/> is <c>null</c>.</exception>
public static Type[] GetAllTypesSafely(this Assembly assembly, bool logLoaderExceptions = true)
{
Argument.IsNotNull("assembly", assembly);
Type[] foundAssemblyTypes;
RegisterAssemblyWithVersionInfo(assembly);
try
{
foundAssemblyTypes = assembly.GetTypesEx();
}
catch (ReflectionTypeLoadException typeLoadException)
{
foundAssemblyTypes = (from type in typeLoadException.Types
where type != null
select type).ToArray();
Log.Warning("A ReflectionTypeLoadException occured, adding all {0} types that were loaded correctly", foundAssemblyTypes.Length);
if (logLoaderExceptions)
{
Log.Warning("The following loading exceptions occurred:");
foreach (var error in typeLoadException.LoaderExceptions)
{
// Fix mono issue https://github.com/Catel/Catel/issues/1071
if (error != null)
{
Log.Warning(" " + error.Message);
}
}
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to get types from assembly '{0}'", assembly.FullName);
foundAssemblyTypes = ArrayShim.Empty <Type>();
}
return(foundAssemblyTypes);
}
/// <summary>
/// Modifies the source data before passing it to the target for display in the UI.
/// </summary>
/// <param name="value">The source data being passed to the target.</param>
/// <param name="targetType">The <see cref="T:System.Type" /> of data expected by the target dependency property.</param>
/// <param name="parameter">An optional parameter to be used in the converter logic.</param>
/// <returns>The value to be passed to the target dependency property.</returns>
protected override object Convert(object value, Type targetType, object parameter)
{
var methodName = parameter as string;
if (value is null || methodName is null)
{
return(value);
}
var bindingFlags = BindingFlagsHelper.GetFinalBindingFlags(true, true);
var methodInfo = value.GetType().GetMethodEx(methodName, ArrayShim.Empty <Type>(), bindingFlags);
if (methodInfo is null)
{
return(value);
}
return(methodInfo.Invoke(value, ArrayShim.Empty <object>()));
}
/// <summary>
/// Determines whether the specified type is serializable.
/// </summary>
/// <param name="type">The type.</param>
/// <returns><c>true</c> if the specified type is serializable; otherwise, <c>false</c>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception>
public bool IsTypeSerializable(Type type)
{
return(_isTypeSerializableCache.GetFromCacheOrFetch(type, () =>
{
if (type.IsAbstractEx())
{
return false;
}
if (type.IsInterfaceEx())
{
return false;
}
if (type.IsEnumEx())
{
return true;
}
if (IsSpecialCollectionType(type))
{
return true;
}
// Should have an empty constructor
if (type.GetConstructorEx(ArrayShim.Empty <Type>()) == null)
{
return false;
}
// Type must be public
if (!type.IsPublicEx() && !type.IsNestedPublicEx())
{
return false;
}
// TODO: Add more checks?
return true;
}));
}
private static void AssertSerializationCalls(object obj, string serializationMode, string[] fieldNames)
{
foreach (var fieldName in fieldNames)
{
var field = obj.GetType().GetFieldEx(fieldName);
var fieldValue = (int)field.GetValue(obj);
Assert.AreEqual(1, fieldValue, $"{obj.GetType().Name}.{fieldName} should have been 1 for serialization mode {serializationMode}");
}
var methodInfo = obj.GetType().GetMethodEx("ClearSerializationCounters");
methodInfo.Invoke(obj, ArrayShim.Empty <object>());
if (obj is ComputerSettings computerSettings)
{
foreach (var iniFile in computerSettings.IniFileCollection)
{
AssertSerializationCalls(iniFile, serializationMode, fieldNames);
}
return;
}
else if (obj is IniFile iniFile)
{
foreach (var iniEntry in iniFile.IniEntryCollection)
{
AssertSerializationCalls(iniEntry, serializationMode, fieldNames);
}
return;
}
else if (obj is IniEntry iniEntry)
{
// No need to check children
return;
}
Assert.Fail($"Unsupported model '{obj.GetType()}'");
}
public async Task <IEnumerable <LogFilterGroup> > LoadAsync()
{
var applicationDataDirectory = Catel.IO.Path.GetApplicationDataDirectory();
var configFile = Path.Combine(applicationDataDirectory, LogFilterGroupsConfigFile);
if (_fileService.Exists(configFile))
{
try
{
using (var stream = _fileService.OpenRead(configFile))
{
return((LogFilterGroup[])_xmlSerializer.Deserialize(typeof(LogFilterGroup[]), stream));
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
return(ArrayShim.Empty <LogFilterGroup>());
}
/// <summary>
/// Raises the events for differences.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="oldValidationData">The old validation data.</param>
/// <param name="newValidationData">The new validation data.</param>
private void RaiseEventsForDifferences(object value, ValidationData oldValidationData, ValidationData newValidationData)
{
// Warnings - fields
RaiseEventsForDifferencesInFields(value, oldValidationData?.FieldWarnings ?? (IEnumerable <FieldWarningOrErrorInfo>)ArrayShim.Empty <FieldWarningOrErrorInfo>(), newValidationData.FieldWarnings, ValidationType.Warning);
// Warnings - business
RaiseEventsForDifferencesInBusiness(value, oldValidationData?.BusinessWarnings ?? (IEnumerable <BusinessWarningOrErrorInfo>)ArrayShim.Empty <BusinessWarningOrErrorInfo>(), newValidationData.BusinessWarnings, ValidationType.Warning);
// Errors - fields
RaiseEventsForDifferencesInFields(value, oldValidationData?.FieldErrors ?? (IEnumerable <FieldWarningOrErrorInfo>)ArrayShim.Empty <FieldWarningOrErrorInfo>(), newValidationData.FieldErrors, ValidationType.Error);
// Errors - business
RaiseEventsForDifferencesInBusiness(value, oldValidationData?.BusinessErrors ?? (IEnumerable <BusinessWarningOrErrorInfo>)ArrayShim.Empty <BusinessWarningOrErrorInfo>(), newValidationData.BusinessErrors, ValidationType.Error);
}
public Assembly[] GetAssemblies()
{
lock (_lock)
{
if (_loadedAssemblies == null)
{
var loadedAssemblies = new List <Assembly>();
#if NETFX_CORE
var folder = Package.Current.InstalledLocation;
// Note: normally it's bad practice to use task.Wait(), but GetAssemblies must be blocking to cache it all
// Note: winmd cannot be read, see https://stackoverflow.com/questions/9136683/cannot-get-types-from-winmd-file,
// so we create a hashset of all winmd files and ignore them
var winmdQueryOptions = new QueryOptions(CommonFileQuery.OrderByName, new[] { ".winmd" });
winmdQueryOptions.FolderDepth = FolderDepth.Shallow;
var winmdQueryResult = folder.CreateFileQueryWithOptions(winmdQueryOptions);
var winmdTask = winmdQueryResult.GetFilesAsync().AsTask();
winmdTask.Wait();
var winmdFiles = new HashSet <string>(winmdTask.Result.Select(x => x.Name.Substring(0, x.Name.Length - x.FileType.Length)), StringComparer.OrdinalIgnoreCase);
// Get assemblies
var assemblyQueryOptions = new QueryOptions(CommonFileQuery.OrderByName, new[] { ".dll", ".exe" /*, ".winmd" */ });
assemblyQueryOptions.FolderDepth = FolderDepth.Shallow;
var assemblyQueryResult = folder.CreateFileQueryWithOptions(assemblyQueryOptions);
var assembliesTask = assemblyQueryResult.GetFilesAsync().AsTask();
assembliesTask.Wait();
var assemblyFiles = assembliesTask.Result.ToImmutableHashSet();
var arrayToIgnore = KnownPrefixesToIgnore.ToArray();
foreach (var file in assemblyFiles)
{
try
{
if (file.Name.StartsWithAnyIgnoreCase(arrayToIgnore))
{
continue;
}
Log.Debug($"Loading assembly from file '{file.Name}'");
var assemblyName = file.Name.Substring(0, file.Name.Length - file.FileType.Length);
if (winmdFiles.Contains(assemblyName))
{
Log.Debug($"Ignoring assembly load of '{file.Name}' because it's (most likely) not a managed assembly (because .winmd exists)");
continue;
}
var assembly = LoadAssemblyFromFile(file);
if (assembly != null)
{
loadedAssemblies.Add(assembly);
}
}
catch (Exception ex)
{
Log.Warning(ex, $"Failed to load assembly '{file}'");
}
}
#else
var currentdomain = typeof(string).GetTypeInfo().Assembly.GetType("System.AppDomain").GetRuntimeProperty("CurrentDomain").GetMethod.Invoke(null, ArrayShim.Empty <object>());
var method = currentdomain.GetType().GetRuntimeMethod("GetAssemblies", ArrayShim.Empty <Type>());
var assemblies = method.Invoke(currentdomain, ArrayShim.Empty <object>()) as Assembly[];
loadedAssemblies.AddRange(assemblies);
#endif
_loadedAssemblies = loadedAssemblies.ToArray();
}
return(_loadedAssemblies);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NotSupportedInPlatformException"/> class.
/// </summary>
/// <param name="message">The message.</param>
public NotSupportedInPlatformException(string message)
: this(message, ArrayShim.Empty <object>())
{
}
/// <summary>
/// Creates an instance of the specified type using the specified parameters as injection values.
/// </summary>
/// <param name="typeToConstruct">The type to construct.</param>
/// <param name="tag">The preferred tag when resolving dependencies.</param>
/// <param name="parameters">The parameters to inject.</param>
/// <param name="autoCompleteDependencies">if set to <c>true</c>, the additional dependencies will be auto completed.</param>
/// <returns>The instantiated type using dependency injection.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="typeToConstruct" /> is <c>null</c>.</exception>
private object CreateInstanceWithSpecifiedParameters(Type typeToConstruct, object tag, object[] parameters, bool autoCompleteDependencies)
{
Argument.IsNotNull("typeToConstruct", typeToConstruct);
if (parameters == null)
{
parameters = ArrayShim.Empty <object>();
}
var previousRequestPath = _currentTypeRequestPath.Value;
try
{
var typeRequestInfo = new TypeRequestInfo(typeToConstruct);
_currentTypeRequestPath.Value = TypeRequestPath.Branch(previousRequestPath, typeRequestInfo);
var constructorCacheKey = new ConstructorCacheKey(typeToConstruct, autoCompleteDependencies, parameters);
var typeConstructorsMetadata = GetTypeMetaData(typeToConstruct);
var constructorCacheValue = GetConstructor(constructorCacheKey);
if (constructorCacheValue.ConstructorInfo != null)
{
var cachedConstructor = constructorCacheValue.ConstructorInfo;
var instanceCreatedWithInjection = TryCreateToConstruct(typeToConstruct, cachedConstructor, tag, parameters, false, false, typeConstructorsMetadata);
if (instanceCreatedWithInjection != null)
{
return(instanceCreatedWithInjection);
}
Log.Warning("Found constructor for type '{0}' in constructor, but it failed to create an instance. Removing the constructor from the cache", typeToConstruct.FullName);
SetConstructor(constructorCacheKey, constructorCacheValue, null);
}
Log.Debug("Creating instance of type '{0}' using specific parameters. No constructor found in the cache, so searching for the right one", typeToConstruct.FullName);
var constructors = typeConstructorsMetadata.GetConstructors(parameters.Length, !autoCompleteDependencies).SortByParametersMatchDistance(parameters).ToList();
for (int i = 0; i < constructors.Count; i++)
{
var constructor = constructors[i];
var instanceCreatedWithInjection = TryCreateToConstruct(typeToConstruct, constructor, tag, parameters, true, i < constructors.Count - 1, typeConstructorsMetadata);
if (instanceCreatedWithInjection != null)
{
// We found a constructor that works, cache it
SetConstructor(constructorCacheKey, constructorCacheValue, constructor);
// Only update the rule when using a constructor for the first time, not when using it from the cache
ApiCop.UpdateRule <TooManyDependenciesApiCopRule>("TypeFactory.LimitDependencyInjection", x => x.SetNumberOfDependenciesInjected(typeToConstruct, constructor.GetParameters().Count()));
return(instanceCreatedWithInjection);
}
}
Log.Debug("No constructor could be used, cannot construct type '{0}' with the specified parameters", typeToConstruct.FullName);
}
catch (CircularDependencyException)
{
throw;
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to construct type '{0}'", typeToConstruct.FullName);
throw;
}
finally
{
_currentTypeRequestPath.Value = previousRequestPath;
}
return(null);
}
private void UpdateShapeColor(Shape shape, bool isSelected)
{
var storyboard = new Storyboard();
if (shape is not null && shape.Fill is null)
{
#pragma warning disable WPF0041 // Set mutable dependency properties using SetCurrentValue.
shape.Fill = (SolidColorBrush)TryFindResource(ThemingKeys.AccentColorBrush40);
#pragma warning restore WPF0041 // Set mutable dependency properties using SetCurrentValue.
}
var fromColor = ((SolidColorBrush)shape?.Fill)?.Color ?? Colors.Transparent;
var targetColor = this.GetAccentColorBrush(isSelected).Color;
var colorAnimation = new ColorAnimation(fromColor, (Color)targetColor, WizardConfiguration.AnimationDuration);
Storyboard.SetTargetProperty(colorAnimation, new PropertyPath("Fill.(SolidColorBrush.Color)", ArrayShim.Empty <object>()));
storyboard.Children.Add(colorAnimation);
storyboard.Begin(shape);
}
/// <summary>
/// Wraps the specified framework element without any buttons.
/// </summary>
/// <param name="frameworkElement">The framework element.</param>
/// <param name="wrapOptions">The wrap options.</param>
/// <param name="parentContentControl">The parent content control.</param>
/// <returns>
/// <see cref="Grid"/> that contains the wrapped content.
/// </returns>
/// <remarks>
/// The framework element that is passed must be disconnected from the parent first. It is recommended to first check whether a
/// framework element can be wrapped by using the <see cref="CanBeWrapped"/> method.
/// <para />
/// This method will automatically handle the disconnecting of the framework element from the parent is the <paramref name="parentContentControl"/>
/// is passed.
/// </remarks>
public Grid Wrap(FrameworkElement frameworkElement, WrapControlServiceWrapOptions wrapOptions, ContentControl parentContentControl = null)
{
return(Wrap(frameworkElement, wrapOptions, ArrayShim.Empty <DataWindowButton>(), parentContentControl));
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
{
return(ArrayShim.Empty <object>());
}
/// <summary>
/// Creates root of type request path.
/// </summary>
/// <param name="name">Path's name</param>
/// <returns></returns>
public static TypeRequestPath Root(string name = null)
{
return(new TypeRequestPath(ArrayShim.Empty <TypeRequestInfo>(), name));
}
public void ReturnsEmptyStringForEmptyArray()
{
Assert.AreEqual(string.Empty, TypeHelper.FormatInnerTypes((IEnumerable <string>)ArrayShim.Empty <string>()));
}