c# - solo - Expresión regular para el número decimal

expresion regular solo numeros mayores que 0

Question

Necesito validar una entrada de textbox y solo puedo permitir entradas decimales como: X,XXX (solo un dígito antes del signo decimal y una precisión de 3).

Estoy usando C # e intento esto ^[0-9]+(/.[0-9]{1,2})?$ ?

Answer 1

Acabo de descubrir que TryParse() tiene un problema que explica miles de separadores. Ejemplo en En-US, 10,36.00 está bien. Tenía un escenario específico donde el separador de miles no debería considerarse y, por lo tanto, la expresión regular /d(/./d) resultó ser la mejor opción. Por supuesto, tenía que mantener la variable de carácter decimal para diferentes configuraciones regionales.

Answer 2

En .NET, recomiendo construir dinámicamente la expresión regular con el separador decimal del contexto cultural actual:

using System.Globalization;
...
NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;
Regex re = new Regex("^(?//d+("
+ Regex.Escape(nfi.CurrencyDecimalSeparator)
+ "//d{1,2}))$");

Es posible que desee proxeneta la expresión regular al permitir separadores 1000er de la misma manera que el separador decimal.

Answer 3

En general, es decir, decimales ilimitados:

^-?(([1-9]/d*)|0)(.0*[1-9](0*[1-9])*)?$

Answer 4

Hay un enfoque alternativo, que no tiene problemas con I18n (permitiendo "," o "." Pero no ambos): Decimal.TryParse .

Intenta convertir, ignorando el valor.

bool IsDecimalFormat(string input) {
Decimal dummy;
return Decimal.TryParse(input, out dummy);
}

Esto es significativamente más rápido que usar una expresión regular, ver abajo.

(La sobrecarga de Decimal.TryParse se puede usar para un control más preciso).

Resultados de la prueba de rendimiento: Decimal.TryParse: 0.10277ms, Regex: 0.49143ms

Código ( PerformanceHelper.Run es un asistente que ejecuta el delegado para el recuento de iteraciones pasado y devuelve el TimeSpan promedio):

using System;
using System.Text.RegularExpressions;
using DotNetUtils.Diagnostics;
class Program {
static private readonly string[] TestData = new string[] {
"10.0",
"10,0",
"0.1",
".1",
"Snafu",
new string(''x'', 10000),
new string(''2'', 10000),
new string(''0'', 10000)
};
static void Main(string[] args) {
Action parser = () => {
int n = TestData.Length;
int count = 0;
for (int i = 0; i < n; ++i) {
decimal dummy;
count += Decimal.TryParse(TestData[i], out dummy) ? 1 : 0;
}
};
Regex decimalRegex = new Regex(@"^[0-9]([/./,][0-9]{1,3})?$");
Action regex = () => {
int n = TestData.Length;
int count = 0;
for (int i = 0; i < n; ++i) {
count += decimalRegex.IsMatch(TestData[i]) ? 1 : 0;
}
};
var paserTotal = 0.0;
var regexTotal = 0.0;
var runCount = 10;
for (int run = 1; run <= runCount; ++run) {
var parserTime = PerformanceHelper.Run(10000, parser);
var regexTime = PerformanceHelper.Run(10000, regex);
Console.WriteLine("Run #{2}: Decimal.TryParse: {0}ms, Regex: {1}ms",
parserTime.TotalMilliseconds,
regexTime.TotalMilliseconds,
run);
paserTotal += parserTime.TotalMilliseconds;
regexTotal += regexTime.TotalMilliseconds;
}
Console.WriteLine("Overall averages: Decimal.TryParse: {0}ms, Regex: {1}ms",
paserTotal/runCount,
regexTotal/runCount);
}
}

Answer 5

Mientras lidiaba con esto, TryParse en 3.5 tiene NumberStyles: el siguiente código también debería funcionar sin Regex para ignorar miles de separadores.

double.TryParse(length, NumberStyles.AllowDecimalPoint,CultureInfo.CurrentUICulture, out lengthD))

No es relevante para la pregunta original, pero confirma que TryParse () es una buena opción.

Answer 6

/d{1}(/./d{1,3})?
Match a single digit 0..9 «/d{1}»
Exactly 1 times «{1}»
Match the regular expression below and capture its match into backreference number 1 «(/./d{1,3})?»
Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
Match the character “.” literally «/.»
Match a single digit 0..9 «/d{1,3}»
Between one and 3 times, as many times as possible, giving back as needed (greedy) «{1,3}»
Created with RegexBuddy

Partidos:
1
1.2
1.23
1.234

Answer 7

^[0-9]([.,][0-9]{1,3})?$

Permite:

0
1
1.2
1.02
1.003
1.030
1,2
1,23
1,234

PERO NO:

.1
,1
12.1
12,1
1.
1,
1.2345
1,2345