如何将对嵌套类成员的访问限制为封闭类？

Question

是否可以指定嵌套类的成员可以由封闭类访问，但不能由其他类访问？

这是问题的说明（当然我的实际代码有点复杂......）：

public class Journal
{
    public class JournalEntry
    {
        public JournalEntry(object value)
        {
            this.Timestamp = DateTime.Now;
            this.Value = value;
        }

        public DateTime Timestamp { get; private set; }
        public object Value { get; private set; }
    }

    // ...
}

我想阻止客户端代码创建 JournalEntry 实例，但是 Journal 必须能够创建它们。如果我将构造函数设为公开，任何人都可以创建实例...但如果我将其设为私有，Journal 将无法创建实例！

请注意，JournalEntry 类必须是公共的，因为我希望能够向客户端代码公开现有条目。

任何建议将不胜感激！

---

更新：感谢大家的意见，我最终选择了公共 IJournalEntry 接口，由私有 JournalEntry 类实现（尽管我的问题中有最后一个要求......）

Answer 1

实际上，这个问题有一个完整且简单的解决方案，不涉及修改客户端代码或创建接口。

在大多数情况下，该解决方案实际上比基于接口的解决方案更快，并且更易于编码。

public class Journal
{
  private static Func<object, JournalEntry> _newJournalEntry;

  public class JournalEntry
  {
    static JournalEntry()
    {
      _newJournalEntry = value => new JournalEntry(value);
    }
    private JournalEntry(object value)
    {
      ...

Answer 2

如果您的类不太复杂，您可以使用公开可见的接口并将实际实现类设为私有，或者您可以为 JornalEntry 类创建一个受保护的构造函数并拥有一个私有类< code>JornalEntryInstance 派生自 JornalEntry，并带有一个公共构造函数，该构造函数实际上由您的 Journal 实例化。

public class Journal
{
    public class JournalEntry
    {
        protected JournalEntry(object value)
        {
            this.Timestamp = DateTime.Now;
            this.Value = value;
        }

        public DateTime Timestamp { get; private set; }
        public object Value { get; private set; }
    }

    private class JournalEntryInstance: JournalEntry
    { 
        public JournalEntryInstance(object value): base(value)
        { }
    }
    JournalEntry CreateEntry(object value)
    {
        return new JournalEntryInstance(value);
    }
}

如果您的实际类太复杂而无法执行其中任何一项操作，并且您可以避免构造函数不完全不可见，则可以将构造函数设置为内部，以便它仅在程序集中可见。

如果这也不可行，您始终可以将构造函数设为私有，并使用反射从日志类中调用它：

typeof(object).GetConstructor(new Type[] { }).Invoke(new Object[] { value });

现在我想到了，另一种可能性是在包含类中使用私有委托，该委托是从内部类设置

public class Journal
{
    private static Func<object, JournalEntry> EntryFactory;
    public class JournalEntry
    {
        internal static void Initialize()
        {
            Journal.EntryFactory = CreateEntry;
        }
        private static JournalEntry CreateEntry(object value)
        {
            return new JournalEntry(value);
        }
        private JournalEntry(object value)
        {
            this.Timestamp = DateTime.Now;
            this.Value = value;
        }

        public DateTime Timestamp { get; private set; }
        public object Value { get; private set; }
    }

    static Journal()
    {
        JournalEntry.Initialize();
    }
        
    static JournalEntry CreateEntry(object value)
    {
        return EntryFactory(value);
    }
}

的应该为您提供所需的可见性级别，而无需诉诸缓慢的反射或引入额外的类/接口

Answer 3

将 JournalEntry 设为私有嵌套类型。任何公共成员仅对封闭类型可见。

public class Journal
{
    private class JournalEntry
    {
    }
}

如果您需要使 JournalEntry 对象可供其他类使用，请通过公共接口公开它们：

public interface IJournalEntry
{
}

public class Journal
{
    public IEnumerable<IJournalEntry> Entries
    {
        get { ... }
    }

    private class JournalEntry : IJournalEntry
    {
    }
}

Answer 4

一种更简单的方法是仅使用内部构造函数，但通过提供只有合法调用者才能知道的引用来让调用者证明他们是谁（我们不需要关注非公共反射，因为如果调用者可以访问非公共反射，那么我们就已经输掉了这场战斗——他们可以直接访问私有构造函数）；例如：

class Outer {
    // don't pass this reference outside of Outer
    private static readonly object token = new object();

    public sealed class Inner {
        // .ctor demands proof of who the caller is
        internal Inner(object token) {
            if (token != Outer.token) {
                throw new InvalidOperationException(
                    "Seriously, don't do that! Or I'll tell!");
            }
            // ...
        } 
    }

    // the outer-class is allowed to create instances...
    private static Inner Create() {
        return new Inner(token);
    }
}

Answer 5

在这种情况下，您可以：

1. 将构造函数设置为内部构造函数 - 这会阻止程序集外部的构造函数创建新实例，或者...
2. 重构 JournalEntry 类以使用公共接口并创建实际的 JournalEntry< /code> 类私有或内部。然后可以公开接口以供集合使用，同时隐藏实际的实现。

我在上面提到了内部作为有效的修饰符，但是根据您的要求，私有可能是更合适的选择。

编辑：抱歉，我提到了私有构造函数，但您已经在问题中处理了这一点。我很抱歉没有正确阅读它！

Answer 6

对于通用嵌套类=)

我知道这是一个老问题，并且它已经是一个公认的答案，但是对于那些可能有类似情况的谷歌游泳者来说，这个答案可能会提供一些帮助。

我遇到这个问题是因为我需要实现与OP相同的功能。对于我的第一个场景这个和这个答案效果很好。尽管如此，我还需要公开一个嵌套的泛型类。问题是，如果不使自己的类通用，则无法公开具有开放泛型参数的委托类型字段（工厂字段），但显然这不是我们想要的，所以，这是我针对这种情况的解决方案：

public class Foo
{
    private static readonly Dictionary<Type, dynamic> _factories = new Dictionary<Type, dynamic>();

