/// <summary>
/// Registers the model projectors.
/// </summary>
/// <param name="services">The services.</param>
public static void RegisterModelMappers(this IServiceCollection services)
{
services.AddSingleton <IMapperCatalog>((provider) =>
{
var logger = provider.GetService <ILoggerFactory>();
var service = new MapperCatalog(logger);
service.AddMapperFactory(new DefaultMapperFactory());
// register mappers from Assemblies for registration (it includes current Assembly)
AssemblyRegistration.RegisterMappers(assembliesForRegistrations, logger.CreateLogger("Information"), service);
return(service);
});
}
/// <summary>
/// Registers the wrappers.
/// </summary>
/// <param name="services">The services.</param>
public static void RegisterWrappers(this IServiceCollection services)
{
services.AddSingleton <IObservableWrapperCatalog>(
(provider) =>
{
var catalog = new ObservableWrapperCatalog();
// register wrappers from referenced Assemblies
AssemblyRegistration.RegisterWrappers(assembliesForRegistrations, catalog);
// assembliesForRegistrations is not longer required, so is cleared out.
assembliesForRegistrations.Clear();
assembliesForRegistrations = null;
return(catalog);
});
}
public Login(DTE2 dte)
{
Assembly.Load("Xceed.Wpf.Toolkit");
InitializeComponent();
var main = dte.GetMainWindow();
Owner = main;
//Loaded += delegate { this.CenterWindow(main); };
assemblyRegistration = new AssemblyRegistration();
RegisterEvents();
settingsArray = Configuration.LoadConfigs();
}
/// <summary>
/// Read generic model from file.
/// </summary>
/// <typeparam name="TInput">Type for incoming data</typeparam>
/// <typeparam name="TOutput">Type for output data</typeparam>
/// <param name="stream">Stream with model</param>
/// <returns>Model</returns>
public static Task <PredictionModel <TInput, TOutput> > ReadAsync <TInput, TOutput>(Stream stream)
where TInput : class
where TOutput : class, new()
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
var environment = new MLContext();
AssemblyRegistration.RegisterAssemblies(environment);
BatchPredictionEngine <TInput, TOutput> predictor =
environment.CreateBatchPredictionEngine <TInput, TOutput>(stream);
return(Task.FromResult(new PredictionModel <TInput, TOutput>(predictor, stream)));
}
internal PredictionModel(Stream stream)
{
_env = new MLContext();
AssemblyRegistration.RegisterAssemblies(_env);
PredictorModel = new TransformModel(_env, stream);
}
public static RegisteredAssemblyItem RegisterAssembly(Assembly assembly, string registerTypeNamesWithIncludedAssemblyName)
{
lock ( registeredAssemblies )
{
RegisteredAssemblyItem item2 = GetRegisteredAssembly(assembly);
if (item2 != null)
{
return(item2);
}
if (disableAssemblyRegistration == null)
{
ParseDisableAssemblyNamespaceRegistration();
}
RegisteredAssemblyItem item = new RegisteredAssemblyItem();
item.assembly = assembly;
item.registerTypeNamesWithIncludedAssemblyName = registerTypeNamesWithIncludedAssemblyName;
registeredAssemblies.Add(assembly, item);
string name = assembly.GetName().Name;
if (name.EndsWith(".STUB"))
{
name = name.Replace(".STUB", "");
}
bool enabled = !disableAssemblyRegistration.Contains(name);
Log.InvisibleInfo("Register assembly: {0}{1}", (enabled ? "" : "[DISABLED] "), assembly.FullName);
//Log.InvisibleInfo( "AssemblyUtils: RegisterAssembly: {0} {1}", ( enabled ? "" : "[DISABLED]" ), assembly.FullName );
//Log.InvisibleInfo( "AssemblyUtils: RegisterAssembly: [{0}] {1}", ( enabled ? "ENABLED" : "DISABLED" ), assembly.FullName );
if (enabled)
{
StartupTiming.CounterStart("Register assembly \'" + name + "\'");
try
{
var types = assembly.GetExportedTypes();
//optimization
var isBaseNetAssembly = assembly == typeof(string).Assembly || assembly == typeof(Uri).Assembly;
MetadataManager.RegisterTypesOfAssembly(assembly, types);
if (!isBaseNetAssembly)
{
//Android: 8 seconds.
MetadataManager.RegisterAutoConvertItemsForAssembly(assembly, types);
MetadataManager.RegisterExtensions(assembly, types);
//invoke AssemblyRegistration classes
foreach (Type type in types)
{
if (!type.IsAbstract && typeof(AssemblyRegistration).IsAssignableFrom(type))
{
ConstructorInfo constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null, new Type[0] {
}, null);
AssemblyRegistration ins = (AssemblyRegistration)constructor.Invoke(new object[0]);
item.registrationObjects.Add(ins);
ins.OnRegister();
}
}
}
if (EngineApp.ApplicationType == EngineApp.ApplicationTypeEnum.Editor)
{
EditorUtility.RegisterEditorExtensions(assembly);
ResourcesWindowItems.RegisterAssembly(assembly);
}
RegisterAssemblyEvent?.Invoke(assembly);
}
catch (Exception e)
{
Log.Error("Unable to register assembly \'" + name + "\'. " + e.Message);
}
finally
{
StartupTiming.CounterEnd("Register assembly \'" + name + "\'");
}
}
return(item);
}
}
