Inheritance and Polymorphism

[attributes] [access] [Shadows] [MustInherit | NotInheritable] Class Name
    Inherits BaseClass
    ...
End Class

Option Strict On

Public MustInherit Class CatalogItem
    Public Property Title As String
    Public Property Year As Integer

    Protected Sub New(title As String, year As Integer)
        Me.Title = title
        Me.Year = year
    End Sub

    Public MustOverride ReadOnly Property Kind As String

    Public Overridable Function Describe() As String
        Return $"{Kind}: {Title} ({Year})"
    End Function
End Class

Public Class Book
    Inherits CatalogItem

    Public ReadOnly Property Authors As New List(Of String)

    Public Sub New(title As String, year As Integer, ParamArray authors As String())
        MyBase.New(title, year)
        Me.Authors.AddRange(authors)
    End Sub

    Public Overrides ReadOnly Property Kind As String
        Get
            Return "Book"
        End Get
    End Property

    Public Overrides Function Describe() As String
        Return MyBase.Describe() & " by " & String.Join(", ", Authors)
    End Function
End Class

Public Class Magazine
    Inherits CatalogItem

    Public Property IssueNumber As Integer

    Public Sub New(title As String, year As Integer, issueNumber As Integer)
        MyBase.New(title, year)
        Me.IssueNumber = issueNumber
    End Sub

    Public Overrides ReadOnly Property Kind As String = "Magazine"
End Class

Module Program
    Sub Main()
        ' Dim bad = New CatalogItem("x", 2020)   ' BC30569: New cannot be used on a MustInherit class
        Dim items As New List(Of CatalogItem) From {
            New Book("The Pragmatic Programmer", 1999, "Hunt", "Thomas"),
            New Magazine("Byte", 1984, 12),
            New Book("Domain-Driven Design", 2003, "Evans")
        }

        For Each item In items
            Console.WriteLine(item.Describe())
        Next

        Dim first As CatalogItem = items(0)
        Console.WriteLine(first.GetType().Name & " / " & TypeName(first))
        Console.WriteLine(first.Kind)
    End Sub
End Module

Book: The Pragmatic Programmer (1999) by Hunt, Thomas
Magazine: Byte (1984)
Book: Domain-Driven Design (2003) by Evans
Book / Book
Book

Option Strict On

Public MustInherit Class CatalogItem
    Public MustOverride ReadOnly Property Kind As String
    Public Overridable Function Describe() As String
        Return "item"
    End Function
    Public Function Fixed() As String
        Return "fixed"
    End Function
    Public Overridable Function Self() As CatalogItem
        Return Me
    End Function
    Public Overridable ReadOnly Property Count As Integer
        Get
            Return 0
        End Get
    End Property
End Class

Public Class Unfinished                     ' E1: the MustOverride member Kind is not implemented
    Inherits CatalogItem
End Class

Public Class Book
    Inherits CatalogItem
    Public Overrides ReadOnly Property Kind As String = "Book"
    Public Overrides Function Fixed() As String                     ' E2: Fixed is not Overridable
        Return "x"
    End Function
    Protected Overrides Function Describe() As String               ' E3: different access level
        Return "x"
    End Function
    Public Overrides Function Self() As Book                        ' E4: no covariant return types
        Return Me
    End Function
    Public Overrides Property Count As Integer                      ' E5: cannot add a setter
        Get
            Return 1
        End Get
        Set(value As Integer)
        End Set
    End Property
End Class

Public NotInheritable Class Sealed
    Inherits CatalogItem
    Public Overrides ReadOnly Property Kind As String = "Sealed"
End Class

Public Class ExtendsSealed                  ' E6: the base class is NotInheritable
    Inherits Sealed
End Class

Public Class FromString                     ' E7: so is String
    Inherits String
End Class

Public Class TwoBases                       ' E8: only one Inherits clause
    Inherits Book, Object
End Class

Public Class FromInterface                  ' E9: classes inherit only from classes
    Inherits IDisposable
End Class

Public Class Forgetful                      ' E10: MustOverride in a class that is not MustInherit
    Public MustOverride Function Go() As Integer
End Class

Public Structure Pair                       ' E11: structures cannot inherit
    Inherits CatalogItem
End Structure

Public Class Modifiers
    Public Shared Overridable Function Make() As Integer    ' E12: Shared cannot be Overridable
        Return 1
    End Function
    Private Overridable Function Hidden() As Integer        ' E13: Private cannot be Overridable
        Return 2
    End Function
