C# 从另外两个抽象类构造一个抽象类

从另外两个抽象类构造一个抽象类。比如说

public abstract class PlayerBase
{
    public bool IsPlaying { get; set; }
    public abstract void Play();
}
public abstract class VideoPlayerBase : PlayerBase
{
    public abstract void Rotate();
}
public abstract class AudioPlayerBase : PlayerBase
{
    public abstract void Mute();
}

我想要的是使用另外两个（VideoPlayerBase，AudioPlayerBase）抽象类来构建一个新的VedioAudioPlayerBase抽象类，而不需要太多的返工

public abstract class VedioAudioPlayerBase
{


}

谢谢

C#不支持类的多重继承，但它支持接口的多重实现

因此，您可以将适当的方法提取到

IVideoPlayer

和

IAudioPlayer

接口中，然后编写一个实现这两个接口的类

不幸的是，这意味着您不能继承任何实现

但是，您可以将音频和视频逻辑封装在实现IVideoPlayer和IAudioPlayer的类中，并将其用作AudioVideoPlayer类的实现：

public interface IPlayer
{
    bool IsPlaying
    {
        get;
        set;
    }

    void Play();
}

public interface IVideoPlayer: IPlayer
{
    void Rotate();
}

public interface IAudioPlayer: IPlayer
{
    void Mute();
}

public interface IAudioVideoPlayer: IVideoPlayer, IAudioPlayer
{
}

public abstract class PlayerBase: IPlayer
{
    public bool IsPlaying
    {
        get;
        set;
    }

    public abstract void Play();
}

public abstract class VideoPlayerBase: PlayerBase, IVideoPlayer
{
    public abstract void Rotate();
}

public abstract class AudioPlayerBase: PlayerBase, IAudioPlayer
{
    public abstract void Mute();
}

public class VideoPlayer: VideoPlayerBase
{
    public override void Play()
    {
        Console.WriteLine("VideoPlayerBaseImpl:Play()");
    }

    public override void Rotate()
    {
        Console.WriteLine("VideoPlayerBaseImpl:Rotate()");
    }
}

public class AudioPlayer : AudioPlayerBase
{
    public override void Play()
    {
        Console.WriteLine("AudioPlayerBaseImpl:Play()");
    }

    public override void Mute()
    {
        Console.WriteLine("AudioPlayerBaseImpl:Mute()");
    }
}

public class AudioVideoPlayer: IAudioVideoPlayer
{
    public void Rotate()
    {
        _videoPlayer.Rotate();
    }

    public void Mute()
    {
        _audioPlayer.Mute();
    }

    public bool IsPlaying
    {
        get
        {
            return _audioPlayer.IsPlaying && _videoPlayer.IsPlaying;
        }

        set
        {
            _audioPlayer.IsPlaying = value;
            _videoPlayer.IsPlaying = value;
        }
    }

    public void Play()
    {
        _audioPlayer.Play();
        _videoPlayer.Play();
    }

    private readonly AudioPlayer _audioPlayer = new AudioPlayer();
    private readonly VideoPlayer _videoPlayer = new VideoPlayer();
}

C#不支持实现的多重继承。这种情况下的标准方法是使用接口和组合：

public interface IPlayerBase
{
    IsPlaying { get; set; }
    void Play();
}
public interface IVideoPlayerBase : PlayerBase
{
    void Rotate();
}
public interface IAudioPlayerBase : PlayerBase
{
    void Mute();
}


public abstract class AbstractVideoPlayer : IVideoPlayerBase 
{
    public void Rotate() {
       // implementation
    }
}
public abstract class AbstractAudioPlayer : IAudioPlayerBase 
{
    public abstract void Mute() {
       // implementation
    }
}


public abstract class VedioAudioPlayerBase : IVideoPlayerBase, IAudioPlayerBase
{
    IVideoPlayerBase video;
    IAudioPlayerBase audio;

    public void Rotate() {
       video.Rotate();
    }

    public void Mute() {
       audio.Mute();
    }

}

---

谢谢你的回答，但我需要这些类的实现。@Taufiq你不能使用类的多重继承来提供实现。最好的方法是封装和我在回答中建议的类/接口层次结构。