string amt = "4,560";
// Replace comma with EmptyString
amt=amt.Replace(",",string.Empty);
//Then Convert
int amount = Convert.ToInt32(amt);

I believe you can use Parse method. For instance, if you wan to parse a string that contains integer value, you can use:

Int32.Parse(svalue, NumberStyles.AllowThousands,NumberFormatInfo.InvariantInfo)

NumberFormatInfo.InvariantInfo uses comma as a group separator. You can also use Int32.TryParse.

If you want to parse double string, you can use Double.Parse instead. But you'd have to add appropriate flag to allow decimal points.

You can use:

string svalue = "11,200.256";

txtResult.Text = decimal.Parse(svalue, CultureInfo.InvariantCulture.NumberFormat).ToString("F");

To accept a comma as thousands-separator you sghould explicitly use a culture info where this is true. In german culture, for example, the thousands separator is a dot, whereas the comma depicts the decimal separator. So the following line interprets the comma as a thousands separator :

int someValue = int.Parse("13,200", NumberStyles.AllowThousands, CultureInfo.GetCultureInfo("en-us"));

If you want to allow decimals, you should use the AllowSeparator flag too; for leading signs, the AllowLeadingSign. A standard currency value can be converted using the following snippet

double someValue = double.Parse("13,200", NumberStyles.Currency, CultureInfo.GetCultureInfo("en-us"));

You can use the appropriate NumberStyle:

string svalue = GetCurrentPrice();
long value = long.Parse(svalue, System.Globalization.NumberStyles.AllowThousands);

Use TryParse to determine if the conversion succeeed.

private string CalculateCost(int quantity)
    {
        String svalue = GetCurrentPrice();            

        float price = 0;
        if (Single.TryParse(svalue, out price))
        {
            return (price * quantity).ToString("C");
        }
        else return "Unable to get current price";
    }

Which one is the correct answer?

If we have a string, and we expect it to always be an integer best practice is to use Int32.Parse(). If we are collecting input from a user, we can generally use Int32.TryParse(), since it allows more fine-grained control over the situation when the user enters in invalid input.

Convert.ToInt32() takes an object as its argument, and it invokes Int32.TryParse() when it finds that the object taken as the argument is a string. Convert.ToInt32 also does not throw ArgumentNullException when it's argument is null the way Int32.Parse() does. That also means that Convert.ToInt32() is probably a wee bit slower than Int32.Parse() because it has to ask its argument what it's type is.

Convert.ToInt has performance penality. Here is the best practice code

public static int ToInt32(string value)
 {  
   if (value == null) 
    {     
    return 0;   
    }     
return int.Parse(value, CultureInfo.CurrentCulture);
 }

Let's assume the function will always return valid number, so we are not going to check for errors or special cases. Let's also assume that the function returns integer, so I'll do all my code samples for integer. If it's not integer then the code provided below can be easily changed to work with the other types.

If you can guarantee that NumberFormatInfo for current culture in the code where you parse the string will always have "," sign as NumberGroupSeparator then the easiest way to parse the result of GetCurrentPrice() function will be:

int.Parse(svalue, NumberStyles.AllowThousands);

If you cannot guarantee that NumberFormatInfo for the current culture in the code where you parse the string will always have "," sign as NumberGroupSeparator then I believe the easiest way to do the task is:

int.Parse(svalue, NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo);

This will work as NumberFormatInfo.InvariantInfo has "," as NumberGroupSeparator.

Also note that the function name is GetCurrentPrice, so if it will ever be changed to return currency values we can pretty easy modify the code to accommodate the change.