private static List <MethodDefinition> GetMethodsInsideAssembly(String assemblyToLoad, bool includeMethodDefinition, Func <MethodReference, bool> condition)
{
string directory = Path.GetDirectoryName(assemblyToLoad);
BaseAssemblyResolver resolver = (GlobalAssemblyResolver.Instance as BaseAssemblyResolver);
if (!resolver.GetSearchDirectories().Contains(directory))
{
resolver.AddSearchDirectory(directory);
}
var methods = new List <MethodDefinition>();
foreach (MethodDefinition methodDefinition in GetMethods(assemblyToLoad))
{
if ((methodDefinition.HasBody || includeMethodDefinition) && (condition(methodDefinition)))
{
//if (includeMethodsCalled)
//{
// methodsCalled.Add(MethodDetailBuilder.Create(methodDefinition, GetMethodsCalledInsideMethod(methodDefinition, condition)));
//}
//else
//{
// methodsCalled.Add(MethodDetailBuilder.Create(methodDefinition));
//}
methods.Add(methodDefinition);
}
}
return(methods);
}
/// <summary>Adds all subdirectories to the search directories for the resolver to look in.</summary>
public void RecurseSearchDirectories()
{
var directories = resolver
.GetSearchDirectories()
.Select(d => new DirectoryInfo(d))
.Where(d => d.Exists)
.Select(d => d.FullName)
.Distinct()
.ToDictionary(d => d, d => d);
var subdirs = directories.Keys
.SelectMany(d => Directory.GetDirectories(d, ".", SearchOption.AllDirectories))
.Where(d => !directories.ContainsKey(d));
foreach (var dir in subdirs)
{
resolver.AddSearchDirectory(dir);
}
}
void VerifyLinkingOfOtherAssemblies(AssemblyDefinition original)
{
var checks = BuildOtherAssemblyCheckTable(original);
try {
foreach (var assemblyName in checks.Keys)
{
using (var linkedAssembly = ResolveLinkedAssembly(assemblyName)) {
foreach (var checkAttrInAssembly in checks[assemblyName])
{
var attributeTypeName = checkAttrInAssembly.AttributeType.Name;
if (attributeTypeName == nameof(KeptAllTypesAndMembersInAssemblyAttribute))
{
VerifyKeptAllTypesAndMembersInAssembly(linkedAssembly);
continue;
}
if (attributeTypeName == nameof(KeptAttributeInAssemblyAttribute))
{
VerifyKeptAttributeInAssembly(checkAttrInAssembly, linkedAssembly);
continue;
}
if (attributeTypeName == nameof(RemovedAttributeInAssembly))
{
VerifyRemovedAttributeInAssembly(checkAttrInAssembly, linkedAssembly);
continue;
}
var expectedTypeName = checkAttrInAssembly.ConstructorArguments [1].Value.ToString();
var linkedType = linkedAssembly.MainModule.GetType(expectedTypeName);
if (linkedType == null && linkedAssembly.MainModule.HasExportedTypes)
{
linkedType = linkedAssembly.MainModule.ExportedTypes
.FirstOrDefault(exported => exported.FullName == expectedTypeName)
?.Resolve();
}
switch (attributeTypeName)
{
case nameof(RemovedTypeInAssemblyAttribute):
if (linkedType != null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been removed");
}
GetOriginalTypeFromInAssemblyAttribute(checkAttrInAssembly);
break;
case nameof(KeptTypeInAssemblyAttribute):
if (linkedType == null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been kept");
}
break;
case nameof(RemovedInterfaceOnTypeInAssemblyAttribute):
if (linkedType == null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been kept");
}
VerifyRemovedInterfaceOnTypeInAssembly(checkAttrInAssembly, linkedType);
break;
case nameof(KeptInterfaceOnTypeInAssemblyAttribute):
if (linkedType == null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been kept");
}
VerifyKeptInterfaceOnTypeInAssembly(checkAttrInAssembly, linkedType);
break;
case nameof(RemovedMemberInAssemblyAttribute):
if (linkedType == null)
{
continue;
}
VerifyRemovedMemberInAssembly(checkAttrInAssembly, linkedType);
break;
case nameof(KeptBaseOnTypeInAssemblyAttribute):
if (linkedType == null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been kept");
}
VerifyKeptBaseOnTypeInAssembly(checkAttrInAssembly, linkedType);
break;
case nameof(KeptMemberInAssemblyAttribute):
if (linkedType == null)
{
Assert.Fail($"Type `{expectedTypeName}' should have been kept");
}
VerifyKeptMemberInAssembly(checkAttrInAssembly, linkedType);
break;
case nameof(RemovedForwarderAttribute):
if (linkedAssembly.MainModule.ExportedTypes.Any(l => l.Name == expectedTypeName))
{
Assert.Fail($"Forwarder `{expectedTypeName}' should have been removed");
}
break;
case nameof(KeptResourceInAssemblyAttribute):
VerifyKeptResourceInAssembly(checkAttrInAssembly);
break;
case nameof(RemovedResourceInAssemblyAttribute):
VerifyRemovedResourceInAssembly(checkAttrInAssembly);
break;
case nameof(KeptReferencesInAssemblyAttribute):
VerifyKeptReferencesInAssembly(checkAttrInAssembly);
break;
default:
UnhandledOtherAssemblyAssertion(expectedTypeName, checkAttrInAssembly, linkedType);
break;
}
}
}
}
} catch (AssemblyResolutionException e) {
Assert.Fail($"Failed to resolve linked assembly `{e.AssemblyReference.Name}`. It must not exist in any of the output directories:\n\t{_linkedResolver.GetSearchDirectories ().Aggregate ((buff, s) => $"{buff}\n\t{s}")}\n");
}
}
public static AssemblyDefinition GenerateSerializationAssembly(PlatformType platformType, BaseAssemblyResolver assemblyResolver, AssemblyDefinition assembly, string serializationAssemblyLocation, string signKeyFile, List <string> serializatonProjectReferencePaths)
{
// Make sure all assemblies in serializatonProjectReferencePaths are referenced (sometimes they might be optimized out if no direct references)
foreach (var serializatonProjectReferencePath in serializatonProjectReferencePaths)
{
var shortAssemblyName = Path.GetFileNameWithoutExtension(serializatonProjectReferencePath);
// Still in references (not optimized)
if (assembly.MainModule.AssemblyReferences.Any(x => x.Name == shortAssemblyName))
{
continue;
}
// For now, use AssemblyDefinition.ReadAssembly to compute full name -- maybe not very efficient but it shouldn't happen often anyway)
var referencedAssembly = AssemblyDefinition.ReadAssembly(serializatonProjectReferencePath);
assembly.MainModule.AssemblyReferences.Add(AssemblyNameReference.Parse(referencedAssembly.FullName));
}
// Create the serializer code generator
var serializerGenerator = new ComplexSerializerCodeGenerator(assemblyResolver, assembly);
// Register default serialization profile (to help AOT generic instantiation of serializers)
RegisterDefaultSerializationProfile(assemblyResolver, assembly, serializerGenerator);
// Generate serializer code
var serializerGeneratedCode = serializerGenerator.TransformText();
var syntaxTree = CSharpSyntaxTree.ParseText(serializerGeneratedCode);
// Add reference from source assembly
// Use a hash set because it seems including twice mscorlib (2.0 and 4.0) seems to be a problem.
var skipWindows = "Windows, Version=255.255.255.255, Culture=neutral, PublicKeyToken=null";
var compilerOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
// Sign the serialization assembly the same way the source was signed
// TODO: Transmit over command line
if (assembly.Name.HasPublicKey)
{
// TODO: If delay signed, we could actually extract the public key and apply it ourself maybe?
if (signKeyFile == null)
{
throw new InvalidOperationException("Generating serialization code for signed assembly, but no key was specified.");
}
compilerOptions = compilerOptions.WithCryptoKeyFile(signKeyFile).WithStrongNameProvider(new DesktopStrongNameProvider());
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) != ModuleAttributes.StrongNameSigned)
{
// Delay signed
compilerOptions = compilerOptions.WithDelaySign(true);
}
}
var metadataReferences = new List <MetadataReference>();
var assemblyLocations = new HashSet <string>();
foreach (var referencedAssemblyName in assembly.MainModule.AssemblyReferences)
{
// We skip both Windows, and current assembly (AssemblyProcessor.Common, which might be added with an alias)
if (referencedAssemblyName.FullName != skipWindows && referencedAssemblyName.FullName != typeof(ComplexSerializerGenerator).Assembly.FullName && referencedAssemblyName.FullName != "SiliconStudio.AssemblyProcessor")
{
if (assemblyLocations.Add(referencedAssemblyName.Name))
{
//Console.WriteLine("Resolve Assembly for serialization [{0}]", referencedAssemblyName.FullName);
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve(referencedAssemblyName)));
}
}
}
// typeof(Dictionary<,>)
// Special case for 4.5: Because Dictionary<,> is forwarded, we need to add a reference to the actual assembly
var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly);
metadataReferences.Add(CreateMetadataReference(assemblyResolver, mscorlibAssembly));
var collectionType = mscorlibAssembly.MainModule.GetTypeResolved(typeof(Dictionary <,>).FullName);
metadataReferences.Add(CreateMetadataReference(assemblyResolver, collectionType.Module.Assembly));
// Make sure System and System.Reflection are added
// TODO: Maybe we should do that for .NETCore and PCL too? (instead of WinRT only)
if (platformType == PlatformType.WindowsStore || platformType == PlatformType.WindowsPhone)
{
if (assemblyLocations.Add("System"))
{
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve("System")));
}
if (assemblyLocations.Add("System.Reflection"))
{
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve("System.Reflection")));
}
}
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assembly));
assemblyLocations.Add(assembly.Name.Name);
// In case Paradox.Framework.Serialization was not referenced, let's add it.
if (!assemblyLocations.Contains("SiliconStudio.Core"))
{
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve("SiliconStudio.Core")));
assemblyLocations.Add("SiliconStudio.Core");
}
// Create roslyn compilation object
var assemblyName = Path.GetFileNameWithoutExtension(serializationAssemblyLocation);
var compilation = CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, metadataReferences, compilerOptions);
// Do the actual compilation, and check errors
using (var peStream = new FileStream(serializationAssemblyLocation, FileMode.Create, FileAccess.Write))
{
var compilationResult = compilation.Emit(peStream);
if (!compilationResult.Success)
{
var errors = new StringBuilder();
errors.AppendLine(string.Format("Serialization assembly compilation: {0} error(s)", compilationResult.Diagnostics.Count(x => x.Severity >= DiagnosticSeverity.Error)));
foreach (var error in compilationResult.Diagnostics)
{
if (error.Severity >= DiagnosticSeverity.Warning)
{
errors.AppendLine(error.ToString());
}
}
throw new InvalidOperationException(errors.ToString());
}
}
// Run ILMerge
var merge = new ILRepacking.ILRepack()
{
OutputFile = assembly.MainModule.FullyQualifiedName,
DebugInfo = true,
CopyAttributes = true,
AllowMultipleAssemblyLevelAttributes = true,
XmlDocumentation = false,
NoRepackRes = true,
PrimaryAssemblyDefinition = assembly,
WriteToDisk = false,
//KeepFirstOfMultipleAssemblyLevelAttributes = true,
//Log = true,
//LogFile = "ilmerge.log",
};
merge.SetInputAssemblies(new string[] { serializationAssemblyLocation });
// Force to use the correct framework
//merge.SetTargetPlatform("v4", frameworkFolder);
merge.SetSearchDirectories(assemblyResolver.GetSearchDirectories());
merge.Merge();
// Copy name
merge.TargetAssemblyDefinition.Name.Name = assembly.Name.Name;
merge.TargetAssemblyDefinition.Name.Version = assembly.Name.Version;
// Add assembly signing info
if (assembly.Name.HasPublicKey)
{
merge.TargetAssemblyDefinition.Name.PublicKey = assembly.Name.PublicKey;
merge.TargetAssemblyDefinition.Name.PublicKeyToken = assembly.Name.PublicKeyToken;
merge.TargetAssemblyDefinition.Name.Attributes |= AssemblyAttributes.PublicKey;
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) == ModuleAttributes.StrongNameSigned)
{
merge.TargetAssemblyMainModule.Attributes |= ModuleAttributes.StrongNameSigned;
}
}
try
{
// Delete serializer dll
File.Delete(serializationAssemblyLocation);
var serializationAssemblyPdbFilePath = Path.ChangeExtension(serializationAssemblyLocation, "pdb");
if (File.Exists(serializationAssemblyPdbFilePath))
{
File.Delete(serializationAssemblyPdbFilePath);
}
}
catch (IOException)
{
// Mute IOException
}
return(merge.TargetAssemblyDefinition);
}
public static AssemblyDefinition GenerateRoslynAssembly(BaseAssemblyResolver assemblyResolver, AssemblyDefinition assembly, string serializationAssemblyLocation, string signKeyFile, List <string> references, List <AssemblyDefinition> memoryReferences, ILogger log, IEnumerable <string> sourceCodes)
{
var syntaxTrees = sourceCodes.Select(x => CSharpSyntaxTree.ParseText(x));
var compilerOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default);
// Sign the serialization assembly the same way the source was signed
// TODO: Transmit over command line
if (assembly.Name.HasPublicKey)
{
// TODO: If delay signed, we could actually extract the public key and apply it ourself maybe?
if (signKeyFile == null)
{
throw new InvalidOperationException("Generating serialization code for signed assembly, but no key was specified.");
}
compilerOptions = compilerOptions.WithCryptoKeyFile(signKeyFile).WithStrongNameProvider(new DesktopStrongNameProvider());
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) != ModuleAttributes.StrongNameSigned)
{
// Delay signed
compilerOptions = compilerOptions.WithDelaySign(true);
}
}
// Add references (files and in-memory PE data)
var metadataReferences = new List <MetadataReference>();
foreach (var reference in references)
{
metadataReferences.Add(MetadataReference.CreateFromFile(reference));
}
foreach (var reference in memoryReferences)
{
metadataReferences.Add(CreateMetadataReference(assemblyResolver, reference));
}
// typeof(Dictionary<,>)
// Special case for 4.5: Because Dictionary<,> is forwarded, we need to add a reference to the actual assembly
var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly);
metadataReferences.Add(CreateMetadataReference(assemblyResolver, mscorlibAssembly));
var collectionAssembly = CecilExtensions.FindCollectionsAssembly(assembly);
metadataReferences.Add(CreateMetadataReference(assemblyResolver, collectionAssembly));
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assembly));
// In case SiliconStudio.Core was not referenced, let's add it.
if (assembly.Name.Name != "SiliconStudio.Core" && !references.Any(x => string.Compare(Path.GetFileNameWithoutExtension(x), "SiliconStudio.Core", StringComparison.OrdinalIgnoreCase) == 0))
{
metadataReferences.Add(CreateMetadataReference(assemblyResolver, assemblyResolver.Resolve("SiliconStudio.Core")));
}
// Create roslyn compilation object
var assemblyName = assembly.Name.Name + ".Serializers";
var compilation = CSharpCompilation.Create(assemblyName, syntaxTrees, metadataReferences, compilerOptions);
// Do the actual compilation, and check errors
using (var peStream = new FileStream(serializationAssemblyLocation, FileMode.Create, FileAccess.Write))
{
var compilationResult = compilation.Emit(peStream);
if (!compilationResult.Success)
{
var errors = new StringBuilder();
errors.AppendLine(string.Format("Serialization assembly compilation: {0} error(s)", compilationResult.Diagnostics.Count(x => x.Severity >= DiagnosticSeverity.Error)));
foreach (var error in compilationResult.Diagnostics)
{
if (error.Severity >= DiagnosticSeverity.Warning)
{
errors.AppendLine(error.ToString());
}
}
throw new InvalidOperationException(errors.ToString());
}
}
var repackOptions = new ILRepacking.RepackOptions(new string[0])
{
OutputFile = assembly.MainModule.FullyQualifiedName,
DebugInfo = true,
CopyAttributes = true,
AllowMultipleAssemblyLevelAttributes = true,
XmlDocumentation = false,
NoRepackRes = true,
InputAssemblies = new[] { serializationAssemblyLocation },
SearchDirectories = assemblyResolver.GetSearchDirectories(),
SearchAssemblies = references,
};
// Run ILMerge
var merge = new ILRepacking.ILRepack(repackOptions)
{
PrimaryAssemblyDefinition = assembly,
MemoryOnly = true,
//KeepFirstOfMultipleAssemblyLevelAttributes = true,
//Log = true,
//LogFile = "ilmerge.log",
};
try
{
var consoleWriter = Console.Out;
Console.SetOut(TextWriter.Null);
try
{
merge.Repack();
}
finally
{
Console.SetOut(consoleWriter);
}
}
catch (Exception)
{
log.Log(new LogMessage("ILRepack", LogMessageType.Error, string.Format("Error while ILRepacking {0}", assembly.Name.Name)));
throw;
}
// Copy name
merge.TargetAssemblyDefinition.Name.Name = assembly.Name.Name;
merge.TargetAssemblyDefinition.Name.Version = assembly.Name.Version;
// Copy assembly characterics. This is necessary especially when targeting a windows app
merge.TargetAssemblyMainModule.Characteristics = assembly.MainModule.Characteristics;
// Add assembly signing info
if (assembly.Name.HasPublicKey)
{
merge.TargetAssemblyDefinition.Name.PublicKey = assembly.Name.PublicKey;
merge.TargetAssemblyDefinition.Name.PublicKeyToken = assembly.Name.PublicKeyToken;
merge.TargetAssemblyDefinition.Name.Attributes |= AssemblyAttributes.PublicKey;
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) == ModuleAttributes.StrongNameSigned)
{
merge.TargetAssemblyMainModule.Attributes |= ModuleAttributes.StrongNameSigned;
}
}
try
{
// Delete serializer dll
File.Delete(serializationAssemblyLocation);
var serializationAssemblyPdbFilePath = Path.ChangeExtension(serializationAssemblyLocation, "pdb");
if (File.Exists(serializationAssemblyPdbFilePath))
{
File.Delete(serializationAssemblyPdbFilePath);
}
}
catch (IOException)
{
// Mute IOException
}
return(merge.TargetAssemblyDefinition);
}
public static AssemblyDefinition GenerateSerializationAssembly(PlatformType platformType, BaseAssemblyResolver assemblyResolver, AssemblyDefinition assembly, string serializationAssemblyLocation, string signKeyFile = null)
{
// Create the serializer code generator
var serializerGenerator = new ComplexSerializerCodeGenerator(assemblyResolver, assembly);
// Register default serialization profile (to help AOT generic instantiation of serializers)
RegisterDefaultSerializationProfile(assemblyResolver, assembly, serializerGenerator);
// Generate serializer code
var serializerGeneratedCode = serializerGenerator.TransformText();
var compilerParameters = new CompilerParameters();
compilerParameters.IncludeDebugInformation = false;
compilerParameters.GenerateInMemory = false;
compilerParameters.CompilerOptions = "/nostdlib";
compilerParameters.TreatWarningsAsErrors = false;
compilerParameters.TempFiles.KeepFiles = false;
//Console.WriteLine("Generating {0}", serializationAssemblyLocation);
// Add reference from source assembly
// Use a hash set because it seems including twice mscorlib (2.0 and 4.0) seems to be a problem.
var skipWindows = "Windows, Version=255.255.255.255, Culture=neutral, PublicKeyToken=null";
// Sign the serialization assembly the same way the source was signed
// TODO: Transmit over command line
if (assembly.Name.HasPublicKey)
{
// TODO: If delay signed, we could actually extract the public key and apply it ourself maybe?
if (signKeyFile == null)
{
throw new InvalidOperationException("Generating serialization code for signed assembly, but no key was specified.");
}
var assemblyPath = Path.GetDirectoryName(assembly.MainModule.FullyQualifiedName);
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) == ModuleAttributes.StrongNameSigned)
{
// Strongly signed
compilerParameters.CompilerOptions += string.Format(" /keyfile:\"{0}\"", signKeyFile);
}
else
{
// Delay signed
compilerParameters.CompilerOptions += string.Format(" /delaysign+ /keyfile:\"{0}\"", signKeyFile);
}
}
var assemblyLocations = new HashSet <string>();
foreach (var referencedAssemblyName in assembly.MainModule.AssemblyReferences)
{
if (referencedAssemblyName.FullName != skipWindows)
{
if (assemblyLocations.Add(referencedAssemblyName.Name))
{
//Console.WriteLine("Resolve Assembly for serialization [{0}]", referencedAssemblyName.FullName);
compilerParameters.ReferencedAssemblies.Add(assemblyResolver.Resolve(referencedAssemblyName).MainModule.FullyQualifiedName);
}
}
}
// typeof(Dictionary<,>)
// Special case for 4.5: Because Dictionary<,> is forwarded, we need to add a reference to the actual assembly
var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly);
compilerParameters.ReferencedAssemblies.Add(mscorlibAssembly.MainModule.FullyQualifiedName);
var collectionType = mscorlibAssembly.MainModule.GetTypeResolved(typeof(Dictionary <,>).FullName);
compilerParameters.ReferencedAssemblies.Add(collectionType.Module.FullyQualifiedName);
// Make sure System and System.Reflection are added
// TODO: Maybe we should do that for .NETCore and PCL too? (instead of WinRT only)
if (platformType == PlatformType.WindowsStore || platformType == PlatformType.WindowsPhone)
{
if (assemblyLocations.Add("System"))
{
compilerParameters.ReferencedAssemblies.Add(assemblyResolver.Resolve("System").MainModule.FullyQualifiedName);
}
if (assemblyLocations.Add("System.Reflection"))
{
compilerParameters.ReferencedAssemblies.Add(assemblyResolver.Resolve("System.Reflection").MainModule.FullyQualifiedName);
}
}
compilerParameters.ReferencedAssemblies.Add(assembly.MainModule.FullyQualifiedName);
assemblyLocations.Add(assembly.Name.Name);
// In case Paradox.Framework.Serialization was not referenced, let's add it.
if (!assemblyLocations.Contains("SiliconStudio.Core"))
{
compilerParameters.ReferencedAssemblies.Add(assemblyResolver.Resolve("SiliconStudio.Core").MainModule.FullyQualifiedName);
}
compilerParameters.OutputAssembly = serializationAssemblyLocation;
var compilerResults = codeDomProvider.CompileAssemblyFromSource(compilerParameters, serializerGeneratedCode);
if (compilerResults.Errors.HasErrors)
{
var errors = new StringBuilder();
errors.AppendLine(string.Format("Serialization assembly compilation: {0} error(s)", compilerResults.Errors.Count));
foreach (var error in compilerResults.Errors)
{
errors.AppendLine(error.ToString());
}
throw new InvalidOperationException(errors.ToString());
}
// Run ILMerge
var merge = new ILRepacking.ILRepack()
{
OutputFile = assembly.MainModule.FullyQualifiedName,
DebugInfo = true,
CopyAttributes = true,
AllowMultipleAssemblyLevelAttributes = true,
XmlDocumentation = false,
NoRepackRes = true,
PrimaryAssemblyDefinition = assembly,
WriteToDisk = false,
//KeepFirstOfMultipleAssemblyLevelAttributes = true,
//Log = true,
//LogFile = "ilmerge.log",
};
merge.SetInputAssemblies(new string[] { serializationAssemblyLocation });
// Force to use the correct framework
//merge.SetTargetPlatform("v4", frameworkFolder);
merge.SetSearchDirectories(assemblyResolver.GetSearchDirectories());
merge.Merge();
// Add assembly signing info
if (assembly.Name.HasPublicKey)
{
merge.TargetAssemblyDefinition.Name.PublicKey = assembly.Name.PublicKey;
merge.TargetAssemblyDefinition.Name.PublicKeyToken = assembly.Name.PublicKeyToken;
merge.TargetAssemblyDefinition.Name.Attributes |= AssemblyAttributes.PublicKey;
if ((assembly.MainModule.Attributes & ModuleAttributes.StrongNameSigned) == ModuleAttributes.StrongNameSigned)
{
merge.TargetAssemblyMainModule.Attributes |= ModuleAttributes.StrongNameSigned;
}
}
try
{
// Delete serializer dll
File.Delete(serializationAssemblyLocation);
var serializationAssemblyPdbFilePath = Path.ChangeExtension(serializationAssemblyLocation, "pdb");
if (File.Exists(serializationAssemblyPdbFilePath))
{
File.Delete(serializationAssemblyPdbFilePath);
}
}
catch (IOException)
{
// Mute IOException
}
return(merge.TargetAssemblyDefinition);
}
public static void Main(string[] args)
{
bool showHelp = false;
bool listDependenciesOnly = false;
foreach (var s in assemblyResolver.GetSearchDirectories())
{
assemblyResolver.RemoveSearchDirectory(s);
}
var p = new OptionSet()
{
{ "a|assembly-search-directory=", "add a search directory into the assembly resolver", v => assemblyResolver.AddSearchDirectory(v) },
{ "d|list-dependencies-only", "output a list of detected dependencies and exit", v => listDependenciesOnly = v != null },
{ "k|key-pair-file=", "resign assembly with the key pair in file (.snk)", v => LoadKeyPairFile(v) },
{ "v", "increase verbosity", v => { if (v != null)
{
++verbosity;
}
} },
{ "h|help", "show this message and exit", v => showHelp = v != null },
};
if (0 == args.Length)
{
TryHelp();
return;
}
List <string> assemblies;
try
{
assemblies = p.Parse(args);
}
catch (OptionException e)
{
Error(e.Message);
TryHelp();
return;
}
if (showHelp)
{
ShowHelp(p);
return;
}
if (0 == assemblies.Count)
{
Error("No assembly names were given.");
TryHelp();
return;
}
if (0 == assemblyResolver.GetSearchDirectories().Length)
{
assemblyResolver.AddSearchDirectory(".");
}
IEnumerable <AssemblyDefinition> dependendAssemblies;
try
{
dependendAssemblies = FindDependendAssemblies(assemblies).ToList();
}
catch (Exception exception)
{
Error("Unable find dependend assemblies: {0}", exception.ToString());
return;
}
if (listDependenciesOnly)
{
foreach (var a in dependendAssemblies)
{
Console.WriteLine(a.MainModule.FullyQualifiedName);
}
return;
}
foreach (var d in ProcessAssemblies(dependendAssemblies).ToList())
{
try
{
WriteAssembly(d);
}
catch (Exception exception)
{
Error("Unable to write assembly: {0}", exception.ToString());
continue;
}
}
}
