C# 将结构与泛型一起使用-不一致的可访问性

我试图在继承结构时使用泛型，请参阅

  public class AuditLogEntry : ObjectBase<AuditLogEntry.AuditLogEntryStruct>
    {

        private struct AuditLogEntryStruct
        {
            public int AuditID;
        }
}

 public abstract class ObjectBase<T> 
{
}

公共类AuditLogEntry:ObjectBase
{
私有结构AuditLogEntryStruct
{
公众内部审计；
}
}
公共抽象类对象库
{
}

它不允许我对结构使用private，因为它会抛出错误： 可访问性不一致：基类“ObjectBaseAuditLogEntry.AuditLogEntryStruct>”的可访问性低于类“AuditLogEntry”

然而，我并不想公开我的结构。 有什么想法吗？ 谢谢 亚历克斯

后续问题：

以下是我们正在尝试做的：

class AuditLogEntry : ObjectBase<AuditLogEntry.AuditLogEntryStruct>
{
  internal struct AuditLogEntryStruct
        {
            public int AuditID;
}

  public int AuditID
        {
            get
            {
                return udtObject.AuditID;
            }
set{
BeginEdit();
 udtObject.AuditID = value;
        }

}

 class ObjectBase<T>
{
  protected T udtObject;
        protected T udtPreEditObject;

  protected  void BeginEdit()
        {
            if (!IsDirty)
            {
                IsDirty = true;
                udtPreEditObject = udtObject;
            }
        }
}

class AuditLogEntry:ObjectBase
{
内部结构AuditLogEntryStruct
{
公众内部审计；
}
公众智力测验
{
得到
{
返回udtObject.audited；
}
设置{
BeginEdit（）；
udtObject.AuditID=值；
}
}
类对象库
{
受保护对象；
受保护的udtPreEditObject；
受保护的void BeginEdit（）
{
如果（！IsDirty）
{
IsDirty=true；
udtPreEditObject=udtObject；
}
}
}

我不知道如何在公开AuditLogEntryStruct中实现这一点？ 谢谢

---

Alex

如果一个或多个类型参数不是公共的，则无法从泛型类派生公共类

任何类型派生的类型必须与派生类一样可访问，包括作为基类的类型参数提供的任何类型参数

如果你有

public class publicClass{}

但是，如果将任何类更改为

internal class internalClass{}

只有其他内部类可以从中派生

如果您将其中一种类型作为类型参数传递，则情况也是如此。下面的前三种类型有效，而第四种类型无效

public class A : List<publicClass>{}
internal class B : List<internalClass>{}
internal class C : List<publicClass>{}

//not valid because D has wider accessibility than the close generic type List<internalClass>
public class D : List<internalClass>{}

公共类A:列表{}
内部类B:列表{}
内部类C:列表{}
//无效，因为D具有比关闭泛型类型列表更广泛的可访问性
公共类D:列表{}

编辑 语言团队在某个时候不得不做出决定，是将声明声明为您的无效，还是使用您的类型，从而导致非法访问无法访问的无效类型。在您的情况下，将有多个方法返回除类之外的所有其他人都无法访问的类型，并且许多方法正在执行其他类无法提供的类型的参数。因此，只有类的对象才能真正使用类的对象。您可以使用组合而不是继承来解决此问题

public class AuditLogEntry
{
        private ObjectBase<AuditLogEntry.AuditLogEntryStruct> _entry;
        private struct AuditLogEntryStruct
        {
            public int AuditID;
        }
}

public abstract class ObjectBase<T> 
{
}

公共类AuditLogEntry
{
私有ObjectBase\u条目；
私有结构AuditLogEntryStruct
{
公众内部审计；
}
}
公共抽象类对象库
{
}

考虑以下示例：

public class Foo : List<Bar>
{
    private struct Bar { }
}


var myFoo = new Foo();
...
var x = myFoo()[0]; // expression on the right side is of type Bar, yet Bar is inaccessible

让结构实现它，并将其用作类型参数

public class AuditLogEntry : ObjectBase<IStructsWithSomeFunctionality> { ... }

公共类AuditLogEntry:ObjectBase{…}

编译器会知道最后一行中的类型，但是x的声明是非法的。这只是一个例子，说明为什么一个可访问性比基类的type参数更广的类会引入不一致性。直觉提示

myFoo（）[0]

是一个合法的表达式，但是它的类型是不可访问的，因此不一致。我同意您试图提出的观点，但您所写的是不正确的。如果Foo有以下方法

object getFirst（）{return myFoo（）[0]；}

您仍然可以访问同一个对象，编译器仍然需要知道该对象的类型（该类型不是object，而是Bar）。我再次同意这个例子，它解释了为什么这个例子是无效的，这是非常无效的。在你的例子中，外面看到的表达式是

object

类型，而不是

List

迭代器属性，它是

T

。我指的是静态的，编译时表达式类型。无论如何，我会更改这与将代码行更改为

object x=myFoo（）[0]没有区别

这正是我的观点，声明是非法的。出于好奇，如果语言编译器试图公开在其某些声明中使用非公共类的公共类型，您知道框架会做什么吗？我认为，如果系统只是将成员的使用限制为可以访问其类型的代码。这至少在两种情况下有用：（1）模块希望允许外部代码使用其接口，但不添加新的实现；（2）只允许内部继承的模块希望受保护的成员使用内部类型。@supercat我还没有尝试过（为了好玩，我试着对CLR做一些奇怪的事情）如果我猜猜的话，我会说CLR不会抱怨。你可以将“this”的类型更改为完全不同的类型，在某些情况下，它会改变行为，但这并不会真正改变任何东西，而且会执行得很好，所以他们可能会将这些规则留给语言来决定self@RuneFS：我很高兴我对这类事情很好奇，因为正如我所说的，似乎至少有两种合理的用法可以允许类型将内部类型暴露给那些可以使用它们的实体，我真的看不到一个很好的基础来禁止它，除非它会导致框架出现问题。

public class AuditLogEntry : ObjectBase<IStructsWithSomeFunctionality> { ... }