Finden Sie die Anzahl der Dezimalstellen im Dezimalwert, unabhängig von der Kultur

Ich frage mich, ob es eine präzise und genaue Möglichkeit gibt, die Anzahl der Dezimalstellen in einem Dezimalwert (als int) herauszuholen, die für verschiedene Kulturinformationen sicher verwendet werden kann.

Beispiel:
19.0 sollte 1 zurückgeben,
27.5999 sollte 4 zurückgeben,
19.12 sollte 2 zurückgeben
usw.

Ich habe eine Abfrage geschrieben, bei der eine Zeichenfolge auf einen Punkt aufgeteilt wurde, um Dezimalstellen zu finden:

int priceDecimalPlaces = price.ToString().Split('.').Count() > 1 
                  ? price.ToString().Split('.').ToList().ElementAt(1).Length 
                  : 0;

Mir fällt jedoch ein, dass dies nur in Regionen funktioniert, in denen das '.' als Dezimaltrennzeichen und ist daher systemübergreifend sehr spröde.

Ich habe Joes Weg benutzt , um dieses Problem zu lösen :)

decimal argument = 123.456m;
int count = BitConverter.GetBytes(decimal.GetBits(argument)[3])[2];

Da keine der Antworten gut genug für die in Dezimalzahlen konvertierte magische Zahl "-0.01f" war, GetDecimal((decimal)-0.01f);
kann ich nur davon ausgehen, dass vor 3 Jahren ein kolossaler Mind-Fart-Virus alle angegriffen hat :)
Hier scheint etwas zu funktionieren Implementierung dieses bösen und monströsen Problems, des sehr komplizierten Problems des Zählens der Dezimalstellen nach dem Punkt - keine Zeichenfolgen, keine Kulturen, keine Notwendigkeit, die Bits zu zählen und keine Notwendigkeit, Mathematikforen zu lesen. Nur einfache Mathematik der 3. Klasse.

public static class MathDecimals
{
    public static int GetDecimalPlaces(decimal n)
    {
        n = Math.Abs(n); //make sure it is positive.
        n -= (int)n;     //remove the integer part of the number.
        var decimalPlaces = 0;
        while (n > 0)
        {
            decimalPlaces++;
            n *= 10;
            n -= (int)n;
        }
        return decimalPlaces;
    }
}

private static void Main(string[] args)
{
    Console.WriteLine(1/3m); //this is 0.3333333333333333333333333333
    Console.WriteLine(1/3f); //this is 0.3333333

    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.0m));                  //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(1/3m));                  //28
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)(1 / 3f)));     //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-1.123m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces(43.12345m));             //5
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0));                     //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.01m));                 //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-0.001m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.00000001f)); //8
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.0001234f));   //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.01f));        //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.01f));       //2
}

Ich würde die Lösung wahrscheinlich in der Antwort von @ fixagon verwenden .

Während die Dezimalstruktur keine Methode zum Abrufen der Anzahl der Dezimalstellen hat, können Sie Decimal.GetBits aufrufen , um die Binärdarstellung zu extrahieren, und dann den ganzzahligen Wert und die Skalierung verwenden, um die Anzahl der Dezimalstellen zu berechnen.

Dies wäre wahrscheinlich schneller als das Formatieren als Zeichenfolge, obwohl Sie eine Menge Dezimalstellen verarbeiten müssten, um den Unterschied zu bemerken.

Ich werde die Implementierung als Übung verlassen.

Eine der besten Lösungen zum Ermitteln der Anzahl der Stellen nach dem Dezimalpunkt finden Sie im Beitrag von burning_LEGION .

Hier verwende ich Teile aus einem STSdb-Forumsartikel: Anzahl der Nachkommastellen .

In MSDN können wir die folgende Erklärung lesen:

"Eine Dezimalzahl ist ein Gleitkommawert, der aus einem Vorzeichen, einem numerischen Wert, bei dem jede Ziffer im Wert zwischen 0 und 9 liegt, und einem Skalierungsfaktor besteht, der die Position eines Gleitkommapunkts angibt, der das Integral und den Bruch trennt Teile des numerischen Wertes. "

Und auch:

"Die binäre Darstellung eines Dezimalwerts besteht aus einem 1-Bit-Vorzeichen, einer 96-Bit-Ganzzahl und einem Skalierungsfaktor, mit dem die 96-Bit-Ganzzahl geteilt und angegeben wird, welcher Teil davon ein Dezimalbruch ist. Der Skalierungsfaktor ist implizit die Zahl 10, angehoben auf einen Exponenten im Bereich von 0 bis 28. "

Auf interner Ebene wird der Dezimalwert durch vier ganzzahlige Werte dargestellt.

