Accessor for formatted sub-list of dictionary possible without creating a new object every time?

Question

first off - yes, I had a look at this question: Is object creation in getters bad practice?. I am also not talking about initializing an object in the accessors / mutators, it is about a specific part of the object I want to be returned in a specific way.

My question is more specific; It does not necessarily only apply to C#, however I am currently looking for a solution to implement in my C# project.

I have a class with a dictionary that maps date objects to a decimal value. In one accessor, I want to return a list of all the keys of the dictionary, another accessors returns the values. What I also want to have is an accessor that gives me the decimal values in a specific format. It would look something like this:

class Class
{
    // Some other properties...
    // ....

    private Dictionary<DateTime, decimal> dict;

    public Class(Dictionary<DateTime, decimal> dict)
    {
        this.dict = dict;
    }

    private string FormatTheWayIWant(decimal dt)
    {
        // Format decimal value.
        string s = String.Format("{0:F}", dt);
        return s;
    }

    public ReadOnlyCollection<DateTime> DateTimes
    {
        get { return new ReadOnlyCollection<DateTime>(this.dict.Keys.ToList()); }
    }

    public ReadOnlyCollection<decimal> Values
    {
        get { return new ReadOnlyCollection<decimal>(this.dict.Values.ToList()); }
    }

    public ReadOnlyCollection<string> FormattedStrings
    {
        get
        {
            // Format each decimal value they way I want.
            List<string> list = new List<string>();
            foreach (decimal dt in dict.Keys)
            {
                list.Add(FormatTheWayIWant(dt));
            }
            return new ReadOnlyCollection<string>(list);
        }
    }
}

This way I can make the following calls (which is my goal!):

DateTime dateTime = DateTimes[0];
decimal s = Values[0];
string formattedS = FormattedStrings[0];

The problem with this approach is that I create a new list everytime I invoke the FormattedStrings accessor, even if I only need one of the formatted strings. I know this is not good practice and can introduce unnecessary performance issues...

The alternatives I thought of are:

1. I could extend the decimal class and implement a custom ToString()-method.
2. Or overwrite the KeyValuePair<DateTime, decimal> class and use an indexer in my class.
3. Or I create a method with a parameter for the index and return just the one formatted string.
4. Or I could have an own list for the accessor, which gets updated in the set-method for my dictionary everytime I update the dictionary.

The question I have is, is there a way to make this work with an accessor instead of a method, creating custom classes or having strange side effects on other objects when assigning a value?

Thank you in advance.

Answer 1

This is VB, but you get the idea...

Public Class Something

  Public Property Items As Dictionary(Of DateTime, String)

  Public Readonly Property FormattedItem(ByVal index As Int32) As String
    ' add error checking/handling as appropriate
    Return Me.Items.Keys(index).ToString("custom format")  '  or whatever your formatting function looks like.
  End Property
End Class

Answer 2

Ofcourse this can be done with an accessor. You just have to create 3 separate classes for each desired element of your processed collection. Those classes should have their own indexers, so you would be able to access the elements as a list. The difference would be, that they compute each element on demand (wchich is called lazy initialization). So it would go like this (example for your FormattedStrings):

class Class
{
    // ...

    MyFormattedStrings FormattedStrings
    {
        get {return new MyFormattedStringsIndexer<string>(this.dict.Values.ToList());}
    }
}

class MyFormattedStringsIndexer<T>
{
    private IList<T> list;  // we take only reference, so there is no overhead

    public MyFormattedStringsCollection (IList<T> list)
    {
        this.list = list;
    }

    // the indexer:
    public T this[int i]
    {
        get
        {
            // this is where the lazy stuff happens:
            // compute the desired element end return it
        }
        set
        {
            // ...
        }
    }
}

Now you can use your Class like this:

string formattedS = FormattedStrings[5];

and each element you access will be computed as you access it. This solution also has the advantage of separating concerns, so should you ever had to implement different logic for one of your 3 accessors it would be just a matter of extending one of the indexers.

You can read more about indexeres here: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx

Answer 3

Your Dates and Strings property getters are returning a new list on each call. Therefore if a caller does the following:

Class myClass = ...
for(i=0; i<myClass.Strings.Count; i++)
{
    var s = myClass.Strings[i];
    ...
}

then each iteration of the loop will create a new list.

I'm not clear on what you're really trying to achieve here. You are wrapping the dictionary's Keys and Values properties in ReadOnlyCollections. This gives you an indexer, which doesn't have much meaning as the order of the Keys in a Dictionary<TKey, TValue> is unspecified.

Coming (at last!) to your question, if you want to do the formatting in a "lazy" manner, you could create a custom class that implements a readonly IList<string>, and wraps your list of keys (IList<DateTime>). Most of the implementation is boilerplate, and your indexer will do the formatting. You could also cache the formatted values so that you only format once if accessed multiple times. Something like:

public class MyFormattingCollection : IList<string>
{
    private IList<decimal> _values;
    private IList<string> _formattedValues;

    public MyFormattingCollection(IList<DateTime> values)
    {
        _values = values;
        _formattedValues = new string[_values.Count];
    }

    public string this[int index]
    {
        get
        {
            var result = _formattedValues[index];
            if (result == null)
            {
                result = FormatTheWayIWant(_values[index]);
                _formattedValues[index] = result;
            }
            return result;
       }
       set
       {
           // Throw: it's a readonly collection
       }
    }

    // Boilerplate implementation of readonly IList<string> ...
}

Answer 4

It looks like a good candidate for a new class

public class MyObject
{
    public DateTime Key {get;set;}
    public String Name {get;set;}
    public String FormattedString {get;}
}

And then it can be used in any container (List<MyObject>, Dictionary<MyObject>, etc).