/// <summary>
/// Copies configuration from poco <paramref name="src"/> to <paramref name="dst"/>.
///
/// Since packageloaders are type names in the poco, any new type will be loaded and instantiated.
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
public static void Assign(PackageFileProviderOptionsRecord src, IPackageFileProviderOptions dst)
{
dst.AllowOpenFiles = src.AllowOpenFiles;
dst.ReuseFailedResult = src.ReuseFailedResult;
dst.MaxMemorySnapshotLength = src.MaxMemorySnapshotLength;
dst.MaxTempSnapshotLength = src.MaxTempSnapshotLength;
// Update packageloaders.
// Make list of new types
List <Type> newPackageLoaders = (src.PackageLoaders ?? new string[0]).Select(typeName => Type.GetType(typeName, true)).ToList();
// Make list of old types
Dictionary <Type, IPackageLoader> oldPackageLoaders = (dst.PackageLoaders ?? new IPackageLoader[0]).ToDictionary(pl => pl.GetType());
// Make new array
IPackageLoader[] newArray = new IPackageLoader[newPackageLoaders.Count];
for (int i = 0; i < newArray.Length; i++)
{
Type type = newPackageLoaders[i];
IPackageLoader pl;
if (!oldPackageLoaders.TryGetValue(type, out pl))
{
pl = (IPackageLoader)Activator.CreateInstance(type);
}
newArray[i] = pl;
}
// A new reference must always be created to trigger reload as per contract.
dst.PackageLoaders = newArray;
}
/// <summary>
/// Assign options and return <paramref name="fileProvider"/>.
/// </summary>
/// <param name="fileProvider"></param>
/// <param name="options"></param>
/// <returns>fileProvider</returns>
public static IPackageFileProvider SetOptions(this IPackageFileProvider fileProvider, IPackageFileProviderOptions options)
{
fileProvider.Options = options;
return(fileProvider);
}
/// <summary>
/// Set policy whether to cache and reuse failed open package attempt.
///
/// If this policy is allowed, then <see cref="IPackageFileProvider"/> remembers what package files
/// could not be opened. Error result can be evicted just like other cached info.
///
/// If this policy is disallowed, then <see cref="IPackageFileProvider"/> will retry opening packages
/// if they are requested again, even if they had failed previously.
/// </summary>
/// <param name="options"></param>
/// <param name="reuseFailedResult"></param>
/// <returns></returns>
public static IPackageFileProviderOptions SetReuseFailedResult(this IPackageFileProviderOptions options, bool reuseFailedResult)
{
options.ReuseFailedResult = reuseFailedResult;
return(options);
}
/// <summary>
/// Configure package file provider to log errors and then throw them.
/// </summary>
/// <param name="options"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static IPackageFileProviderOptions SetToThrowAndLogErrors(this IPackageFileProviderOptions options, ILogger logger)
=> options.SetErrorHandler(e => {
logger.LogError(e.LoadError, "Failed to open package file: {0}", options);
return(false);
});
/// <summary>
/// Set maximum memory temp file snapshot length. If value is over 0, then temp file snapshots are allowed.
///
/// Note, that the options must be configured with TempProvider for temp files to work.
/// </summary>
/// <param name="options"></param>
/// <param name="maxTempFileSnapshotLength"></param>
/// <returns></returns>
public static IPackageFileProviderOptions SetTempFileSnapshotLength(this IPackageFileProviderOptions options, long maxTempFileSnapshotLength)
{
options.MaxTempSnapshotLength = maxTempFileSnapshotLength;
return(options);
}
/// <summary>
/// Set policy whether open files is allowed or not.
///
/// If open files is allowed, then <see cref="IPackageFileProvider"/> can keep open files
/// and keep them open for prolonged time.
///
/// If the policy is disallowed, then the <see cref="IPackageFileProvider"/> will open files
/// only to make snapshot copies of them.
/// </summary>
/// <param name="options"></param>
/// <param name="allowOpenFiles"></param>
/// <returns></returns>
public static IPackageFileProviderOptions SetAllowOpenFiles(this IPackageFileProviderOptions options, bool allowOpenFiles)
{
options.AllowOpenFiles = allowOpenFiles;
return(options);
}
/// <summary> /// Add package loaders. /// </summary> /// <param name="options"></param> /// <param name="loaders"></param> /// <returns></returns> public static IPackageFileProviderOptions AddPackageLoaders(this IPackageFileProviderOptions options, IEnumerable <IPackageLoader> loaders) => options.SetPackageLoaders(options.PackageLoaders.Concat(loaders).ToArray());
/// <summary> /// Add package loaders. /// </summary> /// <param name="options"></param> /// <param name="loaders"></param> /// <returns></returns> public static IPackageFileProviderOptions AddPackageLoaders(this IPackageFileProviderOptions options, params IPackageLoader[] loaders) => options.SetPackageLoaders(options.PackageLoaders.Concat(loaders).ToArray());
/// <summary> /// Add package loader. /// </summary> /// <param name="options"></param> /// <param name="loader"></param> /// <returns></returns> public static IPackageFileProviderOptions AddPackageLoader(this IPackageFileProviderOptions options, IPackageLoader loader) => options.SetPackageLoaders(options.PackageLoaders.Concat(Enumerable.Repeat(loader, 1).ToArray()));
/// <summary>
/// Assign new set of package loaders.
///
/// <param name="options"></param>
/// <param name="packageLoaders"></param>
/// </summary>
/// <returns>file provider</returns>
public static IPackageFileProviderOptions SetPackageLoaders(this IPackageFileProviderOptions options, IEnumerable <IPackageLoader> packageLoaders)
{
options.PackageLoaders = packageLoaders;
return(options);
}
/// <summary> /// Configure file provider to let package loading errors be thrown. /// </summary> /// <param name="options"></param> /// <returns></returns> public static IPackageFileProviderOptions SetToThrowErrors(this IPackageFileProviderOptions options) => options.SetErrorHandler(throw_errors);
/// <summary> /// Configure package file provider to suppress package loading errors. /// When package loading fails and error is suppressed, then the file is treated as it is normal non-package file. /// </summary> /// <param name="options"></param> /// <returns></returns> public static IPackageFileProviderOptions SetToSuppressErrors(this IPackageFileProviderOptions options) => options.SetErrorHandler(suppress_errors);
/// <summary>
/// Assign package loading error handler. Logging can be added here.
///
/// Set this delegate to null to let exception be thrown to caller.
/// Usually when handling <see cref="IFileInfo"/> or <see cref="IDirectoryContents"/>.
///
/// If delegate returns true, then the exception is suppressed and the
/// package is handled as a regular file and not opened.
/// </summary>
/// <param name="options"></param>
/// <param name="errorHandler"></param>
/// <returns></returns>
public static IPackageFileProviderOptions SetErrorHandler(this IPackageFileProviderOptions options, Func <PackageEvent, bool> errorHandler)
{
options.ErrorHandler = errorHandler;
return(options);
}