Es gibt eine öffentlich verfügbare GetBits-Funktion zum Abrufen der internen Darstellung. Die Funktion gibt ein int [] Array zurück:

[__DynamicallyInvokable] 
public static int[] GetBits(decimal d)
{
    return new int[] { d.lo, d.mid, d.hi, d.flags };
}

Das vierte Element des zurückgegebenen Arrays enthält einen Skalierungsfaktor und ein Vorzeichen. Und wie der MSDN sagt, ist der Skalierungsfaktor implizit die Zahl 10, die auf einen Exponenten zwischen 0 und 28 angehoben wird. Genau das brauchen wir.

Basierend auf allen obigen Untersuchungen können wir also unsere Methode konstruieren:

private const int SIGN_MASK = ~Int32.MinValue;

public static int GetDigits4(decimal value)
{
    return (Decimal.GetBits(value)[3] & SIGN_MASK) >> 16;
}

Hier wird ein SIGN_MASK verwendet, um das Vorzeichen zu ignorieren. Nach logisch und wir haben auch das Ergebnis mit 16 Bit nach rechts verschoben, um den tatsächlichen Skalierungsfaktor zu erhalten. Dieser Wert gibt schließlich die Anzahl der Stellen nach dem Dezimalpunkt an.

Beachten Sie, dass MSDN hier auch sagt, dass der Skalierungsfaktor auch alle nachgestellten Nullen in einer Dezimalzahl beibehält. Nachgestellte Nullen wirken sich nicht auf den Wert einer Dezimalzahl in Arithmetik- oder Vergleichsoperationen aus. Nachfolgende Nullen werden jedoch möglicherweise von der ToString-Methode angezeigt, wenn eine geeignete Formatzeichenfolge angewendet wird.

Diese Lösung sieht aus wie die beste, aber warten Sie, es gibt noch mehr. Durch den Zugriff auf private Methoden in C # können wir Ausdrücke verwenden, um einen direkten Zugriff auf das Flag-Feld zu erstellen und die Erstellung des int-Arrays zu vermeiden:

public delegate int GetDigitsDelegate(ref Decimal value);

public class DecimalHelper
{
    public static readonly DecimalHelper Instance = new DecimalHelper();

    public readonly GetDigitsDelegate GetDigits;
    public readonly Expression<GetDigitsDelegate> GetDigitsLambda;

    public DecimalHelper()
    {
        GetDigitsLambda = CreateGetDigitsMethod();
        GetDigits = GetDigitsLambda.Compile();
    }

    private Expression<GetDigitsDelegate> CreateGetDigitsMethod()
    {
        var value = Expression.Parameter(typeof(Decimal).MakeByRefType(), "value");

        var digits = Expression.RightShift(
            Expression.And(Expression.Field(value, "flags"), Expression.Constant(~Int32.MinValue, typeof(int))), 
            Expression.Constant(16, typeof(int)));

        //return (value.flags & ~Int32.MinValue) >> 16

        return Expression.Lambda<GetDigitsDelegate>(digits, value);
    }
}

Dieser kompilierte Code wird dem Feld GetDigits zugewiesen. Beachten Sie, dass die Funktion den Dezimalwert als ref empfängt, sodass kein tatsächliches Kopieren durchgeführt wird - nur ein Verweis auf den Wert. Die Verwendung der GetDigits-Funktion von DecimalHelper ist einfach:

decimal value = 3.14159m;
int digits = DecimalHelper.Instance.GetDigits(ref value);

Dies ist die schnellstmögliche Methode, um die Anzahl der Stellen nach dem Dezimalpunkt für Dezimalwerte zu ermitteln.

Sich auf die interne Darstellung von Dezimalstellen zu verlassen, ist nicht cool.

Wie wäre es damit:

    int CountDecimalDigits(decimal n)
    {
        return n.ToString(System.Globalization.CultureInfo.InvariantCulture)
                //.TrimEnd('0') uncomment if you don't want to count trailing zeroes
                .SkipWhile(c => c != '.')
                .Skip(1)
                .Count();
    }

Sie können die InvariantCulture verwenden

string priceSameInAllCultures = price.ToString(System.Globalization.CultureInfo.InvariantCulture);

Eine andere Möglichkeit wäre, so etwas zu tun:

private int GetDecimals(decimal d, int i = 0)
{
    decimal multiplied = (decimal)((double)d * Math.Pow(10, i));
    if (Math.Round(multiplied) == multiplied)
        return i;
    return GetDecimals(d, i+1);
}

Die meisten Leute hier scheinen nicht zu wissen, dass Dezimalstellen nachgestellte Nullen als wichtig für das Speichern und Drucken betrachten.