End Class

Public Class Sealing
    Public NotOverridable Function Lock() As Integer        ' E14: NotOverridable needs Overrides
        Return 3
    End Function
End Class

Public Class OpenBase
    Inherits CatalogItem
    Public Overrides ReadOnly Property Kind As String = "Open"
    Public Overrides Function Describe() As String
        Return "open"
    End Function
End Class

Public NotInheritable Class Closed
    Inherits OpenBase
    Public NotOverridable Overrides Function Describe() As String   ' E15: pointless in a NotInheritable class
        Return "closed"
    End Function
End Class

Module Program
    Sub Main()
    End Sub
End Module

Program.vb(100,12): error BC30607: 'NotInheritable' classes cannot have members declared 'NotOverridable'.
Program.vb(21,14): error BC30610: Class 'Unfinished' must either be declared 'MustInherit' or override the following inherited 'MustOverride' member(s):
Program.vb(28,31): error BC31086: 'Public Overrides Function Fixed() As String' cannot override 'Public Function Fixed() As String' because it is not declared 'Overridable'.
Program.vb(31,34): error BC30266: 'Protected Overrides Function Describe() As String' cannot override 'Public Overridable Function Describe() As String' because they have different access levels.
Program.vb(34,31): error BC30437: 'Public Overrides Function Self() As Book' cannot override 'Public Overridable Function Self() As CatalogItem' because they differ by their return types.
Program.vb(37,31): error BC30362: 'Public Overrides Property Count As Integer' cannot override 'Public Overridable ReadOnly Property Count As Integer' because they differ by 'ReadOnly' or 'WriteOnly'.
Program.vb(52,14): error BC30299: 'ExtendsSealed' cannot inherit from class 'Sealed' because 'Sealed' is declared 'NotInheritable'.
Program.vb(56,14): error BC30299: 'FromString' cannot inherit from class 'String' because 'String' is declared 'NotInheritable'.
Program.vb(60,5): error BC30121: 'Inherits' can appear only once within a 'Class' statement and can only specify one class.
Program.vb(64,14): error BC30258: Classes can inherit only from other classes.
Program.vb(67,14): error BC31411: 'Forgetful' must be declared 'MustInherit' because it contains methods declared 'MustOverride'.
Program.vb(72,5): error BC30628: Structures cannot have 'Inherits' statements.
Program.vb(76,19): error BC30501: 'Shared' cannot be combined with 'Overridable' on a method declaration.
Program.vb(79,13): error BC31408: 'Private' and 'Overridable' cannot be combined.
Program.vb(85,36): error BC31088: 'NotOverridable' cannot be specified for methods that do not override another method.

Option Strict On

Public Class Base
    Public Overridable Function Format(value As Integer, Optional prefix As String = "base") As String
        Return prefix & ":" & value
    End Function
End Class

Public Class Derived
    Inherits Base

    Public Overrides Function Format(value As Integer, Optional prefix As String = "derived") As String
        Return "[" & MyBase.Format(value, prefix) & "]"
    End Function
End Class

Module Program
    Sub Main()
        Dim d As New Derived()
        Dim b As Base = d
        Console.WriteLine(d.Format(1))
        Console.WriteLine(b.Format(1))
    End Sub
End Module

Program.vb(12,31): error BC30307: 'Public Overrides Function Format(value As Integer, [prefix As String = "derived"]) As String' cannot override 'Public Overridable Function Format(value As Integer, [prefix As String = "base"]) As String' because they differ by the default values of optional parameters.

Option Strict On

Public Class CatalogItem
    Public Overridable Function Label() As String
        Return "CatalogItem.Label"
    End Function

    Public Function Fixed() As String
        Return "CatalogItem.Fixed"
    End Function

    Public Overridable Function Shelf() As String
        Return "CatalogItem.Shelf"
    End Function

    Public Sub Show(n As Integer)
        Console.WriteLine("CatalogItem.Show(Integer) " & n)
    End Sub

    Public Sub Show(s As String)
        Console.WriteLine("CatalogItem.Show(String) " & s)
    End Sub
End Class

Public Class Book
    Inherits CatalogItem

    Public Overrides Function Label() As String
        Return "Book.Label"
    End Function

    Public Shadows Function Fixed() As String
        Return "Book.Fixed"
    End Function

    Public Shadows Function Shelf() As String
        Return "Book.Shelf"
    End Function

    Public Overloads Sub Show(d As Double)
        Console.WriteLine("Book.Show(Double) " & d)
    End Sub
