Question

I’m trying to make a control template for a table where each column is related to a drop-down list of possible values, and each row has it’s own unique set of ‘selected values’. It looks like this:

<DataTemplate x:Key="ColourCellDataTemplate">
    <local:ColourDictionary Key="{TemplateBinding Content}">
        <local:ColourDictionary.ContentTemplate>
            <DataTemplate>
                <TextBlock Style="{StaticResource EditableTextCell}" Text="{Binding ColourName}" />
            </DataTemplate>
        </local:ColourDictionary.ContentTemplate>
    </local:ColourDictionary>
</DataTemplate>

I have about 10 of these classes, each initialized with a different datatable and sort key, but all the underlying operations and events are the same.

Each of these classes has their own static cached DataView member, which is shared between all instances of that class:

public class ColourDictionary : DataTableDictionary
{
    private static DataView cachedView;

    public ColourDictionary(){ }

    protected override DataView createView()
    {
        if (CachedView == null)
        {
            CachedView = base.buildView(table:((App)App.Current).ApplicationData.Colours, 
                                        keyField:"ColorCode");
        }
        return CachedView;
    }
}

As you can see – when the base class goes to create the DataView for use by the dictionary, it uses a virtual method which allows the different inheriting classes to pass on their own view – but each class needs to keep track of their own static cache.

I was hoping that this caching was logic I could keep in the base class so that “CreateView()” would only need to return a new DataView and would only ever be called once, after which the base class would simply use it’s own cache for each inheriting class type.

---

Solution

Thank you so much for two very good and very valid ideas. I hope you both get more upvotes. I went with the latter solution because I’m a sucker for brevity. I then went a little further so that the implementing classes need only override a virtual property getter to satisfy the requirements:

public class CATCodeDictionary : DataTableDictionary<CATCodeDictionary>
{
    protected override DataTable table { get { return ((App)App.Current).ApplicationData.CATCodeList; } }
    protected override string indexKeyField { get { return "CatCode"; } }
    public CATCodeDictionary() { }
}
public class CCYDictionary : DataTableDictionary<CCYDictionary>
{
    protected override DataTable table { get { return ((App)App.Current).ApplicationData.CCYList; } }
    protected override string indexKeyField { get { return "CCY"; } }
    public CCYDictionary() { }
}
public class COBDictionary : DataTableDictionary<COBDictionary>
{
    protected override DataTable table { get { return ((App)App.Current).ApplicationData.COBList; } }
    protected override string indexKeyField { get { return "COB"; } }
    public COBDictionary() { }
}    
etc...

Base Class

public abstract class DataTableDictionary<T> : where T : DataTableDictionary<T>
{
    private static DataView _IndexedView = null;

    protected abstract DataTable table { get; }
    protected abstract string indexKeyField { get; }

    public DataTableDictionary()
    {
        if( _IndexedView == null)
        {
            _IndexedView = CreateIndexedView(table.Copy(), indexKeyField);
        }
    }

    private DataView CreateIndexedView(DataTable table, string indexKey)
    {   // Create a data view sorted by ID ( keyField ) to quickly find a row.
        DataView dataView = new DataView(table);
        dataView.Sort = indexKey;
        return dataView;
    }

Answer 1

You can use generics:

public class DataTableDictionary<T> where T: DataTableDictionary<T>
{
    private static DataView cachedView;  
}

public class ColourDictionary : DataTableDictionary<ColourDictionary>
{
}

public class XyDictionary : DataTableDictionary<XyDictionary>
{
}

Here each class has its own static member.