Perché non posso derivare da tempo?
-
21-09-2019 - |
Domanda
La mia funzione restituisce un po 'di valore a lungo che contiene due valori inferiori e superiori 32 bit.
Ho pensato che il modo migliore per gestire il valore di ritorno è quello di ricavare il mio tipo personalizzato dalla lunga e fornire Tipo estensori come GetLowerValue (), GetHigherValue ().
Il problema è che .NET non consente di derivare dalla lunga
Se si compila che
public class SubmitOrderResult : long
{
}
si ottiene:
cannot derive from sealed type 'long'
Perché è progettato in modo e in che modo può superarla?
Grazie
Soluzione
Come i tipi di valore già menzionati in .NET sono sigillati in modo non c'è modo è possibile derivare dalla lunga. È necessario creare metodi di estensione come suggerito.
Esempio
public static class LongExtensions
{
public static long GetLowerValue(this long value)
{
...
}
public static long GetHigherValue(this long value)
{
...
}
}
Altri suggerimenti
Non è possibile derivare da uno qualsiasi dei tipi .NET di valore - sono tutti sigillati, per definizione,
.Forse si potrebbe implementare i metodi GetLowerValue e GetHigherValue come metodi di estensione?
My restituisce alcuni valori lunga che contiene due valori inferiori e superiori 32 bit.
Che suona come un hack molto, molto sporco. Potrebbe essere appropriato per lingue close-metallo (ad esempio C), ma non per un livello superiore, linguaggio orientato agli oggetti.
In linguaggi OO, si estende il sistema di tipo, non infastidire i tipi esistenti per fare la vostra offerta. Così, la soluzione dovrebbe essere quello di creare un nuovo tipo che trasporta i tuoi dati.
Che cosa si può fare è scrivere una struct con gli operatori conversione implicita. Che funzionerà esattamente nel modo desiderato:
public struct SubmitOrderResult
{
private long _result;
public SubmitOrderResult(long result)
{
_result = result;
}
public long Result
{
get { return _result; }
set { _result = value; }
}
public int GetHigherValue()
{
return (int)(_result >> 32);
}
public int GetLowerValue()
{
return (int)_result;
}
public static implicit operator SubmitOrderResult(long result)
{
return new SubmitOrderResult(result);
}
public static implicit operator long(SubmitOrderResult result)
{
return result._result;
}
}
Poi si può fare:
SubmitOrderResult result = someObject.TheMethod();
Console.WriteLine(result.GetHigherValue());
Console.WriteLine(result.GetLowerValue());
... piace solo si voleva.
Se ho capito bene, la vostra funzione restituisce in realtà due valori, e il fatto che si comprimerle in un long
è un dettaglio di implementazione. In questo caso, nascondere questo particolare e creare una classe che contiene il valore e le operazioni necessarie:
public class SubmitOrderResult
{
private readonly long value_;
public int OneValue
{
get { return (int)(value_ >> 32); }
}
public int TheOtherValue
{
get { return (int)(value_ & 0xFFFFFFFF); }
}
public SubmitOrderResult(long value)
{ value_ = value; }
}
Non si può superarla.
Come long
è un tipo sigillato e quindi non si può ereditare da loro. Vedere la MSDN
Perché le strutture sono implicitamente sigillate, che non può essere ereditata.
Per ulteriori informazioni, vedere Inheritance (Guida per programmatori C #) .