C# 与对象列表的接口<；IAnotherInterface>；-这可能吗？

是否可以定义一个接口，其中一个对象是另一个接口的列表

我有两个EF对象：

=====

class ImageType1
{
字符串Id
字符串名
列表大小
}
类ImageType1Size
{
字符串Id
整数宽度
整数高度
}
类别ImageType2
{
字符串用户ID
字符串图像ID
字符串名
列表大小
}
类ImageType2Size
{
字符串用户ID
字符串图像ID
整数宽度
整数高度
}

=====

对于每个图像大小类，所有属性都是键（只是旁注）

现在，我要做的是创建以下两个接口：

=====

接口IImage
{
字符串名
列表大小
}
界面图像大小
{
整数宽度
整数高度
}

=====

在我的项目中，我为ImageType1、ImageType1Size、ImageType2和ImageType2Size创建了分区，每个分区都使用各自的接口

public void Example()
{
  List<ImageType1Size> Sizes1 = new List<ImageType1Size>();
  List<ImageType2Size> Sizes2 = new List<ImageType2Size>();
  List<IImageSize> Sizes;

  Sizes1 = Sizes; // These won't compile because the compiler can't guarantee that an
  Sizes2 = Sizes; // IImageSize is an ImageType1Size. It could be an ImageType2Size

  Sizes = Sizes1; // These will compile because the compiler knows that both 
  Sizes = Sizes2; // ImageType1Size and ImageType2Size are IImageSize's
}

我在尝试强制转换ImageType1和ImageType2中的Sizes属性以使用接口IImageSize时出错

=====

这可能吗？如果我不清楚，请让我知道，我会重新措辞的问题

---

谢谢

由于ImageType1类的签名强制ImageType1.Size仅包含ImageType1Size对象，因此不允许在ImageType1.Size中存储IIImageSize，因为这将允许将非ImageType1Size对象（例如ImageType2Size）添加到列表中

这意味着您不能在ImageType1.Size中存储任何旧的IImageSize，这可能是您想要的

但是，在执行其他操作时，您仍然可以使用ImageSize1和ImageSize2对象，就像它们是IImageSizes一样，例如

void Test()
{
    ImageType2 image = new ImageType2();
...
    foreach(var size in image.Sizes)
    {
        if(IsTooBig(size))
        {
            MessageBox.Show("I'm too big!")l
        }
    }
}

bool IsTooBig(IImageSize imagesize)
{
    return imagesize.Width > 500;
}

---

现在您可以在ImageType1Size和ImageType2Size对象上使用iStobig

关于演员名单，以前有过一次又一次的讨论

你可以在这里读到它，但要点是你不能用C

---

<代码>前缀（IIIMAISISION in list）{int IWD= ISISIG.WITH；}

> p>这里可能要考虑泛型：

interface IImage<TSize> where TSize : IImageSize
{
    List<TSize> Sizes { get; }
}

class ImageType1 : IImage<ImageType1Size>
{
    List<ImageType1Size> Sizes { get; private set; }
}

接口IImage，其中TSize:IImageSize
{
列表大小{get；}
}
类别ImageType1:IImage
{
列表大小{get；private set；}
}

或者，这将起作用：

interface IImage
{
    IEnumerable<IImageSize> Sizes { get; }
}

class ImageType1
{
    public List<ImageType1Size> SizeList { get; private set; }

    public IEnumerable<IImageSize> Sizes { get { return SizeList; } }
}

接口IImage
{
IEnumerable size{get；}
}
类别ImageType1
{
公共列表大小列表{get；private set；}
公共IEnumerable size{get{return SizeList；}}
}

---

这取决于您如何操作数据的最佳方式。

要建立在默认值的基础上。kramer说，如果您在其他地方明确需要

IImage

作为一种类型，您可以按如下方式拆分接口：

interface IImage
{
  string Name
}
interface IImage<TSize> : IImage where TSize : IImageSize
{
    List<TSize> Sizes { get; }
}

class ImageType1 : IImage<ImageType1Size>
{
    List<ImageType1Size> Sizes { get; private set; }
}

---

不幸的是，这无法做到。当推理为什么时，在界面之外考虑你的问题是有帮助的。

public void Example()
{
  List<ImageType1Size> Sizes1 = new List<ImageType1Size>();
  List<ImageType2Size> Sizes2 = new List<ImageType2Size>();
  List<IImageSize> Sizes;

  Sizes1 = Sizes; // These won't compile because the compiler can't guarantee that an
  Sizes2 = Sizes; // IImageSize is an ImageType1Size. It could be an ImageType2Size

  Sizes = Sizes1; // These will compile because the compiler knows that both 
  Sizes = Sizes2; // ImageType1Size and ImageType2Size are IImageSize's
}

public void示例（）
{
列表大小1=新列表（）；
列表大小2=新列表（）；
列表大小；
Sizes1=size；//这些不会编译，因为编译器不能保证
Sizes2=Sizes；//IImageSize是ImageType1Size。它可以是ImageType2Size
size=Sizes1；//这些将被编译，因为编译器知道
size=Sizes2；//ImageType1Size和ImageType2Size是IImageSize的
}

现在您可以将其与您的类进行比较

class ImageType1 : IImageType
{
  string Id {get; set;}
  string Name {get; set;}
  List<ImageType1Size> Sizes {get; set;} // This is just like Sizes1 = Sizes in the
                                         // example above.
}

public void Test(IImageSize imageSize)
{
  IImageType imageType = new ImageType1();

  imageType.Add(imageSize) // This would compile, as IImageType.Sizes will 
                           // take any IImageSize

  // But what really happens behind the interface is this:
  ((ImageType1)imageType)Sizes.Add(imageSize);    

  // Trying to insert an IImageSize into the collection
  // doesn't work, because the compiler can't guarantee that 
  // it's an ImageType1Size
}

class ImageType1:IImageType
{
字符串Id{get；set；}
字符串名称{get；set；}
列表大小{get；set；}//这与
//上面的例子。
}
公共空隙测试（IImageSize imageSize）
{
IImageType imageType=新的ImageType1（）；
imageType.Add（imageSize）//这将被编译，正如IImageType.Sizes将被编译一样
//拿任意尺寸的
//但界面背后真正发生的是：
（（ImageType1）imageType）大小。添加（imageSize）；
//正在尝试将IImageSize插入集合
//不起作用，因为编译器不能保证这一点
//这是一个ImageType1Size
}

注：我假设您的示例显示

interface IImage
{
  string Name
  List<ImageSize> Sizes
}

接口IImage
{
字符串名
列表大小
}

实际上应该是

interface IImage
{
  string Name
  List<IImageSize> Sizes
}

接口IImage
{
字符串名
列表大小
}

---

因为您没有在其他地方提到“ImageSize”类型。

您能给出给出此错误的确切代码行吗。在你提供答案后，你会更容易清楚地给出答案。我最终选择了选项2。谢谢

interface IImage
{
  string Name
  List<ImageSize> Sizes
}

interface IImage
{
  string Name
  List<IImageSize> Sizes
}