Get All Assemblies

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace ConsoleApp1
{
internal class Program
{
private static string filePath = string.Empty;
private static string fileName = string.Empty;
private static string fileNameWithNoExtension = string.Empty;

private static void Main(string[] args)
{
List<Assembly> allAssemblies = new List<Assembly>();

StringBuilder sbType = new StringBuilder();
StringBuilder sbMethod = new StringBuilder();

string referenceIncludeLine = string.Empty;

string folderPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

bool searchOnlyInterface = false; // Search Class, Abstract
//bool searchOnlyInterface = true; // Search Interface

Type[] types;

string[] arrayDllStartsWith = new[] { "Abc", "Def" };
string[] arrayDllEndsWith = new[] { ".cs" };
string[] arrayContainWords = new[] { "Export", "Pdf" };
string[] arrayNotContainWords = new[] { "Get_", "Set_" };

foreach (string dll in Directory.GetFiles(folderPath, "*.dll"))
{
try
{
if (!string.IsNullOrWhiteSpace(dll))
{
filePath = dll;
fileNameWithNoExtension = Path.GetFileNameWithoutExtension(dll);

// Type name contain "Pronexus"
// Type name contain "Pnex"
bool anyItem = false;
foreach (var item in arrayDllStartsWith)
{
if (fileNameWithNoExtension.StartsWith(item))
{
anyItem = true;
break;
}
}

// Type name not contain ".cs"
bool neverItem = false;
foreach (var item in arrayDllEndsWith)
{
if (!fileNameWithNoExtension.EndsWith(item))
{
neverItem = true;
break;
}
}
if (anyItem && neverItem)
{
var assembly = Assembly.LoadFile(dll);
if (assembly != null)
{
allAssemblies.Add(assembly);
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}

Console.WriteLine("Count Assemblies: {0}", allAssemblies.Count);

foreach (var assembly in allAssemblies)
{
try
{
if (assembly != null)
{
if (searchOnlyInterface)
{
types = assembly.GetTypes().Where(type => type.IsClass && type.IsAbstract).ToArray();
}
else
{
types = assembly.GetTypes().Where(type => type.IsInterface).ToArray();
}

foreach (Type type in types)
{
try
{
if (type != null && !string.IsNullOrWhiteSpace(type.Name))
{
string typeName = type.Name.Replace("`1", "").Replace("`2", "").Replace("`3", "");

// Type name contain "Pdf"
// Type name contain "Export"
bool trueContain = false;
foreach (var word in arrayContainWords)
{
if (typeName.Contains(word))
{
trueContain = true;
break;
}
}
if (trueContain)
{
Console.WriteLine(typeName);
sbType.AppendLine(typeName);

var methods = type.GetMethods();
try
{
foreach (var method in methods)
{
string methodName = method.Name.Replace("`1", "").Replace("`2", "").Replace("`3", "");

// Method name contain "Pdf"
// Method name contain "Export"
bool trueContain2 = false;
foreach (var word in arrayContainWords)
{
if (methodName.Contains(word))
{
trueContain2 = true;
break;
}
}

// Method name not contain Get_
// Method name not contain Set_
bool notContain = false;
foreach (var word in arrayNotContainWords)
{
if (!methodName.Contains(word))
{
notContain = true;
break;
}
}

if (trueContain2 && !notContain)
{
Console.WriteLine(methodName);
sbMethod.AppendLine(methodName);
}
}
}
catch (Exception e3)
{
Debug.WriteLine(e3.ToString());
}
}
}
}
catch (Exception e2)
{
Debug.WriteLine(e2.ToString());
}
}
}
}
catch (Exception e1)
{
Debug.WriteLine(e1.ToString());
}
}

File.WriteAllText(Path.Combine(folderPath, "Types.txt"), sbType.ToString(), Encoding.UTF8);
File.WriteAllText(Path.Combine(folderPath, $"Types_{DateTime.Now.ToString("yyyyMMddHHmmm")}.txt"), sbType.ToString(), Encoding.UTF8);

File.WriteAllText(Path.Combine(folderPath, "Methods.txt"), sbMethod.ToString(), Encoding.UTF8);
File.WriteAllText(Path.Combine(folderPath, $"Methods_{DateTime.Now.ToString("yyyyMMddHHmmm")}.txt"), sbMethod.ToString(), Encoding.UTF8);

Console.WriteLine("---------- ----------");
Console.WriteLine("Done");
Console.ReadLine();
}
}
}

Using Reflection

using System;
using System.IO;
using System.Text;

namespace ConsoleApp1
{
internal class Program
{
private static string ReferenceInclude = "<Reference Include=\"{0}\"><HintPath>{1}</HintPath></Reference>";
private static string fileNameWithOutExtension = string.Empty;
private static string folderPath = @"C:\temp\";

private static void Main(string[] args)
{
StringBuilder sb = new StringBuilder();

if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}

foreach (string dll in Directory.GetFiles(folderPath, "*.dll"))
{
if (!string.IsNullOrWhiteSpace(dll))
{
fileNameWithOutExtension = Path.GetFileNameWithoutExtension(dll);

if (fileNameWithOutExtension.StartsWith("MyNamespace") && !fileNameWithOutExtension.EndsWith(".cs"))
{
sb.AppendLine(string.Format(ReferenceInclude, fileNameWithOutExtension, dll));
}
}
}

File.WriteAllText(Path.Combine(folderPath, "DEF.txt"), sb.ToString(), Encoding.UTF8);
File.WriteAllText(Path.Combine(folderPath, $"DEF_{DateTime.Now.ToString("yyyyMMddHHmmm")}.txt"), sb.ToString(), Encoding.UTF8);
}
}
}

Loading .NET Assemblies out of Seperate Folders - Rick Strahl's Web Log (west-wind.com)

c# - how to load all assemblies from within your /bin directory - Stack Overflow

using System;
using System.Reflection;
using System.Security.Policy;

class ADGetAssemblies
{
public static void Main()
{
AppDomain currentDomain = AppDomain.CurrentDomain;

//Provide the current application domain evidence for the assembly.
Evidence asEvidence = currentDomain.Evidence;
//Load the assembly from the application directory using a simple name.

//Create an assembly called CustomLibrary to run this sample.
currentDomain.Load("CustomLibrary",asEvidence);

//Make an array for the list of assemblies.
Assembly[] assems = currentDomain.GetAssemblies();

//List the assemblies in the current application domain.
Console.WriteLine("List of assemblies loaded in current appdomain:");
foreach (Assembly assem in assems)
Console.WriteLine(assem.ToString());
}
}