系统的类设计是分层的，但并不整齐

我已经遇到过好几次了，所以我想用一个真实的例子来了解更有经验的C#开发人员如何处理这个问题。

我正在围绕非托管的MediaInfo库编写一个.NET包装程序，该库收集有关媒体文件（电影、图像…）的各种数据

MediaInfo有许多功能，每个功能都适用于不同类型的文件。例如，"PixelAspectRatio"适用于图像和视频，但不适用于音频、字幕或其他内容。

我想包装的功能的子集如下：

General Video   Audio    Text   Image  Chapters  Menu    (Name of function)    
x       x       x        x      x      x         x       Format
x       x       x        x      x      x         x       Title
x       x       x        x      x      x         x       UniqueID
x       x       x        x      x                x       CodecID
x       x       x        x      x                x       CodecID/Hint
        x       x        x      x                x       Language
x       x       x        x      x                        Encoded_Date
x       x       x        x      x                        Encoded_Library
x       x       x        x      x                        InternetMediaType
x       x       x        x      x                        StreamSize
        x       x        x      x                        BitDepth
        x       x        x      x                        Compression_Mode
        x       x        x      x                        Compression_Ratio
x       x       x        x                       x       Delay
x       x       x        x                       x       Duration
        x       x        x                               BitRate
        x       x        x                               BitRate_Mode
        x       x        x                               ChannelLayout
        x       x        x                               FrameCount
        x       x        x                               FrameRate
        x       x        x                               MuxingMode
        x       x        x                               MuxingMode
        x       x        x                               Source_Duration
        x                x      x                        Height
        x                x      x                        Width
        x                       x                        PixelAspectRatio
                x                                        SamplingRate
x                                                        Album
x                                                        AudioCount
x                                                        ChaptersCount
x                                                        EncodedBy
x                                                        Grouping
x                                                        ImageCount
x                                                        OverallBitRate
x                                                        OverallBitRate_Maximum
x                                                        OverallBitRate_Minimum
x                                                        OverallBitRate_Nominal
x                                                        TextCount
x                                                        VideoCount

正如您所看到的，一个不错的类映射的开始将是一个特定于每个流类型的功能的类，以及一个具有所有类型通用功能的基类。

然后这条路就不那么明显了。{general，video，audio，text，and image}流类型共有许多功能。好吧，我想我可以用一个臭名字做一个类，比如"GeneralVideoAudioTextImage"，然后用另一个名为GeneralVideoAudieText（继承自GeneralVideoAudidTextImage）的类来实现这些东西的通用功能，但不能用"Image"流。我想，这将尴尬地遵循类层次结构的"is a"规则。

这看起来已经不优雅了，但偶尔也会出现像"宽度"这样的情况，它们不适合任何一个组，而这个组完全是另一个组的子集。这些情况可以在必要时简单地复制功能——分别在视频、文本和图像中实现，但这显然违反了DRY。

一个常见的第一种方法是MI，C#不支持它。对此，通常的答案似乎是"将MI与接口结合使用"，但我无法完全理解DRY是如何做到这一点的。也许是我的失败。

类层次结构以前已经在SO上讨论过，MI的替代方案（扩展方法等）也讨论过，但这些解决方案似乎都不太适合。例如，扩展方法似乎更适合于源代码无法编辑的类，如String类，并且更难定位，因为它们与类没有真正的联系，尽管它们可能有效。我还没有发现关于这种情况的问题，尽管这可能是我使用搜索工具的失败。

一个MediaInfo功能的例子，包装，可能是：

int _width = int.MinValue;
/// <summary>Width in pixels.</summary>
public int width {
    get {
        if(_width == int.MinValue)
            _width = miGetInt("Width");
        return _width;
    }
}
// ... (Elsewhere, in another file) ...
/// <summary>Returns a MediaInfo value as an int, 0 if error.</summary>
/// <param name="parameter">The MediaInfo parameter.</param>
public int miGetInt(string parameter) {
    int parsedValue;
    string miResult = mediaInfo.Get(streamKind, id, parameter);
    int.TryParse(miResult, out parsedValue);
    return parsedValue;
}

我的问题是：你是如何处理这样的情况的，这些系统有点等级森严，但并不完全？你是否找到了一个相当优雅的策略，或者只是接受了并非每个简单的问题都有一个？

abstract class Media  {
 // General properties/functions
}
class VideoAndImageCommon { // Crappy name but you get the idea
 // Functions used by both video and images
}
interface IVideoAndImageCommon {
 // Common Video & Image interface
}
class Video : Media, IVideoAndImageCommon {
  private readonly VideoAndImageCommon _commonImpl = new VideoAndImageCommon();
  // Implementation of IVideoAndImageCommon delegates to _commonImpl.
}
class Image : Media, IVideoAndImageCommon {
  private readonly VideoAndImageCommon _commonImpl = new VideoAndImageCommon();
  // Implementation of IVideoAndImageCommon delegates to _commonImpl.
}

    ///<summary>Represents a single video stream.</summary>
    public sealed class VideoStream : Media, IGeneralVideoAudioTextImageMenuCommon,
    IGeneralVideoAudioTextMenuCommon, IVideoAudioTextImageMenuCommon,
    IVideoTextImageCommon, /* ...ad nauseum. */
    {
        // What would you even name these variables?
        GeneralVideoAudioTextImageMenuCommon gvatimCommon;
        GeneralVideoAudioTextMenuCommon gvatmCommon;
        VideoAudioTextImageMenuCommon vatimCommon;
        VideoTextImageCommon vticCommon;
        public VideoStream(MediaInfo mi, int id) {
        gvatimCommon = new GeneralVideoAudioTextImageMenuCommon(mi, id);
        gvatmCommon = new GeneralVideoAudioTextMenuCommon(mi, id);
        vatimCommon = new VideoAudioTextImageMenuCommon(mi, id);
        vticCommon = new VideoTextImageCommon(mi, id);
        // --- and more. There are so far at least 10 groupings. 10!
        /* more code */
    }

public class MultiStreamCommon : Media
{
    public MultiStreamCommon(MediaInfo mediaInfo, StreamKind kind, int id)
        : base(mediaInfo, id) {
            this.kind = kind;
    }
    #region AllStreamsCommon
    string _format;
    ///<summary>The format or container of this file or stream.</summary>
    ///<example>Windows Media, JPEG, MPEG-4.</example>
    public string format { /* implementation */ };
    string _title;
    ///<summary>The title of the movie, track, song, etc..</summary>
    public string title { /* implementation */ };
    /* more accessors */
    #endregion
    #region VideoAudioTextCommon
    /* Methods appropriate to this region. */
    #endregion
    // More regions, one for each grouping.
}

public sealed class VideoStream : Media
{
    readonly MultiStreamCommon streamCommon;
    ///<summary>VideoStream constructor</summary>
    ///<param name="mediaInfo">A MediaInfo object.</param>
    ///<param name="id">The ID for this audio stream.</param>
    public VideoStream(MediaInfo mediaInfo, int id) : base(mediaInfo, id) {
        this.kind = StreamKind.Video;
        streamCommon = new MultiStreamCommon(mediaInfo, kind, id);
    }
    public string format { get { return streamCommon.format; } }
    public string title { get { return streamCommon.title; } }
    public string uniqueId { get { return streamCommon.uniqueId; } }
    /* ...One line for every media function relevant to this stream type */
}