public void SetUp()
{
_name = "TestValue1966998320";
_version = new Version();
_location = "TestValue1955409253";
_testClass = new ReferencedAssembly(_name, _version, _location);
}
/// <summary>
/// 安装
/// </summary>
/// <returns></returns>
public Plugin Install()
{
if (InitType == null)
{
throw new Exception($"插件【{PluginName} {ID}】未设置初始化类型");
}
if (InitMethod == null)
{
throw new Exception($"插件【{PluginName} {ID}】未设置初始化方法");
}
var method = InitType.GetMethod(InitMethod);
if (method == null)
{
throw new Exception($"插件【{PluginName} {ID}】 初始化类型【{InitType}】不包含初始化方法【{InitMethod}】");
}
try
{
var obj = ReferencedAssembly.CreateInstance(InitType.FullName);
method.Invoke(obj, null);
}catch (Exception ex)
{
throw new Exception($"安装插件【{PluginName} {ID}】失败，失败原因：", ex);
}
Installed = true;
return(this);
}
private ReferencedAssembly LoadReferencedAssembly(AssemblyName reference, out AssemblyName[] referencedAssemblyReferences)
{
referencedAssemblyReferences = null;
ReferencedAssembly referencedAssembly;
try
{
var files = Directory.GetFiles(_workingDirectory, reference.Name + ".???", SearchOption.TopDirectoryOnly);
var file = files.FirstOrDefault(x => x.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || x.EndsWith(".exe", StringComparison.OrdinalIgnoreCase));
if (file != null)
{
referencedAssemblyReferences = Assembly.ReflectionOnlyLoadFrom(file).GetReferencedAssemblies();
//reload the assembly name from the file (reason: the assembly name taken from the assembly loaded by the reflection only load is not complete)
reference = AssemblyName.GetAssemblyName(file);
}
else
{
referencedAssemblyReferences = Assembly.ReflectionOnlyLoad(reference.FullName).GetReferencedAssemblies();
}
referencedAssembly = new ReferencedAssembly(reference);
}
catch (Exception e)
{
referencedAssembly = new ReferencedAssembly(reference, e);
}
if (!_cache.ContainsKey(reference.FullName))
{
_cache.Add(reference.FullName, referencedAssembly);
}
return(referencedAssembly);
}
private ReferencedAssembly LoadEntryPoint(string filePath, out AssemblyName[] assemblyReferences)
{
assemblyReferences = Assembly.ReflectionOnlyLoadFrom(filePath).GetReferencedAssemblies();
var assembly = AssemblyName.GetAssemblyName(filePath);
var referencedAssembly = new ReferencedAssembly(assembly)
{
Category = Category.EntryPoint,
};
_cache.Add(assembly.FullName, referencedAssembly);
return(referencedAssembly);
}
private ReferencedAssembly LoadReferencedAssembly(AssemblyName reference, out AssemblyName[] referencedAssemblyReferences)
{
referencedAssemblyReferences = null;
ReferencedAssembly referencedAssembly;
try
{
string file = null;
foreach (var dir in _searchDirectories)
{
var files = Directory.GetFiles(dir, reference.Name + ".???", SearchOption.TopDirectoryOnly);
file = files.FirstOrDefault(x => x.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || x.EndsWith(".exe", StringComparison.OrdinalIgnoreCase));
if (file != null)
{
break;
}
}
if (file != null)
{
referencedAssemblyReferences = Assembly.ReflectionOnlyLoadFrom(file).GetReferencedAssemblies();
//read additional information from file as the assembly name loaded by the ReflectionOnly load is not complete.
var temp = AssemblyName.GetAssemblyName(file);
if (temp.FullName == reference.FullName)
{
reference.ProcessorArchitecture = temp.ProcessorArchitecture;
}
}
else
{
referencedAssemblyReferences = Assembly.ReflectionOnlyLoad(reference.FullName).GetReferencedAssemblies();
}
referencedAssembly = new ReferencedAssembly(reference);
}
catch (Exception e)
{
referencedAssembly = new ReferencedAssembly(reference, e);
}
if (!_cache.ContainsKey(reference.FullName))
{
_cache.Add(reference.FullName, referencedAssembly);
}
return(referencedAssembly);
}
private string BuildComment(ReferencedAssembly referencedAssembly)
{
var comment = new StringBuilder();
if (referencedAssembly.LoadingError != null)
{
comment.AppendLine($"Error message: {referencedAssembly.LoadingError.Message}");
comment.AppendLine($"Error type: {referencedAssembly.LoadingError.GetType().Name}.");
}
if (referencedAssembly.PossibleLoadingErrorCauses != null && referencedAssembly.PossibleLoadingErrorCauses.Any())
{
comment.AppendLine($"Details: {string.Join("; ", referencedAssembly.PossibleLoadingErrorCauses)}");
}
return(comment.ToString());
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("Could not load referenced assembly:");
sb.Append(Environment.NewLine);
sb.Append(ReferencedAssembly.ToString());
sb.Append(Environment.NewLine);
sb.Append("from:");
sb.Append(Environment.NewLine);
sb.Append(CurrentAssembly);
sb.Append(Environment.NewLine);
sb.Append(Environment.NewLine);
sb.Append("Currently loaded assemblies:");
sb.Append(Environment.NewLine);
foreach (var cle in CurrentlyLoadedAssemblies)
{
sb.Append(cle.ToString());
sb.Append(Environment.NewLine);
}
return(sb.ToString());
}
private void ReadReferencesRecursively(ReferencedAssembly assembly, AssemblyName[] references)
{
foreach (var reference in references)
{
if (_skipSystemAssemblies
&&
(reference.Name == "mscorlib" ||
reference.Name == "System" ||
reference.Name.StartsWith("System."))
)
{
continue;
}
if (_cache.ContainsKey(reference.FullName))
{
_result.AddReference(assembly, _cache[reference.FullName]);
continue;
}
AssemblyName[] referencedAssemblyReferences;
var referencedAssembly = LoadReferencedAssembly(reference, out referencedAssemblyReferences);
if (referencedAssembly.Category != Category.Missed)
{
var isNewReference = _result.AddReference(assembly, referencedAssembly);
if (isNewReference)
{
ReadReferencesRecursively(referencedAssembly, referencedAssemblyReferences);
}
}
else
{
_result.AddReference(assembly, referencedAssembly);
}
}
}
public void CompileSite(string siteRoot, ReferencedAssembly[] references)
{
List<SourceFile> files = GetSourceFiles(siteRoot ?? defaultSiteRoot);
if (files.Count == 0)
return;
ApplyPreCompilationStepsOn(files);
string targetDirectory = Path.Combine(siteRoot, "Bin");
string targetTemporarySourceFilesDirectory = GetTargetTemporarySourceFilesDirectory(targetDirectory);
if (options.KeepTemporarySourceFiles)
{
DeleteFilesIn(targetTemporarySourceFilesDirectory);
foreach (SourceFile file in files)
SaveFile(file, targetTemporarySourceFilesDirectory);
if (options.AllowPartiallyTrustedCallers)
SaveAllowPartiallyTrustedCallersFileTo(targetTemporarySourceFilesDirectory);
}
if (!parameters.GenerateInMemory)
parameters.OutputAssembly = Path.Combine(targetDirectory, "CompiledViews.dll");
List<ReferencedAssembly> actualReferences = new List<ReferencedAssembly>();
if (options.References != null)
actualReferences.AddRange(options.References);
if (references != null)
actualReferences.AddRange(references);
foreach (ReferencedAssembly reference in actualReferences)
{
string assemblyName = reference.Name;
if (reference.Source == ReferencedAssembly.AssemblySource.BinDirectory)
assemblyName = Path.Combine(targetDirectory, assemblyName);
parameters.CompilerOptions += " /r:\"" + assemblyName + "\"";
}
CompilerResults results;
CodeDomProvider codeProvider;
try
{
codeProvider = CodeDomProvider.GetCompilerInfo("csharp").CreateProvider();
}
catch (SecurityException)
{
codeProvider = new CSharpCodeProvider();
}
catch (ConfigurationException)
{
codeProvider = new CSharpCodeProvider();
}
if (options.KeepTemporarySourceFiles)
{
results = codeProvider.CompileAssemblyFromFile(parameters, Directory.GetFiles(targetTemporarySourceFilesDirectory, String.Format("*{0}",AspViewCompiler.ViewSourceFileExtension), SearchOption.TopDirectoryOnly));
}
else
{
string[] sources = GetSourcesFrom(files);
results = codeProvider.CompileAssemblyFromSource(parameters, sources);
}
ThrowIfErrorsIn(results, files);
if (options.AutoRecompilation)
assembly = results.CompiledAssembly;
else
pathToAssembly = results.PathToAssembly;
}
public void CanGetLocatableName()
{
Assert.That(_testClass.LocatableName, Is.EqualTo(_name));
_testClass = new ReferencedAssembly("nunit.framework", new Version(3, 1), _location);
Assert.That(_testClass.LocatableName, Is.EqualTo("nunit.framework(3)"));
}
public void CanConstruct()
{
var instance = new ReferencedAssembly(_name, _version, _location);
Assert.That(instance, Is.Not.Null);
}
private bool HasCommentNode(ReferencedAssembly referencedAssembly)
{
return(referencedAssembly.LoadingError != null || referencedAssembly.PossibleLoadingErrorCauses.Any());
}
