/// <summary>
/// 存储程序集。
/// </summary>
/// <param name="descriptor">程序集描述符。</param>
/// <param name="fileName">程序集文件名称。</param>
public void StoreAssembly(AssemblyDescriptor descriptor, string fileName)
{
var path = PrecompiledAssemblyPath(descriptor);
Logger.Information("存储程序集 {0} 到程序集探测目录", descriptor.ToString());
_appDataFolder.StoreFile(fileName, path);
}
AssemblyDescriptor GetAssembly(string name)
{
if (name == null)
{
return(_defaultAssembly);
}
AssemblyDescriptor rv;
if (!AssemblyNameCache.TryGetValue(name, out rv))
{
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var match = loadedAssemblies.FirstOrDefault(a => a.GetName().Name == name);
if (match != null)
{
AssemblyNameCache[name] = rv = new AssemblyDescriptor(match);
}
else
{
// iOS does not support loading assemblies dynamically!
//
#if !__IOS__
AssemblyNameCache[name] = rv = new AssemblyDescriptor(Assembly.Load(name));
#endif
}
}
return(rv);
}
public void ProcessRuntimeDescriptorSaveTest()
{
AssemblyServiceRepository repo = GetAssemblyManagementRepository(GetConsoleLogger(), nameof(ProcessRuntimeDescriptorSaveTest));
repo.SetDaoNamespace <ProcessRuntimeDescriptor>();
repo.Database.TryEnsureSchema <Dao.AssemblyDescriptor>();
List <AssemblyDescriptor> descriptors = AssemblyDescriptor.GetCurrentAppDomainDescriptors().ToList();
ProcessRuntimeDescriptor current = ProcessRuntimeDescriptor.PersistCurrentToRepo(repo);
Expect.AreEqual(descriptors.Count, current.AssemblyDescriptors.Length, "Number of descriptors didn't match");
ProcessRuntimeDescriptor retrieved = repo.Retrieve <ProcessRuntimeDescriptor>(current.Id);
Expect.AreEqual(descriptors.Count, retrieved.AssemblyDescriptors.Length, "Number of retrieved descriptors didn't match");
foreach (AssemblyDescriptor descriptor in retrieved.AssemblyDescriptors)
{
AssemblyDescriptor retrievedDescriptor = repo.Retrieve <AssemblyDescriptor>(descriptor.Uuid);
OutLineFormat("Checking {0}", ConsoleColor.DarkBlue, retrievedDescriptor.AssemblyFullName);
AssemblyDescriptor actual = descriptors.FirstOrDefault(d =>
d.Name.Equals(retrievedDescriptor.Name) &&
d.FileHash.Equals(retrievedDescriptor.FileHash) &&
d.AssemblyFullName.Equals(retrievedDescriptor.AssemblyFullName)
);
Expect.AreEqual(actual.AssemblyReferenceDescriptors?.Count, retrievedDescriptor.AssemblyReferenceDescriptors?.Count);
OutLineFormat("ProcessRuntimeDescriptors count {0}", retrievedDescriptor.ProcessRuntimeDescriptors.Count);
}
}
/// <summary>
/// 存储程序集。
/// </summary>
/// <param name="moduleName">模块名称。</param>
public void StoreAssembly(string moduleName)
{
var descriptor = _extensionManager.GetExtension(moduleName);
if (descriptor == null)
{
return;
}
/* var paths = GetModuleAssemblyPaths(descriptor);
* if (paths == null)
* return;
*
* foreach (var item in paths)
* {
* var assembly = item.Key;
* var fileName = item.Value;
* StoreAssembly(assembly, _applicationFolder.MapPath(fileName));
* }*/
var path = GetModuleAssemblyPath(descriptor);
Logger.Information("为模块 \"{1}\" 存储程序集文件 \"{0}\"", path, moduleName);
var assemblyDescriptor = new AssemblyDescriptor(moduleName);
StoreAssembly(assemblyDescriptor, _applicationFolder.MapPath(path));
}
private static void OutputInfo(AssemblyDescriptor descriptor)
{
OutLineFormat("Name: {0}", ConsoleColor.Cyan, descriptor.AssemblyFullName);
OutLineFormat("Hash: {0}", ConsoleColor.DarkCyan, descriptor.FileHash);
OutLineFormat("\tReference count: {0}", ConsoleColor.Blue, descriptor.AssemblyReferenceDescriptors?.Count);
OutLine();
}
public void SaveDescriptorSavesReferences()
{
AssemblyServiceRepository repo = GetAssemblyManagementRepository(GetConsoleLogger(), nameof(SaveDescriptorDoesntDuplicate));
repo.Database.TryEnsureSchema <Dao.AssemblyDescriptor>();
AssemblyDescriptor[] descriptors = AssemblyDescriptor.GetCurrentAppDomainDescriptors().ToArray();
for (int i = 0; i < 3; i++)
{
foreach (AssemblyDescriptor descriptor in descriptors)
{
int?referenceCount = descriptor.AssemblyReferenceDescriptors?.Count;
if (referenceCount > 0)
{
AssemblyDescriptor wrapped = repo.Save(descriptor);
AssemblyDescriptor retrieved = repo.Retrieve <AssemblyDescriptor>(wrapped.Id);
Expect.AreEqual(referenceCount, retrieved.AssemblyReferenceDescriptors?.Count);
Pass(descriptor.AssemblyFullName);
}
else
{
OutLineFormat("No references: {0}", ConsoleColor.Cyan, descriptor.AssemblyFullName);
}
}
}
}
private static IReadOnlyList <MetadataReference> GetMetadataReferences(DataBuilderOptions options,
Type accessorType)
{
var references = new List <AssemblyDescriptor>(options?.MigrationAssemblyReferences.Distinct());
// Add DbContextAccessor AssemblyReference
var accessorReference = AssemblyDescriptor.Create(accessorType?.Assembly);
if (!references.Contains(accessorReference))
{
references.Add(accessorReference);
}
references.Sort();
return(references.Select(refer => refer.ToMetadataReference()).AsReadOnlyList());
//var metadatas = new List<MetadataReference>();
//foreach (var reference in references)
//{
// if (reference.CopyLocal)
// {
// if (reference.Location.IsEmpty())
// throw new InvalidOperationException(InternalResource.InvalidOperationExceptionNotFindPathForAssemblyReferenceFormat.Format(reference.ToString()));
// File.Copy(reference.Location, Path.Combine(assemblyPath.BasePath, Path.GetFileName(reference.Location)), overwrite: true);
// }
// metadatas.AddRange(reference.Metadatas);
//}
}
private AssemblyDescriptor GetAssembly(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
AssemblyDescriptor rv;
if (!AssemblyNameCache.TryGetValue(name, out rv))
{
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var match = loadedAssemblies.FirstOrDefault(a => a.GetName().Name == name);
if (match != null)
{
AssemblyNameCache[name] = rv = new AssemblyDescriptor(match);
}
else
{
// iOS does not support loading assemblies dynamically!
//
#if __IOS__
throw new InvalidOperationException(
$"Assembly {name} needs to be referenced and explicitly loaded before loading resources");
#else
name = Uri.UnescapeDataString(name);
AssemblyNameCache[name] = rv = new AssemblyDescriptor(Assembly.Load(name));
#endif
}
}
return(rv);
}
public void CanSaveAndRetrieveAllCurrentAppDomainDescriptorsTest()
{
DaoRepository daoRepo = GetAssemblyManagementRepository(GetConsoleLogger());
AssemblyDescriptor[] descriptors = AssemblyDescriptor.GetCurrentAppDomainDescriptors().ToArray();
foreach (AssemblyDescriptor descriptor in descriptors)
{
OutLine("Before save");
OutputInfo(descriptor);
AssemblyDescriptor saved = daoRepo.Save(descriptor);
OutLine("Original after save", ConsoleColor.Yellow);
OutputInfo(descriptor);
OutLine("Result after save", ConsoleColor.DarkYellow);
OutputInfo(saved);
Expect.AreEqual(descriptor.AssemblyFullName, saved.AssemblyFullName, "AssemlbyFullName didn't match");
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "AssemblyReferenceDescriptors count didn't match");
AssemblyDescriptor retrieved = daoRepo.Retrieve <AssemblyDescriptor>(saved.Uuid);
OutLine("Retrieved after save", ConsoleColor.DarkGreen);
OutputInfo(saved);
Expect.AreEqual(descriptor.AssemblyFullName, retrieved.AssemblyFullName, "AssemlbyFullName didn't match");
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, retrieved.AssemblyReferenceDescriptors?.Count, "AssemblyReferenceDescriptors count didn't match");
}
}
public AssetLoader(Assembly assembly = null)
{
if (assembly == null)
assembly = Assembly.GetEntryAssembly();
if (assembly != null)
_defaultAssembly = new AssemblyDescriptor(assembly);
}
private void projectView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Node.Parent == null)
{
return;
}
string clicked = e.Node.Parent.Text.Trim();
if (clicked.Equals("Assemblies"))
{
SampleAssembly = (AssemblyDescriptor)e.Node.Tag;
UIServices.AssemblyUtilities.LoadAssemblyToList(SampleAssembly.Assembly, lstVwAssemblies);
}
else if (clicked.Equals("Mapped Objects"))
{
MapReferences select = (MapReferences)e.Node.Tag;
ctxMapForMethods.DropDownItems.Clear();
ctxDataForMethods.DropDownItems.Clear();
foreach (MethodParameterMap aMap in select.ViableInfo.TheMap.MethodParameters)
{
string method = Parameters.FormParameterMethod(aMap);
var aMenuItem = ctxMapForMethods.DropDownItems.Add(method);
aMenuItem.Click += mnuMapWindow_Click;
aMenuItem.Tag = aMap;
aMenuItem = ctxDataForMethods.DropDownItems.Add(method);
aMenuItem.Click += mnuQueryWindow_Click;
aMenuItem.Tag = aMap;
}
}
}
public AssetLoader(Assembly assembly = null)
{
if (assembly == null)
{
assembly = Assembly.GetEntryAssembly();
}
_defaultAssembly = new AssemblyDescriptor(assembly);
}
protected void StoreAssemblyFileChunks(AssemblyDescriptor assemblyDescriptor)
{
Assembly assembly = Assembly.Load(assemblyDescriptor.AssemblyFullName);
FileInfo fileInfo = assembly.GetFileInfo();
Args.ThrowIf(!fileInfo.Sha256().Equals(assemblyDescriptor.FileHash), "FileHash validation failed: {0}", assemblyDescriptor.AssemblyFullName);
FileService.StoreFileChunksInRepo(fileInfo, assemblyDescriptor.Name);
}
private void mnuFindAssembly_Click(object sender, EventArgs e)
{
try
{
UIServices.AssemblyUtilities.AddAssembly(projectView, dlgOpenAssembly, ctxAssemblyNode);
SampleAssembly = (AssemblyDescriptor)projectView.SelectedNode.Tag;
UIServices.AssemblyUtilities.LoadAssemblyToList(SampleAssembly.Assembly, lstVwAssemblies);
}
catch { }
}
public void AssemblyDescriptorHasReferenceDescriptorsTest()
{
Assembly current = Assembly.GetExecutingAssembly();
AssemblyName[] assNames = current.GetReferencedAssemblies().Where(AssemblyDescriptor.AssemblyNameFilter).ToArray();
AssemblyDescriptor descriptor = new AssemblyDescriptor(current);
Expect.IsTrue(assNames.Length > 0);
Expect.AreEqual(assNames.Length, descriptor.AssemblyReferenceDescriptors.Count);
}
/// <summary>
/// 删除程序集。
/// </summary>
/// <param name="descriptor">程序集描述符。</param>
public void DeleteAssembly(AssemblyDescriptor descriptor)
{
var path = PrecompiledAssemblyPath(descriptor);
if (!_appDataFolder.FileExists(path))
{
return;
}
Logger.Information("从程序集探测目录删除程序集 {0}", descriptor.ToString());
_appDataFolder.DeleteFile(path);
}
AssemblyDescriptor GetAssembly(string name)
{
if (name == null)
return _defaultAssembly;
AssemblyDescriptor rv;
if (!AssemblyNameCache.TryGetValue(name, out rv))
AssemblyNameCache[name] = rv =
new AssemblyDescriptor(AppDomain.CurrentDomain.GetAssemblies()
.FirstOrDefault(a => a.GetName().Name == name)
?? Assembly.Load(name));
return rv;
}
public void AssemblyDescriptorHasReferenceDescriptorsTest()
{
Assembly current = Assembly.GetExecutingAssembly();
AssemblyName[] assNames = current.GetReferencedAssemblies().Where(AssemblyDescriptor.AssemblyNameFilter).ToArray();
AssemblyDescriptor descriptor = new AssemblyDescriptor(current);
Thread.Sleep(300);
(assNames.Length > 0).IsTrue();
Message.PrintLine("Assembly names: {0}", assNames.Select(an => an.Name).ToArray().ToDelimited(s => s, ", "));
(descriptor.AssemblyReferenceDescriptors.Count > 0).IsTrue();
}
public List <AssemblyDescriptor> GetLoadedAssemblyInformation()
{
var assemblyDescriptors = new List <AssemblyDescriptor>();
var applicationModel = BuildApplicationModel();
if (applicationModel != null && applicationModel.Controllers.Any())
{
foreach (var controller in applicationModel.Controllers)
{
var assembly = controller.ControllerType.Assembly;
if (assemblyDescriptors.Any(k => k.ComponentId == assembly.GetComponentId()))
{
continue;
}
var assemblyInfo = new AssemblyInformationHelper(assembly);
var viewComponents = GetViewComponents(assembly);
var assemblyDescriptor = new AssemblyDescriptor
{
IsHosting = assemblyInfo.IsHosting,
ComponentId = assemblyInfo.ComponentId,
Title = assemblyInfo.Title,
PackageId = assemblyInfo.PackageId,
PackageVersion = assemblyInfo.PackageVersion,
Authors = assemblyInfo.Authors,
Company = assemblyInfo.Company,
Product = assemblyInfo.Product,
Description = assemblyInfo.Description,
Copyright = assemblyInfo.Copyright,
LicenceUrl = assemblyInfo.LicenceUrl,
ProjectUrl = assemblyInfo.ProjectUrl,
IconUrl = assemblyInfo.IconUrl,
RepositoryUrl = assemblyInfo.RepositoryUrl,
Tags = assemblyInfo.Tags,
ReleaseNotes = assemblyInfo.ReleaseNotes,
NeutrelLanguage = assemblyInfo.NeutrelLanguage,
Version = assemblyInfo.Version,
FileVersion = assemblyInfo.FileVersion,
ViewComponents = viewComponents
};
var avmComponent = new List <ComponentControllerDescriptor>(); // Controller
GetAssemblyController(ref avmComponent, controller);
assemblyDescriptor.Controllers = avmComponent;
assemblyDescriptors.Add(assemblyDescriptor);
}
}
return(assemblyDescriptors);
}
public void CanSaveAndRetrieveAssemblyDescriptorTest()
{
DaoRepository daoRepo = GetAssemblyManagementRepository(GetConsoleLogger());
AssemblyDescriptor descriptor = new AssemblyDescriptor(Assembly.GetExecutingAssembly());
Expect.IsTrue(descriptor.AssemblyReferenceDescriptors.Count > 0, "No references found");
AssemblyDescriptor saved = daoRepo.Save(descriptor);
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "Saved references didn't match");
AssemblyDescriptor retrieved = daoRepo.Retrieve <AssemblyDescriptor>(descriptor.Uuid);
Expect.AreEqual(descriptor.AssemblyReferenceDescriptors?.Count, saved.AssemblyReferenceDescriptors?.Count, "Retrieved references didn't match");
}
/// <summary>
/// 根据程序集描述符装载一个程序集。
/// </summary>
/// <param name="assemblyLoader">程序集装载机。</param>
/// <param name="descriptor">程序集描述符。</param>
/// <returns>程序集。</returns>
/// <exception cref="ArgumentNullException"><paramref name="descriptor"/> 为null。</exception>
public static Assembly Load(this IAssemblyLoader assemblyLoader, AssemblyDescriptor descriptor)
{
if (assemblyLoader == null)
{
throw new ArgumentNullException("assemblyLoader");
}
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
return(assemblyLoader.Load(descriptor.FullName));
}
public void StoreAndDeleteAssemblyTest()
{
var descriptor = new AssemblyDescriptor("SuperRocket.Framework.Tests");
if (AssemblyProbingFolder.AssemblyExists(descriptor))
{
AssemblyProbingFolder.DeleteAssembly(descriptor);
}
AssemblyProbingFolder.StoreAssembly(descriptor, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, descriptor.Name + ".dll"));
Assert.IsTrue(AssemblyProbingFolder.AssemblyExists(descriptor));
AssemblyProbingFolder.DeleteAssembly(descriptor);
Assert.IsFalse(AssemblyProbingFolder.AssemblyExists(descriptor));
}
internal AssemblyDescriptor ReadAssembly()
{
var assemblyId = PrimitiveReader.ReadInt32();
if (assembliesList.Count <= assemblyId)
{
var descriptor = AssemblyDescriptor.ReadFromStream(this);
assembliesList.Add(descriptor);
return(descriptor);
}
else
{
return(assembliesList[assemblyId]);
}
}
internal int TouchAndWriteAssemblyId(AssemblyDescriptor assembly)
{
int assemblyId;
if (assemblyIndices.ContainsKey(assembly))
{
assemblyId = assemblyIndices[assembly];
writer.Write(assemblyId);
return(assemblyId);
}
assemblyId = nextAssemblyId++;
assemblyIndices.Add(assembly, assemblyId);
writer.Write(assemblyId);
assembly.WriteTo(this);
return(assemblyId);
}
AssemblyDescriptor GetAssembly(string name)
{
if (name == null)
{
return(_defaultAssembly);
}
AssemblyDescriptor rv;
if (!AssemblyNameCache.TryGetValue(name, out rv))
{
AssemblyNameCache[name] = rv =
new AssemblyDescriptor(AppDomain.CurrentDomain.GetAssemblies()
.FirstOrDefault(a => a.GetName().Name == name)
?? Assembly.Load(name));
}
return(rv);
}
private void WriteAssemblySpec(AssemblyDescriptor assembly)
{
WriteIdentifier(assembly.Name, true);
_writer.Write(", Version=");
_writer.Write(assembly.Version.ToString());
_writer.Write(", PublicKeyToken=");
var token = assembly.GetPublicKeyToken();
if (token is null)
{
_writer.Write("null");
}
else
{
WriteHexBlob(token);
}
_writer.Write(", Culture=");
WriteIdentifier(assembly.Culture ?? "neutral");
}
private void Init(Type t)
{
UnderlyingType = t;
TypeAssembly = AssemblyDescriptor.CreateFromAssembly(t.Assembly);
genericArguments = new List <TypeDescriptor>();
if (UnderlyingType.IsGenericType)
{
GenericFullName = UnderlyingType.GetGenericTypeDefinition().FullName;
GenericAssemblyQualifiedName = UnderlyingType.GetGenericTypeDefinition().AssemblyQualifiedName;
foreach (var genericArgument in UnderlyingType.GetGenericArguments())
{
genericArguments.Add(TypeDescriptor.CreateFromType(genericArgument));
}
}
else
{
GenericAssemblyQualifiedName = UnderlyingType.AssemblyQualifiedName;
GenericFullName = UnderlyingType.FullName;
}
if (t.BaseType != null)
{
System.IO.File.AppendAllText("/tmp/log", string.Format("Setting base type '{0}' for '{1}' in Init method\n", t.BaseType.FullName, t.FullName));
baseType = TypeDescriptor.CreateFromType(t.BaseType);
}
var fieldsToDeserialize = new List <FieldInfoOrEntryToOmit>();
foreach (var field in StampHelpers.GetFieldsInSerializationOrder(UnderlyingType, true))
{
fieldsToDeserialize.Add(new FieldInfoOrEntryToOmit(field));
if (!field.IsTransient())
{
fields.Add(new FieldDescriptor(field));
}
}
FieldsToDeserialize = fieldsToDeserialize;
}
private void Init(Type t)
{
UnderlyingType = t;
TypeAssembly = AssemblyDescriptor.CreateFromAssembly(t.Assembly);
genericArguments = new List <TypeDescriptor>();
if (UnderlyingType.IsGenericType)
{
GenericFullName = UnderlyingType.GetGenericTypeDefinition().FullName;
GenericAssemblyQualifiedName = UnderlyingType.GetGenericTypeDefinition().AssemblyQualifiedName;
foreach (var genericArgument in UnderlyingType.GetGenericArguments())
{
genericArguments.Add(TypeDescriptor.CreateFromType(genericArgument));
}
}
else
{
GenericAssemblyQualifiedName = UnderlyingType.AssemblyQualifiedName;
GenericFullName = UnderlyingType.FullName;
}
if (t.BaseType != null)
{
baseType = TypeDescriptor.CreateFromType(t.BaseType);
}
var fieldsToDeserialize = new List <FieldInfoOrEntryToOmit>();
foreach (var field in StampHelpers.GetFieldsInSerializationOrder(UnderlyingType, true))
{
fieldsToDeserialize.Add(new FieldInfoOrEntryToOmit(field));
if (!field.IsTransient())
{
fields.Add(new FieldDescriptor(field));
}
}
FieldsToDeserialize = fieldsToDeserialize;
}
public void SaveDescriptorDoesntDuplicate()
{
AssemblyServiceRepository repo = GetTestRepo(nameof(SaveDescriptorDoesntDuplicate));
AssemblyDescriptor descriptor = new AssemblyDescriptor(Assembly.GetExecutingAssembly());
AssemblyDescriptor one = repo.Save(descriptor);
AssemblyDescriptor two = repo.Save(descriptor);
Expect.IsNotNull(one, "first save returned null");
Expect.IsNotNull(two, "second save returned null");
Expect.AreEqual(one.Id, two.Id, "Ids didn't match");
Expect.AreEqual(one.Uuid, two.Uuid, "Uuids didn't match");
Dao.AssemblyDescriptorCollection descriptors = Dao.AssemblyDescriptor
.Where(q =>
q.AssemblyFullName == descriptor.AssemblyFullName &&
q.FileHash == descriptor.FileHash &&
q.Name == descriptor.Name, repo.Database);
Expect.AreEqual(1, descriptors.Count);
}
public static void AddAssembly(TreeView projectView, OpenFileDialog dlgOpenAssembly, ContextMenuStrip menu)
{
try
{
if (dlgOpenAssembly.ShowDialog() == DialogResult.OK)
{
Assembly loadedAssm = Assembly.LoadFrom(dlgOpenAssembly.FileName);
AssemblyDescriptor aDescriptor = new AssemblyDescriptor();
aDescriptor.Assembly = loadedAssm;
aDescriptor.Enums = loadedAssm.GetTypes().Where(x => x.IsEnum);
aDescriptor.AbstractClasses = loadedAssm.GetTypes().Where(x => x.IsAbstract);
aDescriptor.Interfaces = loadedAssm.GetTypes().Where(x => x.IsInterface);
TreeNode aNode = projectView.Nodes[0].Nodes[2].Nodes.Add(System.IO.Path.GetFileName(dlgOpenAssembly.FileName));
aNode.ToolTipText = dlgOpenAssembly.FileName;
aNode.Tag = aDescriptor;
aNode.ContextMenuStrip = menu;
projectView.SelectedNode = aNode;
}
}
catch
{
MessageBox.Show("Unable to load assembly", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static IDataBuilder AddDatabaseDesignTime <TDesignTime>(this IDataBuilder builder)
where TDesignTime : class, IDesignTimeServices
{
builder.NotNull(nameof(builder));
var designTimeType = typeof(TDesignTime);
builder.SetProperty(p => p.DatabaseDesignTimeType, designTimeType);
var designTime = designTimeType.EnsureCreate <TDesignTime>();
designTime.ConfigureDesignTimeServices(builder.Services);
builder.Services.Configure <DataBuilderOptions>(options =>
{
var reference = AssemblyDescriptor.Create(designTimeType.Assembly);
if (!options.MigrationAssemblyReferences.Contains(reference))
{
options.MigrationAssemblyReferences.Add(reference);
}
});
return(builder);
}
public void SetDefaultAssembly(Assembly assembly)
{
_defaultAssembly = new AssemblyDescriptor(assembly);
}
private AssemblyDescriptor GetAssembly(string name)
{
if (name == null)
{
return _defaultAssembly;
}
AssemblyDescriptor rv;
if (!AssemblyNameCache.TryGetValue(name, out rv))
{
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var match = loadedAssemblies.FirstOrDefault(a => a.GetName().Name == name);
if (match != null)
{
AssemblyNameCache[name] = rv = new AssemblyDescriptor(match);
}
else
{
// iOS does not support loading assemblies dynamically!
//
#if !__IOS__
AssemblyNameCache[name] = rv = new AssemblyDescriptor(Assembly.Load(name));
#endif
}
}
return rv;
}
/// <summary>
/// 装载程序集。
/// </summary>
/// <param name="descriptor">程序集描述符。</param>
/// <returns>程序集。</returns>
public Assembly LoadAssembly(AssemblyDescriptor descriptor)
{
var path = PrecompiledAssemblyPath(descriptor);
return(!_appDataFolder.FileExists(path) ? null : _assemblyLoader.Load(descriptor));
}
