public void NonGeneratedInjectionConfigurationSerializationTest()
{
string configurationSerialized =
@"<Configuration>
<InjecteeAssemblies>
<InjecteeAssembly AssemblyPath=""lib1.dll"">
</InjecteeAssembly>
<InjecteeAssembly AssemblyPath=""lib2.dll"">
</InjecteeAssembly>
</InjecteeAssemblies>
<InjectedMethods>
<InjectedMethod AssemblyPath=""TestInjectedLibrary.dll"" MethodFullName=""TestInjectedLibrary.TestInjectedMethods.Complex"" InjectionPosition=""InjecteeMethodStart"" />
</InjectedMethods>
</Configuration>
";
InjectionConfiguration configurationDeserialized =
SimpleXmlSerializationUtility.XmlDeserializeFromString <InjectionConfiguration>(configurationSerialized);
string configurationSerializedAgain = SimpleXmlSerializationUtility.XmlSerializeToString(configurationDeserialized);
configurationSerializedAgain = NormalizeNewlines(configurationSerializedAgain.Trim());
configurationSerialized = NormalizeNewlines(configurationSerialized.Trim());
Console.WriteLine(configurationSerializedAgain);
Assert.AreEqual(configurationSerialized, configurationSerializedAgain);
}
public void GenerateSchema()
{
InjectionConfiguration configuration = GetInjectionConfiguration();
string configurationSerialized = SimpleXmlSerializationUtility.GenerateXmlSchemaString(configuration);
Console.WriteLine(configurationSerialized);
}
public void InjectionConfigurationSerializationTest()
{
InjectionConfiguration configuration = GetInjectionConfiguration();
string configurationSerialized = SimpleXmlSerializationUtility.XmlSerializeToString(configuration);
Console.WriteLine(configurationSerialized);
Console.WriteLine();
InjectionConfiguration configurationDeserialized =
SimpleXmlSerializationUtility.XmlDeserializeFromString <InjectionConfiguration>(configurationSerialized);
string configurationSerializedAgain = SimpleXmlSerializationUtility.XmlSerializeToString(configurationDeserialized);
Console.WriteLine(configurationSerializedAgain);
Assert.AreEqual(configurationSerialized, configurationSerializedAgain);
}
private void ExecuteInjection()
{
#if !DEBUG
try {
#endif
string serializedInjectorConfiguration;
if (_commandLineOptions.ReadConfigurationFromStandardInput)
{
serializedInjectorConfiguration = Console.In.ReadToEnd();
}
else
{
if (!File.Exists(_commandLineOptions.ConfigurationFilePath))
{
throw new MethodInlineInjectorException(
"Injection configuration file doesn't exists",
new FileNotFoundException(_commandLineOptions.ConfigurationFilePath)
);
}
serializedInjectorConfiguration = File.ReadAllText(_commandLineOptions.ConfigurationFilePath);
}
Log.Debug($"Input configuration:{Environment.NewLine}{serializedInjectorConfiguration}");
if (String.IsNullOrWhiteSpace(serializedInjectorConfiguration))
{
throw new MethodInlineInjectorException("Injector configuration is empty");
}
Log.Info("Parsing configuration file");
ValidateConfiguration(serializedInjectorConfiguration);
InjectionConfiguration injectionConfiguration =
SimpleXmlSerializationUtility.XmlDeserializeFromString <InjectionConfiguration>(serializedInjectorConfiguration);
Log.Info("Resolving configuration file");
ResolvedInjectionConfiguration resolvedInjectionConfiguration =
ResolvedInjectionConfigurationLoader.LoadFromInjectionConfiguration(injectionConfiguration);
Log.Info("Starting injection");
MethodInlineInjector assemblyMethodInjector = new MethodInlineInjector(resolvedInjectionConfiguration);
int injectedMethodCount = 0;
assemblyMethodInjector.BeforeMethodInjected += tuple => injectedMethodCount++;
assemblyMethodInjector.Inject();
Log.InfoFormat("Injected {0} methods", injectedMethodCount);
Log.Info("Writing modified assemblies");
foreach (ResolvedInjecteeAssembly injecteeAssembly in resolvedInjectionConfiguration.InjecteeAssemblies)
{
string path = injecteeAssembly.AssemblyDefinition.MainModule.FullyQualifiedName;
Log.DebugFormat("Writing assembly {0} to '{1}'", injecteeAssembly.AssemblyDefinition.FullName, path);
injecteeAssembly.AssemblyDefinition.Write(path);
}
#if !DEBUG
}
catch (MethodInlineInjectorException e) {
string message = "Fatal error: " + e;
if (e.InnerException != null)
{
message += Environment.NewLine;
message += "Error details: ";
message += e.InnerException;
}
Log.Fatal(message);
Environment.ExitCode = 1;
}
#endif
}
private ResolvedInjecteeAssembly GetInjecteeAssembly(InjecteeAssembly sourceInjecteeAssembly)
{
List <IgnoredMemberReference> ignoredMemberReferences = new List <IgnoredMemberReference>();
List <AllowedAssemblyReference> allowedAssemblyReferences = new List <AllowedAssemblyReference>();
void LoadIgnoredMemberReferences(IEnumerable <IIgnoredMemberReference> items)
{
foreach (IIgnoredMemberReference item in items)
{
if (item is IgnoredMemberReference ignoredMemberReference)
{
ignoredMemberReferences.Add(ignoredMemberReference);
continue;
}
if (item is IgnoredMemberReferenceInclude ignoredMemberReferenceInclude)
{
try {
Log.DebugFormat("Loading ignored member references list include at '{0}'", ignoredMemberReferenceInclude.Path);
string includeXml = File.ReadAllText(ignoredMemberReferenceInclude.Path);
IgnoredMemberReferencesIncludeLoader ignoredMemberReferencesIncludeLoader =
SimpleXmlSerializationUtility.XmlDeserializeFromString <IgnoredMemberReferencesIncludeLoader>(includeXml);
LoadIgnoredMemberReferences(ignoredMemberReferencesIncludeLoader.Items);
} catch (Exception e) {
Console.WriteLine(e);
throw new MethodInlineInjectorException(
$"Unable to load ignored member references list include at '{ignoredMemberReferenceInclude.Path}'",
e
);
}
}
}
}
void LoadAllowedAssemblyReferences(IEnumerable <IAllowedAssemblyReference> items)
{
foreach (IAllowedAssemblyReference item in items)
{
if (item is AllowedAssemblyReference allowedAssemblyReference)
{
allowedAssemblyReferences.Add(allowedAssemblyReference);
continue;
}
if (item is AllowedAssemblyReferenceInclude allowedAssemblyReferenceInclude)
{
Log.DebugFormat("Loading allowed assembly references list include at '{0}'", allowedAssemblyReferenceInclude.Path);
try {
string includeXml = File.ReadAllText(allowedAssemblyReferenceInclude.Path);
AllowedAssemblyReferenceIncludeLoader allowedAssemblyReferencesLoader =
SimpleXmlSerializationUtility.XmlDeserializeFromString <AllowedAssemblyReferenceIncludeLoader>(includeXml);
LoadAllowedAssemblyReferences(allowedAssemblyReferencesLoader.Items);
} catch (Exception e) {
throw new MethodInlineInjectorException(
$"Unable to load allowed assembly references list include at '{allowedAssemblyReferenceInclude.Path}'",
e
);
}
}
}
}
LoadIgnoredMemberReferences(sourceInjecteeAssembly.IgnoredMemberReferences);
LoadAllowedAssemblyReferences(sourceInjecteeAssembly.AllowedAssemblyReferences);
List <ResolvedAllowedAssemblyReference> resolvedAllowedAssemblyReferences =
allowedAssemblyReferences
.Select(item => new ResolvedAllowedAssemblyReference(AssemblyNameReference.Parse(item.Name), item.Path, item.StrictNameCheck))
.ToList();
// Configure assembly resolver for this assembly
IgnoringExceptionsAssemblyResolver assemblyResolver = CreateAssemblyResolver(resolvedAllowedAssemblyReferences);
AssemblyDefinitionCachedData assemblyDefinitionCachedData =
GetAssemblyDefinitionCachedData(sourceInjecteeAssembly.AssemblyPath, assemblyResolver);
Log.DebugFormat(
"Calculating injectee methods in assembly '{0}'",
assemblyDefinitionCachedData.AssemblyDefinition.MainModule.FullyQualifiedName);
List <MethodDefinition> filteredInjecteeMethods =
GetFilteredInjecteeMethods(assemblyDefinitionCachedData, ignoredMemberReferences);
ResolvedInjecteeAssembly resolvedInjecteeAssembly =
new ResolvedInjecteeAssembly(
assemblyDefinitionCachedData.AssemblyDefinition,
filteredInjecteeMethods,
resolvedAllowedAssemblyReferences,
assemblyResolver
);
return(resolvedInjecteeAssembly);
}
