¿Cómo comparo y afirmo que la cadena es mayor que USD1000 cuando el valor que obtuve es USD42,000? ¿Cómo convierto esta cadena en entero?

¿Cómo comparo y afirmo que la cadena es mayor que USD1000 cuando el valor que obtuve es USD42,000? ¿Cómo convierto esta cadena en entero?

Solución de cómo comparo y afirmo que la cadena es mayor que USD1000 cuando el valor que obtuve es USD42,000. ¿Cómo convierto esta cadena en un número entero?
Se muestra a continuación:

string carPrice = driver.FindElement(By.XPath("//body/main[1]/article[1]/section[1]/section[1]/section[4]/div[1]/div[1]/div[1]/div[1]/div[2]/div[1]/div[1]/h3[1]")).Text;
string basePrice = "USD1000";

carPrice es un valor dinámico que contiene moneda y coma como 42 000 USD

Si su formato de precios es fijo, puede usar este //USD42,000

char[] delimiterChars = {',','U','S','D'};
string[] values =carPrice.Split(delimiterChars);
string join = string.Join("", values);
int price = int.parse(join);

Aquí hay varios métodos de extensión de idioma para ayudar, ignore las extensiones de matriz, ya tenía varios de estos dando vueltas.

Fuente completa

public static class Extensions
{
    /// <summary>
    /// Convert string to decimal
    /// </summary>
    /// <param name="sender">assumed value has one or more digest</param>
    /// <returns>decimal value or will throw an exception if can not convert e.g. an empty string</returns>
    public static decimal ToDecimal(this string sender) =>
        decimal.Parse(Regex.Replace(sender, @"[^d.]", ""));

    /// <summary>
    /// Any value in array greater than checkValue
    /// </summary>
    /// <param name="sender">valid decimal array</param>
    /// <param name="checkValue">check if an element in sender is greater than this value</param>
    /// <returns>true if condition is met, false if not met</returns>
    public static bool GreaterThan(this decimal[] sender, decimal checkValue) =>
        sender.Any(value => value > checkValue);

    /// <summary>
    /// Is sender greater than checkValue
    /// </summary>
    /// <param name="sender">valid decimal value</param>
    /// <param name="checkValue">is sender greater than this value</param>
    /// <returns>true if condition is met, false if not met</returns>
    public static bool GreaterThan(this decimal sender, decimal checkValue) =>
        sender > checkValue;

    public static decimal[] ToDecimalArray(this string[] sender)
    {

        var decimalArray = Array
            .ConvertAll(sender,
                (input) => new
                {
                    IsDecimal = decimal.TryParse(Regex.Replace(input, @"[^d.]", ""), out var doubleValue),
                    Value = doubleValue
                })
            .Where(result => result.IsDecimal)
            .Select(result => result.Value)
            .ToArray();

        return decimalArray;

    }
}

Prueba unitaria

using ConvertingUnitTest.Base;
using ConvertingUnitTest.Classes;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace ConvertingUnitTest
{
    [TestClass]
    public partial class MainTest : TestBase
    {
        [TestMethod]
        [TestTraits(Trait.SingleConvert)]
        public void TestToDecimal()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();
            decimal expected = 1000;
            
            Assert.AreEqual(basePrice, expected);

        }
        
        [TestMethod]
        [TestTraits(Trait.SingleConvert)]
        public void TestStringValueIsNotGreaterThan()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();

            string value = "USD999";
            
            Assert.IsFalse(value.ToDecimal() > basePrice);
        }
        
        [TestMethod]
        [TestTraits(Trait.SingleConvert)]
        public void TestStringValueIsGreaterThan()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();

            string value = "USD1001";

            Assert.IsTrue(value.ToDecimal() > basePrice);
        }
        
        [TestMethod]
        [TestTraits(Trait.SingleConvert)]
        public void TestStringWithWhiteSpace()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();

            string value = "USD10 01";

            Assert.IsTrue(value.ToDecimal() > basePrice);
        }

        [TestMethod]
        [TestTraits(Trait.ArrayConvert)]
        public void TestStringArrayNotGreaterThan()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();
            
            string[] values = { "USD999", "", "USD20" };

            var onlyDecimalArray = values.ToDecimalArray();
            
            Assert.IsFalse(onlyDecimalArray.GreaterThan(basePrice));
        }
        [TestMethod]
        [TestTraits(Trait.ArrayConvert)]
        public void TestStringArrayIsGreaterThan()
        {
            string mockedBasePrice = "USD1000";
            decimal basePrice = mockedBasePrice.ToDecimal();

            string[] values = { "USD999", "USD2020", "USD20" };

            var onlyDecimalArray = values.ToDecimalArray();

            Assert.IsTrue(onlyDecimalArray.GreaterThan(basePrice));
            Assert.IsTrue(onlyDecimalArray[1].GreaterThan(basePrice));
        }

    }
}

Lo anterior debe ser:

int price = int.Parse(join);

Solo una simple P mayúscula para analizar.