    private static void AddFactory<T>(Func<Boo<T>> factory)
        => _factories[typeof(T)] = factory;

    public void TestMeDude<T>()
    {
        if (!_factories.TryGetValue(typeof(T), out var factory))
        {
            Console.WriteLine("Creating factory");
            RuntimeHelpers.RunClassConstructor(typeof(Boo<T>).TypeHandle);
            factory = _factories[typeof(T)];
        }
        else
        {
            Console.WriteLine("Factory previously created");
        }

        var boo = (Boo<T>)factory();
        boo.ToBeSure();
    }

    public class Boo<T>
    {
        static Boo() => AddFactory(() => new Boo<T>());

        private Boo() { }

        public void ToBeSure() => Console.WriteLine(typeof(T).Name);
    }
}

我们有 < strong>Boo 作为具有私有构造函数的内部嵌套类，我们在父类上维护一个字典，其中包含利用动态优势的通用工厂。因此，每次调用 TestMeDude 时，Foo 都会搜索 T 的工厂是否已创建，如果没有，则调用嵌套类的静态构造函数来创建它。

测试：

private static void Main()
{
    var foo = new Foo();

    foo.TestMeDude<string>();
    foo.TestMeDude<int>();
    foo.TestMeDude<Foo>();

    foo.TestMeDude<string>();

    Console.ReadLine();
}

输出为：

Answer 7

Grizzly 建议的解决方案确实使在其他地方创建嵌套类变得有点困难，但并非不可能，就像 Tim Pohlmann 写的那样，有人仍然可以继承它并使用继承类 ctor。

我利用了嵌套类可以访问容器私有属性这一事实，因此容器可以很好地询问，并且嵌套类可以访问该构造函数。

 public class AllowedToEmailFunc
{
    private static Func<long, EmailPermit> CreatePermit;

    public class EmailPermit
    {
        public static void AllowIssuingPermits()
        {
            IssuegPermit = (long userId) =>
            {
                return new EmailPermit(userId);
            };
        }

        public readonly long UserId;

        private EmailPermit(long userId) 
        {
            UserId = userId;
        }
    }

    static AllowedToEmailFunc()
    {
        EmailPermit.AllowIssuingPermits();
    }

    public static bool AllowedToEmail(UserAndConf user)
    {
        var canEmail = true; /// code checking if we can email the user
        if (canEmail)
        {
            return IssuegPermit(user.UserId);
        }
        else
        {
            return null
        }

    }
}

---

这个解决方案不是我在日常工作中会做的事情，不是因为它会导致其他地方出现问题，而是因为它是非常规的（我以前从未见过它），所以它可能会给其他开发人员带来痛苦。