/// <summary>
/// Creates an instance of the specified type.
/// </summary>
/// <typeparam name="T">The type to create.</typeparam>
/// <param name="assembly">The assmblies to search.</param>
/// <param name="preferences">Preferences to use in selecting a type to create.</param>
public static T Create <T>(Assembly assembly, TypePreferences preferences) where T : class
{
Type[] types;
try {
types = assembly.GetTypes();
} catch {
try {
types = assembly.GetExportedTypes();
} catch {
types = Array.Empty <Type>();
}
}
if (!types.Any())
{
IgnoreAssembly(assembly);
return(null);
}
var feedback = CreateWithFeedback <T>(types, preferences);
if (feedback.AttributesExisted)
{
return(feedback.Instance);
}
IgnoreAssembly(assembly);
return(null);
}
private static TypeCreationFeedback <T> CreateWithFeedback <T>(Type[] types, TypePreferences preferences) where T : class
{
bool attributesExist = false;
foreach (Type t in types)
{
var definitions = t.GetCustomAttributes <ClassDefinitionAttribute>();
if (definitions != null && definitions.Any())
{
attributesExist = true;
foreach (ClassDefinitionAttribute definition in definitions)
{
if (typeof(T).IsAssignableFrom(t) && string.Compare(preferences?.Code, definition.Code, StringComparison.CurrentCultureIgnoreCase) == 0)
{
T rtn = CreateFromType <T>(t, preferences);
if (rtn != null)
{
return(new TypeCreationFeedback <T>()
{
Instance = rtn,
AttributesExisted = true
});
}
}
}
}
}
return(new TypeCreationFeedback <T>()
{
Instance = null,
AttributesExisted = attributesExist
});
}
private static T CreateFromType <T>(Type type, TypePreferences preferences) where T : class
{
var c = type.GetConstructor(Array.Empty <Type>());
if (c == null)
{
return(null);
}
int expectedAssignments = preferences?.Properties?.Count ?? 0;
List <Tuple <PropertyInfo, object> > assignments = null;
if (preferences?.Properties != null)
{
var propertyNames = preferences.Properties.Keys;
foreach (string propertyName in propertyNames)
{
var property = type.GetProperty(propertyName);
if (property != null && PropertyAllowsValue(property, preferences.Properties[propertyName]))
{
if (assignments == null)
{
assignments = new List <Tuple <PropertyInfo, object> >();
}
assignments.Add(new Tuple <PropertyInfo, object>(property, preferences.Properties[propertyName]));
}
}
}
if (expectedAssignments != (assignments?.Count ?? 0))
{
return(null);
}
T rtn = c.Invoke(Array.Empty <object>()) as T;
if (assignments != null)
{
foreach (Tuple <PropertyInfo, object> assingment in assignments)
{
assingment.Item1.SetMethod.Invoke(rtn, new[] { assingment.Item2 });
}
}
return(rtn);
}
/// <summary>
/// Creates an instance of the specified type.
/// </summary>
/// <typeparam name="T">The type to create.</typeparam>
/// <param name="preferences">Preferences to use in selecting a type to create.</param>
public static T Create <T>(TypePreferences preferences) where T : class
{
T rtn = null;
foreach (Assembly assembly in from a in AssemblyCache.ToArray() select a)
{
rtn = Create <T>(assembly, preferences);
if (rtn != null)
{
return(rtn);
}
}
if (preferences?.SearchPaths != null && preferences.SearchPaths.Count > 0)
{
var loadedFileNames = from a in AssemblyCache.ToArray() where !a.IsDynamic select a.Location;
foreach (string path in from p in preferences.SearchPaths.Distinct() where !string.IsNullOrWhiteSpace(p) select p)
{
var fileNames = from n in Directory.GetFiles(path, "*.dll") where !loadedFileNames.Contains(n) select n;
if (fileNames != null)
{
foreach (string fileName in fileNames)
{
var unknownAssembly = Assembly.LoadFile(fileName);
rtn = Create <T>(unknownAssembly, preferences);
if (rtn != null)
{
CacheAssembly(unknownAssembly);
return(rtn);
}
}
}
}
}
return(null);
}
/// <summary>
/// Creates an instance of the specified type.
/// </summary>
/// <typeparam name="T">The type to create.</typeparam>
/// <param name="types">The types to search.</param>
/// <param name="preferences">Preferences to use in selecting a type to create.</param>
public static T Create <T>(Type[] types, TypePreferences preferences) where T : class
{
return(CreateWithFeedback <T>(types, preferences).Instance);
}
