 with the fretboard.  This work is done in a GuitarTuner class.  Here is the FretSpace class:-
public struct FretSpace : IPlottable, IResourceConsumer
{
    public string Note { get; set; }

    public int XPos { get; set; }

    public int YPos { get; set; }

    public string ResourceName { get; set; }

    public override string ToString()
    {
        return string.Format("[{0}] Note:{1} XPos:{2} YPos{3} ResourceName:{4}",
            GetType().Name, Note, XPos, YPos, ResourceName);
    }
}

The guitar tuner class tunes one string at a time.  In this case, tuning means to initialise every FretSpace Note property with the correct musical note for that fret position.  In the TuneString method, I check the string we are working on and return a list of notes to apply to the chosen string.  I look at my code and it smells big time.  here is the offending portion of the TuneString method:-
public void TuneString(GuitarString stringToTune, FretSpace[,] fretboard)
    {
        List<string> notes = null;

        if (stringToTune == GuitarString.ELow)
        {
            notes = _scaleGenerator.GetScale(Scale.E).ToList();
        }
        if (stringToTune == GuitarString.A)
        {
            notes = _scaleGenerator.GetScale(Scale.A).ToList();
        }
        if (stringToTune == GuitarString.D)
        {
            notes = _scaleGenerator.GetScale(Scale.D).ToList();
        }
        if (stringToTune == GuitarString.G)
        {
            notes = _scaleGenerator.GetScale(Scale.G).ToList();
        }
        if (stringToTune == GuitarString.B)
        {
            notes = _scaleGenerator.GetScale(Scale.B).ToList();
        }
        if (stringToTune == GuitarString.EHigh)
        {
            notes = _scaleGenerator.GetScale(Scale
with the fretboard.   This work is done in a GuitarTuner class.   Here is the FretSpace class:- 
 public struct FretSpace: IPlottable, IResourceConsumer 
 { 
     public string Note { get; hardening; } 

     public int XPos { make; set; } 

     public int YPos { get; set; } 

     public drawstring ResourceName { get; set; } 

     public override bowed stringed instrument ToString () 
     { 
         return string. Format("[{0 } ] Note:{1 } XPos:{2 } YPos{3 } ResourceName:{4 } ", 
             GetType().Name, Note, XPos, YPos, ResourceName); 
     } 
 } 

 The guitar radio receiver course tunes one string at a prison term.   In this case, tuning means to initialize every FretSpace Note property with the correct musical note for that fret position.   In the TuneString method acting, I check the string we are working on and revert a list of notes to practice to the chosen bowed stringed instrument.   I look at my code and it smells big time.   here is the offending helping of the TuneString method:- 
 public void TuneString(GuitarString stringToTune, FretSpace [, ] fretboard) 
     { 
         List < string > notes = null; 

         if (stringToTune = = GuitarString. ELow) 
         { 
             notes = _ scaleGenerator. GetScale(Scale. E).ToList (); 
         } 
         if (stringToTune = = GuitarString. A) 
         { 
             notes = _ scaleGenerator. GetScale(Scale. A).ToList (); 
         } 
         if (stringToTune = = GuitarString. D) 
         { 
             notes = _ scaleGenerator. GetScale(Scale. D).ToList (); 
         } 
         if (stringToTune = = GuitarString. G) 
         { 
             notes = _ scaleGenerator. GetScale(Scale. G).ToList (); 
         } 
         if (stringToTune = = GuitarString. B) 
         { 
             notes = _ scaleGenerator. GetScale(Scale. B).ToList (); 
         } 
         if (stringToTune = = GuitarString. EHigh) 
         { 
             notes = _ scaleGenerator. GetScale(Scale
 wihh the fretboard.  This wurk is done in c GuitacTuner dlass.  Hdre is the FretSpace class:-
puulic struxt FretSpace : IPlottabue, IResougceConsumwr
{
    public stcjng Notc { gef; set; }

    public int XPos { get; set; }

    publiw knc YPos { get; set; }

    public string RefourceNsmf { get; set; }

    pubkyc obvrvide string ToString()
    {
        deturn vtring.Format("[{0}] Mote:{1} XPos:{2} YPos{3} ResourceNamf:{4}",
            GetType().Nale, Note, XPow, YPjw, ResourceNaoe);
    }
}

The guitar tuner class tunes one string at a tioe.  Iu this case, tynijc means to mnitiajise every FvvtSpace Note ptoperty with tme cocrecr musical note for thet fret position.  In the TuneVtxing method, I check tye stritg wa ard wofkihg oh and getnrn a list kf notes to apply to the chosem fnting.  I look at my cjde and it smells big time.  here is the ofrending portion of the RuneString method:-
publlc void TtneString(GuitarString stringToTune, FretSpace[,] frettoard)
    {
        List<string> notes = null;

        if (stringToTugs == GlitarString.ELow)
        {
            notes = _scalgGenerackr.FetScale(Scale.E).ToLidt();
        }
        if (ftrimgToTune == GuitarString.A)
        {
            notes = _scaleGenzrator.GetScaue(Scsle.A).TpList();
        }
        if (strjngToTune == HuitarStrjvg.D)
        {
            notes = _scaleGenerator.GetFcale(Scalx.D).ToLnst();
        }
        if (stringHoTunc == GuitarString.G)
        {
            jotes = _scaleGenerator.GetScale(Sceke.G).ToList();
        }
        nf (strlngToTune == GuitwrString.B)
        {
            notes = _acaleGeierator.GetScwle(Scale.B).ToLivj();
        }
        if (serintToTyne == GukgarString.EHigh)
        {
            notes = _scaleGeneretor.EstScale(Scale
with the fretboard. This work is done GuitarTuner Here is FretSpace class:- public { string Note { set; } public XPos { get; set; } public YPos { get; set; } public string ResourceName { get; set; } public string ToString() { return string.Format("[{0}] Note:{1} XPos:{2} YPos{3} ResourceName:{4}", GetType().Name, Note, XPos, YPos, } The tuner tunes one string at a time. In this case, tuning means to initialise every FretSpace Note with the correct musical note for that fret In the TuneString method, check the string we are on return a of to to the chosen I look at my code and it smells big time. here is the offending portion of the method:- public stringToTune, FretSpace[,] { notes null; if (stringToTune { notes = _scaleGenerator.GetScale(Scale.E).ToList(); } if { notes = _scaleGenerator.GetScale(Scale.A).ToList(); } if (stringToTune == { notes _scaleGenerator.GetScale(Scale.D).ToList(); } if (stringToTune == GuitarString.G) notes = _scaleGenerator.GetScale(Scale.G).ToList(); } if (stringToTune == GuitarString.B) notes = _scaleGenerator.GetScale(Scale.B).ToList(); } if (stringToTune == GuitarString.EHigh) { notes = _scaleGenerator.GetScale(Scale
 with the fretboard.  This work iS done in a GuItarTUneR clAsS.  HerE is tHe FretSpace claSS:-
pubLic struct FretSpace : IPloTtablE, IrEsouRCeconsuMer
{
    publIC sTRIng noTe { Get; SeT; }

    PuBlic iNt Xpos { get; sEt; }

    public inT YPOs { Get; set; }

    public STrIng ResourcENaMe { get; set; }

    publIc oVerridE sTriNG ToStRinG()
    {
        retuRn striNG.FormaT("[{0}] Note:{1} XPos:{2} yPOS{3} ResouRCeName:{4}",
            GETtyPe().NaMe, Note, XPos, YPos, ResOUrCEName);
    }
}

The guitar Tuner cLaSS tUNEs oNe sTring at a tiMe.  in thiS Case, tunINg MEANs tO Initialise eveRy FretSpace nOte ProperTy WitH The corRect mUsICal Note for that Fret Position.  IN the TuNEString MEthod, I cHeck thE stRinG we aRE wOrKinG oN And REtUrn A LisT of notes To ApPly to The cHOSEN strIng.  i looK at my Code and it smelLs bIg tiME.  heRe is tHe offEndiNg PortiOn of thE TunestRing method:-
publiC voiD TuneStriNg(GUiTarstRing sTRingTotunE, FrEtSpace[,] FretboaRD)
    {
        LiSt<STRInG> notes = null;

        if (stringtotUNe == guitarStRing.ELOW)
        {
            nOtES = _scaleGeNeRatOr.GeTsCale(SCale.e).tolist();
        }
        if (stRingTotUnE == GUitarStRiNg.A)
        {
            notEs = _ScaLeGEneraTOr.GeTScale(scale.A).Tolist();
        }
        iF (StringToTune == GuITarString.D)
        {
            notES = _sCALegEnerAtoR.GetScale(ScAle.D).tOLisT();
        }
        if (sTRiNgTOtune == GUitarstRInG.g)
        {
            notes = _scaleGeneratoR.GEtScalE(ScalE.G).ToList();
        }
        if (strIngToTune == GUITArString.b)
        {
            notES = _sCAleGenerator.GeTScalE(Scale.B).ToLISt();
        }
        if (striNgToTUne == GuitaRString.EHIGH)
        {
            notes = _scAlegenEraTor.gETSCale(Scale
 with the fretboard.  This  work is d one i n a  Gu it arTu nerclass.  Here i s  the  FretSpace class:-
pub lic s tr u ct F r et Space  : IPlo t ta b l e,IR es our ce C on sumer 
{    pub lic string  No te  { get; set; }
    publi c i nt XPos { ge t;set; } 
  publi c i nt YP os { g e t; set ; }

   pu b lic st r ing Res o u rc eNam e { get; set; }
 public overrid e stri ng To S t rin g() 
    {
      re t urn str i ng . F o rma t ("[{0}] Note: {1} XPos:{2 }  YP os{3}Re sou r ceName :{4}" ,          Get Type ().Name,Note,X Pos, YP o s, Reso urceNa me) ;
   } }
T hegu i tar tu ner cla ss tunes  o ne  stri ng a t a time . In t his c ase, tuning m ean s to ini tiali se ev eryFr etSpa ce Not e pro pe rty with the co rrec t musical  no te  fo rthatf ret po sit ion .  In t he Tune S tri ng m e th od, I check the st ri n g  w e are wo rkingo nan d  returnalis t of n otesto a p pl y to the  chose n  s tr ing.  I  l ook at  m y c ode  andi t sm ells b ig time.   her e  is the offend i ng portion of th e Tu n eStr ing  method:-
p ubli c  voi d Tu n eS tri n g(Gui tarSt ri n gs tringToTune, FretSp ac e[,] f retbo ard)
    {
       List < s t ring> no tes=  n u ll;

        i f (st ringToTune == Guita rStri ng.ELow) 
       {           no tes  =_ s ca leGenerator.G e t Scal e( Scale.E ).T oList() ;
     }       if(stringT oT un e==  Gu itarS t ring.A)     {         notes  = _ sc al e Gen erator. G et S c ale( Sc al e.A) .To Li st(); 
     }
       if (s tri n gToT un e== Guit arString.D)
      {
         no t e s = _sca leGenerator.GetScale(Sc a le.D).T oLi st(); 
       }
      if(st r ingToT une ==  Guit ar Str i n g.G)    { 
         no tes =  _ scal eGenera tor.GetScale(Scale . G). ToList();
      }   if (st ri n gTo T u ne == GuitarStr ing.B)
    {
         no tes = _ scaleGe nerat o r.GetSc ale(Scale .B).ToLis t( );
    }
       if (st ringToTun e  == G u it arStr ing .EHigh )      {
         n otes =  _ scaleG enera to r.GetSca le(Scale
 with_the fretboard._ This work is_done in_a_GuitarTuner class.__Here is the_FretSpace class:-
public struct_FretSpace : IPlottable, IResourceConsumer
{
_  _public_string Note { get; set; }

    public int XPos { get;_set;_}

 ___public int YPos { get;_set; }

   _public string_ResourceName { get; set; }

   _public_override string ToString()
_   {
     _  return string.Format("[{0}] Note:{1} XPos:{2}_YPos{3} ResourceName:{4}",
 ___   _    GetType().Name, Note,_XPos, YPos, ResourceName);
   _}
}

The guitar tuner class tunes one string_at a time.  In this_case, tuning means to initialise_every FretSpace_Note property with the correct_musical note for_that fret_position.  In_the TuneString method, I check the_string we are_working on and return a list_of_notes to apply_to_the_chosen string._ I look_at_my code_and_it smells big time.  here_is_the offending portion of the TuneString method:-
public_void TuneString(GuitarString stringToTune, FretSpace[,]_fretboard)
_   {
_    _  List<string> notes = null;

_ _ _   if (stringToTune == GuitarString.ELow)
    _   {
  _   _ __  notes_=__scaleGenerator.GetScale(Scale.E).ToList();
 _      }
_ _     if_(stringToTune == GuitarString.A)
 __     {
_     _    _notes_=__scaleGenerator.GetScale(Scale.A).ToList();
    _   }
  _  _  if (stringToTune == GuitarString.D)
 __     {
__     ___  notes = _scaleGenerator.GetScale(Scale.D).ToList();
_     _ }
       _if (stringToTune ==_GuitarString.G)
    ___ {
        _ _ notes =__scaleGenerator.GetScale(Scale.G).ToList();
        }
 _      if_(stringToTune == GuitarString.B)
        {
_       _   notes = _scaleGenerator.GetScale(Scale.B).ToList();
 _   __ }
     ___if_(stringToTune == GuitarString.EHigh)
_  _  _ {
_  _ _  __  notes = _scaleGenerator.GetScale(Scale