Pourquoi je ne peux pas tirer de temps?

Question

Ma fonction retourne une valeur à long qui contient deux valeurs en 32 bits inférieurs et supérieurs.

Je pensais que les meilleures façons de gérer la valeur de retour est de tirer mon type personnalisé de long et fournir des diluants tels que de type GetLowerValue (), GetHigherValue ().

Le problème est que .NET ne permet pas de tirer de long

Si vous compilez que

public class SubmitOrderResult : long
{
}

vous obtenez:

cannot derive from sealed type 'long'

Pourquoi est conçu de manière à ce que et comment peut la surmonter?

Merci

Answer 1

Comme les types de valeurs déjà mentionnées dans .NET sont scellés donc il n'y a aucun moyen que vous pouvez tirer de la longue. Vous devez créer des méthodes d'extension comme l'a suggéré.

Exemple

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

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

Answer 2

Vous ne pouvez pas tirer de l'un des types de valeur .NET - ils sont tous scellés par définition

.

Peut-être que vous pourriez mettre en œuvre vos méthodes GetLowerValue et GetHigherValue comme méthodes d'extension?

Answer 3

  

Ma fonction retourne une valeur de temps qui contient deux valeurs en 32 bits inférieurs et supérieurs.

Cela ressemble à un hack vraiment, vraiment sale. Il pourrait être approprié pour les gros-métal langues (par exemple C) mais pas pour un niveau supérieur, langage orienté objet.

Dans les langues OO, vous étendez le système de type, ne harcèle pas les types existants pour faire votre appel d'offres. Ainsi, la solution devrait être de créer un nouveau type qui porte vos informations.

Answer 4

Qu'est-ce que vous pouvez faire est d'écrire un struct avec les opérateurs de conversion implicite. Cela fonctionne exactement comme vous le souhaitez:

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

Ensuite, vous pouvez faire:

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

... comme vous voulez.

Answer 5

Si je comprends bien, votre fonction retourne en fait deux valeurs, et le fait que vous les emballer dans un long est un détail de mise en œuvre. Dans ce cas, cacher ce détail et créer une classe qui contient la valeur et les opérations nécessaires:

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

Vous ne pouvez pas surmonter.

Comme long est un type scellé et donc vous ne pouvez pas hériter d'eux. Voir MSDN

  

Parce que struct sont implicitement scellés, ils ne peuvent être héritées.

     

Pour plus d'informations, consultez Héritage (Guide de programmation C #) .