End Class

Public Class Atlas
    Inherits CatalogItem

    ' Shadows hides every Show of CatalogItem by name; without it the compiler warns (BC40003).
    Public Shadows Sub Show(d As Double)
        Console.WriteLine("Atlas.Show(Double) " & d)
    End Sub
End Class

Module Program
    Sub Main()
        Dim b As New Book()
        Dim viaBase As CatalogItem = b

        Console.WriteLine("Overrides: " & viaBase.Label() & " | " & b.Label())
        Console.WriteLine("Shadows  : " & viaBase.Fixed() & " | " & b.Fixed())
        Console.WriteLine("Shadows over Overridable: " & viaBase.Shelf() & " | " & b.Shelf())

        b.Show(1)
        b.Show("two")
        b.Show(3.5)

        Dim a As New Atlas()
        a.Show(4.5)
        a.Show(5)   ' Integer widens to Double: the base overloads are not even considered
        CType(a, CatalogItem).Show(5)
    End Sub
End Module

Overrides: Book.Label | Book.Label
Shadows  : CatalogItem.Fixed | Book.Fixed
Shadows over Overridable: CatalogItem.Shelf | Book.Shelf
CatalogItem.Show(Integer) 1
CatalogItem.Show(String) two
Book.Show(Double) 3.5
Atlas.Show(Double) 4.5
Atlas.Show(Double) 5
CatalogItem.Show(Integer) 5

Option Strict On

Public Class LoanPolicy
    Public Sub New()
        Me.New(14)                         ' constructor chaining inside one class
    End Sub

    Public Sub New(days As Integer)
        LoanDays = days
        Console.WriteLine("LoanPolicy.New(" & days & "): MyClass.Name() = " & MyClass.Name() & ", Me.Name() = " & Me.Name())
    End Sub

    Public ReadOnly Property LoanDays As Integer

    Public Overridable Function Name() As String
        Return "standard"
    End Function

    Public Function ViaMe() As String
        Return "ViaMe -> " & Me.Name()
    End Function

    Public Function ViaMyClass() As String
        Return "ViaMyClass -> " & MyClass.Name()
    End Function
End Class

Public Class StudentPolicy
    Inherits LoanPolicy

    Public Sub New()
        MyBase.New(28)
    End Sub

    Public Overrides Function Name() As String
        Return "student"
    End Function
End Class

Module Program
    Sub Main()
        Dim p As New StudentPolicy()
        Console.WriteLine(p.ViaMe())
        Console.WriteLine(p.ViaMyClass())
        Console.WriteLine(p.LoanDays)
        Dim q As New LoanPolicy()
        Console.WriteLine(q.LoanDays)
    End Sub
End Module

LoanPolicy.New(28): MyClass.Name() = standard, Me.Name() = student
ViaMe -> student
ViaMyClass -> standard
28
LoanPolicy.New(14): MyClass.Name() = standard, Me.Name() = standard
14

Option Strict On
Imports System.Reflection

Public MustInherit Class AbstractItem
End Class

Public Class ConcreteItem
End Class

Class Holder
    Dim hidden As Integer
    Sub NoModifier()
    End Sub
End Class

Module Program
    Sub Show(t As Type)
        For Each c In t.GetConstructors(BindingFlags.Instance Or BindingFlags.Public Or BindingFlags.NonPublic)
            Console.WriteLine(t.Name & " constructor: IsPublic=" & c.IsPublic & " IsFamily(Protected)=" & c.IsFamily)
        Next
    End Sub

    Sub Main()
        Show(GetType(AbstractItem))
        Show(GetType(ConcreteItem))
        Dim f = GetType(Holder).GetField("hidden", BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public)
        Console.WriteLine("Dim field IsPrivate=" & f.IsPrivate)
        Console.WriteLine("Sub without modifier IsPublic=" & GetType(Holder).GetMethod("NoModifier").IsPublic)
        Console.WriteLine("Top-level Class without modifier: IsNotPublic=" & GetType(Holder).IsNotPublic)
    End Sub
End Module

AbstractItem constructor: IsPublic=False IsFamily(Protected)=True
ConcreteItem constructor: IsPublic=True IsFamily(Protected)=False
Dim field IsPrivate=True
Sub without modifier IsPublic=True
Top-level Class without modifier: IsNotPublic=True

