How to avoid a switch block with 300 cases?

Question

I am trying to add 300 Challenges into my program, but only display them if the CompletionValue.IsChecked = false;

If you were creating this program. How would you store the Challenges? I am using a switch but having 300 cases is overkill, is there a better way?

Any recommendation on to improve the code is well appreciated. I am somewhat new to this.

    Random rand = new Random();
    // Constructor
    public MainPage()
    {
        InitializeComponent();
        AnswerValue.Visibility = Visibility.Collapsed;
        Load();

    }


    private void Load()
    {
        int random = rand.Next(1, 4);
        switch (random)
        {
            case 1:
                Challenge1();
                break;
            case 2:
                Challenge2();
                break;
            case 3:
                Challenge3();
                break;
        }
    }

    private void Challenge1()
    {
        DifficultyValue.Text = "20%";
        CompletionValue.IsChecked = false;
        TitleValue.Text = "Chicken or Egg?";
        QuestionValue.Text = "Can you answer the ancient question: Which came first the chicken of the egg?";
        bmp.UriSource = new Uri("Images/Challenge1.png", UriKind.Relative);
        ImageValue.Source = bmp;
        ImageValue.Visibility = Visibility.Visible;
        ResourceValue.Text = "Resource: Brain Games";
        AnswerValue.Text = "The Egg. According to paleontologists, reptiles and dinosaurs existed long before birds and chickens.  Fossilized eggs dating back on hundred millions years have been uncovered. Thus it can be said that eggs came before chickens.";

    }

    private void Challenge2()
    {
        DifficultyValue.Text = "25%";
        CompletionValue.IsChecked = false;
        TitleValue.Text = "Halving Seven";
        QuestionValue.Text = "Can you prove that seven is half of twelve?";
        bmp.UriSource = new Uri("Images/Challenge2.png", UriKind.Relative);
        ImageValue.Source = bmp;
        ImageValue.Visibility = Visibility.Visible;
        ResourceValue.Text = "Resource: Yahoo Questions";
        AnswerValue.Text = "Roman numeral for 12 - XII \n Cut the roman numeral in half. you will get VII, which is 7.";

    }

    private void Challenge3()
    {
        DifficultyValue.Text = "25%";
        CompletionValue.IsChecked = false;
        TitleValue.Text = "Three-coin flip";
        QuestionValue.Text = "You ask a friend about probability, and he tells you the following: The odds of three tossed coins turning up all heads or all tails is one in two, that is, fifty-fifty. That’s because anytime you toss three coins, at least two must match, either two heads or two tails.  So that means the third coin—which is equally likely to be heads or tails—determines the odds.” Is your friend right? If not, what are the odds of three tossed coins turning up all heads or all tails?";
        bmp.UriSource = new Uri("Images/Challenge3.png", UriKind.Relative);
        ImageValue.Source = bmp;
        ImageValue.Visibility = Visibility.Visible;
        ResourceValue.Text = "Resource: Brain Games";
        AnswerValue.Text = "Answer will be available soon";
    }

Answer 1

Your challenges look awfully similar to each other, right? This is a case where you want to extract out a common data structure, and have each challenge represented as a piece of data.

With a uniform representation for your challenges, you set up the UI based on the challenge data for a particular challenge ID.

It is always possible to move your data into XML files, JSON files, or a database, but first see if the simple C# solution works for you:

// Note: This example is simplified for readability

// Here is the common data structure that can represent all challenges
private class Challenge
{
    public string Title { get; set; }
    public string Question { get; set; }
    public string ImagePath { get; set; }
}

// All of the challenges are defined right here, as simple data
private Challenge[] _allChallenges = new Challenge[]
{
    new Challenge
    {
        Title = "Chicken or Egg?",
        Question = "Can you answer the ancient question: Which came first the chicken of the egg?",
        ImagePath = "Images/Challenge1.png",
    },
    new Challenge
    {
        Title = "Halving Seven?",
        Question = "Can you prove that seven is half of twelve?",
        ImagePath = "Images/Challenge1.png",
    },
}

// Choosing challenges is as simple as indexing into the array
private void Load()
{
    int random = rand.Next(1, 4);
    Challenge chosenChallenge = _allChallenges[random];
    LoadChallenge(chosenChallenge);
}

// Setting up the UI for a challenge means extracting information from the data structure
private void LoadChallenge(Challenge chosenChallenge)
{
    TitleValue.Text = chosenChallenge.Title;
    QuestionValue.Text = chosenChallenge.Text;
    bmp.UriSource = new Uri(chosenChallenge.ImagePath, UriKind.Relative);
    ImageValue.Source = bmp;
    ImageValue.Visibility = Visibility.Visible;
}

You can consider this as a form of declarative programming. An important part of your program, the challenges themselves, have been converted from imperative statements (setting UI properties) into very simple data declarations.

By making this conversion, you can even check each challenge to make sure that all of the parts are filled out. Then you'll be sure that the title, question, resource, answer, etc. is set for each of your 300 challenges.

