I am trying to create a program that will calculate different musical scales based on the starting note that you provide.

I have an enumeration for the different notes:

``public enum NoteValue{A = 0,Asharp = 1,B = 2,C = 3,Csharp = 4,D = 5,Dsharp = 6,E = 7,F = 8,Fsharp = 9,G = 10,Gsharp = 11}``

I then have a method that sets each note

`` public void setNotes(NoteValue startingNote){//Creates an array of notes the size that is specifiedtheNote = new Note[(numberOfNotes)];//Sets the notestheNote[0] = new Note(startingNote);theNote[1] = new Note((startingNote + step[1]));theNote[2] = new Note((startingNote + step[2] + step[1]));theNote[3] = new Note((startingNote + step[3] + step[2] + step[1]));theNote[4] = new Note((startingNote + step[4] + step[3] + step[2] + step[1]));theNote[5] = new Note((startingNote + step[5] + step[4] + step[3] + step[2] + step[1]));theNote[6] = new Note((startingNote - step[7]));Console.WriteLine("{0} \n{1} \n{2} \n{3} \n{4} \n{5} \n{6}",theNote[0].value, theNote[1].value, theNote[2].value, theNote[3].value,theNote[4].value, theNote[5].value, theNote[6].value);}``

The issue I'm having is that if it goes I start with G (which is 10 in my enumeration),

it will just start printing numbers after G#. Can I make it so that it will return

back to 0 after 11, rather than just keep going on?

I'll get something like this (for major scale):

G

12

14

15

17

19

G

A

B

C

D

E

F#

Is there any way to fix this? Thank you.

Enumerations as they are defined in C# are basically "strongly typed" wrappers for integral types (integers).

If you want this sort of wrapping behavior for integers, the common solution is to use the modulo (`%`) operator:

``````int note = 12;
var correctlyWrappedNote = note % 12; // will equal 0
``````

This is logically equivalent to taking a remainder after dividing by 12.

You should then be able to cast it back to your `NoteValue` type:

``````var actualNote = (NoteValue)correctlyWrappedNote;
``````

If you feed a negative number to modulo, though, you'll get a negative result. If you have to deal with negative numbers, then there's an extra step:

``````int note = -1;
var correctlyWrappedNote = note % 12; // will equal -1

if (correctlyWrappedNote < 0)
correctlyWrappedNote = 12 + correctlyWrappedNote; // will equal 11

var actualNote = (NoteValue)correctlyWrappedNote; // Will equal Gsharp
``````

@Merlyn's answer contains the gist of what you need to do, but using `%12` just because your enum member's happen to be 12 and because each number 0 through 11 is assigned to one of the enum members is a recipe for broken code down the line. To make it more change resilient, you could write it like this

``````var notes = Enum.GetValues(typeof(NoteValue)); //array
var startingNote = Array.IndexOf(notes,NoteValue.Fsharp);//8
var fourNotesAfterStartingNote = notes[(startingNote+4)%notes.Length];//Asharp
``````

The above code will continue to function correctly even if a new note is added. Unlikely maybe- but then again code always changes :)

Top