Por que não posso derivar de muito tempo?

Question

Minha função retorna algum valor longo que contém dois valores em 32 bits inferiores e mais altos.

Eu pensei que as melhores maneiras de lidar com o valor de retorno é derivar meu tipo personalizado de longo e fornecer extensores de tipo como getLowerValue (), GethigherValue ().

O problema é que o .NET não permite derivar de muito tempo

Se você compilar isso

public class SubmitOrderResult : long
{
}

você recebe:

cannot derive from sealed type 'long'

Por que isso foi projetado e como pode superá -lo?

Obrigado

Answer 1

Como já mencionado, os tipos de valor no .NET são selados, para que não haja como derivar por muito tempo. Você deve criar métodos de extensão conforme sugerido.

Exemplo

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

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

Answer 2

Você não pode derivar de nenhum dos tipos de valor .NET - todos são selados por definição.

Talvez você possa implementar seus métodos GetLowerValue e GethigherValue como métodos de extensão?

Answer 3

Minha função retorna algum valor longo que contém dois valores em 32 bits inferiores e mais altos.

Parece um hack muito, muito sujo. Pode ser apropriado para idiomas de quase metal (por exemplo, C), mas não para uma linguagem orientada a objetos de nível superior.

Em idiomas OO, você estende o sistema de tipos, não assedia os tipos existentes para fazer sua oferta. Assim, a solução deve ser criar um novo tipo que carregue suas informações.

Answer 4

O que você pode fazer é escrever uma estrutura com operadores de conversão implícitos. Isso funcionará exatamente da maneira que você deseja:

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

Então você pode fazer:

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

... assim como você queria.

Answer 5

Se eu entendi corretamente, sua função realmente retorna dois valores e o fato de que você os empacota em um long é um detalhe de implementação. Nesse caso, oculte esse detalhe e crie uma classe que contém o valor e as operações necessárias:

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

Você não pode superar isso.

Como long é um tipo selado e, portanto, você não pode herdar deles. Veja o Msdn

Como as estruturas são implicitamente seladas, elas não podem ser herdadas.

Para mais informações, veja Herança (guia de programação C#).