0,1 m, 0,10 m und 0,100 m können also als gleich verglichen werden, sie werden unterschiedlich gespeichert (als Wert / Skala 1/1, 10/2 bzw. 100/3) und als 0,1, 0,10 bzw. 0,100 gedruckt von ToString().

Daher melden die Lösungen, die eine "zu hohe Genauigkeit" melden, tatsächlich die richtige Genauigkeit zu decimalden Bedingungen.

Darüber hinaus sind mathematische Lösungen (wie das Multiplizieren mit Zehnerpotenzen) wahrscheinlich sehr langsam (die Dezimalzahl ist für die Arithmetik ~ 40x langsamer als das Doppelte, und Sie möchten auch kein Gleitkomma mischen, da dies wahrscheinlich zu Ungenauigkeiten führt ). In ähnlicher Weise ist das Umwandeln in intoder longals Mittel zum Abschneiden fehleranfällig ( decimalhat eine viel größere Reichweite als beide - es basiert auf einer 96-Bit-Ganzzahl).

Obwohl dies als solches nicht elegant ist, ist Folgendes wahrscheinlich einer der schnellsten Wege, um die Genauigkeit zu ermitteln (wenn es als "Dezimalstellen ohne nachgestellte Nullen" definiert ist):

public static int PrecisionOf(decimal d) {
  var text = d.ToString(System.Globalization.CultureInfo.InvariantCulture).TrimEnd('0');
  var decpoint = text.IndexOf('.');
  if (decpoint < 0)
    return 0;
  return text.Length - decpoint - 1;
}

Die invariante Kultur garantiert ein '.' Als Dezimalpunkt werden nachgestellte Nullen abgeschnitten, und dann muss nur noch geprüft werden, wie viele Positionen nach dem Dezimalpunkt verbleiben (falls es überhaupt eine gibt).

Bearbeiten: Rückgabetyp in int geändert

Und hier ist eine andere Möglichkeit: Verwenden Sie den Typ SqlDecimal, der eine Skalierungseigenschaft mit der Anzahl der Stellen rechts von der Dezimalstelle hat. Wandeln Sie Ihren Dezimalwert in SqlDecimal um und greifen Sie dann auf Scale zu.

((SqlDecimal)(decimal)yourValue).Scale

Bisher weisen fast alle aufgelisteten Lösungen GC-Speicher zu. Dies ist zwar die C # -Methode, aber in leistungskritischen Umgebungen alles andere als ideal. (Diejenigen, die keine Use-Schleifen zuweisen und auch keine nachgestellten Nullen berücksichtigen.)

Um GC-Zuordnungen zu vermeiden, können Sie einfach in einem unsicheren Kontext auf die Skalierungsbits zugreifen. Das mag fragil klingen, aber laut Microsoft-Referenzquelle ist das Strukturlayout der Dezimalzahl sequentiell und enthält sogar einen Kommentar, um die Reihenfolge der Felder nicht zu ändern:

    // NOTE: Do not change the order in which these fields are declared. The
    // native methods in this class rely on this particular order.
    private int flags;
    private int hi;
    private int lo;
    private int mid;

Wie Sie sehen können, ist das erste int hier das Flag-Feld. Aus der Dokumentation und wie in anderen Kommentaren hier erwähnt, wissen wir, dass nur die Bits von 16-24 die Skala codieren und dass wir das 31. Bit vermeiden müssen, das das Vorzeichen codiert. Da int die Größe von 4 Bytes hat, können wir dies sicher tun:

internal static class DecimalExtensions
{
  public static byte GetScale(this decimal value)
  {
    unsafe
    {
      byte* v = (byte*)&value;
      return v[2];
    }
  }
}

Dies sollte die leistungsstärkste Lösung sein, da keine GC-Zuordnung des Byte-Arrays oder der ToString-Konvertierungen vorhanden ist. Ich habe es gegen .Net 4.x und .Net 3.5 in Unity 2019.1 getestet. Wenn es Versionen gibt, bei denen dies fehlschlägt, lassen Sie es mich bitte wissen.

Bearbeiten:

Vielen Dank an @Zastai, der mich an die Möglichkeit erinnert hat, ein explizites Strukturlayout zu verwenden, um praktisch dieselbe Zeigerlogik außerhalb von unsicherem Code zu erreichen:

[StructLayout(LayoutKind.Explicit)]
public struct DecimalHelper
{
    const byte k_SignBit = 1 << 7;

    [FieldOffset(0)]
    public decimal Value;

