| private Load ( string assemblyString ) : Assembly | ||
| assemblyString | string | |
| return | Assembly | |
private static Assembly GenerateAssembly(string code, AssemblyName name)
{
//Compile the source code
var references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
MetadataReference.CreateFromFile(typeof(TabularQueryProvider).Assembly.Location),
MetadataReference.CreateFromFile(typeof(TabularTableMappingAttribute).Assembly.Location),
};
var st = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create(name.FullName, new[] { st }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var result = compilation.Emit(name.CodeBase);
if (!result.Success)
{
var failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
var message = string.Join("\n", failures.Select(x => $"{x.Id}: {x.GetMessage()}"));
throw new InvalidOperationException("Compilation failures!\n\n" + message + "\n\nCode:\n\n" + code);
}
var assembly = Assembly.Load(name);
return(assembly);
}
// get all dependency directories
static HashSet <string> GetDependencyDirectories(AssemblyName[] dependencies)
{
// Since this assembly is already loaded in the domain this is a
// no-op and returns the already loaded assembly
return(new HashSet <string>(
dependencies.Select(dependency => Path.GetDirectoryName(Assembly.Load(dependency).Location))
));
}
public static void DiscoverCompiledTypes([NotNull] Stream stream)
{
// unfortunately, we don't have any methods to load an assembly from Stream
using (var byteStream = new MemoryStream())
{
stream.CopyTo(byteStream);
DiscoverCompiledTypes(Assembly.Load(byteStream.ToArray()));
}
}
private static IEnumerable <Type> GetTypes()
{
var types = new List <Type>();
var assemblies = CompilationPipeline.GetAssemblies();
foreach (var assembly in assemblies)
{
var compiledAssembly = Assembly.Load(assembly.name);
types.AddRange(compiledAssembly.ExportedTypes);
}
types.Sort((a, b) => string.Compare(a.FullName, b.FullName, StringComparison.Ordinal));
return(types);
}
static Assembly LoadFromFile(string assemblyPath)
{
var pdbPath = Path.ChangeExtension(assemblyPath, "pdb");
var rawAssembly = File.ReadAllBytes(assemblyPath);
if (File.Exists(pdbPath))
{
return(Assembly.Load(rawAssembly, File.ReadAllBytes(pdbPath)));
}
var mdbPath = Path.ChangeExtension(assemblyPath, "mdb");
if (File.Exists(mdbPath))
{
return(Assembly.Load(rawAssembly, File.ReadAllBytes(mdbPath)));
}
return(Assembly.Load(rawAssembly));
}
// get all non-dynamic assembly directories
static HashSet <string> GetNonDynamicAssemblyDirectories(Assembly[] assemblies)
{
HashSet <string> paths = new HashSet <string>();
foreach (Assembly assembly in assemblies)
{
if (!assembly.IsDynamic)
{
// need to check if file exists to avoid potential
// FileNotFoundException in Assembly.Load
string assemblyName = assembly.GetName().Name;
if (File.Exists(assemblyName))
{
paths.Add(Path.GetDirectoryName(Assembly.Load(assemblyName).Location));
}
}
}
return(paths);
}
public Models.Assembly Parse(string assemblyFile, bool bParseNamespace = true)
{
try
{
var namespaces = new List <Namespace>();
var b = File.ReadAllBytes(assemblyFile);
var assembly = Assembly.Load(b);
//var assembly = Assembly.LoadFile(assemblyFile);
if (bParseNamespace)
{
_reader = new XmlDocCommentReader(assemblyFile.Replace(".dll", ".xml"));
FindTypes(assembly, namespaces);
namespaces = namespaces.OrderBy(o => o.Name).ToList();
foreach (var nameSpace in namespaces)
{
nameSpace.Classes = nameSpace.Classes.OrderBy(c => c.Name).ToList();
}
}
var a = new Models.Assembly
{
Id = assembly.ManifestModule.ModuleVersionId,
Name = assembly.GetName().Name,
FullName = assembly.FullName,
Namespaces = namespaces
};
return(a);
}
catch (Exception ex)
{
Trace.TraceError("DLL {0} : Parse Problem. {1} => {2}", assemblyFile, ex.Message, ex.Source);
return(null);
}
}
public override void LoadPlugin()
{
base.LoadPlugin();
HarmonyInstance = new Harmony("uEssentialsAntiTrack");
try
{
AssemblyRef asm = AssemblyRef.Load("UEssentials");
if (asm == null)
{
throw new FileNotFoundException();
}
Type anylitics = asm.GetType("Essentials.Misc.Analytics");
if (anylitics != null)
{
MethodInfo sendAnylticicsEvent = anylitics.GetMethod("SendEvent", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (sendAnylticicsEvent != null)
{
HarmonyInstance.CreateProcessor(sendAnylticicsEvent).AddPrefix(typeof(AntiTracker).GetMethod("BlockMethod")).Patch();
Logger.Log("uEssentials analytics blocked.");
}
else
{
Logger.Log("Failed to find Analytics SendEvent Method.");
}
}
else
{
Logger.Log("Failed to find Analytics Type.");
}
}
catch (FileNotFoundException)
{
Logger.Log("uEssentials is not installed.");
}
}
