Question

I’ve got problem using generics. I’m creating an interface called IProblem, where each problem has results (answers) and a result (if it is correct)

public interface IProblem<T>
{
    ushort ResultCount { get; }
    T[] Results { get; }

    bool IsCorrect();
}

public abstract class ProblemBase<T> : IProblem<T>
{
    private T[] _results;
    private ushort? _resultCount;

    public ushort ResultCount
    {
        get
        {
            if (_resultCount == null) throw new ArgumentNullException("_resultCount");
            return (ushort)_resultCount;
        }
        protected set
        {
            if (_resultCount != value)
                _resultCount = value;
        }
    }

    public T[] Results
    {
        get
        {
            if (_results == null)
                _results = new T[ResultCount];

            return _results;
        }
    }

    public abstract bool IsCorrect();
}

This is an example where I create an arithmetic problem, called ProblemA. T is decimal because the array datatype should be decimal (anothers problems maybe might have string, or int)

public class ProblemA: ProblemBase<decimal>
{
    private decimal _number1;
    private decimal _number2;
    private Operators _operator;

    public decimal Number1
    {
        get { return _number1; }
        set { _number1 = value; }
    }

    public decimal Number2
    {
        get { return _number2; }
        set { _number2 = value; }
    }

    public Operators Operator
    {
        get { return _operator; }
        set { _operator = value; }
    }

    public decimal Result
    {
        get { return Results[0]; }
        set { Results[0] = value; }
    }

    public ProblemA()
    {
        this.ResultCount = 1;
    }

    public override bool IsCorrect()
    {
        bool result;

        switch (_operator)
        {
            case Operators.Addition:
                result = this.Result == (this.Number1 + this.Number2);
                break;
            case Operators.Subtract:
                result = this.Result == (this.Number1 - this.Number2);
                break;
            case Operators.Multiplication:
                result = this.Result == (this.Number1 * this.Number2);
                break;
            case Operators.Division:
                result = this.Result == (this.Number1 / this.Number2);
                break;
            default:
                throw new ArgumentException("_operator");
        }

        return result;
    }
}

I’m using MVVM, so I’d like to have a ViewModel for each problem where contains ProblemBase<T> as property, but how it’s a generic, I guess it will be a problem if a put in IProblemViewModel as generic.

public interface IProblemViewModel : IViewModel
{
    ProblemBase<T> Problem { get; set; }
}

I said this because later a plan to use a ObservableCollection<IProblemViewModel>, so I’m not sure if there’s no problem if I write IProblemViewModel or IProblemViewModel<T>.
Thanks in advance.

Answer 1

Maybe I haven’t understood this perfectly, but is this what you are after?

    ObservableCollection<IProblemViewModel<object>> collection = new ObservableCollection<IProblemViewModel<object>>
    {
        new ProblemViewModel<DerivedResult>(),
        new ProblemViewModel<OtherResult>()
    };

This can be achieved by declaring the generic argument as covariant.

You could also change the collection to

ObservableCollection<IProblem<BaseType>>

and just have it accept a specific result chain. In this example, DerivedResult and OtherResult must then inherit from BaseType to fit into the collection.

The big caveat is that primitive types don’t fit into this hierarchy, in any way. You will have to wrap them in IProblem<IntResult> and so on.

Of course, you could implement a simple carrier, for example Boxer which would box any value type instead of implementing one for each type.

One last caveat: It’s not possible to have a ‘set’ property on a covariant type, so IProblemViewModel can only support get.

A complete, compilable example:

class Program
{

    public interface IProblem<out T>
    {
        ushort ResultCount { get; }
        T[] Results { get; }

        bool IsCorrect();
    }

    public class ProblemBase<T> : IProblem<T>
    {
        private T[] _results;
        private ushort? _resultCount;

        public ushort ResultCount
        {
            get
            {
                if (_resultCount == null) throw new ArgumentNullException("_resultCount");
                return (ushort)_resultCount;
            }
            protected set
            {
                if (_resultCount != value)
                    _resultCount = value;
            }
        }

        public T[] Results
        {
            get
            {
                if (_results == null)
                    _results = new T[ResultCount];

                return _results;
            }
        }

        public bool IsCorrect()
        {
            return true;
        }
    }

    public interface IProblemViewModel<out T>
    {
        IProblem<T> Problem { get; }
    }

    public class BaseResult
    {

    }

    public class DerivedResult : BaseResult
    {

    }

    public class OtherResult : BaseResult
    {

    }

    public class ProblemViewModel<T> : IProblemViewModel<T>
    {

        public IProblem<T> Problem
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }


    static void Main(string[] args)
    {
        ObservableCollection<IProblemViewModel<object>> collection = new ObservableCollection<IProblemViewModel<object>>
        {
            new ProblemViewModel<DerivedResult>(),
            new ProblemViewModel<OtherResult>()
            //, new ProblemViewModel<int>()   // This is not possible, does not compile.
        };
    }
}