Answer 2

You can save the challenges in a database or a file. I do see you are using a random number and display only 1 challenge. The DB can be something like

ChallengeId, DifficultyValue, TitleValue ... 

The ChallengeId will be the questionId number. So depending on the random number generated you can choose the particular ChallengeId and the relevant data.

Answer 3

What you should really look into is encapsulation and polymorphic code. By encapsulating your like properties into a single class, you have a better way of representing the "Challenge" as a whole, and being able to reuse the parts that you have to type over and over again (.Text = "...") will make your future coding life infinitely better. Granted, even coding the list of Challenge entities, as I have below, would be not fun, you have to enter that data somewhere sometime. We're just going to consider this a coding exercise, you could easily adapt the code below to populate _challenges from a database or serialized file.

public class Challenge
{
    public int Id {get;set;}
    public int Difficulty {get;set;}
    public bool IsCompleted {get;set;}
    public string Title {get;set;}
    public string Question {get;set;}
    public string Answer {get;set;}
}

public class MainPage
{
    private List<Challenge> _challenges;
    private Random rand = new Random();
    public MainPage()
    {
        _challenges = new List<Challenge> {
            new Challenge {
                    Id = 1,
                    Difficulty = 20,
                    Title = "What came first?",
                    Question =  "The chicken or the egg?",
                    Answer = "The egg." },
            new Challenge {
                    Id = 2,
                    Difficulty = 30,
                    Title = "Make 7 from 12?",
                    Question =  "Can you prove 7 is half of 12?",
                    Answer = "VII" }};
    }

    public void LoadChallenge(Challenge challenge)
    {
        Difficulty.Test = String.Format("%{0}", callenge.Difficulty);
        Completeted.Value = challenge.IsCompleted;
        Title.Test = challenge.Title;
        // etc
    }

    public void StartNewChallenge()
    {
        Challenge nextChallenge = null;
        while(nextChallenge == null)
        {
            var nextId = rand.Next(1,2);
            nextChallenge = _challenges
                .Where(x => x.Id == nextId && !x.IsCompleted)
                .SingleOrDefault(); // default to null if completed == true
        }
        LoadChallenge(nextChallenge);
    }

}

Answer 4

Yet another alternative might be some kind of factory method:

MyForm.cs

public class MyForm
{
    Random rand = new Random();
    // Constructor
    public MainPage()
    {
        InitializeComponent();
        AnswerValue.Visibility = Visibility.Collapsed;
        Load();
    }

    private void Load()
    {
        int random = rand.Next(1, 4);
        DisplayChallenge(ChallengeFactory.GetChallenge(random));
    }

    private void DisplayChallenge(ChallengeFactory.Challenge challengeToDisplay)
    {
        DifficultyValue.Text = String.Format("{0}%", challengeToDisplay.Difficulty);
        CompletionValue.IsChecked = challengeToDisplay.IsChecked;
        TitleValue.Text = challengeToDisplay.Title;
        QuestionValue.Text = challengeToDisplay.Question;
        ImageValue.Source = challengeToDisplay.ImageSource;
        ImageValue.Visibility = challengeToDisplay.Visible;
        ResourceValue.Text = challengeToDisplay.ResourceValue;
        AnswerValue.Text = challengeToDisplay.Answer;
    }
}

ChallengeFactory.cs

public static class ChallengeFactory
{
    public class Challenge
    {
        public int Difficulty { get; set; }
        public bool IsChecked { get; set; }
        public string Title { get; set; }
        public string Question { get; set; }
        public Uri ImageSource { get; set; }
        public bool Visible { get; set; }
        public string ResourceValue { get; set; }
        public string Answer { get; set; }

        private Challenge(int difficulty, bool isChecked, string title, string question, Uri imageSource, bool visible, string resourceValue, string answer)
        {
            // assign each of the arguments to the instance properties
        }
    }

    public static Challenge GetChallenge(int challengeNumber)
    {
        switch(challengeNumber)
        {
            case 1:
                return new Challenge(20, false, "Chicken or Egg?", "Can you answer the ancient question: Which came first the chicken of the egg?", new Uri("Images/Challenge1.png", UriKind.Relative), true, "Resource: Brain Games", "The Egg...");
            break;
            case 2:
                // new challenge for challenge #2
            break;
            case 3:
                // new challenge for challenge #3
            break;
        }
    }
}

Note that I have made the Challenge class a nested class inside of the Factory class. The good thing about doing this is that you can make the constructor of the challenge private (meaning that you cannot create "invalid" types of challenges through anything but the factory method. The bad thing about doing this is that you have to further qualify the Challenge class by prefixing it with it's containing class, that is, ChallengeFactory. I think it's worth the extra qualifier in this case.

Ultimately I think you are stuck having to create a switch SOMEWHERE if you plan on defining all of your challenges in code. As others have said, you can significantly reduce the amount of code you need to write (and thus, the switch) by defining your challenges in an external data source (such as a database) and having a single method to read, parse, and create a Challenge instance.