public void ShouldBeAbleToGetGeneratedDtoAssembly()
{
string curDir = Environment.CurrentDirectory;
string newDir = Path.Combine(curDir, string.Format("{0}_{1}"._Format(MethodBase.GetCurrentMethod().Name, 4.RandomLetters())));
if (!Directory.Exists(newDir))
{
Directory.CreateDirectory(newDir);
}
Environment.CurrentDirectory = newDir;
Assembly assembly = typeof(MainObject).Assembly;
string pocoAssembly = Dto.GetDefaultFileName(assembly);
if (File.Exists(pocoAssembly))
{
File.Delete(pocoAssembly);
}
// Do it thrice to ensure testing of multiple execution paths within implementation
GeneratedAssemblyInfo assemblyInfo = Dto.GetGeneratedDtoAssemblyInfo(typeof(MainObject).Assembly);
assemblyInfo = Dto.GetGeneratedDtoAssemblyInfo(typeof(MainObject).Assembly);
assemblyInfo = Dto.GetGeneratedDtoAssemblyInfo(typeof(MainObject).Assembly);
Environment.CurrentDirectory = curDir;
}
public GeneratedAssemblyInfo GetAssemblyInfo()
{
FileName = "{0}Dao"._Format(Schema.Name);
string fileName = Path.GetFileNameWithoutExtension(FileName);
FilePath = Path.Combine(Workspace, "{0}.dll");
return(GeneratedAssemblyInfo.GetGeneratedAssembly(FilePath, this));
}
public GeneratedAssemblyInfo GenerateAssembly()
{
string sourcePath = Path.Combine(Workspace, "src");
GenerateSource(sourcePath);
GeneratedAssemblyInfo result = Compile(sourcePath);
return(result);
}
public void Dispose()
{
if (TargetAssemblyInfo != null)
{
TargetAssemblyInfo.AssemblyRawData = null;
TargetAssemblyInfo.AssemblyTypes = null;
TargetAssemblyInfo.TargetAssembly = null;
TargetAssemblyInfo = null;
}
}
public static GeneratedAssemblyInfo LoadPocoLibrary(byte[] classLibData)
{
GeneratedAssemblyInfo aInfo = new GeneratedAssemblyInfo();
aInfo.AssemblyRawData = classLibData;
aInfo.TargetAssembly = Assembly.Load(aInfo.AssemblyRawData);
aInfo.AssemblyTypes = LoadPocoLibrary(aInfo.TargetAssembly);
return(aInfo);
}
/// <summary>
/// Generates an assembly containing Dto's that represent all the
/// Dao's found in the sepecified daoAssembly. A Dto or (DTO) is
/// a Data Transfer Object and represents only the properties of
/// a Dao. A Dao or (DAO) is a Data Access Object that represents
/// both properties and methods to create, retrieve, update and delete.
/// </summary>
/// <param name="daoAssembly"></param>
/// <returns></returns>
public static GeneratedAssemblyInfo GetGeneratedDtoAssemblyInfo(Assembly daoAssembly, string fileName = null)
{
lock (_genLock)
{
DaoToDtoGenerator generator;
string defaultFileName = GetDefaultFileName(daoAssembly, out generator);
fileName = fileName ?? defaultFileName;
GeneratedAssemblyInfo assemblyInfo = GeneratedAssemblyInfo.GetGeneratedAssembly(fileName, generator);
return(assemblyInfo);
}
}
public GeneratedAssemblyInfo GenerateAssembly()
{
CompilerResults results;
string fileName = $"{WrapperNamespace}.Wrapper.dll";
new DirectoryInfo(WriteSourceTo).ToAssembly(fileName, out results);
GeneratedAssemblyInfo result = new GeneratedAssemblyInfo(fileName, results);
result.Save();
return(result);
}
private void GenerateAssembly(DaoAssemblyGenerator generator, DirectoryInfo srcDir, out string dest)
{
GeneratedAssemblyInfo assembly = generator.Compile(srcDir.FullName, "{0}.dll"._Format(Namespace));
FileInfo assemblyFile = assembly.GetAssembly().GetFileInfo();
dest = Path.Combine(this.WorkspaceFolder, "bin", assemblyFile.Name);
DirectoryInfo destDir = new DirectoryInfo(Path.Combine(this.WorkspaceFolder, "bin"));
if (!destDir.Exists)
{
Directory.CreateDirectory(destDir.FullName);
}
assemblyFile.CopyTo(dest);
}
public GeneratedAssemblyInfo GenerateDtoAssembly(string nameSpace, string fileName)
{
Type oneDao = DaoAssembly.GetTypes().FirstOrDefault(t => t.HasCustomAttributeOfType <TableAttribute>());
string writeSourceTo = Path.Combine(RuntimeSettings.AppDataFolder, "DtoTemp_{0}"._Format(Dao.ConnectionName(oneDao)));
DirectoryInfo sourceDir = SetSourceDir(writeSourceTo);
WriteDtoSource(nameSpace, writeSourceTo);
sourceDir.ToAssembly(fileName, out CompilerResults results);
GeneratedAssemblyInfo result = new GeneratedAssemblyInfo(fileName, results);
result.Save();
return(result);
}
public GeneratedAssemblyInfo Compile(string sourcePath, string fileName = null)
{
fileName = fileName ?? FileName;
CompilerResults compileResult = AdHocCSharpCompiler.CompileDirectory(new DirectoryInfo(sourcePath), fileName, ReferenceAssemblyPaths, false);
if (compileResult.Errors.Count > 0)
{
throw new CompilationException(compileResult);
}
GeneratedAssemblyInfo result = new GeneratedAssemblyInfo(FilePath, compileResult);
result.Save();
return(result);
}
public GeneratedAssemblyInfo GenerateAssembly()
{
Args.ThrowIfNullOrEmpty(AssemblyName, nameof(AssemblyName));
GeneratedAssemblyInfo result = null;
AutoResetEvent wait = new AutoResetEvent(false);
GenerateCsFiles(Types, (o, a) =>
{
CompilerResults compilerResults = AdHocCSharpCompiler.CompileDirectory(new DirectoryInfo(CsFileDirectory), AssemblyName, new Assembly[] { typeof(IMessage).Assembly });
result = new GeneratedAssemblyInfo(AssemblyName, compilerResults);
wait.Set();
});
wait.WaitOne();
return(result);
}
public GeneratedAssemblyInfo GenerateAssembly()
{
OnAssemblyGenerating(new ProxyAssemblyGenerationEventArgs {
ServiceType = ServiceType, ServiceSettings = ServiceSettings
});
ProxyModel proxyModel = RenderCode();
CompilerResults compileResult = AdHocCSharpCompiler.CompileSource(Code.ToString(), FileName, proxyModel.ReferenceAssemblies);
if (compileResult.Errors.Count > 0)
{
throw new CompilationException(compileResult);
}
GeneratedAssemblyInfo result = new GeneratedAssemblyInfo(FileName, compileResult);
result.Save();
OnAssemblyGenerated(new ProxyAssemblyGenerationEventArgs {
ServiceType = ServiceType, ServiceSettings = ServiceSettings
});
return(result);
}
public GeneratedAssemblyInfo GenerateAssembly()
{
if (_generatedAssemblyInfos.ContainsKey(ServiceType))
{
return(_generatedAssemblyInfos[ServiceType]);
}
ProxyAssemblyGeneratorService genSvc = ProxyAssemblyGeneratorService.Default;
ServiceResponse response = genSvc.GetBase64ProxyAssembly(ServiceType.Namespace, ServiceType.Name);
if (!response.Success)
{
throw new ApplicationException(response.Message);
}
// write bytes to temp
byte[] assembly = response.Data.ToString().FromBase64();
string path = Path.Combine(SystemPaths.Current.Generated, $"{ServiceType.Name}_{ServiceSettings.Protocol}_{ServiceSettings.Host}_{ServiceSettings.Port}_proxy.dll");
File.WriteAllBytes(path, assembly);
// load the assembly from the file
GeneratedAssemblyInfo info = new GeneratedAssemblyInfo(Assembly.LoadFile(path));
_generatedAssemblyInfos[ServiceType] = info;
return(info);
}
public void Init(GeneratedAssemblyInfo targetAssemblyInfo)
{
TargetAssemblyInfo = targetAssemblyInfo;
}
public GeneratedAssemblyInfo GetAssembly()
{
return(GeneratedAssemblyInfo.GetGeneratedAssembly(FileName, this));
}
public Assembly GetGeneratedAssembly()
{
return(GeneratedAssemblyInfo.GetGeneratedAssembly(InfoFileName, this).Assembly);
}
public GenerateDaoAssemblyEventArgs(GeneratedAssemblyInfo generatedAssemblyInfo)
{
this.GeneratedAssemblyInfo = generatedAssemblyInfo;
}
public Assembly GetAssembly()
{
return(GeneratedAssemblyInfo.GetGeneratedAssembly(AssemblyName, this));
}
/// <summary>
/// Get the associated Dto types for the
/// Dao types in the specified daoAssembly.
/// </summary>
/// <param name="daoAssembly"></param>
/// <returns></returns>
public static Type[] GetTypesFromDaos(Assembly daoAssembly)
{
GeneratedAssemblyInfo assemblyInfo = GetGeneratedDtoAssemblyInfo(daoAssembly);
return(assemblyInfo.GetAssembly().GetTypes());
}
