比较两个对象的最佳方法。 测验

Question

Im making a new years eve quiz for some friends. The quiz itself is done and working I just thought it would be cool to autocorrect the answers once they are posted.

The question is what's the best way to compare the posted object with an object that has all the right answers, reflection?. There has to be a slick way to do it and avoid having a lot of if's.

public class QuizModel
{
    public string Name { get; set; }
    public string Quiz1 { get; set; }
    public string Quiz2 { get; set; }
    public string Quiz3 { get; set; }
    etc..
}

You dont have to write me any code. I just want some directions on what the best ( and most important the coolest) way to do it :)

Answer 1

You don't need to use reflection to compare values, no :)

If all of the values are encapsulated within a model, then so should be the comparison logic. One simple approach could be to just override .Equals() . Something like this:

public override bool Equals(object obj)
{
    if (obj == null)
        return false;
    if (!(obj is QuizModel))
        return false;
    var quiz = obj as QuizModel;
    return
        quiz.Name.Equals(this.Name) &&
        quiz.Quiz1.Equals(this.Quiz1) &&
        // etc.
}

Of course, that's the easy part. The real challenge is going to be that string comparison logic. Strings sounds like free text input. So if one of the answers is "Christmas Day" then what do you do with inputs like "Christmas day" or "christmas" or "december 25th" and so on? That's up to your business logic. But the actual logic of "are these two objects equal" is pretty straightforward.

Semantically you might choose not to override .Equals() for this purpose. I could see a good argument against it, claiming that the objects are different but simply contain the same values. (A great real world example of this are identical twins.) So you may choose to implement something else, like IEquatable or just a custom method like .IsEqualTo(QuizModel quiz) . But the logic therein would be the same either way.

Answer 2

As for your explanation, the implementation of this class should be a list of answers (or a dictionary, or an array, etc):

public class QuizModel
{
    public string Name { get; set; }
    public List<string> Quizs { get; set; }
}

Then, to check if all the answers are the same:

public bool AreEqual(model1, model2){

  for(var i = 0; i < Math.Min(model1.Quizs.Count, model2.Quizs.Count); ++i)
    if(model1.Quizs[i] != model2.Quizs[i])
      return false;

  return true;
}

In a similar way you can get the number of answers that are identical.

Answer 3

I'm giving you two solutions to your question. I think you want to give scores to your friends(I would do that). If so, here is a solution that give you the score for the answer, I'm supposing that every quiz has the same value and you have the correct answer for all the quiz. First you could try by reflection compare all the values of the quizes, and return total(assuming your quizes have the same value. Then if you want to be more flexible below I suggest you a possible solution when the quizes may have a different value(score).

1) public class QuizModel { public string Name { get; set; } public string Quiz1 { get; set; } public string Quiz2 { get; set; } public string Quiz3 { get; set; } }

public class QuizComparer
{

    public QuizComparer(QuizModel correctOne, IComparer<string> comparer, int quizValue = 1)
    {
        this.CorrectOne = correctOne;
        this.Comparer = comparer;
        this.QuizValue = quizValue;
    }
    public int Compare(QuizModel toCompareOne)
    {
        Type type = toCompareOne.GetType();
        var propertiesInfo = type.GetProperties();

        int result = 0;

        foreach (var propertyInfo in propertiesInfo)
        {
            if (propertyInfo.CanRead)
            {
                var toCompareOnePropertyValue = type.GetProperty(propertyInfo.Name).GetValue(toCompareOne).ToString();
                var correctOnePropertyValue = type.GetProperty(propertyInfo.Name).GetValue(this.CorrectOne).ToString();

                if (Comparer.Compare(toCompareOnePropertyValue, correctOnePropertyValue) == 0)//equals
                {
                    result += QuizValue;
                }

            }
        }

        return result;
    }

    public QuizModel CorrectOne { get; set; }

    public IComparer<string> Comparer { get; set; }


    public int QuizValue { get; set; }
}

2) Secondly if you want to give to your quizes individual scores, you could find this very helpful:

public class QuizModel
{
    public string Name { get; set; }
    [QuizValue(value: 1)]
    public string Quiz1 { get; set; }

    [QuizValue(value: 2)]
    public string Quiz2 { get; set; }

    [QuizValue(value: 3)]
    public string Quiz3 { get; set; }
}

public class QuizComparer
{

    public QuizComparer(QuizModel correctOne, IComparer<string> comparer, int quizValue = 1)
    {
        this.CorrectOne = correctOne;
        this.Comparer = comparer;
        this.QuizDefaultValue = quizValue;
    }
    public int Compare(QuizModel toCompareOne)
    {
        Type type = toCompareOne.GetType();
        var propertiesInfo = type.GetProperties();

        int result = 0;

        foreach (var propertyInfo in propertiesInfo)
        {
            if (propertyInfo.CanRead && propertyInfo.Name != "Name")
            {
                var toCompareOnePropertyValue = type.GetProperty(propertyInfo.Name).GetValue(toCompareOne).ToString();
                var correctOnePropertyValue = type.GetProperty(propertyInfo.Name).GetValue(this.CorrectOne).ToString();

                int value = GetQuizValue(propertyInfo);
                if (Comparer.Compare(toCompareOnePropertyValue, correctOnePropertyValue) == 0)//equals
                {
                    result += value;
                }

            }
        }

        return result;
    }

    private int GetQuizValue(PropertyInfo propertyInfo)
    {
        var attributes = propertyInfo.GetCustomAttributes(typeof(QuizValue), false);

        int value = this.QuizDefaultValue;
        if (attributes != null && attributes.Count() > 0)
        {
            var quizValueAttribute = attributes[0];
            if (quizValueAttribute is QuizValue)
            {
                var quizValue = quizValueAttribute as QuizValue;
                value = quizValue.Value;
            }

        }
        return value;
    }

    public QuizModel CorrectOne { get; set; }

    public IComparer<string> Comparer { get; set; }


    public int QuizDefaultValue { get; set; }
}

[System.AttributeUsage(System.AttributeTargets.Property)]
public class QuizValue : System.Attribute
{

    public QuizValue(int value = 1)
    {
        this.Value = value;
    }

    public int Value
    {
        get;
        set;
    }
}

Answer 4

Please try like below, May this will leads you to get what you think

It will always compare the Quiz2 with the Quiz1 value.

public string Quiz1 {get; set;}

[CompareAttribute("Quiz1", ErrorMessage = "Quiz2 is mismatch with Quiz1")]
public string Quiz2 { get; set; }

Answer 5

this will give you wrong answers only:

var quiz = new QuizModel() { Name = "Quiz 1", Quiz1 = "Correct answer", Quiz2 = "Correct answer", Quiz3 = "Correct answer"  };
var correctQuiz = new QuizModel() { Name = "Quiz 1",  Quiz1 = "Correct answer", Quiz2 = "Wrong answer", Quiz3 = "Wrong answer 2" };

Func<QuizModel, List<string>> getListOfAnswers = (currentquiz) => 
(
    from property
    in typeof(QuizModel).GetProperties()
    select property.Name + " " + property.GetValue(currentquiz)
).ToList();

var answers = getListOfAnswers(quiz);
var correctAnswers = getListOfAnswers(correctQuiz); 

var wrongAnswers = correctAnswers.Except(answers);  

output:

Quiz2 Wrong answer

Quiz3 Wrong answer 2

This solution is using Reflection, LINQ and Anonymous functions at once so it's very cool :)