Questa strategia comporta la sostituzione di "Mi piace" di questo:
public class Politician
{
public const int Infidelity = 0;
public const int Embezzlement = 1;
public const int FlipFlopping = 2;
public const int Murder = 3;
public const int BabyKissing = 4;
public int MostNotableGrievance { get; set; }
}
Con:
public class Politician
{
public MostNotableGrievance MostNotableGrievance { get; set; }
}
public class MostNotableGrievance
{
public static readonly MostNotableGrievance Infidelity = new MostNotableGrievance(0);
public static readonly MostNotableGrievance Embezzlement = new MostNotableGrievance(1);
public static readonly MostNotableGrievance FlipFlopping = new MostNotableGrievance(2);
public static readonly MostNotableGrievance Murder = new MostNotableGrievance(3);
public static readonly MostNotableGrievance BabyKissing = new MostNotableGrievance(4);
public int Code { get; private set; }
private MostNotableGrievance(int code)
{
Code = code;
}
}
Perché è esattamente preferibile fare del tipo un'enumerazione, in questo modo:
public class Politician
{
public MostNotableGrievance MostNotableGrievance { get; set; }
}
public enum MostNotableGrievance
{
Infidelity = 0,
Embezzlement = 1,
FlipFlopping = 2,
Murder = 3,
BabyKissing = 4
}
Non esiste alcun comportamento associato al tipo e, in ogni caso, dovresti comunque utilizzare un diverso tipo di refactoring, ad esempio "Sostituisci il codice del tipo con sottoclassi" + "Sostituisci il condizionale con il polimorfismo".
Tuttavia, l'autore spiega perché aggrotta le sopracciglia su questo metodo (in Java?):
Numeric type codes, or enumerations, are a common feature of C-based languages. With symbolic names they can be quite readable. The problem is that the symbolic name is only an alias; the compiler still sees the underlying number. The compiler type checks using the number 177 not the symbolic name. Any method that takes the type code as an argument expects a number, and there is nothing to force a symbolic name to be used. This can reduce readability and be a source of bugs.
Ma quando si tenta di applicare questa affermazione a C #, questa affermazione non sembra vera: non accetterà un numero perché un'enumerazione viene effettivamente considerata come una classe. Quindi il seguente codice:
public class Test
{
public void Do()
{
var temp = new Politician { MostNotableGrievance = 1 };
}
}
Non verrà compilato. Quindi questo refactoring può essere considerato non necessario nei nuovi linguaggi di alto livello, come C #, o non sto considerando qualcosa?