Di recente, ho pensato all'uso di as , is e cast diretto in C #.
Logicamente, è un'idea migliore da usare:
var castedValue = value as type;
if (null != castedValue)
{
// Use castedValue.
}
di:
if (value is type)
{
var castedValue = (type)value;
// Use castedValue.
}
Ma ho ancora problemi con questo tipo di pattern:
if (value is Implementation1)
{
var castedValue = (Implementation1)value;
// Use castedValue in a first way.
}
else if (value is Implementation2)
{
var castedValue = (Implementation2)value;
// Use castedValue in a second way.
}
else if (value is Implementation3)
{
var castedValue = (Implementation3)value;
// Use castedValue in a thrid way.
}
// And so on...
Come posso migliorare questo codice per evitare di trasmettere due volte quando è OK, ed è davvero necessario eseguire il cast due volte?
Non voglio rendere il codice illeggibile, ma l'idea non è quella di testare un cast se uno precedente è riuscito.
Ho avuto diverse idee per risolvere questo problema, ma nessuno di loro sembra davvero soddisfare le condizioni ...
Modifica
Ecco un caso che ho ... C'è questo oggetto che viene creato da una parte inferiore del codice su cui non ho il controllo. Questo oggetto può essere di diversi tipi ereditati. Nel mio livello, voglio creare un oggetto specifico a seconda di questo tipo. Ho questa classe di costruttore:
public static IHighLevelObject MakeHighLevelObject(LowLevelObject lowLevelObject)
{
IHighLevelObject highLevelObject;
if (lowLevelObject is LowLevelObject1)
{
highLevelObject = new HighLevelObject1((LowLevelObject1)lowLevelObject);
}
else if (lowLevelObject is LowLevelObject2)
{
highLevelObject = new HighLevelObject2((LowLevelObject2)lowLevelObject);
}
else if (lowLevelObject is LowLevelObject3)
{
highLevelObject = new HighLevelObject3((LowLevelObject3)lowLevelObject);
}
// And so on...
return highLevelObject;
}
Come posso risolvere questo caso?