/// <summary>
/// <para>Initializes a new instance of the <see cref="OperationExecutor" /> class.</para>
/// <para>The arguments supported by <paramref name="args" /> are:</para>
/// <para><c>targetName</c>--The assembly name of the target project.</para>
/// <para><c>startupTargetName</c>--The assembly name of the startup project.</para>
/// <para><c>projectDir</c>--The target project's root directory.</para>
/// <para><c>rootNamespace</c>--The target project's root namespace.</para>
/// </summary>
/// <param name="reportHandler"> The <see cref="IOperationReportHandler" />. </param>
/// <param name="args"> The executor arguments. </param>
public OperationExecutor([NotNull] object reportHandler, [NotNull] IDictionary args)
{
Check.NotNull(reportHandler, nameof(reportHandler));
Check.NotNull(args, nameof(args));
var unwrappedReportHandler = ForwardingProxy.Unwrap <IOperationReportHandler>(reportHandler);
_reporter = new OperationReporter(unwrappedReportHandler);
_targetName = (string)args["targetName"];
_startupTargetName = (string)args["startupTargetName"];
_projectDir = (string)args["projectDir"];
_rootNamespace = (string)args["rootNamespace"];
_language = (string)args["language"];
// TODO: Flow in from tools (issue #8332)
_designArgs = Array.Empty <string>();
var toolsVersion = (string)args["toolsVersion"];
var runtimeVersion = ProductInfo.GetVersion();
if (toolsVersion != null &&
new SemanticVersionComparer().Compare(toolsVersion, runtimeVersion) < 0)
{
_reporter.WriteWarning(DesignStrings.VersionMismatch(toolsVersion, runtimeVersion));
}
}
public static ScaffoldedModel ScaffoldContext(
[NotNull] string provider,
[NotNull] string connectionString,
[CanBeNull] string outputDir,
[CanBeNull] string outputContextDir,
[CanBeNull] string dbContextClassName,
[NotNull] IEnumerable <string> schemas,
[NotNull] IEnumerable <string> tables,
bool useDataAnnotations,
bool overwriteFiles,
bool useDatabaseNames)
{
var unwrappedReportHandler = ForwardingProxy.Unwrap <IOperationReportHandler>(new OperationReportHandler());
var reporter = new OperationReporter(unwrappedReportHandler);
var _servicesBuilder = new DesignTimeServicesBuilder(Assembly.GetExecutingAssembly(), reporter, Array.Empty <string>());
var services = _servicesBuilder.Build(provider);
var scaffolder = services.GetRequiredService <IReverseEngineerScaffolder>();
var @namespace = "DiplomWork";
var scaffoldedModel = scaffolder.ScaffoldModel(
connectionString,
tables,
schemas,
@namespace,
null,
MakeDirRelative(outputDir, outputContextDir),
dbContextClassName,
new ModelReverseEngineerOptions {
UseDatabaseNames = useDatabaseNames
},
new ModelCodeGenerationOptions {
UseDataAnnotations = useDataAnnotations
});
return(scaffoldedModel);
}
public void Invoke_forwards_messages_to_target()
{
var domain = AppDomain.CreateDomain("ForwardingProxyTests", null, AppDomain.CurrentDomain.SetupInformation);
try
{
var target = domain.CreateInstanceAndUnwrap(
typeof(DummyType).Assembly().FullName,
typeof(DummyType).FullName,
false,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance,
null,
new[] { "Value1" },
null,
null);
var forwardingProxy = new ForwardingProxy<DummyType>(target);
var proxy = forwardingProxy.GetTransparentProxy();
Assert.NotEqual(target, proxy);
Assert.Equal("Value1", proxy.GetValue());
}
finally
{
AppDomain.Unload(domain);
}
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="OperationExecutor" /> class.</para>
/// <para>The arguments supported by <paramref name="args" /> are:</para>
/// <para><c>targetName</c>--The assembly name of the target project.</para>
/// <para><c>startupTargetName</c>--The assembly name of the startup project.</para>
/// <para><c>projectDir</c>--The target project's root directory.</para>
/// <para><c>rootNamespace</c>--The target project's root namespace.</para>
/// </summary>
/// <param name="reportHandler"> The <see cref="IOperationReportHandler" />. </param>
/// <param name="args"> The executor arguments. </param>
public OperationExecutor([NotNull] object reportHandler, [NotNull] IDictionary args)
{
Check.NotNull(reportHandler, nameof(reportHandler));
Check.NotNull(args, nameof(args));
var unwrappedReportHandler = ForwardingProxy.Unwrap <IOperationReportHandler>(reportHandler);
var reporter = new OperationReporter(unwrappedReportHandler);
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
_projectDir = (string)args["projectDir"];
var rootNamespace = (string)args["rootNamespace"];
var language = (string)args["language"];
// TODO: Flow in from tools (issue #8332)
var designArgs = Array.Empty <string>();
// NOTE: LazyRef is used so any exceptions get passed to the resultHandler
var startupAssembly = new LazyRef <Assembly>(
() => Assembly.Load(new AssemblyName(startupTargetName)));
var assembly = new LazyRef <Assembly>(
() =>
{
try
{
return(Assembly.Load(new AssemblyName(targetName)));
}
catch (Exception ex)
{
throw new OperationException(
DesignStrings.UnreferencedAssembly(targetName, startupTargetName),
ex);
}
});
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
reporter,
assembly.Value,
startupAssembly.Value,
designArgs));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
reporter,
startupAssembly.Value,
_projectDir,
rootNamespace,
language,
designArgs));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
reporter,
assembly.Value,
startupAssembly.Value,
_projectDir,
rootNamespace,
language,
designArgs));
}
public OperationExecutor([NotNull] object logHandler, [NotNull] IDictionary args)
{
Check.NotNull(logHandler, nameof(logHandler));
Check.NotNull(args, nameof(args));
var unwrappedLogHandler = ForwardingProxy.Unwrap <IOperationLogHandler>(logHandler);
var loggerProvider = new LoggerProvider(name => new CommandLoggerAdapter(name, unwrappedLogHandler));
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
var projectDir = (string)args["projectDir"];
var rootNamespace = (string)args["rootNamespace"];
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
loggerProvider,
targetName,
startupTargetName));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
loggerProvider,
targetName,
startupTargetName,
projectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
loggerProvider,
targetName,
startupTargetName,
projectDir,
rootNamespace));
}
public OperationExecutor([NotNull] object reportHandler, [NotNull] IDictionary args)
{
Check.NotNull(reportHandler, nameof(reportHandler));
Check.NotNull(args, nameof(args));
var unwrappedReportHandler = ForwardingProxy.Unwrap <IOperationReportHandler>(reportHandler);
var reporter = new OperationReporter(unwrappedReportHandler);
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
var environment = (string)args["environment"];
_projectDir = (string)args["projectDir"];
var contentRootPath = (string)args["contentRootPath"];
var rootNamespace = (string)args["rootNamespace"];
// NOTE: LazyRef is used so any exceptions get passed to the resultHandler
var startupAssembly = new LazyRef <Assembly>(
() => Assembly.Load(new AssemblyName(startupTargetName)));
var assembly = new LazyRef <Assembly>(
() =>
{
try
{
return(Assembly.Load(new AssemblyName(targetName)));
}
catch (Exception ex)
{
throw new OperationException(
DesignStrings.UnreferencedAssembly(targetName, startupTargetName),
ex);
}
});
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
reporter,
assembly.Value,
startupAssembly.Value,
environment,
contentRootPath));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
reporter,
startupAssembly.Value,
environment,
_projectDir,
contentRootPath,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
reporter,
assembly.Value,
startupAssembly.Value,
environment,
_projectDir,
contentRootPath,
rootNamespace));
}
public OperationExecutor([NotNull] object logHandler, [NotNull] IDictionary args)
{
Check.NotNull(logHandler, nameof(logHandler));
Check.NotNull(args, nameof(args));
var unwrappedLogHandler = ForwardingProxy.Unwrap <IOperationLogHandler>(logHandler);
var loggerProvider = new LoggerProvider(name => new CommandLoggerAdapter(name, unwrappedLogHandler));
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
var environment = (string)args["environment"];
var projectDir = (string)args["projectDir"];
var rootNamespace = (string)args["rootNamespace"];
var startupAssembly = Assembly.Load(new AssemblyName(startupTargetName));
Assembly assembly;
try
{
assembly = Assembly.Load(new AssemblyName(targetName));
}
catch (Exception ex)
{
throw new OperationException(CommandsStrings.UnreferencedAssembly(targetName, startupTargetName), ex);
}
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
loggerProvider,
assembly,
startupAssembly,
projectDir, environment));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
loggerProvider,
assembly,
startupAssembly,
environment,
projectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
loggerProvider,
assembly,
startupAssembly,
environment,
projectDir,
rootNamespace));
}
public void Forwards_to_instances_of_a_different_type()
{
using (var directory = new TempDirectory())
{
var source = new BuildSource
{
TargetDir = directory.Path,
Sources = { @"
using System;
namespace Microsoft.EntityFrameworkCore.Design.Internal
{
// NOTE: This interface will have a different identity than the one above
internal interface IMagic
{
int Number { get; }
}
internal class Magic : MarshalByRefObject, IMagic
{
public int Number
{
get { return 7; }
}
}
}" }
};
var build = source.Build();
var domain = AppDomain.CreateDomain(
"ForwardingProxyTest",
null,
new AppDomainSetup { ApplicationBase = build.TargetDir });
try
{
var target = domain.CreateInstanceAndUnwrap(
build.TargetName,
"Microsoft.EntityFrameworkCore.Design.Internal.Magic");
var forwardingProxy = new ForwardingProxy<IMagic>(target);
var transparentProxy = forwardingProxy.GetTransparentProxy();
Assert.Equal(7, transparentProxy.Number);
}
finally
{
AppDomain.Unload(domain);
}
}
}
protected OperationBase([NotNull] object resultHandler)
{
Check.NotNull(resultHandler, nameof(resultHandler));
_resultHandler = ForwardingProxy.Unwrap <IOperationResultHandler>(resultHandler);
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="OperationExecutor" /> class.</para>
/// <para>The arguments supported by <paramref name="args" /> are:</para>
/// <para><c>targetName</c>--The assembly name of the target project.</para>
/// <para><c>startupTargetName</c>--The assembly name of the startup project.</para>
/// <para><c>projectDir</c>--The target project's root directory.</para>
/// <para><c>rootNamespace</c>--The target project's root namespace.</para>
/// </summary>
/// <param name="reportHandler"> The <see cref="IOperationReportHandler" />. </param>
/// <param name="args"> The executor arguments. </param>
public OperationExecutor([NotNull] object reportHandler, [NotNull] IDictionary args)
{
Check.NotNull(reportHandler, nameof(reportHandler));
Check.NotNull(args, nameof(args));
var unwrappedReportHandler = ForwardingProxy.Unwrap <IOperationReportHandler>(reportHandler);
var reporter = new OperationReporter(unwrappedReportHandler);
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
_projectDir = (string)args["projectDir"];
var rootNamespace = (string)args["rootNamespace"];
var language = (string)args["language"];
var toolsVersion = (string)args["toolsVersion"];
// TODO: Flow in from tools (issue #8332)
var designArgs = Array.Empty <string>();
var runtimeVersion = ProductInfo.GetVersion();
if (toolsVersion != null &&
new SemanticVersionComparer().Compare(RemovePatch(toolsVersion), RemovePatch(runtimeVersion)) < 0)
{
reporter.WriteWarning(DesignStrings.VersionMismatch(toolsVersion, runtimeVersion));
}
// NOTE: LazyRef is used so any exceptions get passed to the resultHandler
var startupAssembly = new LazyRef <Assembly>(
() => Assembly.Load(new AssemblyName(startupTargetName)));
var assembly = new LazyRef <Assembly>(
() =>
{
try
{
return(Assembly.Load(new AssemblyName(targetName)));
}
catch (Exception ex)
{
throw new OperationException(
DesignStrings.UnreferencedAssembly(targetName, startupTargetName),
ex);
}
});
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
reporter,
assembly.Value,
startupAssembly.Value,
designArgs));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
reporter,
assembly.Value,
startupAssembly.Value,
_projectDir,
rootNamespace,
language,
designArgs));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
reporter,
assembly.Value,
startupAssembly.Value,
_projectDir,
rootNamespace,
language,
designArgs));
string RemovePatch(string versionString)
{
var prereleaseIndex = versionString.IndexOf("-", StringComparison.Ordinal);
if (prereleaseIndex != -1)
{
versionString = versionString.Substring(0, prereleaseIndex);
}
var version = new Version(versionString);
return(new Version(version.Major, version.Minor).ToString());
}
}
public OperationExecutor([NotNull] object logHandler, [NotNull] IDictionary args, [NotNull] AssemblyLoader assemblyLoader)
{
Check.NotNull(logHandler, nameof(logHandler));
Check.NotNull(args, nameof(args));
Check.NotNull(assemblyLoader, nameof(assemblyLoader));
var unwrappedLogHandler = ForwardingProxy.Unwrap <IOperationLogHandler>(logHandler);
var loggerProvider = new LoggerProvider(name => new CommandLoggerAdapter(name, unwrappedLogHandler));
var targetName = (string)args["targetName"];
var startupTargetName = (string)args["startupTargetName"];
var environment = (string)args["environment"];
_projectDir = (string)args["projectDir"];
var startupProjectDir = (string)args["startupProjectDir"];
var rootNamespace = (string)args["rootNamespace"];
// NOTE: LazyRef is used so any exceptions get passed to the resultHandler
var startupAssembly = new LazyRef <Assembly>(
() => assemblyLoader.Load(startupTargetName));
var assembly = new LazyRef <Assembly>(
() =>
{
try
{
return(assemblyLoader.Load(targetName));
}
catch (Exception ex)
{
throw new OperationException(
ToolsCoreStrings.UnreferencedAssembly(targetName, startupTargetName),
ex);
}
});
_contextOperations = new LazyRef <DbContextOperations>(
() => new DbContextOperations(
loggerProvider,
assembly.Value,
startupAssembly.Value,
environment,
startupProjectDir));
_databaseOperations = new LazyRef <DatabaseOperations>(
() => new DatabaseOperations(
loggerProvider,
assemblyLoader,
startupAssembly.Value,
environment,
_projectDir,
startupProjectDir,
rootNamespace));
_migrationsOperations = new LazyRef <MigrationsOperations>(
() => new MigrationsOperations(
loggerProvider,
assembly.Value,
assemblyLoader,
startupAssembly.Value,
environment,
_projectDir,
startupProjectDir,
rootNamespace));
}
public void Invoke_can_forward_messages_to_unrelated_types()
{
using (var compiler = new CSharpCodeProvider())
{
var results = compiler.CompileAssemblyFromSource(new CompilerParameters(), Source);
if (results.Errors.HasErrors)
{
Debug.Fail(results.Errors.Cast<CompilerError>().FirstOrDefault(e => !e.IsWarning).ToString());
}
var domain = AppDomain.CreateDomain(
"ForwardingProxyTests",
null,
new AppDomainSetup { ApplicationBase = Path.GetDirectoryName(results.PathToAssembly) });
try
{
var target = domain.CreateInstanceAndUnwrap(
results.CompiledAssembly.FullName,
typeof(LooseDummyType).FullName);
var forwardingProxy = new ForwardingProxy<LooseDummyType>(target);
var proxy = forwardingProxy.GetTransparentProxy();
Assert.Equal("FromRemote", proxy.GetValue());
}
finally
{
AppDomain.Unload(domain);
}
}
}
