Frammento di codice singolo per eseguire due diverse operazioni

Ciò che stai descrivendo sembra che tu voglia qualcosa di simile alla relazione tra DateTime e TimeSpan . Forse potresti descriverlo come Note e NoteShift . Penso che chiamarlo Note invece di OctaveNote sia molto più chiaro se si considera che C7 è una nota diversa da C4 (C nella 7a ottava vs C nel 4 °).

Apprendendo ulteriormente dalla relazione tra DateTime e TimeSpan , potresti ridurre la complessità interna della matematica memorizzando la nota come un intero. Sta a te decidere se questo intero rappresenta una frequenza o una posizione sulla scala. Il concetto di come rappresentare Note viene eseguito nelle funzioni di formattazione.

Tecnicamente parlando ci sono 12 note in scala moderna con A4 essendo 440Hz . Ogni ottava rappresenta un raddoppio della frequenza in modo che A5 sia 880Hz e A3 sia 220Hz. Questi sono dettagli rappresentativi che puoi incorporare come metodo per ottenere la frequenza dalla nota.

Diciamo che devi rappresentare 8 ottave (la tastiera a 88 tasti inizia da A0 e termina a C8). Potresti rappresentare tutto questo come un numero compreso tra 0 e 107. Ciò rende la matematica molto più semplice.

public class Note
{
    public byte MaxOctave = 8;
    public enum Name { C, Csharp, D, Dsharp, E, F, Fsharp, G, Gsharp, A, Asharp, B };
    private final byte note;

    public Note(Name name, byte octave)
    {
        note = ((octave + 1) * ((byte) name)) - 1;
    }

    private Note(byte newNote)
    {
        if (newNote < 0 || newNote > ((byte)Enum.GetNames(typeof(Name)).Length * MaxOctave))
        {
            throw new ArgumentOutOfRangeException(nameof(newNote));
        }

        note = newNote;
    }

    public Note ChangePitch(NoteShift shift)
    {
        return new Note(note + shift.relativeNote);
    }

    public override string ToString()
    {
        var notesPerOctave = (byte)Enum.GetNames(typeof(Name)).Length;
        var nameVal = note % notesPerOctave;
        var octave = note / notesPerOctave;

        var name = (Name)Enum.GetValue(typeof(Name), nameVal);
        return $"{name}{octave}";
    }
}

Il tuo NoteShift avrebbe solo un byte positivo o un byte negativo per l'importo da spostare. Hai la complicazione matematica nella chiamata a ToString() , ma in genere non viene chiamata per tutto il tempo.

public class NoteShift
{
    final byte relativeNote; // package access

    public NoteShift(byte shift)
    {
        relativeNote = shift;
    }

    public static NoteShift AddNotes(byte notes)
    {
        return new NoteShift(notes);
    }

    public static NoteShift AddOctaves(byte octaves)
    {
        return new NoteShift(octaves * (byte)Enum.GetNames(typeof(Note.Name)).Length);
    }
}

Un ulteriore vantaggio di questo accordo è che è possibile impiegare un sovraccarico dell'operatore intelligente per addizione, sottrazione, maggiore, minore e uguale. Oltre all'implementazione di IComparable<Note> e IEquatable<Note> . Questo può rendere la tua libreria molto più espressiva. Assicurati solo che il tipo di operatori che hai sovraccaricato abbia senso. Ad esempio, non esiste un vero motivo per moltiplicare o dividere le note.

Il modo più elegante per farlo è rappresentare OctiveNote come un intero. Questo è veloce, ma dovrebbe essere facile da tradurre:

enum Note: Int {
    case c, d, e, f, g, a, b
}

struct OctiveNote {
    let rawValue: Int

    init?(rawValue: Int) {
        precondition(rawValue >= 0)
        self.rawValue = rawValue
    }

    init(n: Note, o: Int) {
        precondition(o >= 0)
        rawValue = o * 7 + n.rawValue
    }

    var note: Note {
        return Note(rawValue: rawValue % 7)!
    }

    var octive: Int {
        return rawValue / 7
    }
}

Con quanto sopra, le tue funzioni di pitch sono semplicemente addizioni e sottrazioni.

extension OctiveNote {
    func pitched(byTones tones: Int) -> OctiveNote {
        precondition(rawValue + tones >= 0)
        return OctiveNote(rawValue: rawValue + tones)!
    }
}

Ora puoi:

var n = OctiveNote(n: .a, o: 5) // n = A5
n = n.pitched(byTones: 1)       // n = B5
n = n.pitched(byTones: 1)       // n = C6
n = n.pitched(byTones: 1)       // n = D6
n = n.pitched(byTones: -3)      // n = A5

Puoi sostituire PitchUp e PitchDown con una singola funzione. Aggiungi un secondo parametro che indica la direzione in cui cambiare il tono. Ad esempio:

public enum PitchDirection
{
    Up,
    Down
}

public OctaveNote ChangePitch(byte tones, PitchDirection direction)
{
    byte octaveShift = (byte)(tones / 7);
    byte newOct = direction == PitchDirection.Up
                    ? (byte)(o + octaveShift)
                    : (byte)(o - octaveShift);

    char noteShift = (char)(tones % 7);
    char temp = direction == PitchDirection.Up
                    ? n + noteShift
                    : n - noteShift;
    Note newNote = (Note)((((int)(temp) % 7) + 7) % 7);
    if (direction == PitchDirection.Up && newNote < n)
    {
        newOct++;
    }
    if (direction == PitchDirection.Down && newNote > n)
    {
        newOct--;
    }

    return new OctaveNote(newNote, newOct);
}

Non ho provato questo (l'ho appena estratto dalla cima della mia testa), ma dovrebbe indirizzarti nella giusta direzione.