Option Strict On

Public MustInherit Class CatalogItem
    Public Property Title As String = ""
    Public Overridable Function Describe() As String
        Return "item"
    End Function
End Class

Public Class Book
    Inherits CatalogItem
    Public Overrides Function Describe() As String
        Return "book"
    End Function
End Class

Module Program
    ' Overload resolution happens at compile time, from the static types of the arguments.
    Sub Print(item As CatalogItem)
        Console.WriteLine("Print(CatalogItem): " & item.Describe())
    End Sub

    Sub Print(book As Book)
        Console.WriteLine("Print(Book): " & book.Describe())
    End Sub

    Sub Main()
        Dim b As New Book()
        Dim asItem As CatalogItem = b

        Print(b)                    ' static type Book
        Print(asItem)               ' static type CatalogItem, although the object is a Book
        Print(DirectCast(asItem, Book))
    End Sub
End Module

Print(Book): book
Print(CatalogItem): book
Print(Book): book

Option Strict On

Public MustInherit Class CatalogItem
    Public Property Title As String = ""
    Public MustOverride ReadOnly Property Kind As String
End Class

Public Class Book
    Inherits CatalogItem
    Public Property Pages As Integer
    Public Overrides ReadOnly Property Kind As String = "Book"
End Class

Public Class Textbook
    Inherits Book
    Public Property Course As String = ""
End Class

Public Class Magazine
    Inherits CatalogItem
    Public Property IssueNumber As Integer
    Public Overrides ReadOnly Property Kind As String = "Magazine"
End Class

Module Program
    Function Summarize(item As CatalogItem) As String
        If TypeOf item Is Textbook Then
            Return "textbook for " & DirectCast(item, Textbook).Course
        ElseIf TypeOf item Is Book Then
            Return "book with " & DirectCast(item, Book).Pages & " pages"
        ElseIf TypeOf item Is Magazine Then
            Return "issue " & DirectCast(item, Magazine).IssueNumber
        End If
        Return "unknown"
    End Function

    Sub Main()
        Dim items As CatalogItem() = {
            New Book With {.Title = "Clean Code", .Pages = 464},
            New Textbook With {.Title = "Algorithms", .Course = "CS101", .Pages = 900},
            New Magazine With {.Title = "Byte", .IssueNumber = 7}
        }

        For Each item In items
            Console.WriteLine(item.Title & ": " & Summarize(item))
        Next
        Console.WriteLine()

        Dim t As CatalogItem = items(1)
        Console.WriteLine("TypeOf t Is Book       : " & (TypeOf t Is Book))
        Console.WriteLine("TypeOf t Is Textbook   : " & (TypeOf t Is Textbook))
        Console.WriteLine("t.GetType() = GetType(Book)    : " & (t.GetType() = GetType(Book)))
        Console.WriteLine("GetType(Book).IsInstanceOfType(t): " & GetType(Book).IsInstanceOfType(t))
        Console.WriteLine("TypeOf t IsNot Magazine: " & (TypeOf t IsNot Magazine))

        Dim nothingItem As CatalogItem = Nothing
        Console.WriteLine("TypeOf Nothing Is Book : " & (TypeOf nothingItem Is Book))
        Console.WriteLine("TryCast(Nothing)       : " & (TryCast(nothingItem, Book) Is Nothing))
        Console.WriteLine()

        Dim asBook As Book = TryCast(items(2), Book)
        Console.WriteLine("TryCast(magazine, Book) Is Nothing: " & (asBook Is Nothing))
        Dim viaCType As Book = CType(items(1), Book)
        Console.WriteLine("CType(textbook, Book)   : " & viaCType.Title)

        Try
            Dim wrong As Book = DirectCast(items(2), Book)
            Console.WriteLine(wrong.Title)
        Catch ex As InvalidCastException
            Console.WriteLine(ex.GetType().Name & ": " & ex.Message)
        End Try

        Select Case True
            Case TypeOf t Is Magazine : Console.WriteLine("select: magazine")
            Case TypeOf t Is Book : Console.WriteLine("select: book")
            Case Else : Console.WriteLine("select: other")
        End Select
    End Sub
End Module

Clean Code: book with 464 pages
Algorithms: textbook for CS101
Byte: issue 7

