Here are the examples of the csharp api System.Reflection.Assembly.LoadFrom(string) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
620 Examples
19
Source : ModLoader.cs
with MIT License
from Ciastex
with MIT License
from Ciastex
private bool LoadDependenciesForMod(string rootPath, string[] deps)
{
var baseDependencyDirPath = Path.Combine(rootPath, Defaults.PrivateDependencyDirectory);
foreach (var dep in deps)
{
var targetDepPath = Path.Combine(baseDependencyDirPath, dep);
try
{
Log.Info($"Loading dependency replacedembly '{dep}'...");
replacedembly.LoadFrom(targetDepPath);
}
catch (ReflectionTypeLoadException rtle)
{
Log.ReflectionTypeLoadException(rtle);
return false;
}
catch (Exception e)
{
Log.Exception(e);
return false;
}
}
return true;
}
19
Source : App.xaml.cs
with GNU General Public License v3.0
from CitizensReactor
with GNU General Public License v3.0
from CitizensReactor
private replacedembly Getreplacedembly(string replacedemblyName, List<DirectoryInfo> directories)
{
foreach (var directory in PluginDirectories)
{
string folderPath = directory.FullName;
string replacedemblyPath = Path.Combine(folderPath, replacedemblyName);
if (!File.Exists(replacedemblyPath)) continue;
replacedembly replacedembly = replacedembly.LoadFrom(replacedemblyPath);
return replacedembly;
}
return null;
}
19
Source : DetoursNetLoader.cs
with MIT License
from citronneur
with MIT License
from citronneur
public static int Start(string arguments)
{
string replacedemblyName = System.Environment.GetEnvironmentVariable("DETOURSNET_replacedEMBLY_PLUGIN");
replacedembly replacedembly = replacedembly.LoadFrom(replacedemblyName);
foreach(var method in replacedembly.FindAttribute(typeof(OnInitAttribute))) {
method.Invoke(null, null);
}
foreach (var method in replacedembly.FindAttribute(typeof(DetoursAttribute))) {
var attribute = (DetoursAttribute)method.GetCustomAttributes(typeof(DetoursAttribute), false)[0];
DelegateStore.Mine[method] = Delegate.CreateDelegate(attribute.DelegateType, method);
IntPtr module = LoadLibrary(attribute.Module);
if (module == IntPtr.Zero) {
continue;
}
IntPtr real = GetProcAddress(module, method.Name);
if (real == IntPtr.Zero) {
continue;
}
// record pointer
IntPtr import = real;
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(ref real, Marshal.GetFunctionPointerForDelegate(DelegateStore.Mine[method]));
DetourTransactionCommit();
// Add function to pinvoke cache
DetoursCLRSetGetProcAddressCache(module, method.Name, real);
// and so on patch IAT of clr module
DetoursPatchIAT(GetModuleHandle("clr.dll"), import, real);
DelegateStore.Real[method] = Marshal.GetDelegateForFunctionPointer(real, attribute.DelegateType);
}
return 0;
}
19
Source : ApplicationDeploymentWrapper.cs
with GNU General Public License v3.0
from ClusterM
with GNU General Public License v3.0
from ClusterM
private static void init()
{
try
{
string runtimeDirectory = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
replacedembly systemDeploymentreplacedembly = replacedembly.LoadFrom(Path.Combine(runtimeDirectory, "System.Deployment.dll"));
applicationDeploymentType = systemDeploymentreplacedembly.GetType("System.Deployment.Application.ApplicationDeployment");
}
catch (FileNotFoundException e)
{
Console.WriteLine("Could not load System.Deployment.dll dynamically: {0}", e.Message);
}
finally
{
inited = true;
}
}
19
Source : assemblymanager.cs
with MIT License
from CoFlows
with MIT License
from CoFlows
public static replacedembly LoadreplacedemblyPath(string name)
{
string path = Findreplacedembly(name);
replacedembly replacedembly = null;
if (path != null)
{
try
{
replacedembly = replacedembly.LoadFrom(path);
}
catch (Exception)
{
}
}
return replacedembly;
}
19
Source : assemblymanager.cs
with MIT License
from CoFlows
with MIT License
from CoFlows
public static replacedembly LoadreplacedemblyFullPath(string name)
{
replacedembly replacedembly = null;
if (Path.IsPathRooted(name))
{
if (!Path.HasExtension(name))
{
name = name + ".dll";
}
if (File.Exists(name))
{
try
{
replacedembly = replacedembly.LoadFrom(name);
}
catch (Exception)
{
}
}
}
return replacedembly;
}
19
Source : Program.cs
with MIT License
from copyliu
with MIT License
from copyliu
[STAThread]
public static void Unregister()
{
ITfCategoryMgr c = new ITfCategoryMgr();
foreach (var supportCategory in SupportCategories)
{
var r = c.UnregisterCategory(CLSID_TEXTSERVICE, supportCategory, CLSID_TEXTSERVICE);
Console.WriteLine(r.ToString());
}
ITfInputProcessorProfiles p = new ITfInputProcessorProfiles();
var result = p.Unregister(CLSID_TEXTSERVICE);
Console.WriteLine(result.ToString());
var regservice = new RegistrationServices();
regservice.Unregisterreplacedembly(replacedembly.LoadFrom("YIME.Core.dll"));
}
19
Source : Program.cs
with MIT License
from copyliu
with MIT License
from copyliu
[STAThread]
public static void Register()
{
var regservice = new RegistrationServices();
regservice.Registerreplacedembly(replacedembly.LoadFrom("YIME.Core.dll"),
replacedemblyRegistrationFlags.SetCodeBase);
var iconname = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(replacedembly.GetEntryreplacedembly().Location),
"YIME.Core.dll");
Console.WriteLine(iconname);
Console.WriteLine(CultureInfo.GetCultureInfo("zh-cn").LCID);
//Insert code here.
var p = new ITfInputProcessorProfiles();
var result = p.Register(CLSID_TEXTSERVICE);
Console.WriteLine(result.ToString());
result = p.AddLanguageProfile(CLSID_TEXTSERVICE, new LangID((ushort)CultureInfo.GetCultureInfo("zh-cn").LCID), GUID_PROFILE,
name.ToCharArray(), (uint)name.ToCharArray().Length, iconname.ToCharArray(), (uint)iconname.Length, 0);
Console.WriteLine(result.ToString());
var c = new ITfCategoryMgr();
foreach (var supportCategory in SupportCategories)
{
var r = c.RegisterCategory(CLSID_TEXTSERVICE, supportCategory, CLSID_TEXTSERVICE);
Console.WriteLine(r.ToString());
}
}
19
Source : AutofacModuleRegister.cs
with Apache License 2.0
from CoreUnion
with Apache License 2.0
from CoreUnion
protected override void Load(ContainerBuilder builder)
{
var basePath = AppContext.BaseDirectory;
#region 带有接口层的服务注入
var servicesDllFile = Path.Combine(basePath, "CoreCms.Net.Services.dll");
var repositoryDllFile = Path.Combine(basePath, "CoreCms.Net.Repository.dll");
if (!(File.Exists(servicesDllFile) && File.Exists(repositoryDllFile)))
{
var msg = "Repository.dll和Services.dll 丢失,因为项目解耦了,所以需要先F6编译,再F5运行,请检查 bin 文件夹,并拷贝。";
throw new Exception(msg);
}
// AOP 开关,如果想要打开指定的功能,只需要在 appsettigns.json 对应对应 true 就行。
//var cacheType = new List<Type>();
//if (AppSettingsConstVars.RedisConfigEnabled)
//{
// builder.RegisterType<RedisCacheAop>();
// cacheType.Add(typeof(RedisCacheAop));
//}
//else
//{
// builder.RegisterType<MemoryCacheAop>();
// cacheType.Add(typeof(MemoryCacheAop));
//}
// 获取 Service.dll 程序集服务,并注册
var replacedemblysServices = replacedembly.LoadFrom(servicesDllFile);
//支持属性注入依赖重复
builder.RegisterreplacedemblyTypes(replacedemblysServices).AsImplementedInterfaces().InstancePerDependency()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);
// 获取 Repository.dll 程序集服务,并注册
var replacedemblysRepository = replacedembly.LoadFrom(repositoryDllFile);
//支持属性注入依赖重复
builder.RegisterreplacedemblyTypes(replacedemblysRepository).AsImplementedInterfaces().InstancePerDependency()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);
// 获取 Service.dll 程序集服务,并注册
//var replacedemblysServices = replacedembly.LoadFrom(servicesDllFile);
//builder.RegisterreplacedemblyTypes(replacedemblysServices)
// .AsImplementedInterfaces()
// .InstancePerDependency()
// .PropertiesAutowired()
// .EnableInterfaceInterceptors()//引用Autofac.Extras.DynamicProxy;
// .InterceptedBy(cacheType.ToArray());//允许将拦截器服务的列表分配给注册。
//// 获取 Repository.dll 程序集服务,并注册
//var replacedemblysRepository = replacedembly.LoadFrom(repositoryDllFile);
//builder.RegisterreplacedemblyTypes(replacedemblysRepository)
// .AsImplementedInterfaces()
// .PropertiesAutowired()
// .InstancePerDependency();
#endregion
}
19
Source : PreferencesRenderersScanner.cs
with Apache License 2.0
from cosmos-loops
with Apache License 2.0
from cosmos-loops
private static IEnumerable<replacedembly> GetAllUnlinkedreplacedemblies() {
var directoryRoot = new DirectoryInfo(Directory.GetCurrentDirectory());
var files = directoryRoot.GetFiles("Cosmos.Logging.Renderers.*.dll", SearchOption.AllDirectories);
foreach (var file in files) {
yield return replacedembly.LoadFrom(file.FullName);
}
}
19
Source : Program.cs
with BSD 3-Clause "New" or "Revised" License
from CosmosOS
with BSD 3-Clause "New" or "Revised" License
from CosmosOS
private static void Run()
{
try
{
var xUserComments = _Args["UserComments", "UC"];
if (xUserComments != null) _Gen.EmitUserComments = xUserComments.Check("ON", new string[] { "ON", "OFF" }).ToUpper() == "ON";
//
var xSourceCode = _Args["SourceCode", "SC"];
if (xSourceCode != null) _Gen.EmitSourceCode = xSourceCode.Check("ON", new string[] { "ON", "OFF" }).ToUpper() == "ON";
//
var xOutput = _Args["Out", "O"];
if (xOutput != null) _OutputPath = xOutput.Value;
//
_Append = _Args["Append", "A"] != null;
if (_Append && xOutput == null) throw new Exception("Use of -Append requires use of -Out.");
//
var xCPU = _Args["CPU"];
if (xCPU == null) throw new Exception("-CPU is a required parameter.");
_CPU = xCPU.Check("", new string[] { "X86", "ARM" }, true).ToUpper();
// Plugins
var xPlugins = _Args.GetSwitches("PlugIn");
foreach (var xPlugin in xPlugins)
{
// TODO Load plugins
throw new Exception("TODO");
}
foreach (var xArg in _Args.Args)
{
string xVal = xArg.Value;
if (!Path.IsPathRooted(xVal))
{
xVal = Path.Combine(Directory.GetCurrentDirectory(), xVal);
}
if (Directory.Exists(xVal))
{
// If dir specified, find all .xs files
string xPath = Path.GetFullPath(xVal);
_XsFiles.AddRange(Directory.GetFiles(xPath, "*.xs"));
}
else if (File.Exists(xVal))
{
// Load .XS inputs, or replacedemblies to load into compiler itself (plugins etc?)
string xExt = Path.GetExtension(xVal).ToUpper();
if (xExt == ".XS")
{
_XsFiles.Add(Path.GetFullPath(xVal));
}
else if (xExt == ".DLL")
{
_replacedemblies.Add(replacedembly.LoadFrom(xVal));
}
else
{
throw new Exception($"Not a valid file type: {xVal}");
}
}
else
{
throw new Exception($"Not a valid file or directory: {xVal}");
}
}
if(_XsFiles.Count == 0)
{
throw new Exception("No xs files to compiler were found");
}
if (_Args["Gen2"] != null)
{
RunGen2();
}
else
{
RunGen1();
}
}
catch (Exception ex)
{
if (_Args["WaitOnError"] != null)
{
Console.WriteLine();
Console.WriteLine("Waiting on error. Press Enter to exit.");
Console.WriteLine($"Exception: {ex}");
Console.ReadLine();
}
Environment.Exit(-1);
}
}
19
Source : ContainerBuilderExtensions.cs
with MIT License
from craigbridges
with MIT License
from craigbridges
internal static replacedembly[] GetAllreplacedemblies(this ContainerBuilder builder)
{
if (_allreplacedemblies == null)
{
var currentreplacedembly = replacedembly.GetExecutingreplacedembly();
var currentDirectory = currentreplacedembly.GetDirectoryPath();
var fileNames = new List<string>(FindreplacedemblyFileNames(currentDirectory));
var loadedreplacedemblies = new List<replacedembly>();
foreach (var replacedemblyFile in fileNames)
{
loadedreplacedemblies.Add(replacedembly.LoadFrom(replacedemblyFile));
}
_allreplacedemblies = loadedreplacedemblies.ToArray();
}
IEnumerable<string> FindreplacedemblyFileNames(string path)
{
path = path.Replace("\\\\", "\\");
if (Directory.Exists(path))
{
var fileNames = Directory.EnumerateFiles(path, "*.dll", SearchOption.AllDirectories);
return fileNames.Where(x => false == x.Contains(@"\runtimes\"));
}
else
{
return new string[] { };
}
}
return _allreplacedemblies;
}
19
Source : Program.cs
with MIT License
from CXuesong
with MIT License
from CXuesong
static void Main(string[] args)
{
if (args.Length < 1)
{
Usage();
}
string path = null;
string locale = null;
string replacedemblyPath = null;
string methodPath = null;
for (var i = 0; i < args.Length; ++i)
{
var arg = args[i];
if (arg.StartsWith("-"))
{
switch (arg)
{
case "-c":
if (++i < args.Length)
{
locale = args[i];
}
break;
case "-g":
if (++i < args.Length)
{
replacedemblyPath = Path.GetFullPath(args[i]);
}
if (++i < args.Length)
{
methodPath = args[i];
}
break;
default:
Usage();
break;
}
}
else
{
path = arg;
}
}
if (replacedemblyPath != null)
{
var replacedembly = replacedembly.LoadFrom(replacedemblyPath);
var methodParts = methodPath.Split('.');
var methodName = methodParts.Last();
var clreplacedName = string.Join(".", methodParts.Take(methodParts.Count() - 1));
var clreplacedType = replacedembly.GetType(clreplacedName);
var method = clreplacedType.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
var methodArgs = new object[method.GetParameters().Length];
var form = method.Invoke(null, methodArgs);
var formPath = clreplacedName + ".resx";
using (var stream = new FileStream(formPath, FileMode.Create))
using (var writer = new ResXResourceWriter(stream))
{
form.GetType().InvokeMember("SaveResources",
BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy,
null, form, new object[] { writer });
}
Console.WriteLine($"Generated {formPath} by calling {methodPath} in {replacedemblyPath}.");
}
else
{
var isResX = Path.GetExtension(path) == ".resx";
IResourceWriter writer = null;
FileStream outStream = null;
if (locale != null)
{
var outPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path) + "-" + locale + Path.GetExtension(path));
Console.Write($"Copying to {outPath}");
Console.WriteLine();
outStream = new FileStream(outPath, FileMode.Create);
writer = isResX ? (IResourceWriter)new ResXResourceWriter(outStream) : (IResourceWriter)new ResourceWriter(outStream);
}
using (var stream = new FileStream(path, FileMode.Open))
using (var reader = isResX ? (IResourceReader)new ResXResourceReader(stream) : (IResourceReader)new ResourceReader(stream))
using (outStream)
using (writer)
{
int values = 0;
int lists = 0;
int templates = 0;
foreach (DictionaryEntry entry in reader)
{
var fullKey = (string)entry.Key;
var value = (string)entry.Value;
var typeAndKey = fullKey.Split(SEPERATOR);
var type = typeAndKey.Last();
if (writer == null)
{
Console.WriteLine($"{fullKey}: {value}");
}
else
{
if (type == "LIST" || type == "TEMPLATE")
{
writer.AddResource(fullKey, MakeList(from elt in SplitList(value) select "<" + elt + ">"));
}
else
{
writer.AddResource(fullKey, "<" + value + ">");
}
}
switch (type)
{
case "VALUE": ++values; break;
case "LIST": ++lists; break;
case "TEMPLATE": ++templates; break;
}
}
Console.WriteLine($"Found {values} values, {lists} lists and {templates} templates");
}
}
}
19
Source : ReflectionHelper.cs
with MIT License
from dahall
with MIT License
from dahall
public static Type LoadType(string typeName, string asmRef)
{
Type ret = null;
if (!TryGetType(replacedembly.LoadFrom(asmRef), typeName, ref ret))
if (!TryGetType(replacedembly.GetExecutingreplacedembly(), typeName, ref ret))
if (!TryGetType(replacedembly.GetCallingreplacedembly(), typeName, ref ret))
TryGetType(replacedembly.GetEntryreplacedembly(), typeName, ref ret);
return ret;
}
19
Source : ReflectionHelper.cs
with MIT License
from dahall
with MIT License
from dahall
private static bool TryGetType(string asmRef, string typeName, ref Type type)
{
try
{
if (System.IO.File.Exists(asmRef))
return TryGetType(replacedembly.LoadFrom(asmRef), typeName, ref type);
}
catch { }
return false;
}
19
Source : ReflectionExtensions.cs
with MIT License
from dahall
with MIT License
from dahall
public static Type LoadType(string typeName, string asmRef = null)
{
replacedembly asm = null;
try { asm = replacedembly.LoadFrom(asmRef); } catch { }
if (!TryGetType(asm, typeName, out var ret))
{
foreach (var asm2 in AppDomain.CurrentDomain.Getreplacedemblies())
if (TryGetType(asm2, typeName, out ret)) break;
}
return ret;
}
19
Source : Program.cs
with MIT License
from Daimler
with MIT License
from Daimler
private static MMUDescription GetDescriptionFromClreplaced(string path)
{
//Load the mmu from filesystem and instantiate
replacedembly replacedembly = replacedembly.LoadFrom(path);
//Get the specific type of the clreplaced which implementd the IMotionModelUnitDev interface
Type clreplacedType = GetMMUClreplacedType(replacedembly);
if (clreplacedType != null)
{
//Get all defined attributes
List<object> attributes = GetAttributes(clreplacedType);
MMUDescriptionAttribute mmuDescriptionAttr = attributes.Find(s => s is MMUDescriptionAttribute) as MMUDescriptionAttribute;
var mParamterAttr = attributes.Where(s => s is MParameterAttribute);
var simEvents = attributes.Where(s => s is MSimulationEventAttribute);
//Create the mmu description
MMUDescription mmuDescription = new MMUDescription()
{
Name = mmuDescriptionAttr.Name,
Author = mmuDescriptionAttr.Author,
Version = mmuDescriptionAttr.Version,
MotionType = mmuDescriptionAttr.MotionType,
LongDescription = mmuDescriptionAttr.LongDescription,
ShortDescription = mmuDescriptionAttr.ShortDescription,
//Language can be automatically set
Language = "C#",
//Auto-generate an ID
ID = Guid.NewGuid().ToString(),
//Use the replacedembly name from the path
replacedemblyName = System.IO.Path.GetFileName(path)
};
//Add all parameters
if (mParamterAttr != null)
{
mmuDescription.Parameters = new System.Collections.Generic.List<MParameter>();
foreach (MParameterAttribute param in mParamterAttr)
{
mmuDescription.Parameters.Add(new MParameter(param.Name, param.Type, param.Description, param.Required));
}
}
//Add all events (if defined)
if (simEvents != null)
{
mmuDescription.Events = new System.Collections.Generic.List<string>();
foreach (MSimulationEventAttribute param in simEvents)
{
mmuDescription.Events.Add(param.Type);
}
}
//Return the created MMU Description
return mmuDescription;
}
return null;
}
19
Source : Program.cs
with MIT License
from Damon-Salvatore
with MIT License
from Damon-Salvatore
static void Main(string[] args)
{
// 程序依据需求的不同,耦合度不断的变化,开发者应该对这一些列变化深入掌握,才能更好的把握.Net原理
#region 【1】普通对象的创建:性能最好,最容易理解,耦合度最高
Console.WriteLine("\r\n【1】普通对象的创建----------------------------------");
Student student1 = new Student();
Console.WriteLine(student1.GetEnreplacedyTypeById(1));
#endregion
#region 【2】基于接口的对象创建:接口更好的体现面向抽象编程,一定程度解耦
Console.WriteLine("\r\n【2】基于接口的对象创建-----------------------------");
IQueryService student2 = new Student();
Console.WriteLine(student2.GetEnreplacedyTypeById(2));
#endregion
#region 【3】反射的基本使用
Console.WriteLine("\r\n【3】反射的基本使用----------------------------------");
replacedembly replaced3 = replacedembly.Load("myApp"); //在当前运行目录下根据程序集名称加载
string path = System.IO.Directory.GetCurrentDirectory() + "\\myApp.dll";
Console.WriteLine(path);
//使用完整的路径加载程序集文件,。net core中需要在 根目录执行 dotnet myApp.dll
replacedembly replaced3_2 = replacedembly.LoadFile(path);
//根据程序集文件名称,加载当前运行目录下的程序集,net core中需要在 根目录执行 dotnet myApp.dll
replacedembly replaced3_3 = replacedembly.LoadFrom("myApp.dll");
//观察程序集对象给我们提供的信息
foreach (var item in replaced3.GetTypes()) //Type表示当前程序集中所能找到的可用类型
{
Console.WriteLine(item.Name + " \t" + item);
}
Console.WriteLine("----------------------------------------");
foreach (var item in replaced3_2.GetTypes()) //Type表示当前程序集中所能找到的可用类型
{
Console.WriteLine(item.Name + " \t" + item);
}
Console.WriteLine("----------------------------------------");
foreach (var item in replaced3_3.GetTypes()) //Type表示当前程序集中所能找到的可用类型
{
Console.WriteLine(item.Name + " \t" + item);
}
#endregion
#region 【4】基于反射的对象创建
Console.WriteLine("\r\n【4】基于反射的对象创建-----------------------------");
replacedembly replaced4 = replacedembly.Load("myApp");
// 根据一个类或接口的完全限定名,得到这个类型,这个类型可以是我目前使用的各种类型:
// 类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义,以及开放或封闭构造的泛型类型。
Type studentType = replaced4.GetType("myApp.School.Student");
Student student4 = (Student)Activator.CreateInstance(studentType); //Activator并非反射中的类
Student student4_2 = (Student)replacedembly.Load("myApp").CreateInstance("myApp.School.Student");
IQueryService student4_3 = (Student)replacedembly.Load("myApp").CreateInstance("myApp.School.Student");
Console.WriteLine(student4.GetEnreplacedyTypeById(1));
Console.WriteLine(student4_2.GetEnreplacedyTypeById(2));
Console.WriteLine(student4_3.GetEnreplacedyTypeById(3));
#endregion
#region 【5】反射的基本使用(对象的延迟创建:简单工厂,抽象工厂...)
Console.WriteLine("\r\n【5】反射在简单工厂中的使用-------------------------");
IQueryService student5 = SimpleFactory.GetEnreplacedy();
Console.WriteLine(student5.GetEnreplacedyTypeById(1));
#endregion
#region 【6】在反射中使用构造方法
Console.WriteLine("\r\n【6】在反射中使用构造方法-----------------------");
Type stuType = replacedembly.Load("myApp").GetType("myApp.School.Student");
//获取程序集中指定类型的构造方法
ConstructorInfo[] ctors = stuType.GetConstructors();
Console.WriteLine("当前类型中构造函数的总数:" + ctors.Length);
//显示所有的构造方法在IL中的名称(在IL中都是.ctor,可以通过ILDASM工具查看)
foreach (ConstructorInfo item in ctors)
{
Console.WriteLine(item.Name);
}
//通过构造方法创建对象(请用断点调试下面的三条语句)
object stuObj6 = Activator.CreateInstance(stuType);//调用无参数的构造方法
object stuObj6_2 = Activator.CreateInstance(stuType, new object[] { 1001 });//调用一个参数的构造方法
object stuObj6_3 = Activator.CreateInstance(stuType, new object[] { 1001, "小李子" });//调用两个参数的构造方法
#endregion
#region 【7】单利模式中私有构造方法调用
Console.WriteLine("\r\n【7】单利模式中私有构造方法调用--------------");
President newPresident = President.GetPresident();
newPresident.SayHello();
Type presidentType = replacedembly.Load("myApp").GetType("myApp.School.President");
object president = Activator.CreateInstance(presidentType, true);//true表示可以匹配私有构造方法(请断点调试观察)
#endregion
#region 【8】泛型类中使用反射创建对象
Console.WriteLine("\r\n【8】泛型类中使用反射创建对象--------------");
//泛型类在IL中和普通类名称是不一样的,请大家通过ILDASM查看,比如Instructor2`2 后面的“ `2 ” 如果是三个泛型参数,则后面是3
//也可以通过控制台,直接查看输出,比如【3】中的输出
Type genericInstructorType = replacedembly.Load("myApp").GetType("myApp.School.Instructor2`2");
Type commonType = genericInstructorType.MakeGenericType(new Type[] { typeof(string), typeof(string) });
object objInstructor = Activator.CreateInstance(commonType);
((Instructor2<string, string>)objInstructor).SayHello("计算机系", "辅导员");
#endregion
#region 【9】基于反射调用实例公有方法、私有方法、静态方法
Console.WriteLine("\r\n【9】基于反射调用实例公有方法、私有方法、静态方法--------------");
Type teacherType9 = replacedembly.Load("myApp").GetType("myApp.School.Teacher");
object teacher = Activator.CreateInstance(teacherType9);
//以下输出内容为:属性对应的方法、自定义的各种方法、通过继承获得的方法(特别注意,这里全部是公有方法!)
foreach (MethodInfo item in teacherType9.GetMethods())
{
Console.WriteLine(item.Name);
}
Console.WriteLine("\r\n-----------------------------------------------------");
//通过方法名获取方法
MethodInfo method = teacherType9.GetMethod("SayHello");
method.Invoke(teacher, null);//调用无参数方法使用null
MethodInfo method9_1 = teacherType9.GetMethod("Teach", new Type[] { typeof(int) });
method9_1.Invoke(teacher, new object[] { 1 });//调用1个参数的方法
MethodInfo method9_2 = teacherType9.GetMethod("Teach", new Type[] { typeof(int), typeof(string) });
method9_2.Invoke(teacher, new object[] { 1, "第3章" });//调用2个参数的方法
MethodInfo method9_3 = teacherType9.GetMethod("Teach", new Type[] { typeof(int), typeof(string), typeof(string) });
method9_3.Invoke(teacher, new object[] { 1, "第3章", ".Net反射技术" });//调用3个参数的方法
Console.WriteLine("\r\n-----------------------------------------------------");
MethodInfo method9_4 = teacherType9.GetMethod("GetSalary", BindingFlags.Instance | BindingFlags.NonPublic);
method9_4.Invoke(teacher, null);//调用私有方法
Console.WriteLine("\r\n-----------------------------------------------------");
MethodInfo method9_5 = teacherType9.GetMethod("Lecture", new Type[] { typeof(string) });
method9_5.Invoke(teacher, new object[] { ".Net反射的原理和应用" });//调用静态方法
method9_5.Invoke(null, new object[] { ".Net反射的原理和应用" });//调用静态方法第一个实例可以为null,实例方法调用则不能省略
Console.WriteLine("\r\n-----------------------------------------------------");
MethodInfo method9_6 = teacherType9.GetMethod("TeachAdvancedCourse");
MethodInfo genericMethod9_6 = method9_6.MakeGenericMethod(typeof(string), typeof(int));
genericMethod9_6.Invoke(teacher, new object[] { "8:00-10:00", 2 });
#endregion
#region 【10】基于反射调用字段和属性
Console.WriteLine("\r\n【10】基于反射调用公有属性和字段-------------------");
Type teacherType10 = replacedembly.Load("myApp").GetType("myApp.School.Teacher");
object teacher10 = Activator.CreateInstance(teacherType10);
//显示全部属性
foreach (PropertyInfo item in teacherType10.GetProperties())
{
Console.WriteLine(item.Name);
}
Console.WriteLine("\r\n--------------------------------------------------");
//显示全部字段
foreach (FieldInfo item in teacherType10.GetFields())
{
Console.WriteLine(item.Name);
}
Console.WriteLine("\r\n--------------------------------------------------");
//给属性赋值
PropertyInfo property = teacherType10.GetProperty("Department");
property.SetValue(teacher10, ".Net教学组");
Console.WriteLine(property.GetValue(teacher10));
//给字段赋值
FieldInfo field = teacherType10.GetField("Company");
field.SetValue(teacher10, "腾讯课堂");
Console.WriteLine(field.GetValue(teacher10));
#endregion
#region 【11】关于反射的性能测试和优化
Console.WriteLine("\r\n【11】关于反射的性能测试和优化-------------------");
long time1 = 0;
long time2 = 0;
long time3 = 0;
//普通方法
Stopwatch sw1 = new Stopwatch();
sw1.Start();
for (int i = 0; i < 1000000; i++)
{
Teacher myTeacher = new Teacher();
myTeacher.Test();
}
sw1.Stop();
time1 = sw1.ElapsedMilliseconds;
//反射方法(大概是普通方法的500多倍)
Stopwatch sw2 = new Stopwatch();
sw2.Start();
for (int i = 0; i < 1000000; i++)
{
Teacher myTeacher = (Teacher)replacedembly.Load("myApp").CreateInstance("myApp.School.Teacher");
myTeacher.Test();
}
sw2.Stop();
time2 = sw2.ElapsedMilliseconds;
//优化反射方法(和普通方法相差无几)
Stopwatch sw3 = new Stopwatch();
sw3.Start();
Type tType = replacedembly.Load("myApp").GetType("myApp.School.Teacher");
for (int i = 0; i < 1000000; i++)
{
Teacher myTeacher = (Teacher)Activator.CreateInstance(tType);
myTeacher.Test();
}
sw3.Stop();
time3 = sw3.ElapsedMilliseconds;
Console.WriteLine($"普通方法:{time1}\t反射方法:{time2} 优化反射方法:{time3}");
#endregion
Console.Read();
}
19
Source : SOArchitecture_EditorUtility.cs
with MIT License
from DanielEverland
with MIT License
from DanielEverland
private static void CreatePropertyDrawerGraph()
{
_propertyDrawerGraph = new PropertyDrawerGraph();
HashSet<string> replacedemblyNamesToCheck = new HashSet<string>()
{
"replacedembly-CSharp-Editor",
};
GetAllreplacedetDefintionNames(replacedemblyNamesToCheck);
string dataPath = Application.dataPath;
string libraryPath = dataPath.Substring(0, dataPath.LastIndexOf('/')) + "/Library/Scriptreplacedemblies";
foreach (string file in Directory.GetFiles(libraryPath))
{
if(replacedemblyNamesToCheck.Contains(Path.GetFileNameWithoutExtension(file)) && Path.GetExtension(file) == ".dll")
{
replacedembly replacedembly = replacedembly.LoadFrom(file);
_propertyDrawerGraph.CreateGraph(replacedembly);
}
}
}
19
Source : AssemblyLoadContext.cs
with MIT License
from dapplo
with MIT License
from dapplo
public replacedembly LoadFromreplacedemblyPath(string replacedemblyPath)
{
return replacedembly.LoadFrom(replacedemblyPath);
}
19
Source : LanguageStep.cs
with GNU General Public License v3.0
from darakeon
with GNU General Public License v3.0
from darakeon
[Given(@"I have these enums")]
public void GivenIHaveTheseEnums(Table table)
{
keys = new List<Pair>();
foreach (var row in table.Rows)
{
var section = row["Section"];
var project = row["Project"];
var path = row["Path"];
var type = row["Enum"];
var @namespace = $"DFM.{project}";
var replacedembly = replacedembly.LoadFrom($"{@namespace}.dll");
if (!String.IsNullOrEmpty(path))
@namespace += $".{path}";
var fullname = @namespace + "." + type;
var @enum = replacedembly.GetType(fullname);
if (@enum == null)
throw new InvalidEnumArgumentException(fullname);
Enum.GetNames(@enum)
.Select(m => new Pair(section, m))
.ToList()
.ForEach(keys.Add);
}
}
19
Source : ApplicationManager.cs
with GNU General Public License v2.0
from DarthAffe
with GNU General Public License v2.0
from DarthAffe
private void LoadDeviceProviders()
{
string deviceProvierDir = Path.Combine(Path.GetDirectoryName(replacedembly.GetEntryreplacedembly().Location) ?? string.Empty, DEVICEPROVIDER_DIRECTORY);
if (!Directory.Exists(deviceProvierDir)) return;
foreach (string file in Directory.GetFiles(deviceProvierDir, "*.dll"))
{
try
{
replacedembly replacedembly = replacedembly.LoadFrom(file);
foreach (Type loaderType in replacedembly.GetTypes().Where(t => !t.IsAbstract && !t.IsInterface && t.IsClreplaced
&& typeof(IRGBDeviceProviderLoader).IsreplacedignableFrom(t)))
{
if (Activator.CreateInstance(loaderType) is IRGBDeviceProviderLoader deviceProviderLoader)
{
//TODO DarthAffe 03.06.2018: Support Initialization
if (deviceProviderLoader.RequiresInitialization) continue;
RGBSurface.Instance.LoadDevices(deviceProviderLoader);
}
}
}
catch { /* #sadprogrammer */ }
}
}
19
Source : AppLoader.cs
with Apache License 2.0
from datalust
with Apache License 2.0
from datalust
replacedembly OnreplacedemblyResolve(object _, ResolveEventArgs e)
{
if (e.Name == null) return null;
var target = new replacedemblyName(e.Name);
foreach (var contract in _contracts)
{
if (contract.GetName().Name!.Equals(target.Name))
return contract;
}
var replacedemblyFile = Path.Combine(_packageBinaryPath, target.Name + ".dll");
if (File.Exists(replacedemblyFile)) return replacedembly.LoadFrom(replacedemblyFile);
return null;
}
19
Source : AppLoader.cs
with Apache License 2.0
from datalust
with Apache License 2.0
from datalust
IEnumerable<replacedembly> LoadPackagereplacedemblies()
{
var loaded = new Dictionary<string, replacedembly>();
foreach (var replacedemblyFile in Directory.GetFiles(_packageBinaryPath, "*.dll"))
{
var fn = Path.GetFileNameWithoutExtension(replacedemblyFile);
if (_contracts
.Any(hosted => hosted.GetName().Name!.Equals(fn, StringComparison.OrdinalIgnoreCase)))
continue;
try
{
var replacedembly = replacedembly.LoadFrom(replacedemblyFile);
loaded.Add(replacedembly.FullName!, replacedembly);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
}
return loaded.Values;
}
19
Source : Program.cs
with GNU General Public License v3.0
from dawn-lc
with GNU General Public License v3.0
from dawn-lc
public static replacedembly CurrentDomain_replacedemblyResolve(object sender, ResolveEventArgs args)
{
string[] replacedemblyName = args.Name.Split(',');
DirectoryInfo DirectoryInfo = new DirectoryInfo(Environment.CurrentDirectory + "\\Bin\\");
try
{
if (!DirectoryInfo.Exists)
{
Directory.CreateDirectory(DirectoryInfo.FullName);
}
if (!replacedemblyName[0].Contains(MethodBase.GetCurrentMethod().DeclaringType.Namespace))
{
switch (replacedemblyName[0])
{
default:
return replacedembly.LoadFrom(DirectoryInfo.FullName + replacedemblyName[0] + ".dll");
}
}
}
catch (IOException)
{
using (MemoryStream replacedembly = new MemoryStream())
{
replacedembly.GetExecutingreplacedembly().GetManifestResourceStream(MethodBase.GetCurrentMethod().DeclaringType.Namespace + ".Resources." + replacedemblyName[0] + ".dll").CopyTo(replacedembly);
return replacedembly.Load(replacedembly.ToArray());
}
}
catch (Exception ex)
{
Console.WriteLine("加载程序集出错!请向开发者提交以下错误信息。");
Console.WriteLine(ex.ToString());
}
return null;
}
19
Source : ConstraintManager.cs
with GNU General Public License v3.0
from dclamage
with GNU General Public License v3.0
from dclamage
private static IEnumerable<Type> GetAllConstraints()
{
List<replacedembly> replacedemblies = AppDomain.CurrentDomain.Getreplacedemblies().ToList();
// Dynamically include the plugins replacedembly
try
{
foreach (string file in Directory.EnumerateFiles(@"./plugins", "*.dll", new EnumerationOptions() { MatchCasing = MatchCasing.CaseInsensitive, IgnoreInaccessible = true, AttributesToSkip = FileAttributes.Hidden | FileAttributes.System | FileAttributes.Directory }))
{
if (!file.EndsWith("SudokuSolver.dll"))
{
try
{
replacedembly replacedembly = replacedembly.LoadFrom(file);
replacedemblies.Add(replacedembly);
}
catch (Exception e)
{
throw new ArgumentException($"**WARNING** Could not load plugin at {file}: {e.Message}");
}
}
}
}
catch (Exception) { }
return replacedemblies
.Where(replacedembly => !replacedembly.IsDynamic)
.SelectMany(replacedembly => replacedembly.GetExportedTypes())
.Where(IsValidConstraint);
}
19
Source : Tools.cs
with BSD 3-Clause "New" or "Revised" License
from debug-sharp
with BSD 3-Clause "New" or "Revised" License
from debug-sharp
public static Type GetTypeGlobaly (string replacedemblyName, string fullClreplacedName) {
// do not use this - it gets all loaded replacedemblies into memory
//Dim replacedemblies As Reflection.replacedembly() = AppDomain.CurrentDomain.Getreplacedemblies()
// do not use this - it gets all replacedemblies from references
//AppDomain.CurrentDomain.Getreplacedemblies()
Type type = null;
// use this - it gets all replacedemblies in aplication directory
try {
IEnumerable<replacedembly> replacedemblies =
from file in Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory)
where Path.GetExtension(file) == ".dll"
select replacedembly.LoadFrom(file);
foreach (replacedembly replacedembly in replacedemblies) {
if (replacedembly.GetName().Name == replacedemblyName) {
type = replacedembly.GetType(fullClreplacedName);
break;
}
}
} catch {
}
return type;
}
19
Source : STNodeTreeView.cs
with MIT License
from DebugST
with MIT License
from DebugST
private STNodeTreeCollection AddreplacedemblyPrivate(string strFile) {
strFile = System.IO.Path.GetFullPath(strFile);
var asm = replacedembly.LoadFrom(strFile);
STNodeTreeCollection items = new STNodeTreeCollection(System.IO.Path.GetFileNameWithoutExtension(strFile));
foreach (var v in asm.GetTypes()) {
if (v.IsAbstract) continue;
if (v.IsSubclreplacedOf(m_type_node_base)) this.AddSTNode(v, items, items.Name, false);
}
return items;
}
19
Source : DependencyResolver.cs
with MIT License
from devlooped
with MIT License
from devlooped
static replacedembly? OnreplacedemblyResolve(object? sender, ResolveEventArgs args)
{
if (searchPaths.Count == 0)
return null;
var requested = new replacedemblyName(args.Name);
if (requested.Name == null)
return null;
foreach (var dir in searchPaths)
{
var file = Path.GetFullPath(Path.Combine(dir, requested.Name + ".dll"));
if (File.Exists(file))
{
try
{
var actual = replacedemblyName.GetreplacedemblyName(file);
// Only load compatible versions, allowing only minor version
// mismatch.
if (actual.Version.Major == requested.Version.Major &&
actual.Version.Minor >= requested.Version.Minor)
return replacedembly.LoadFrom(file);
}
catch (Exception e)
{
Debug.Fail($"Failed to load an replacedembly from '{file}'.", e.ToString());
}
}
}
return null;
}
19
Source : ModuleInitializer.cs
with MIT License
from devlooped
with MIT License
from devlooped
static replacedembly OnreplacedemblyResolve(object sender, ResolveEventArgs args)
{
var name = new replacedemblyName(args.Name).Name;
var file = Path.Combine(Thisreplacedembly.Project.MSBuildBinPath, name + ".dll");
File.AppendAllText(logFile, $"Resolving {name}\r\n");
if (name.StartsWith("Microsoft.Build") && File.Exists(file))
{
File.AppendAllText(logFile, $"Found {file}\r\n");
return replacedembly.LoadFrom(file);
}
return null;
}
19
Source : Program.cs
with Apache License 2.0
from devonfw
with Apache License 2.0
from devonfw
private static void LoadControllersFromreplacedembly(string replacedemblyName)
{
//Todo: Reflection to get replacedemblies
var asm = replacedembly.LoadFrom(replacedemblyName);
asm.GetTypes().Where(type => typeof(ApiController).IsreplacedignableFrom(type));
}
19
Source : AssemblyInfo.cs
with MIT License
from DevZest
with MIT License
from DevZest
public Info Read(string replacedemblyFile)
{
Info info = new Info();
replacedembly replacedembly = replacedembly.LoadFrom(replacedemblyFile);
object[] attributes = replacedembly.GetCustomAttributes(typeof(replacedemblyProductAttribute), false);
if (attributes == null || attributes.Length != 1)
info.Product = null;
else
info.Product = ((replacedemblyProductAttribute)attributes[0]).Product;
info.replacedemblyVersion = replacedembly.GetName().Version;
info.replacedemblyFileVersion = GetreplacedemblyFileVersion(replacedembly);
info.ReleaseDate = GetReleaseDate(info.replacedemblyFileVersion);
LicenseItemAttribute[] licenseItemAttributes = (LicenseItemAttribute[])replacedembly.GetCustomAttributes(typeof(LicenseItemAttribute), false);
KeyValuePair<string, string>[] licenseItems = new KeyValuePair<string, string>[licenseItemAttributes.Length];
for (int i = 0; i < licenseItemAttributes.Length; i++)
{
licenseItems[i] = new KeyValuePair<string,string>(licenseItemAttributes[i].Name, licenseItemAttributes[i].GetDescription(replacedembly, CultureInfo.CurrentCulture));
}
info.LicenseItems = new ReadOnlyCollection<KeyValuePair<string, string>>(licenseItems);
info.replacedemblyData = replacedemblyLicense.GetreplacedemblyData(replacedembly);
info.PublicKeyXml = LicenseClient.PublicKeyXmlFromreplacedembly(replacedembly);
return info;
}
19
Source : ImplementationLoaderSubModule.cs
with MIT License
from DiplomacyTeam
with MIT License
from DiplomacyTeam
private static IEnumerable<MBSubModuleBase> LoadAllImplementations(ILogger? logger)
{
logger?.LogInformation("Loading implementations...");
var implementationreplacedemblies = new List<replacedembly>();
var replacedemblies = AppDomain.CurrentDomain.Getreplacedemblies().Where(a => !a.IsDynamic).ToList();
var thisreplacedembly = typeof(ImplementationLoaderSubModule).replacedembly;
var replacedemblyFile = new FileInfo(thisreplacedembly.Location);
if (!replacedemblyFile.Exists)
{
logger?.LogError("replacedembly file does not exists!");
yield break;
}
var replacedemblyDirectory = replacedemblyFile.Directory;
if (replacedemblyDirectory?.Exists != true)
{
logger?.LogError("replacedembly directory does not exists!");
yield break;
}
var implementations = replacedemblyDirectory.GetFiles("Bannerlord.Diplomacy.*.dll");
if (implementations.Length == 0)
{
logger?.LogError("No implementations found.");
yield break;
}
var gameVersion = ApplicationVersionHelper.GameVersion();
if (gameVersion is null)
{
logger?.LogError("Failed to get Game version!");
yield break;
}
var implementationsFiles = implementations.Where(x => replacedemblies.All(a => Path.GetFileNameWithoutExtension(a.Location) != Path.GetFileNameWithoutExtension(x.Name)));
var implementationsWithVersions = GetImplementations(implementationsFiles, logger).ToList();
if (implementationsWithVersions.Count == 0)
{
logger?.LogError("No compatible implementations were found!");
yield break;
}
var implementationsForGameVersion = ImplementationForGameVersion(gameVersion.Value, implementationsWithVersions).ToList();
switch (implementationsForGameVersion.Count)
{
case > 1:
{
logger?.LogInformation("Found multiple matching implementations:");
foreach (var (implementation1, version1) in implementationsForGameVersion)
logger?.LogInformation("Implementation {name} for game {gameVersion}.", implementation1.Name, version1);
logger?.LogInformation("Loading the latest available.");
var (implementation, version) = ImplementationLatest(implementationsForGameVersion);
logger?.LogInformation("Implementation {name} for game {gameVersion} is loaded.", implementation.Name, version);
implementationreplacedemblies.Add(replacedembly.LoadFrom(implementation.FullName));
break;
}
case 1:
{
logger?.LogInformation("Found matching implementation. Loading it.");
var (implementation, version) = implementationsForGameVersion[0];
logger?.LogInformation("Implementation {name} for game {gameVersion} is loaded.", implementation.Name, version);
implementationreplacedemblies.Add(replacedembly.LoadFrom(implementation.FullName));
break;
}
case 0:
{
logger?.LogInformation("Found no matching implementations. Loading the latest available.");
var (implementation, version) = ImplementationLatest(implementationsWithVersions);
logger?.LogInformation("Implementation {name} for game {gameVersion} is loaded.", implementation.Name, version);
implementationreplacedemblies.Add(replacedembly.LoadFrom(implementation.FullName));
break;
}
}
var subModules = implementationreplacedemblies.SelectMany(a =>
{
try
{
return a.GetTypes().Where(t => typeof(MBSubModuleBase).IsreplacedignableFrom(t));
}
catch (Exception e) when (e is ReflectionTypeLoadException)
{
logger?.LogError(e, "Implementation {name} is not compatible with the current game!", Path.GetFileName(a.Location));
return Enumerable.Empty<Type>();
}
}).ToList();
if (subModules.Count == 0)
logger?.LogError("No implementation was initialized!");
foreach (var subModuleType in subModules)
{
var constructor = subModuleType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, Type.EmptyTypes, null);
if (constructor is null)
{
logger?.LogError("SubModule {subModuleType} is missing a default constructor!", subModuleType);
continue;
}
var constructorFunc = AccessTools2.GetDelegate<ConstructorDelegate>(constructor);
if (constructorFunc is null)
{
logger?.LogError("SubModule {subModuleType}'s default constructor could not be converted to a delegate!", subModuleType);
continue;
}
yield return constructorFunc();
}
logger?.LogInformation("Finished loading implementations.");
}
19
Source : ApplicationViewModel_Theming.cs
with MIT License
from Dirkster99
with MIT License
from Dirkster99
private void SwitchToSelectedTheme(IThemeBase nextThemeToSwitchTo)
{
const string themesModul = "Edi.Themes.dll";
try
{
// set the style of the message box display in back-end system.
_MsgBox.Style = MsgBoxStyle.System;
// Get WPF Theme definition from Themes replacedembly
IThemeBase theme = ApplicationThemes.SelectedTheme;
if (theme != null)
{
Application.Current.Resources.MergedDictionaries.Clear();
string themesPathFileName = replacedembly.GetEntryreplacedembly().Location;
themesPathFileName = System.IO.Path.GetDirectoryName(themesPathFileName);
themesPathFileName = System.IO.Path.Combine(themesPathFileName, themesModul);
replacedembly.LoadFrom(themesPathFileName);
if (System.IO.File.Exists(themesPathFileName) == false)
{
_MsgBox.Show(string.Format(CultureInfo.CurrentCulture,
Util.Local.Strings.STR_THEMING_MSG_CANNOT_FIND_PATH, themesModul),
Util.Local.Strings.STR_THEMING_CAPTION,
MsgBoxButtons.OK, MsgBoxImage.Error);
return;
}
foreach (var item in theme.Resources)
{
try
{
var res = new Uri(item, UriKind.Relative);
if (Application.LoadComponent(res) is ResourceDictionary)
{
ResourceDictionary dictionary = Application.LoadComponent(res) as ResourceDictionary;
Application.Current.Resources.MergedDictionaries.Add(dictionary);
}
}
catch (Exception exp)
{
_MsgBox.Show(exp, string.Format(CultureInfo.CurrentCulture, "'{0}'", item), MsgBoxButtons.OK, MsgBoxImage.Error);
}
}
}
}
catch (Exception exp)
{
_MsgBox.Show(exp, Util.Local.Strings.STR_THEMING_CAPTION,
MsgBoxButtons.OK, MsgBoxImage.Error);
}
finally
{
// set the style of the message box display in back-end system.
if (nextThemeToSwitchTo.WPFThemeName != "Generic")
_MsgBox.Style = MsgBoxStyle.WPFThemed;
}
}
19
Source : Read.cs
with MIT License
from Dirkster99
with MIT License
from Dirkster99
private static List<string> TestXML(string sXML)
{
string sreplacedembly = System.Reflection.replacedembly.GetExecutingreplacedembly().CodeBase;
// Replace the information in '<>' brackets with a valid path
// to a XSD file (that you added into your Visual Studio project)
// Be careful: Names are case sensitiv and '.' are delimters.
// Make sure your XSD file is an 'embedded resource'
// "<Namespace>.<FolderName>.<Filename>.xsd"
const string XSD_Location = "ICSharpCode.AvalonEdit.Highlighting.Themes.XML.HlTheme.xsd";
SchemaValidator vs = new SchemaValidator();
replacedembly a = replacedembly.LoadFrom(sreplacedembly);
using (Stream strm = a.GetManifestResourceStream(XSD_Location))
{
if (strm == null)
{
List<string> l = new List<string>();
l.Add(string.Format(CultureInfo.InvariantCulture, "Unable to load XSD: '{0}' file from internal resource.", XSD_Location));
return(l);
}
vs.CheckXML_XSD(sXML, strm);
if (vs.IsSchemaValid == false) // Return strings describing problems (if any)
return vs.ErrorMessages;
}
return null;
}
19
Source : MiniUmlPluginLoader.cs
with MIT License
from Dirkster99
with MIT License
from Dirkster99
private static void loadPluginreplacedembly(string replacedemblyFile,
IMiniUMLDoreplacedent windowViewModel,
IMessageBoxService msgBox)
{
replacedembly replacedembly;
try
{
// Load the plugin replacedembly.
replacedembly = replacedembly.LoadFrom(replacedemblyFile);
// Add an instance of each PluginModel found in the replacedembly to the plugin collection
// and merge its resources into the plugin resource dictionary.
foreach (Type type in replacedembly.GetTypes())
{
if (!type.IsAbstract && typeof(PluginModelBase).IsreplacedignableFrom(type))
{
try
{
// Create PluginModel instance.
PluginModelBase pluginModel = Activator.CreateInstance(type, windowViewModel) as PluginModelBase;
// Plugin names must be unique
foreach (PluginModelBase p in PluginManager.PluginModels)
{
if (p.Name == pluginModel.Name)
throw new Exception(Edi.Util.Local.Strings.STR_MSG_UML_PLugin_Duplicate);
}
// Get the shared resources from the plugin.
ResourceDictionary sharedResources = pluginModel.Resources;
// If we got any resources, merge them into our plugin resource dictionary.
if (sharedResources != null)
PluginManager.PluginResources.MergedDictionaries.Add(sharedResources);
// Add the plugin into the collection of plugins
PluginManager.AddPluginModel(pluginModel);
}
catch (Exception ex)
{
msgBox.Show(ex,
string.Format(Edi.Util.Local.Strings.STR_MSG_ErrorLoadingPlugin, replacedemblyFile),
Edi.Util.Local.Strings.STR_MSG_PluginNotLoaded,
MsgBoxButtons.OK, MsgBoxImage.Error);
////ExceptionManager.Register(ex,
//// "Plugin not loaded.",
//// "An error occured while initializing a plugin found in replacedembly " + replacedemblyFile + ".");
}
}
}
}
catch (Exception ex)
{
msgBox.Show(ex,
string.Format(Edi.Util.Local.Strings.STR_MSG_ErrorWhileLoadingPlugin, replacedemblyFile),
Edi.Util.Local.Strings.STR_MSG_PluginNotLoaded,
MsgBoxButtons.OK, MsgBoxImage.Error);
return;
}
}
19
Source : NugetDirectiveProcessor.cs
with MIT License
from discord-csharp
with MIT License
from discord-csharp
public async Task PreProcess(string directive, ScriptExecutionContext context, Action<string> logger)
{
var actionLogger = new NugetLogger(logger);
var nugetDirective = NugetPreProcessorDirective.Parse(directive);
string frameworkName = replacedembly.GetEntryreplacedembly()!.GetCustomAttributes(true)
.OfType<System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault()!;
NuGetFramework framework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
using var cache = new SourceCacheContext();
var packagesPath = Path.Combine(Path.GetTempPath(), "packages");
await CreateEmptyNugetConfig(packagesPath, nugetDirective.FeedUrl);
var settings = Settings.LoadImmutableSettingsGivenConfigPaths(new[] { Path.Combine(packagesPath, "empty.config") }, new SettingsLoadingContext());
var availablePackages = new HashSet<SourcePackageDependencyInfo>(PackageIdenreplacedyComparer.Default);
#pragma warning disable CS0618 // Type or member is obsolete
var repositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
#pragma warning restore CS0618 // Type or member is obsolete
var repository = repositoryProvider.GetRepositories().FirstOrDefault();
var packageMetadataResource = await repository.GetResourceAsync<PackageMetadataResource>(CancellationToken.None);
var searchMetadata = await packageMetadataResource.GetMetadataAsync(
nugetDirective.PackageId,
includePrerelease: false,
includeUnlisted: false,
cache,
actionLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var latest = searchMetadata.OrderByDescending(a => a.Idenreplacedy.Version).FirstOrDefault();
if (latest is null)
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var packageId = latest.Idenreplacedy;
var dependencyResource = await repository.GetResourceAsync<DependencyInfoResource>();
await GetPackageDependencies(
packageId,
framework,
cache,
repository,
dependencyResource,
availablePackages, actionLogger);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { nugetDirective.PackageId },
Enumerable.Empty<string>(),
Enumerable.Empty<PackageReference>(),
Enumerable.Empty<PackageIdenreplacedy>(),
availablePackages,
new[] { repository.PackageSource },
actionLogger);
var resolver = new PackageResolver();
var toInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(a => availablePackages.Single(b => PackageIdenreplacedyComparer.Default.Equals(b, a)));
var pathResolver = new PackagePathResolver(packagesPath);
var extractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, actionLogger),
actionLogger);
var libraries = new List<string>();
var frameworkReducer = new FrameworkReducer();
var downloadResource = await repository.GetResourceAsync<DownloadResource>(CancellationToken.None);
foreach (var package in toInstall)
{
libraries.AddRange(await Install(downloadResource, package, pathResolver, extractionContext, frameworkReducer, framework, packagesPath, actionLogger));
}
foreach (var path in libraries)
{
var replacedembly = replacedembly.LoadFrom(path);
if (context.TryAddReferencereplacedembly(replacedembly))
{
foreach (var ns in replacedembly.GetTypes().Where(a => a.Namespace != null).Select(a => a.Namespace).Distinct())
{
context.AddImport(ns);
}
}
}
}
19
Source : Preloader.cs
with MIT License
from disunity-hq
with MIT License
from disunity-hq
protected static replacedembly GetStartupreplacedembly(PreloadMod mod) {
var replacedemblyName = mod.Info.Preloadreplacedembly;
var replacedemblyPath = Path.Combine(mod.InstallPath, "preload", $"{replacedemblyName}.dll");
return replacedembly.LoadFrom(replacedemblyPath);
}
19
Source : ServiceCollectionExtension.cs
with MIT License
from doddgu
with MIT License
from doddgu
public static IServiceCollection AddIOC(this IServiceCollection services)
{
services.AddSingleton(services);
services.AddSingleton<IUserService, UserService>();
services.AddDbContext<ADbContext>(options => options.UseSqlServer(AlpacaConfigWrapper.GetConnectionString()));
// Auto load all biz type
var bizDlls = Directory.GetFiles(Path.GetDirectoryName(replacedembly.GetEntryreplacedembly().Location), "Alpaca.Biz.*.dll");
bizDlls.ToList().ForEach(dll =>
{
replacedembly
.LoadFrom(dll)
.GetTypes()
.Where(t => t.Name.EndsWith("Biz"))
.ToList()
.ForEach(bizType => services.AddScoped(bizType));
});
return services;
}
19
Source : XMLHelpGenerator.cs
with GNU General Public License v3.0
from DSorlov
with GNU General Public License v3.0
from DSorlov
public static void GenerateHelp(string inputFile, string outputPath, bool oneFile)
{
GenerateHelp(replacedembly.LoadFrom(inputFile), outputPath, oneFile);
}
19
Source : HTAppFiles.cs
with GNU General Public License v3.0
from DSorlov
with GNU General Public License v3.0
from DSorlov
public static replacedembly currentDomain_replacedemblyResolve(object sender, ResolveEventArgs args)
{
string requestedreplacedembly = string.Format("{0}.dll", args.Name.Substring(0, args.Name.IndexOf(",")));
if (requestedreplacedembly.StartsWith("sorlov.powershell",true,Thread.CurrentThread.CurrentCulture))
{
string replacedemblyPath = Path.Combine(Path.GetDirectoryName(System.Reflection.replacedembly.GetExecutingreplacedembly().Location), requestedreplacedembly);
return replacedembly.LoadFrom(replacedemblyPath); ;
}
else
{
return replacedembly.Load(requestedreplacedembly);
}
}
19
Source : PS1XMLGenerator.cs
with GNU General Public License v3.0
from DSorlov
with GNU General Public License v3.0
from DSorlov
public static void GeneratePS1XML(string sourceDir, string outputPath, string filePrefix)
{
List<replacedembly> replacedList = new List<replacedembly>();
foreach (string file in Directory.GetFiles(sourceDir, "Sorlov.PowerShell.*.dll"))
replacedList.Add(replacedembly.LoadFrom(file));
GeneratePS1XML(replacedList, outputPath, filePrefix);
}
19
Source : ApiApproval.cs
with MIT License
from DynamicsValue
with MIT License
from DynamicsValue
[Fact]
[UseReporter(typeof(DiffReporter))]
[MethodImpl(MethodImplOptions.NoInlining)]
[SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.replacedembly.LoadFrom", Justification = "By design")]
public void ApproveApiNetStd()
{
// Approvals and PublicApiGenerator aren't available for .NET Core, so
// we'll load the .NET Standard FakeItEasy replacedembly from disk and
// examine it.
string codeBase = replacedembly.GetExecutingreplacedembly().CodeBase;
UriBuilder uri = new UriBuilder(new Uri(codeBase));
string replacedemblyPath = Uri.UnescapeDataString(uri.Path);
var containingDirectory = Path.GetDirectoryName(replacedemblyPath);
var configurationName = new DirectoryInfo(containingDirectory).Name;
var replacedemblyFile = @"..\..\..\..\src\FakeItEasy.netstd\bin\" + configurationName + @"\FakeItEasy.dll";
var replacedembly = replacedembly.LoadFrom(replacedemblyFile);
Approvals.Verify(PublicApiGenerator.GetPublicApi(replacedembly));
}
19
Source : ExternalReference.cs
with Apache License 2.0
from eaglet2006
with Apache License 2.0
from eaglet2006
internal void Load(Dictionary<string, Type> dictionary)
{
replacedembly asm = replacedembly.LoadFrom(replacedemblyFile);
foreach (Type type in asm.GetTypes())
{
if (type.GetInterface(Interface.FullName) != null)
{
Data.INamedExternalReference refer = asm.CreateInstance(type.FullName) as
Data.INamedExternalReference;
if (refer == null)
{
Report.WriteErrorLog(string.Format("External reference {0} does not inherit from INamedExternalReference",
type.FullName));
}
else
{
string key = refer.Name.ToLower().Trim();
if (!dictionary.ContainsKey(key))
{
if (refer is replacedysis.Ireplacedyzer)
{
replacedysis.Ireplacedyzer replacedyzer = refer as replacedysis.Ireplacedyzer;
replacedyzer.Init();
}
dictionary.Add(key, type);
}
else
{
Global.Report.WriteErrorLog(string.Format("Reduplicate name = {0} in External reference {1}!",
refer.Name, type.FullName));
}
}
}
}
}
19
Source : Instance.cs
with Apache License 2.0
from eaglet2006
with Apache License 2.0
from eaglet2006
static public object CreateInstance(Type type, string replacedemblyFile)
{
System.Reflection.replacedembly asm;
asm = System.Reflection.replacedembly.LoadFrom(replacedemblyFile);
return asm.CreateInstance(type.FullName);
}
19
Source : IocModule.cs
with MIT License
from ecjtuseclab
with MIT License
from ecjtuseclab
private static NinjectModule getModule()
{
string path = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + @"bin\";
replacedembly replacedembly = replacedembly.LoadFrom(path + dalInfo[0]);
NinjectModule nModule = (NinjectModule)replacedembly.CreateInstance(dalInfo[1]);
return nModule;
}
19
Source : CurrentAppDomain.cs
with Mozilla Public License 2.0
from ehsan2022002
with Mozilla Public License 2.0
from ehsan2022002
internal replacedembly Load(string fileName)
{
try
{
if (ValidateVersion(fileName))
{
if (Owner.Settings.LoadreplacedembliesUnsafe)
return replacedembly.UnsafeLoadFrom(fileName);
else
return replacedembly.LoadFrom(fileName);
// changed Load to LoadFrom, thanks to Frank Fajardo
}
else
return null;
}
catch (Exception exception)
{
Owner.Console.WriteLine("replacedemblyLoad Exception<{1}> {0}", Path.GetFileName(fileName), exception.GetType().Name);
return null;
}
}
19
Source : CurrentAppDomain.cs
with Mozilla Public License 2.0
from ehsan2022002
with Mozilla Public License 2.0
from ehsan2022002
internal replacedembly Load(replacedemblyName name)
{
string localPath = String.Empty;
try
{
bool versionMatch = false;
localPath = false == String.IsNullOrEmpty(name.CodeBase) ? Resolver.UriResolver.ResolveLocalPath(name.CodeBase) : null;
versionMatch = null == localPath ? ValidateVersion(name) : ValidateVersion(localPath);
if (null == localPath)
{
string thisLocalPath = Resolver.UriResolver.ResolveLocalPath(Owner.Thisreplacedembly.CodeBase);
string extension = Path.GetExtension(thisLocalPath);
string path = Path.GetDirectoryName(thisLocalPath);
localPath = Path.Combine(path, name.Name + extension);
}
if (!File.Exists(localPath))
{
Owner.Console.WriteLine("replacedemblyLoad {0} Unable To Find replacedembly In Local Directory.", name.Name);
return null;
}
if (versionMatch)
{
if (Owner.Settings.LoadreplacedembliesUnsafe)
{
return replacedembly.UnsafeLoadFrom(localPath);
}
else
{
return replacedembly.LoadFrom(localPath);
}
}
else
return null;
}
catch (Exception exception)
{
if (localPath != String.Empty && false == String.IsNullOrEmpty(name.CodeBase))
Owner.Console.WriteLine("replacedemblyLoad(From Path) Exception<{1}> {0}", Path.GetFileName(localPath), exception.GetType().Name);
else
Owner.Console.WriteLine("replacedemblyLoad(From Name) Exception<{1}> {0}", name, exception.GetType().Name);
return null;
}
}
19
Source : Factory.cs
with Mozilla Public License 2.0
from ehsan2022002
with Mozilla Public License 2.0
from ehsan2022002
private static replacedembly TryLoadreplacedembly(string fileName)
{
try
{
string directoryName = _thisreplacedembly.CodeBase.Substring(0, _thisreplacedembly.CodeBase.LastIndexOf("/"));
directoryName = directoryName.Replace("/", "\\").Substring(8);
string fullFileName = System.IO.Path.Combine(directoryName, fileName);
if (System.IO.File.Exists(fullFileName))
{
replacedembly replacedembly = System.Reflection.replacedembly.LoadFrom(fullFileName);
Type factoryInfoType = replacedembly.GetType(fileName.Substring(0, fileName.Length - 4) + ".Utils.ProjectInfo", false, false);
NetOffice.IFactoryInfo factoryInfo = Activator.CreateInstance(factoryInfoType) as NetOffice.IFactoryInfo;
bool exists = false;
foreach (IFactoryInfo itemFactory in _factoryList)
{
if (itemFactory.replacedembly.FullName == factoryInfo.replacedembly.FullName)
{
exists = true;
break;
}
}
if (!exists)
{
_factoryList.Add(factoryInfo);
DebugConsole.WriteLine("Recieve IFactoryInfo:{0}:{1}", factoryInfo.replacedembly.FullName, factoryInfo.replacedembly.FullName);
}
return replacedembly;
}
else
{
DebugConsole.WriteLine(string.Format("Unable to resolve replacedembly {0}. The replacedembly doesnt exists in current codebase.", fileName));
return null;
}
}
catch (Exception exception)
{
DebugConsole.WriteException(exception);
return null;
}
}
19
Source : Startup.NetCore.cs
with Apache License 2.0
from elastic
with Apache License 2.0
from elastic
private static replacedembly ResolveDependencies(object sender, ResolveEventArgs args)
{
var replacedemblyName = new replacedemblyName(args.Name);
// Having a non-US locale can cause mscorlib
// to enter the replacedemblyResolve event when searching for resources
// in its satellite replacedemblies. This seems to have been fixed in
// .NET Core in the 2.0 servicing branch, so we should not see this
// occur, but guard against it anyways. If we do see it, exit early
// so we don't cause infinite recursion.
if (string.Equals(replacedemblyName.Name, "System.Private.CoreLib.resources", StringComparison.OrdinalIgnoreCase) ||
string.Equals(replacedemblyName.Name, "System.Net.Http", StringComparison.OrdinalIgnoreCase))
return null;
var path = Path.Combine(Directory, $"{replacedemblyName.Name}.dll");
// Only load the main Elastic.Apm.Profiler.Managed.dll into the default replacedembly Load Context.
// If Elastic.Apm or other libraries are provided by the NuGet package, their loads are handled in the following two ways.
// 1) The replacedemblyVersion is greater than or equal to the version used by Elastic.Apm.Profiler.Managed, the replacedembly
// will load successfully and will not invoke this resolve event.
// 2) The replacedemblyVersion is lower than the version used by Elastic.Apm.Profiler.Managed, the replacedembly will fail to load
// and invoke this resolve event. It must be loaded in a separate replacedemblyLoadContext since the application will only
// load the originally referenced version
if (File.Exists(path))
{
if (replacedemblyName.Name.StartsWith("Elastic.Apm.Profiler.Managed", StringComparison.OrdinalIgnoreCase)
&& replacedemblyName.FullName.IndexOf("PublicKeyToken=ae7400d2c189cf22", StringComparison.OrdinalIgnoreCase) >= 0)
{
Logger.Log(LogLevel.Debug, "Loading {0} replacedembly using replacedembly.LoadFrom", replacedemblyName);
return replacedembly.LoadFrom(path);
}
Logger.Log(LogLevel.Debug, "Loading {0} replacedembly using DependencyLoadContext.LoadFromreplacedemblyPath", replacedemblyName);
return DependencyLoadContext.LoadFromreplacedemblyPath(path);
}
return null;
}
See More Examples