/// <inheritdoc/>
/// <remarks>
/// The <typeparamref name="T"/> object should have a constructor that
/// receives a single parameter of the type
/// <see cref="SqlConnectionProvider"/>.
/// </remarks>
public T CreateProvider(IDictionary <string, string> options)
{
return(CreateProvider(options,
sql_connection_provider =>
RuntimeTypeFactory <T>
.CreateInstance(typeof(T), sql_connection_provider)));
}
/// <summary>
/// Creates new instances to all types that can be assigned
/// to <typeparamref name="T" />.
/// the types.
/// </summary>
/// <param name="types">
/// A list of <see cref="Type"/> objects containing the type to be
/// filtered and instantiated.
/// </param>
/// <param name="fallback">
/// A value that indicates if we should fallback to the default constructor
/// when a constructor that accepts the given <paramref name="args"/> as
/// parameters is not found. Default to <c>true</c>.
/// </param>
/// <param name="throw">
/// A value that indicates if exceptions should be propagated to the
/// caller or silently ignored. Default to <c>true</c>.
/// </param>
/// <param name="args">
/// An array of arguments that match the parameters of the constructor to
/// invoke. If args is an empty array or null, or if a matching constructor
/// is not found the constructor that takes no parameters(the default
/// constructor) is invoked.
/// </param>
/// <returns>
/// An collection of <typeparamref name="T"/> containing an instance for
/// each type of the <paramref name="types"/> list that can be assigned to
/// <typeparamref name="T" />.
/// </returns>
public static IEnumerable <T> CreateInstances <T>(
this IEnumerable <Type> types, bool fallback, bool @throw,
params object[] args) where T : class
{
return
(types
.Where(
t =>
typeof(T).IsAssignableFrom(t) && !(t.IsAbstract || t.IsInterface))
.Select(t =>
RuntimeTypeFactory <T>
.CreateInstance(t, fallback, @throw, args)));
}
/// <summary>
/// Creates an instance of all configured providers that has a factory
/// that implements the <see cref="IProviderFactory"/> intrface and has a
/// constructor that accepts no parameters or a single parameter of the type
/// <see cref="IConfiguration"/>.
/// </summary>
/// <param name="predicate">
/// A <see cref="Func{TResult}"/> that is used to evaluate if we need to
/// create a instance of the given provider node.
/// </param>
/// <param name="settings">
/// A <see cref="IConfiguration"/> containing the configured providers.
/// </param>
/// <returns>
/// A array containing all providers that was created using the configured
/// factories that implements the <see cref="IProviderFactory"/> interface.
/// </returns>
public static TResult[] CreateProviders <TFactory, TResult>(
this IConfiguration settings,
Func <IProvidersNodeGroup, IProviderNode, bool> predicate,
Func <TFactory, IDictionary <string, string>, TResult> factory)
where TFactory : class
{
var providers = settings.Providers;
var list = new List <TResult>();
foreach (IProvidersNodeGroup group in providers)
{
foreach (IProviderNode node in group)
{
if (!predicate(group, node))
{
continue;
}
Type type = GetType(node);
TFactory factory_t = RuntimeTypeFactory <TFactory>
.CreateInstance(type, true, false, settings);
if (factory_t != null)
{
try {
list.Add(factory(factory_t, node.Options.ToDictionary()));
} catch (Exception e) {
MustLogger.ForCurrentProcess.Error(
StringResources.Log_MethodThrowsException.Fmt(
"CreateProviders", kClassName), e);
throw new ConfigurationException(e);
}
}
}
}
return(list.ToArray());
}
