Question

I have a set of custom data types that can be used to manipulate basic blocks of data. For example:

MyTypeA Foo = new MyTypeA();
Foo.ParseString(InputString);
if (Foo.Value > 4) return;

Some of these types define read-only properties that describe aspects of the types (for example a name, bit size, etc.).

In my custom framework I want to be able to provide these types to the user for use in their applications but I also want to give the user a list of the available types which they could easily bind to a combobox. My current approach:

public static class DataTypes
{
    static ReadOnlyCollection<MyDataType> AvailableTypes;

    static DataTypes()
    {
        List<MyDataType> Types = new List<MyDataType>();
        Types.Add(new MyTypeA());
        Types.Add(new MyTypeB());
        AvailableTypes = new ReadOnlyCollection<MyDataType>(Types);
    }
}

What concerns me about this is that the user might obtain a type from the AvailableTypes list (by selecting a combobox item for example) and then use that reference directly rather than creating a clone of the type and using their own reference.

How can I make the list of available types read only so that it doesn’t allow any writing or changes to the type instances, forcing the user to create their own clone?

Alternatively is there a better way of providing a list of available types?

Thanks, Andy

Answer 1

To get around the problems you’ve mentioned, you could create a wrapper around your instances, and have the wrapper provide the functionality you require.

For example:

    public class TypeDescriptor
    {
        private MyDataType _dataType;

        public TypeDescriptor(MyDataType dataType)
        {
            _dataType = dataType;
        }

        public override string ToString()
        {
            return _dataType.ToString();
        }
    }

You class would then look something like:

    public static class DataTypes
    {
        public static ReadOnlyCollection<TypeDescriptor> AvailableTypes;

        static DataTypes()
        {
            List<TypeDescriptor> Types = new List<TypeDescriptor>();
            Types.Add(new TypeDescriptor(new MyTypeA()));
            Types.Add(new TypeDescriptor(new MyTypeB()));
            AvailableTypes = new ReadOnlyCollection<TypeDescriptor>(Types);
        }
    }

Binding to the list and relying on the ToString() will now result in your data types ToString being called.