强制继承对象之间的平等和唯一性

Question

I have a general question about the structure of my object model. Perhaps I am approaching this with tunnel vision from the wrong direction. I have two classes, Item and SerializedItem. I have defined them as such:

public class Item
{
    public string ItemNumber { get; set; }
    public string Description { get; set; }
    public double Cost { get; set; }
}

public class SerializedItem : Item
{
    public string SerialNumber { get; set; }
    public MyObject Location { get; set; }
}

An Item is a generic definition of an item, and contains information common to that product. SerializedItem is a representation of a specific, physical item. My difficulty lies in the fact that only one Item with a particular ItemNumber should exist in memory at anytime, and I am not sure the best pattern to use to enforce that constraint while allowing a SerializedItem to act as its base type.

Maybe this is a more appropriate approach? I don't have a lot of experience using the 'New' keyword, and I've shied away from using it in the past in favor of an inheritance structure that didn't require its use.

public class Item
{
    public string ItemNumber { get; set; }
    public string Description { get; set; }
    public double Cost { get; set; }
}

public class SerializedItem : Item
{
    private Items _item;
    public SerializedItemz(Item item)
    {
        _item = item;
    }

    public new string ItemNumber
    {
        get { return _item.ItemNumber; }
        set { _item.ItemNumber = value; }
    }

    public new string Description
    {
        get { return _item.Description; }
        set { _item.Description = value; }
    }

    public new double Cost
    {
        get { return _item.Cost; }
        set { _item.Cost = value; }
    }

    public string SerialNumber { get; set; }
}

I would appreciate any guidance on how to approach this. I'm not tied to any particular solution.

To provide some clarity:

The Item class is a representation of a particular product, 'Widget A.' It has information about the Widget A's cost, weight, dimensions, etc. No matter how many Widget As are produced, they all share this information.

The SerializedItem class is a representation of an actual item in that product line, 'Widget A 001.' It contains information about the physical location of that item and it's production and sales history.

If the Item object is updated, all SerializedItems should reflect that change.

Answer 1

I am not sure the best pattern to use to enforce that constraint while allowing a SerializedItem to act as its base type

At first glance a flyweight factory pattern would seem appropriate. Create a class whose responsibility is to create Item s, keep track of which ones have already been created, and ensure that only one item with a given key is created.

You can also build logic into the factory to create different subtypes like SerializedItem - you'd just need to provide the appropriate SPI to determine what type is necessary and collect the necessary inputs.

A basic implementation would look something like:

public static class ItemFactory
{
    public static Dictionary<string, Item> _Items = new Dictionary<string, Item>;

    public static Item GetItem(string itemNumber)
    {
        if(!_Items.ContainsKey(itemNumber))
        {
            _Items[itemNumber] = new Item(itemNumber);
            // Initialize item if necessary
        }

        return _Items[itemNumber];
    }
}

The SerializedItem class is a representation of an actual item in that product line

Than an appropriate design is to make Item an ItemType and use composition instead of inheritance . So your second approach (with the change that SerializedItem does NOT inherit from Item ) looks valid.

Answer 2

If Item is truly a non-instantiated base class then mark it as abstract and work through your concrete SerializedItem class ( and any other derived classes you may have ). If you only want a single Item in memory with a given item number then you might consider a Dictionary type collection indexed on the item number.