Question

Scenario: a game with a board, and several tiles on it. Classes: Board, Tile, Player and of course, Game.
Whenever the player presses a tile, his score gets incremented by 1. Board is instantiated inside of Game, and an array of Tile is instantiated inside of Board. My first option to increment that score easily was to make a public static class with a public static field (Score). Of course, it’s rather amateurish. And seemed to break the overall flow of the app.

After some thought, I changed everything to use Events; Tile raises an event when clicked; Board handles that event, and raises another event to the main Game class. Player is instantiated inside of Game; when Game handles the event received from Board, it does a PlayerOne(instance of Player).Score += 1;

Should I just go on ahead and use this flow? Do you have any other architecture/design ideas that would work better? Why would your ideas work better?
I didn’t use custom made events intensively before and I feel that the whole event raising another even idea might be a bit wrong. From afar though, it looks like a good flow. And it certainly does the job correctly.

Answer 1

You should have provided some code.

Should I just go on ahead and use this flow?

Depends on what the events look like.

Do you have any other architecture/design ideas that would work better?

Publish/Subscribe is an alternative. But the .NET events works fine here.

I didn’t use custom made events intensively before and I feel that the whole event raising another even idea might be a bit wrong.

It’s fine to keep encapsulation. I would do something like:

class Tile
{
    public event EventHandler Clicked = delegate{};
}

class Board
{
    private void OnTileClick(object source, EventArgs e)
    {
        var tile = (Tile)source;
        //doSome

        var args = new CustomEventArgs();
        CustomEvent(this, args);
    }

    public event EventHandler<CustomEventArgs> SomeEvent = delegate{};
}

public class SomeCustomEventArgs : EventArgs
{
}