Je veux utiliser regex.Amatch pour trouver tb, gb, MB dans vb.net Visual Basic

• Je n'utiliserais pas une expression régulière pour cela, car une approche beaucoup plus simple (et plus robuste!) décrite ci-dessous. Li>
• Si vous utilisez une expression régulière, vous devez ajouter tous les noms de l'unité à l'expression, qui est douloureux. Les expressions régulières ne sont pas bien adaptées à l'acceptation d'une grande liste de les entrées littérales possibles em>. Li>
• L'utilisation d'une expression régulière signifierait également que l'entrée ne serait pas consciente de la culture, ce qui est mauvais pour la convivialité (autant d'endroits dans le monde échangent le , code> et . code>. code>. > Glyphs en chiffres) - et vous ne voulez vraiment pas gérer des objets comme le groupement de chiffres, etc. li>

  Au lieu de cela, d'abord extrait et validez le nom de l'unité, puis analysez la valeur numérique à l'aide de décimal.tryparse code> p>

  comme (en utilisant C # parce que c'est 2h et je ne suis pas Être payé pour écrire cette réponse): P>

  void Example()
  {
      String textBoxValue = "3 GB";
      if( TryParseBinaryDataQuantity( textBoxValue, out Int64 valueBytes ) )
      {
          MessageBox.Show( "Visual Basic is dead." );
      }
      else
      {
          MessageBox.Show( "Input is not a valid binary data quantity." );
      }
  }
  
  public static Boolean TryParseBinaryDataQuantity( String input, out Int64 valueBytes )
  {
      input = ( input ?? "" ).Trim();
      if( input.Length < 3 ) // input is too short to be meaningful.
      {
          valueBytes = default;
          return false;
      }
  
      // Extract the unit-name by taking the last 3 characters of the input string and trimming any whitespace (this isn't the most robust or correct approach, but I'm feeling lazy):
      String unitName = input.Substring( startIndex: input.Length - 3 );
  
      // Validate the unit-name and get the bytes multiplier:
      if( !TryParseBinaryDataUnit( unitName, out Int64 multiplier ) )
      {
          valueBytes = default;
          return false;
      }
  
      // Consider repeating the above but for the last 2 characters of the string in order to match input like "3GB" instead of "3GiB" and "3 GB" and "3 GiB".
  
      // Parse and multiply:
      String numberPart = input.Substring( startIndex: 0, length: input.Length - 3 );
      if( Decimal.TryParse( numberPart, NumberStyles.Any, CultureInfo.CurrentCulture, out Decimal quantity )
      {
          Decimal bytesValue = quantity * multiplier;
  
          // Fail if the bytesValue is non-integral or negative:
          if( bytesValue != Math.Floor( bytesValue ) || bytesValue < 0 )
          {
              valueBytes = default;
              return false;
          }
  
          return (Int64)bytesValue;
      }
  }
  
  private static Boolean TryParseBinaryDataUnit( String unitName, out Int64 equivalentBytes )
  {
      if( "GB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024 * 1024 * 1024; // or 1000 * 1000 * 1000 depending on if you're differentiating between GiB and GB.
          return true;
      }
      else if( "GiB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024 * 1024 * 1024;
          return true;
      }
      else if( "MiB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024 * 1024;
          return true;
      }
      else if( "MB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024 * 1024;
          return true;
      }
      else if( "KB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024;
          return true;
      }
      else if( "KB".Equals( unitName, StringComparison.CurrentCultureCaseInsensitive ) )
      {
          equivalentBytes = 1024;
          return true;
      }
      else
      {
          equivalentBytes = default;
          return false;
      }
  }
  

Je vous recommanderai d'utiliser une bibliothèque appropriée pour analyser l'entrée donnée. J'en ai utilisé un dans le passé pour faire cela ( https://github.com/omar/bytesize )

Voici un exemple rapide de la façon dont vous pouvez faire cela. Je sais qu'il doit y avoir une meilleure façon de le faire, mais cela ferait le travail =) xxx

entrée> 1234.56MB

sortie> 1.23 gb

Vous pouvez essayer ma méthode comme suit: xxx