    [FieldOffset(0)]
    public readonly uint Flags;
    [FieldOffset(0)]
    public readonly ushort Reserved;
    [FieldOffset(2)]
    byte m_Scale;
    public byte Scale
    {
        get
        {
            return m_Scale;
        }
        set
        {
            if(value > 28)
                throw new System.ArgumentOutOfRangeException("value", "Scale can't be bigger than 28!")
            m_Scale = value;
        }
    }
    [FieldOffset(3)]
    byte m_SignByte;
    public int Sign
    {
        get
        {
            return m_SignByte > 0 ? -1 : 1;
        }
    }
    public bool Positive
    {
        get
        {
            return (m_SignByte & k_SignBit) > 0 ;
        }
        set
        {
            m_SignByte = value ? (byte)0 : k_SignBit;
        }
    }
    [FieldOffset(4)]
    public uint Hi;
    [FieldOffset(8)]
    public uint Lo;
    [FieldOffset(12)]
    public uint Mid;

    public DecimalHelper(decimal value) : this()
    {
        Value = value;
    }

    public static implicit operator DecimalHelper(decimal value)
    {
        return new DecimalHelper(value);
    }

    public static implicit operator decimal(DecimalHelper value)
    {
        return value.Value;
    }
}

Um das ursprüngliche Problem zu lösen, könnten Sie alle Felder abstreifen neben Valueund Scaleaber vielleicht könnte es nützlich sein , für jemanden zu haben , sie alle.

Ich habe gestern eine prägnante kleine Methode geschrieben, die auch die Anzahl der Dezimalstellen zurückgibt, ohne sich auf String-Splits oder Kulturen verlassen zu müssen, was ideal ist:

public int GetDecimalPlaces(decimal decimalNumber) { // 
try {
    // PRESERVE:BEGIN
        int decimalPlaces = 1;
        decimal powers = 10.0m;
        if (decimalNumber > 0.0m) {
            while ((decimalNumber * powers) % 1 != 0.0m) {
                powers *= 10.0m;
                ++decimalPlaces;
            }
        }
return decimalPlaces;

Ich verwende etwas, das Clements Antwort sehr ähnlich ist:

private int GetSignificantDecimalPlaces(decimal number, bool trimTrailingZeros = true)
{
  string stemp = Convert.ToString(number);

  if (trimTrailingZeros)
    stemp = stemp.TrimEnd('0');

  return stemp.Length - 1 - stemp.IndexOf(
         Application.CurrentCulture.NumberFormat.NumberDecimalSeparator);
}

Denken Sie daran, System.Windows.Forms zu verwenden, um Zugriff auf Application.CurrentCulture zu erhalten

Du kannst es versuchen:

int priceDecimalPlaces =
        price.ToString(System.Globalization.CultureInfo.InvariantCulture)
              .Split('.')[1].Length;

Ich verwende den folgenden Mechanismus in meinem Code

  public static int GetDecimalLength(string tempValue)
    {
        int decimalLength = 0;
        if (tempValue.Contains('.') || tempValue.Contains(','))
        {
            char[] separator = new char[] { '.', ',' };
            string[] tempstring = tempValue.Split(separator);

            decimalLength = tempstring[1].Length;
        }
        return decimalLength;
    }

Dezimaleingabe = 3,376; var instring = input.ToString ();

Rufen Sie GetDecimalLength (instring) auf.

Mit der Rekursion können Sie Folgendes tun:

private int GetDecimals(decimal n, int decimals = 0)  
{  
    return n % 1 != 0 ? GetDecimals(n * 10, decimals + 1) : decimals;  
}

string number = "123.456789"; // Convert to string
int length = number.Substring(number.IndexOf(".") + 1).Length;  // 6

Ich schlage vor, diese Methode zu verwenden:

    public static int GetNumberOfDecimalPlaces(decimal value, int maxNumber)
    {
        if (maxNumber == 0)
            return 0;

        if (maxNumber > 28)
            maxNumber = 28;

        bool isEqual = false;
        int placeCount = maxNumber;
        while (placeCount > 0)
        {
            decimal vl = Math.Round(value, placeCount - 1);
            decimal vh = Math.Round(value, placeCount);
            isEqual = (vl == vh);

            if (isEqual == false)
                break;

            placeCount--;
        }
        return Math.Min(placeCount, maxNumber); 
    }

Als Dezimalerweiterungsmethode, die Folgendes berücksichtigt:

• Unterschiedliche Kulturen
• Ganze Zahlen
• Negative Zahlen
• Nachgestellte Nullen auf der Dezimalstelle (z. B. 1,2300M geben 2 statt 4 zurück)

public static class DecimalExtensions
{
    public static int GetNumberDecimalPlaces(this decimal source)
    {
        var parts = source.ToString(CultureInfo.InvariantCulture).Split('.');

        if (parts.Length < 2)
            return 0;

        return parts[1].TrimEnd('0').Length;
    }
}