Abstract class fields redundancy C#

Question

I have base abstract Goods class and inherited Book class.

abstract class Goods
{
    public decimal weight; 
    string Title, BarCode;
    double Price;
    public Goods(string title, string barCode, double price)
    {
        Title = title;
        BarCode = barCode;
        Price = price;
    }
}

abstract class Book : Goods
{
    protected int NumPages;
    public Book(string title, string barCode, double price, int numPages)
        : base(title, barCode, price)
    {
        NumPages = numPages;
        weight = 1;
    }
    public override void display()
    {
        base.display();
        Console.WriteLine("Page Numbers:{0}", NumPages);
    }

}

Should I write title, barCode, price that exist in the Goods class twice? Can I replace this

 public Book(string title, string barCode, double price, int numPages)
        : base(title, barCode, price)

with less redundant construction?

Answer 1

No, this code is not redundant. You must pass values to both Book constructor and base constructor.

I see you assign weight in Book constructor. If you want, you can do the same for other Title, BarCode and Price as well. Then your Goods constructor would be empty. But That would mean that each implementation of Goods would have to do it (which would be a bad thing if there is more logic then simple assign)..

Answer 2

Should I write title, barCode, price that exist in the Goods class twice? Can I replace this ... with less redundant construction?

There is no "redundancy" in this code.

This is the declaration of your constructor [method], specifying the arguments that it takes.

public Book(string title, string barCode, double price, int numPages)

This is the invocation of the base class' constructor, passing the arguments passed to this constructor.

    : base(title, barCode, price)

This is absolutely necessary because your base class can only be constructed using the constructor provided that takes three arguments. You have to provide these argument, either from arguments passed to this constructor or, possibly, by deriving them, as in

    : base(title, barCode, priceDerivedFrom( title, barCode ) )

(Not sure how such a function function would work but, hopefully, you see my point).