¿Por qué no puedo derivar de largo?

Mi función devuelve un valor largo que contiene dos valores en 32 bits más bajos y más altos.

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

El problema es que .NET no permite derivar de largos

Si comstacks eso

public class SubmitOrderResult : long { } 

usted obtiene:

 cannot derive from sealed type 'long' 

¿Por qué está diseñado así y cómo se puede superar?

Gracias

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

Ejemplo

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

No puede derivar de ninguno de los tipos de valores .NET, todos están sellados por definición.

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

Mi función devuelve un valor largo que contiene dos valores en 32 bits más bajos y más altos.

Eso suena como un hack 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 OO, usted extiende el sistema de tipos, no acosa los tipos existentes para hacer su oferta. Por lo tanto, la solución debe ser crear un nuevo tipo que lleve su información.

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

 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 puedes hacer:

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

… como tú querías.

Si entiendo correctamente, su función realmente devuelve dos valores, y el hecho de que los incluya en un long es un detalle de implementación. En ese caso, oculte este detalle y cree una clase que contenga el valor y las operaciones requeridas:

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

No puedes superarlo.

Mientras sea un tipo sellado, no podrá heredar de ellos. Ver la MSDN

Debido a que las estructuras están selladas implícitamente, no se pueden heredar.

Para obtener más información, consulte Herencia (Guía de progtwigción de C #) .