TypeOf t Is Book       : True
TypeOf t Is Textbook   : True
t.GetType() = GetType(Book)    : False
GetType(Book).IsInstanceOfType(t): True
TypeOf t IsNot Magazine: True
TypeOf Nothing Is Book : False
TryCast(Nothing)       : True

TryCast(magazine, Book) Is Nothing: True
CType(textbook, Book)   : Algorithms
InvalidCastException: Unable to cast object of type 'Shelf.Magazine' to type 'Shelf.Book'.
select: book

Option Strict On

Public MustInherit Class CatalogItem
    Public Property Title As String = ""
End Class

Public Class Book
    Inherits CatalogItem
End Class

Public Class Magazine
    Inherits CatalogItem
End Class

Module Program
    Sub PrintTitles(items As IEnumerable(Of CatalogItem))
        For Each item In items
            Console.WriteLine("  " & item.Title)
        Next
    End Sub

    Sub Main()
        Dim books As New List(Of Book) From {New Book With {.Title = "Refactoring"}}

        ' Covariance: IEnumerable(Of Book) is an IEnumerable(Of CatalogItem).
        Console.WriteLine("IEnumerable(Of T) is covariant:")
        PrintTitles(books)

        ' Contravariance: an Action(Of CatalogItem) accepts a Book.
        Dim printItem As Action(Of CatalogItem) = Sub(i) Console.WriteLine("  action got " & i.Title)
        Dim printBook As Action(Of Book) = printItem
        printBook(books(0))

        ' Arrays are covariant too, and unsafe.
        Dim bookArray As Book() = {New Book With {.Title = "Array book"}}
        Dim itemArray As CatalogItem() = bookArray
        Console.WriteLine("array covariance: " & itemArray(0).Title)
        Try
            itemArray(0) = New Magazine With {.Title = "Byte"}
        Catch ex As ArrayTypeMismatchException
            Console.WriteLine("store failed: " & ex.GetType().Name)
        End Try

        ' List(Of T) is invariant: Dim x As List(Of CatalogItem) = books fails with BC36756.
        Dim copy As New List(Of CatalogItem)(books)
        copy.Add(New Magazine With {.Title = "Byte"})
        Console.WriteLine("copy has " & copy.Count & " items, books still has " & books.Count)
    End Sub
End Module

IEnumerable(Of T) is covariant:
  Refactoring
  action got Refactoring
array covariance: Array book
store failed: ArrayTypeMismatchException
copy has 2 items, books still has 1

Option Strict On

Public Class LoanEventArgs
    Inherits EventArgs
    Public ReadOnly Property Borrower As String
    Public Sub New(borrower As String)
        Me.Borrower = borrower
    End Sub
End Class

Public Class Loan
    Public Event Returned As EventHandler(Of LoanEventArgs)
    Public ReadOnly Property Borrower As String

    Public Sub New(borrower As String)
        Me.Borrower = borrower
    End Sub

    Public Sub [Return]()
        OnReturned(New LoanEventArgs(Borrower))
    End Sub

    ' The standard pattern: the event can be raised only inside the declaring class,
    ' so the class offers a Protected Overridable method for derived classes.
    Protected Overridable Sub OnReturned(e As LoanEventArgs)
        RaiseEvent Returned(Me, e)
    End Sub
End Class

Public Class AuditedLoan
    Inherits Loan

    Public Sub New(borrower As String)
        MyBase.New(borrower)
    End Sub

    Protected Overrides Sub OnReturned(e As LoanEventArgs)
        Console.WriteLine("audit: " & e.Borrower & " returned the item")
        MyBase.OnReturned(e)           ' forget this call and no handler is ever notified
    End Sub
End Class

Public Class Reader
    Public Sub Attach(loan As Loan)
        AddHandler loan.Returned, AddressOf OnLoanReturned
    End Sub

    Private Sub OnLoanReturned(sender As Object, e As LoanEventArgs)
        Console.WriteLine("reader notified: " & e.Borrower)
    End Sub
End Class

Public Class CatalogException
    Inherits Exception

    Public Sub New(message As String)
        MyBase.New(message)
    End Sub

    Public Sub New(message As String, innerException As Exception)
        MyBase.New(message, innerException)
    End Sub
End Class

Public Class DuplicateIsbnException
    Inherits CatalogException

    Public ReadOnly Property Isbn As String

    Public Sub New(isbn As String)
        MyBase.New("Duplicate ISBN " & isbn)
        Me.Isbn = isbn
    End Sub
End Class

