如何使用接口和C＃重写用抽象类编写的程序？

Question

The Following C# program was written using abstract classes:

dBase.cs

using System;
namespace nmsD
{
    public abstract class dBase
    {
        protected string s_dBase { get; set; }
        protected abstract void methodX();
        public dBase()
        {
            Console.WriteLine("Construc_dBase");
        }
        public void Dq1 ()
        {
            string s = s_dBase;
            Console.WriteLine("Dq1" + " : " + s);
            methodX();
        }
    }
}

bBase.cs

using System;
using nmsD;
namespace nmsB 
{
    public abstract class bBase: dBase
    {

        public bBase()
        {
            s_dBase = "Prop.bBase.01";
            Console.WriteLine("Construc_bBase");
        }

        protected override void methodX(){
            Console.WriteLine("--->bBase_methodX (NOT SHOW)");
        }
    }

}

bRegular01

using System;
using nmsD;

namespace nmsB 
{
    public class bRegular01 : bBase
    {
        public bRegular01()
        {
            Console.WriteLine("Construc_bRegular01");
            //s_dBase = "Prop.bRegular02.02";
        }
        protected override void methodX()
        {
            Console.WriteLine("--->bRegular01_methodX (OK)");
        }
    }
}

bRegular02

using System;
using nmsD;

namespace nmsB 
{
    public class bRegular02 : bBase
    {
        public bRegular02()
        {
            Console.WriteLine("Construc_bRegular02");
            s_dBase = "Prop.bRegular02.02";
        }

        protected override void methodX()
        {
            Console.WriteLine("--->bRegular02_methodX (OK)");
        }
    }
}

Program.cs

using System;
using nmsB;

namespace nmsApp
{
    class Program
    {
        static void Main(string[] args)
        {
            nmsB.bRegular01 br01 = new nmsB.bRegular01();
            br01.Dq1();

            nmsB.bRegular02 br02 = new nmsB.bRegular02();
            br02.Dq1();

            Console.ReadKey();
        }
    }
}

The output is:

    Construc_dBase
    Construc_bBase
    Construc_bRegular01
    Dq1 : Prop.bBase.01
    --->bRegular01_methodX (OK)
    Construc_dBase
    Construc_bBase
    Construc_bRegular02
    Dq1 : Prop.bRegular02.02
    --->bRegular02_methodX (OK)

The Question is:

If possible, How can I do the same behavior using interfaces? What is the best approach to obtain this result? And why?

Edit:

Thank you very much for the answers. Based in the first answers, and to better understanding, the main objective is: When the method methodX() is called from Dq1. The output must show only the lines with:

--->bRegular01_methodX (OK)
or
--->bRegular02_methodX (OK)

and not must show de line:

--->bBase_methodX (NOT SHOW)

Answer 1

Abstract classes and interfaces aren't the same thing, so you can't have exactly the same behavior.

Interfaces are simply a contract that enforces that inheritors must have the stated methods and properties. An interface cannot have any implementation details.

Abstract classes are classes that just cannot be instantiated and thus have to be inherited from to make an actual object. If you want functions in the base class that don't have to be explicitly overridden in child classes to work, then you cannot use an interface.

The most glaring example of this is your constructor. Interfaces do not define implementations of methods, so something inheriting from an interface would be incapable of outputting your "Construc_dBase" lines without explicitly writing that Console.WriteLine statement in each of those classes' constructors.

The closest you can get, with the code you provided, is to create the following interface:

public interface ISomeInterface
{
    void methodX();
    string s_dBase { get; set; }
}

..And then have that interface inherited on each of your child classes (not the base class).

First I'll explain why and then I'll explain why it's undesirable.

Why:

Abstract methods are identical to interface methods, in their behavior. They define a signature with no implementation and demand that they be overridden or else the program will not compile. The only part of your posted code that meets that template is the methodX function and the string property. Therefore, you can pull them out into an interface. Once you do so, though, you will have to implement them on each and every class that needs to be able to be interpreted as an ISomeInterface (ie needs to be able to call methodX without knowing the implementation). Inheriting the interface on your base class means the base class would have to actually implement them yourself, which looks like it's what you don't want to do.

Why is it undesirable?

You are now responsible for not only inheriting the base class, but now also an interface, to ensure complete interoperability. If that's not too onerous for you, then by all means do that, but it seems pretty unnecessary. Also, there's no longer a guarantee that a nmsD is also an ISomeInterface, unless you explicitly provide an implementation of methodX and s_dBase on the nmsD class, which, again, seems like it's exactly what you don't want to do. Additionally, interfaces do not define accessibility constraints (public, private, protectec, internal), whereas abstract classes can.

Why is it debatable?

There are different ways of doing things, and each has its benefits and drawbacks. Abstract classes tie you down to a single base implementation, while interfaces do not. Interfaces can't provide implementation details at all, while abstract classes can.

This can get into a very off-topic and very drawn-out discussion, though, so I'll cut it off here.

Answer 2

Interfaces can define method and property signatures, but have no implementation. You can change your abstract classes' signatures to interfaces, moving all the implementation to inherited concrete classes.

Abstract classes and Interfaces provide solutions to two different problems, one isn't going to be equally as good as the other for every given scenario. If you need more help, provide more information.

Answer 3

Here is an implementation of the classes provided, using interfaces, and the program's output. I tried not to mess with the naming of the classes.

Output:

Construc_bRegular01
Dq1: Prop.bRegular01.01
--->bRegular01_methodX (OK)
Construc_bRegular02
Dq1: Prop.bRegular02.02
--->bRegular02_methodX (OK)

Code:

namespace nmsD
{
    public interface IdBase
    {
        string s_dBase { get; set; }
        void methodX( );
        void Dq1( );
    }

}

namespace nmsB
{
    using nmsD;

    public class bRegular01 : IdBase
    {
        public bRegular01( )
        {
            Console.WriteLine( "Construc_bRegular01" );
            s_dBase = "Prop.bRegular01.01";
        }

        public string s_dBase { get; set; }

        public void methodX( )
        {
            Console.WriteLine( "--->bRegular01_methodX (OK)" );
        }

        public void Dq1( )
        {
            Console.WriteLine( "Dq1: {0}", s_dBase );
            methodX( );
        }
    }

    public class bRegular02 : IdBase
    {
        public bRegular02( )
        {
            Console.WriteLine( "Construc_bRegular02" );
            s_dBase = "Prop.bRegular02.02";
        }

        public string s_dBase { get; set; }

        public void methodX( )
        {
            Console.WriteLine( "--->bRegular02_methodX (OK)" );
        }

        public void Dq1( )
        {
            Console.WriteLine( "Dq1: {0}", s_dBase );
            methodX( );
        }
    }
}


namespace nmsApp
{
    internal class Program
    {
        private static void Main( string[ ] args )
        {
            nmsB.bRegular01 br01 = new nmsB.bRegular01( );
            br01.Dq1( );

            nmsB.bRegular02 br02 = new nmsB.bRegular02( );
            br02.Dq1( );

            Console.ReadKey( );
        }
    }
}