System.Reflection.Assembly.LoadFrom(string)

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 7

19 Source : ModLoader.cs
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

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

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

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

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

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

[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

[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

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

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

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

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

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

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

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

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

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

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

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

public replacedembly LoadFromreplacedemblyPath(string replacedemblyPath)
        {
            return replacedembly.LoadFrom(replacedemblyPath);
        }

19 Source : LanguageStep.cs
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[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

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

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

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

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

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

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

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