寻找一种隐藏类的方法基类

Question

我正在构建一个库，其中有如下模式：

public class Foo : Foo_Impl
{
}

public class Foo_Impl
{
}

我不希望其他开发人员意外使用 Foo_Impl 类。我可以使用哪些选项来隐藏此内容？我还想将它隐藏在定义它的同一程序集中的其他类中。理想情况下，我很乐意这样做：

public class Foo : Foo_Impl
{
  private class Foo_Impl
  {
  }
}

但由于多种原因，这不起作用。

Answer 1

我还没有看到这个建议，所以我想我应该添加 0.02 美元。

使用组合而不是继承怎么样？ Foo_Impl 的实例可以由 Foo 维护，并且永远不会对外界可见（因为 Foo_impl 对于程序集来说是私有的）。根据需要，可以通过接口将调用传递给 Foo_Impl 函数。您可以获得相同的功能，并且没有任何设计难题。

private class Foo_Impl
{
    public void DoSomething() { }
}

public class Foo
{
    private Foo_Impl _implementation;

    public Foo() { _implementation = new Foo_Impl(); }

    public void DoSomething() { _implementation.DoSomething(); }
}

至于“对程序集中的其他类隐藏它”，如果您确实认为合适，则可以将其设为嵌套类。

Answer 2

使 Foo_Impl 成为一个抽象类。这不会阻止其他开发人员从中派生，但将无法直接创建 Foo_Impl 实例 - 需要通过创建派生对象来实例化它，例如 Foo。

public abstract class Foo_Impl
{
    public Foo_Impl()
    {
    }
}

public class Foo : Foo_Impl
{
    public Foo() // implicitly calls the base class's constructor
    {
    }
}

-

var works = new Foo(); // Works
var error = new Foo_Impl(); // Compiler error

根据 Thomas Levesque 的建议，您还可以选择将抽象构造函数设置为内部：

public abstract class Foo_Impl
{
    internal Foo_Impl()
    {
    }
}

public class Foo : Foo_Impl
{
    public Foo() // implicitly calls the base class's constructor
    {
    }
}

这将防止开发人员从程序集外部继承 Foo_Impl。

Answer 3

没有办法完全隐藏它。如果 Foo 将是公共的，那么它的基类也必须是公共的。但是，您可以通过保护构造函数来阻止其他开发人员创建 Foo_Impl 实例。这样构造函数只能从派生类中使用。

public class Foo_Impl
{
    protected Foo_Impl()
    {
    }
}

public class Foo : Foo_Impl
{
    public Foo() // implicitly calls the base class's protected constructor
    {
    }
}

如果您不希望人们能够创建自己的从 Foo_Impl 派生的类，请将构造函数设为内部

Answer 4

您拥有的选项是：

• 使 Foo_Impl 抽象。开发者将无法直接实例化 Foo_Impl；他们必须声明一个 Foo。不过，Foo_Impl 仍然可以用作方法参数或泛型类型参数，开发人员可以从 Foo_Impl 派生自己的类。

• 将 Foo_Impl 设为内部，并将其和 Foo 与您想要隐藏 Foo_Impl 的任何其他类放在单独的库中。在该程序集之外工作的开发人员将无法看到 Foo_Impl。但是，如果开发人员在运行时具有足够的 CAS 权限，则他们可能能够反映该类型并实例化该类型，并且任何有权访问程序集源代码的开发人员都可以在该程序集中新建一个 Foo_Impl。

• 使 Foo_Impl 的所有构造函数受保护或内部。受保护的构造函数只能由派生类访问，而内部构造函数只能从同一程序集中访问。无论哪种方式，Foo_Impl 都不能由外部人员实例化。但是，开发人员仍然可以将该类用作参数或泛型类型。

• 使用 [Obsolete] 属性将 Foo_Impl 的构造函数或整个类标记为已过时，指定使用此类应触发错误。这是一种 hack，但您既可以防止编译“错误”代码，又可以使用属性的 Message 参数来指定应该使用什么。然而，要小心你的装饰；如果你装饰整个类，我认为编译器不会让你对这个类做任何事情，包括继承它。装饰构造函数应该会阻止大多数编码人员。

Answer 5

这可能听起来很愚蠢，但有一个非常简单的解决方案：记录正确的用法。如果 Foo_Impl 不应该被实例化，那么向类中添加一条注释来说明这一点。也将其包含在有关该类的任何其他文档中。

即使您在此处实现了其他解决方案之一，您也可以（并且应该）执行此操作。

Answer 6

abstract 关键字可能最适合您的场景。请记住，如果您提供一个程序集 (dll)，希望人们利用特定的功能，则可以通过接口实现黑盒范例。如果您提供要使用的接口并在内部实现该接口，则您的程序集可以提供接口引用，而无需移交对实例化类本身的引用。所有开发人员都知道您在接口定义中定义的属性和方法。这在插件架构中非常常见。

Answer 7

好吧，我想我已经解决了这个谜题。您分两部分实现 Foo_Impl。

一种是 publicpartial class Foo_Impl {} 实现，它基本上是一个空类，什么都不做，所以它在任何意义上都不可用。

另一个是作为 Foo:Foo_Impl 类的 私有分部类 Foo_Impl{} 成员实现的。那就是你放置所有只能由 Foo 本身使用的秘密功能的地方。任何类都可以从 Foo_Impl 的公共部分继承，但不能使用仅通过其私有 Foo_Impl 成员才能使用 Foo 的任何私有功能。使用class Voyeur:Foo_Impl示例来说明每个主体都可以继承，但只有Foo可以实例化和使用它。 Voyeur 无法窥视 Foo_Impl 来一睹其有用的私有部分;)。

    using System;



    static class Program
    {


        static void Main(string[] args)
        {

            new Foo();
            new Voyeur();


            Console.ReadLine();

        }


    }


     public partial class Foo_Impl
    {
         // NOTHING in this public partial implementation. 
         // Visible but cannot be used for anything

        protected Foo_Impl()
        {
            Console.Write("public partial Foo_Impl's protected constructor ");
        }

    }



    public class Foo : Foo_Impl
    {
        private partial class Foo_Impl {

            // put all your secret implementations here that you dont want 
            // any other class to accidentally use (except Foo)

            public int fooAccessibleVariable=42;

            public Foo_Impl ()

            {
                Console.Write("private partial Foo_Impl contructor ");

            }



        }

        public Foo():base() // calls the public partial Foo_Impl's construtor
        {
            Console.WriteLine(" called from Foo()");


            Foo_Impl myFoo_Impl =  new Foo_Impl(); // calls the private partial Foo_Imp's constructor
            Console.WriteLine(" called from Foo()");

            Console.WriteLine("private Foo_Impl's variabe thats only accessible to Foo: {0}",
                myFoo_Impl.fooAccessibleVariable);
        }

    }

    class Voyeur:Foo_Impl
    {



        public Voyeur():base()// calls the public partial Foo_Impl's contructor 
        {

            Console.WriteLine("  called from Voyeur()");

        }


    }