Different object types in the same property

Question

Im playing around with RavenDb and am building some kind of quiz. There are different types of question: - Multiple choice (A, B, C or D?) - Date (On what date did...?) - Number (How many...?)

What I did is create a base class Question, with a property Question, which contains the question as a string and a list of Answers, the users have given.

public class Question
{
    public string Question { get; set; }
    public List<Answer> Answers { get; set; }
}

Then I created multiple subclasses, which inherit from Question. For example, NumberQuestion contains the properties MinimumValue and MaximumValue, since this differences per question.

I want users to give an answer, and save that answer to the database. THe problem is, that the answer can be different types, like a DateTime, float or integer(multiple choice). My question is, what is the best way to save the Answer in a RavenDb?

This is what I'm currently doing:

public class Answer
{
    public User User { get; set; }
    public string AnswerString { get; set; }
    public string AnswerType { get; set; }
}

What I do here, is save the answer as a string and save the type (DateTime, float etc) also, so I can parse it later.

It works, but I don't like it very much. There must be another, better way.

Answer 1

If you want to store more than one type in the same property, then just declare the property as a common base type. In your case object will do just fine. When serialized, you will get extra $type fields in the json, which will allow them to be deserialized back into their proper forms.

Let's see if I can offer some advice on your particular domain model.

• Don't confuse a possible answer with an actual one. Give these different names to keep them straight. I'll use Choice to represent a possible answer to a question, and Answer to represent the actual answer given by the user.

• Pay attention to where the Aggregate Entities are. These are what end up in RavenDB as actual documents and get an Id. In your case, I only see two - Question and Exam.

Try this on for size:

public abstract class Question
{
    public string Id { get; set; }
    public string QuestionText { get; set; }
}

public class ValueQuestion : Question
{
    public object CorrectValue { get; set; }
}

public class RangeQuestion : Question
{
    public object MinCorrectValue { get; set; }
    public object MaxCorrectValue { get; set; }
}

public class MultipleChoiceQuestion : Question
{
    public int NumberOfChoicesAllowed { get; set; }
    public List<MultipleChoiceOption> Choices { get; set; }
}

public class MultipleChoiceOption
{
    public char Letter { get; set; }
    public bool Correct { get; set; }
    public object Value { get; set; }
}

public class EssayQuestion : Question
{
    public int MinAnswerLength { get; set; }
    public int MaxAnswerLength { get; set; }
}

public class Exam
{
    public string Id { get; set; }
    public string UserId { get; set; }
    public DateTime Taken { get; set; }
    public decimal Score { get; set; }
    public List<Answer> Answers { get; set; }
}

public class Answer
{
    public string QuestionId { get; set; }
    public bool Correct { get; set; }
    public object Value { get; set; }
}

Generics might be tempting, but I think you'll find that they don't buy you much. In the end, you'll have the same structure in your documents and the same layout in the database. Probably the only difference is that the $type fields are used in different places.

If you want to try a generics-based solution, try this:

public abstract class Question
{
    public string Id { get; set; }
    public string QuestionText { get; set; }
}

public class ValueQuestion<T> : Question
{
    public T CorrectValue { get; set; }
}

public class RangeQuestion<T> : Question
{
    public T MinCorrectValue { get; set; }
    public T MaxCorrectValue { get; set; }
}

public class MultipleChoiceQuestion<T> : Question
{
    public int NumberOfChoicesAllowed { get; set; }
    public List<MultipleChoiceOption<T>> Choices { get; set; }
}

public class MultipleChoiceOption<T>
{
    public char Letter { get; set; }
    public bool Correct { get; set; }
    public T Value { get; set; }
}

public class EssayQuestion : Question
{
    public int MinAnswerLength { get; set; }
    public int MaxAnswerLength { get; set; }
}

public class Exam
{
    public string Id { get; set; }
    public string UserId { get; set; }
    public DateTime Taken { get; set; }
    public decimal Score { get; set; }
    public List<IAnswer> Answers { get; set; }
}

public interface IAnswer
{
    string QuestionId { get; set; }
    bool Correct { get; set; }
}

public class Answer<T> : IAnswer
{
    public string QuestionId { get; set; }
    public bool Correct { get; set; }
    public T Value { get; set; }
}

Answer 2

You could use generics. Create a generic class Question of TAnswer where TAnswer has to inherit from an abstract class Answer. Specific question classes would inherit from that class:

public abstract class Question<TAnswer> where TAnswer : Answer
{
    public Guid Id { get; set; }
    public string Question { get; set; }
    public List<TAnswer> Answers { get; set; }
}

public class DateQuestion : Question<DateAnswer>
{
    //...
}

The classes you use for the answers all inherit from the base class Answer, which has a reference to the question it belongs to and to the user that has answered it. You could then have a separate table for each answer type and thus prevent parsing the types while maintaining the connections between questions, answers and the users that answered them

public abstract class Answer {
    public Guid QuestionId { get; set; }
    public Guid UserId { get; set; }
}

public class MultipleChoiceAnswer :Answer {
    //...
}

public class DateAnswer : Answer {
    //...
}