¿Por qué no puedo derivar de largo?

Question

Mi función devuelve un valor largo que contiene dos valores en 32 bits inferior y superior.

pensé que la mejor manera de manejar valor de retorno es derivar mi tipo personalizado de largo y proporcionar extensores tipo como GetLowerValue(), GetHigherValue().

El problema es que .NET no permite derivar de larga

Si compila que

public class SubmitOrderResult : long 
{ 
} 

que se obtiene:

cannot derive from sealed type 'long' 

¿Por qué está diseñado de tal manera y cómo puede ¿superarlo?

Gracias

Answer 1

Como ya se mencionó, los tipos de valores en .NET están sellados por lo que no hay forma de que pueda derivar de largo. Debe crear métodos de extensión según lo sugerido.

Ejemplo

public static class LongExtensions 
{ 
    public static long GetLowerValue(this long value) 
    { 
     ... 
    } 

    public static long GetHigherValue(this long value) 
    { 
     ... 
    } 
} 

Answer 2

No se puede derivar de cualquiera de los tipos de .NET de valor - todos ellos están sellados por definición.

¿Quizás podría implementar sus métodos GetLowerValue y GetHigherValue como métodos de extensión?

Answer 3

No se puede superarla.

Como long es un tipo sellado y por lo tanto no puede heredar de ellos. Consulte MSDN

Como las estructuras están implícitamente selladas, no se pueden heredar.

Para obtener más información, vea Inheritance (C# Programming Guide).

Answer 4

Si he entendido bien, su función en realidad devuelve dos valores, y el hecho de que empacar ellos en un long es un detalle de implementación. En ese caso, ocultar este detalle y crear una clase que contiene el valor y las operaciones necesarias:

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 5

Mi función devuelve un valor de longitud que contiene dos valores inferiores y superiores en 32 bits.

Eso suena como un truco muy, muy sucio. Podría ser apropiado para lenguajes cercanos al metal (por ejemplo, C) pero no para un lenguaje orientado a objetos de nivel superior.

En los idiomas de OO, extiende el sistema de tipos, no molesta a los tipos existentes para hacer su oferta. Por lo tanto, la solución debe ser crear un nuevo tipo que transmita su información.

Answer 6

Lo que puedes hacer es escribir una estructura con operadores de conversión implícita.Eso funcionará exactamente de la manera que desee:

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

entonces usted puede hacer:

SubmitOrderResult result = someObject.TheMethod(); 
Console.WriteLine(result.GetHigherValue()); 
Console.WriteLine(result.GetLowerValue()); 

... al igual que querías.