Perché non posso derivare da tempo?

Question

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

Answer 1

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)
    {
        ...
    }
}

Answer 2

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?

Answer 3

  

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.

Answer 4

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.

Answer 5

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; }
}

Answer 6

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 #) .