我同意Dai的评论，即根本问题是ClassLibrary1对ClassLibrary2有一个硬编码的依赖关系，因此问题福尔斯在如何将其解耦上。
一种对我有效的方法是建立一个Interface类库，它只包含应用程序可能尝试使用的插件接口（但同时可能没有附加示例），插件服务器和客户端都可以引用它。

Interface类库

namespace Interface
{
    /// <summary>
    /// To be a plugin for this app requires IPlugin at minimum .
    /// </summary>
    public interface IPlugin { }
    public interface ISpecialProduct : IPlugin
    {
        string GetSpecialProduct(string id);
    }
}

类库1

SpecialProduct成员与ClassLibrary2解耦，因为它是接口而不是类。

using Interface; // But 'not' ClassLibrary2
namespace ClassLibrary1
{
    public class Product
    {
        public ISpecialProduct SpecialProduct { get; set; }
    }
}

类库2

using Interface; // The only dependency
namespace ClassLibrary2
{
    public class SpecialProduct : ISpecialProduct
    {
        public string GetSpecialProduct(string id) => Guid.NewGuid().ToString();
    }
}

测试（使用控制台应用程序进行概念验证）

可用的插件位于应用程序运行目录的Plugins子文件夹中。ClassLibrary2最初未被引用或加载。

using Interface;
using ClassLibrary1; // But 'not' ClassLibrary2
internal class Program
{
    static void Main(string[] args)
    {
        Console.Title = "Test optional lib";
        Assembly assySpecial;
        Product product = new Product(); // In ClassLibrary1

        #region N O T    L O A D E D
        // Try get assy (not strong named or picky about version)
        assySpecial =
            AppDomain
            .CurrentDomain
            .GetAssemblies()
            .FirstOrDefault(_ => _.GetName().Name.Equals("ClassLibrary2"));
        Debug.Assert(assySpecial == null, "Expecting assy not loaded");
        Debug.Assert(product.SpecialProduct == null, "Expecting null SpecialProduct");
        if(product.SpecialProduct == null)
        {
            Console.WriteLine("SpecialProduct is not loaded yet.");
        }
        #endregion N O T    L O A D E D

        #region L O A D
        var pluginPath = Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory,
            "Plugins",
            "ClassLibrary2.dll");
        if(File.Exists(pluginPath)) 
        {
            Assembly.LoadFrom(pluginPath);
        }
        #endregion L O A D

        #region L O A D E D
        assySpecial =
            AppDomain
            .CurrentDomain
            .GetAssemblies()
            .FirstOrDefault(_ => _.GetName().Name.Equals("ClassLibrary2"));

        Debug.Assert(assySpecial != null, "Expecting assy loaded");

        if (assySpecial != null)
        {
            product.SpecialProduct = 
                (ISpecialProduct)
                Activator.CreateInstance(
                    assySpecial
                    .GetTypes()
                    .First(_ => _.Name.Equals("SpecialProduct")));
        }

        Console.WriteLine($"SpecialProduct: {product.SpecialProduct?.GetSpecialProduct("123")}");

        Console.ReadKey();
        #endregion L O A D E D
    }
}

要成功阻止一个程序集请求另一个程序集，您需要通过未执行的 * 方法 * 完成对“程序集2”的所有访问。使用if保护访问是不够的，因为整个方法需要首先进行JIT，这需要加载另一个程序集。
什么 * 可能 * 会起作用：

... 
   if (Props.IsClassLibrary2Exists)
       DoThingsWithLibrary2();
   ...

   void DoThingsWithLibrary2()
   {
     // access to Library2 feature must be scoped to methods
     // that are not executed
     ClassLibrary2.SpecialProduct.GetSpecialProduct(Id);
   }

请注意，以一种很难/不可能在运行时修复的方式使用“另一个库”是非常容易的-静态属性/构造函数可以在任何时候调用，因此从另一个库引用任何东西都会失败，从另一个库引用字段/属性/方法参数/返回使用类型甚至通过反射都会失败......以及许多其他情况。
如果可能的话，最好动态加载程序集并让它实现共享接口，这样您就可以将反射限制在示例化部分，但要通过强类型接口使用这些类。