Module Program
    Sub Main()
        Dim loan As New AuditedLoan("Ana")
        Dim reader As New Reader()
        reader.Attach(loan)
        loan.Return()

        Try
            Throw New DuplicateIsbnException("9780132350884")
        Catch ex As DuplicateIsbnException When ex.Isbn.StartsWith("978", StringComparison.Ordinal)
            Console.WriteLine("specific: " & ex.Message)
        Catch ex As CatalogException
            Console.WriteLine("general: " & ex.Message)
        End Try
    End Sub
End Module

audit: Ana returned the item
reader notified: Ana
specific: Duplicate ISBN 9780132350884

Option Strict On

Public Interface IDescribable
    Function Describe() As String
End Interface

Public Class Item
    Implements IDescribable

    Public Overridable Function Describe() As String Implements IDescribable.Describe
        Return "Item"
    End Function
End Class

Public Class Book
    Inherits Item

    Public Overrides Function Describe() As String
        Return "Book"
    End Function
End Class

' Shadows without re-implementing: the interface still points at Item.Describe.
Public Class Atlas
    Inherits Item

    Public Shadows Function Describe() As String
        Return "Atlas"
    End Function
End Class

' Re-implementing the interface rebinds it to the new member.
Public Class Map
    Inherits Item
    Implements IDescribable

    Public Shadows Function Describe() As String Implements IDescribable.Describe
        Return "Map"
    End Function
End Class

Module Program
    Sub Main()
        Dim book As New Book()
        Dim atlas As New Atlas()
        Dim map As New Map()

        For Each d As IDescribable In New IDescribable() {book, atlas, map}
            Console.WriteLine("via interface: " & d.Describe())
        Next
        Console.WriteLine("via Item   : " & CType(atlas, Item).Describe() & ", " & CType(map, Item).Describe())
        Console.WriteLine("via Atlas  : " & atlas.Describe())
        Console.WriteLine("via Map    : " & map.Describe())
    End Sub
End Module

via interface: Book
via interface: Item
via interface: Map
via Item   : Item, Item
via Atlas  : Atlas
via Map    : Map

Option Strict On

Public Interface IDescribable
    Function Describe() As String
End Interface

' An abstract class may implement an interface member by redeclaring it MustOverride.
Public MustInherit Class CatalogItem
    Implements IDescribable

    Public MustOverride Function Describe() As String Implements IDescribable.Describe
End Class

Public Class Book
    Inherits CatalogItem

    Public Overrides Function Describe() As String
        Return "Book"
    End Function
End Class

Module Program
    Sub Main()
        Dim d As IDescribable = New Book()
        Console.WriteLine(d.Describe())
    End Sub
End Module

Book

Option Strict On

Public Class Author
    Public Property Name As String = ""
End Class

Public Class Shelf2
    Public Property Label As String = ""
    Public Property Owner As New Author()
    Public Property Tags As New List(Of String)

    Public Function ShallowCopy() As Shelf2
        Return DirectCast(MemberwiseClone(), Shelf2)    ' Protected member of Object
    End Function
End Class

Module Program
    Sub Main()
        Dim a As New Shelf2 With {.Label = "Fiction"}
        a.Owner.Name = "Ana"
        a.Tags.Add("novel")

        Dim b As Shelf2 = a.ShallowCopy()
        b.Label = "Poetry"
        b.Owner.Name = "Ben"
        b.Tags.Add("verse")

        Console.WriteLine(a.Label & " / " & a.Owner.Name & " / " & String.Join(",", a.Tags))
        Console.WriteLine(b.Label & " / " & b.Owner.Name & " / " & String.Join(",", b.Tags))
        Console.WriteLine(Object.ReferenceEquals(a.Owner, b.Owner))
    End Sub
End Module

Fiction / Ben / novel,verse
Poetry / Ben / novel,verse
True

public abstract class CatalogItem
{
    protected CatalogItem(string title, int year) { Title = title; Year = year; }
    public string Title { get; set; }
    public int Year { get; set; }
    public abstract string Kind { get; }
    public virtual string Describe() => $"{Kind}: {Title} ({Year})";
}

public class Book : CatalogItem
{
    public Book(string title, int year, params string[] authors) : base(title, year) { Authors.AddRange(authors); }
    public List<string> Authors { get; } = new();
    public override string Kind => "Book";
    public override string Describe() => base.Describe() + " by " + string.Join(", ", Authors);
}