Refactoring to avoid the use of dynamic

Question

Based on the answer to my question on StackOverflow, I have ended up with the following code:

public class ColumnDataBuilder<T>
{
    public abstract class MyListViewColumnData
    {
        public string Name { get; protected set; }
        public int Width { get; protected set; }
        public ColumnType Type { get; protected set; }
        public delegate TOUT FormatData<out TOUT>(T dataIn);

        protected abstract dynamic GetData(T dataRow);

        public string GetDataString(T dataRow)
        {
            dynamic data = GetData(dataRow);
            switch (Type)
            {
                case ColumnType.String:
                case ColumnType.Integer:
                case ColumnType.Decimal:
                    return data.ToString();
                case ColumnType.Date:
                    return data.ToShortDateString();
                case ColumnType.Currency:
                    return data.ToString("c");
                    break;
                case ColumnType.Boolean:
                    var b = (bool)data;
                    if (b) return "Y";
                    else return "N";
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

    }

    public class MyListViewColumnData<TOUT> : MyListViewColumnData
    {

        public MyListViewColumnData(string name, int width, ColumnType type, FormatData<TOUT> dataFormater)
        {
            DataFormatter = x => dataFormater(x); // Per http://stackoverflow.com/a/1906850/298754
            Type = type;
            Width = width;
            Name = name;
        }
        public Func<T, TOUT> DataFormatter { get; protected set; }
        protected override dynamic GetData(T dataRow)
        {
            return DataFormatter(dataRow);
        }
    }
 }

This is called from a factory method (in ColumnDataBuilder) as

public MyListViewColumnData Create<TOUT>(string name, int width, ColumnType type, MyListViewColumnData.FormatData<TOUT> dataFormater)
{
    return new MyListViewColumnData<TOUT>(name, width, type, dataFormater);
}
public MyListViewColumnData Create(string name, int width, MyListViewColumnData.FormatData<DateTime> dataFormater)
{
    return new MyListViewColumnData<DateTime>(name, width, ColumnType.Date, dataFormater);
}
...

That, in turn, is called from my code as:

builder.Create("Date", 40, x => x.createdDate);

and

private ListViewItem CreateListViewItem<TDATA>(IEnumerable<ColumnDataBuilder<TDATA>.MyListViewColumnData> columns, TDATA rowData)
{
    var item = new ListViewItem();
    foreach (var col in columns)
    {
        item.SubItems.Add(col.GetDataString(rowData));
    }
    item.SubItems.RemoveAt(0); // We generate an extra SubItem for some reason.
    return item;
}

How can I refactor this so that I'm not using dynamic, but still preserve the syntax as it currently exists in the code?

Answer 1

I don't think you need MyListViewColumnData class there, I would replace it with interface and move the GetDataString implementation to MyListViewColumnData<TOut>. And you don't need dynamic here, just use object instead (yes, it will use boxing for most cases except strings, but it's more efficient than dynamics).

public class ColumnDataBuilder<T>
{
    public interface IMyListViewColumnData
    {
        string Name { get; }
        int Width { get; }
        ColumnType Type { get; }
        string GetDataString(T dataRow);
    }

    public delegate TOut FormatData<out TOut>(T dataIn);

    public class MyListViewColumnData<TOut> : IMyListViewColumnData
    {
        public string Name { get; private set; }
        public int Width { get; private set; }
        public ColumnType Type { get; private set; }
        private readonly FormatData<TOut> _dataFormatter;

        public MyListViewColumnData(string name, int width, ColumnType type, FormatData<TOut> dataFormater)
        {
            _dataFormatter = dataFormater;
            Type = type;
            Width = width;
            Name = name;
        }
        public string GetDataString(T dataRow)
        {
            object data = _dataFormatter(dataRow);

            switch (Type)
            {
                case ColumnType.String:
                case ColumnType.Integer:
                case ColumnType.Decimal:
                    return data.ToString();
                case ColumnType.Date:
                    return ((DateTime)data).ToShortDateString();
                case ColumnType.Currency:
                    return ((decimal)data).ToString("c");
                case ColumnType.Boolean:
                    return (bool)data ? "Y" : "N";
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
    }

    public IMyListViewColumnData Create<TOut>(string name, int width, ColumnType type, FormatData<TOut> dataFormater)
    {
        return new MyListViewColumnData<TOut>(name, width, type, dataFormater);
    }

    public IMyListViewColumnData Create(string name, int width, FormatData<DateTime> dataFormater)
    {
        return new MyListViewColumnData<DateTime>(name, width, ColumnType.Date, dataFormater);
    }
}

public enum ColumnType
{
    String,
    Integer,
    Decimal,
    Date,
    Currency,
    Boolean
}

Update In comments it was asked if you can extract interface for ColumnDataBuilder. Of course you can :), and the easiest way would be to use "Extract interface" refactoring from ReSharper :). If you still don't use it you'll have to do that manually (move the IMyListViewColumnData and FormatData<TOut> declarations out of ColumnDataBuilder<T> first):

public interface IColumnDataBuilder<Tin>
{
    IMyListViewColumnData Create<TOut>(string name, int width, ColumnType type, FormatData<TOut> dataFormater);
    IMyListViewColumnData Create(string name, int width, FormatData<DateTime> dataFormater);
}