# C# Percentage: Format String, Ratio

These C# examples cover percentages. They show how to compute percentages and write to the console.

## Percentages are often useful in programs.

With the numbers one and two, we can get a percentage of 50%. We display and process percentages with doubles. We solve an annoying rounding problem.

Double

Example. First, we see some code that uses string.Format to display two numbers or ratio as a percentage. The following code shows four methods. The first is Main. And the last three are custom methods for displaying percentages.

```C# program that calculates percents

using System;

class Program
{
static void Main()
{
// Display percentage of visits that resulted in purchases.
int purchases = 10;
int visitors = 120;
DisplayPercentage((double)purchases / visitors);

// Display 50 percent with overloaded method.
DisplayPercentage(1, 2);

// Write percentage string of nine tenths.
Console.WriteLine(GetPercentageString((double)9 / 10));
}

/// <summary>
/// This method writes the percentage form of a double to the console.
/// </summary>
static void DisplayPercentage(double ratio)
{
string percentage = string.Format("Percentage is {0:0.0%}", ratio);
Console.WriteLine(percentage);
}

/// <summary>
/// This method writes the percentage of the top number to the bottom number.
/// </summary>
static void DisplayPercentage(int top, int bottom)
{
DisplayPercentage((double)top / bottom);
}

/// <summary>
/// This method returns the percentage-formatted string.
/// </summary>
static string GetPercentageString(double ratio)
{
return ratio.ToString("0.0%");
}
}

Output

Percentage is 8.3%
Percentage is 50.0%
90.0%```  DisplayPercentage accepts a double that is a ratio, usually between 0 and 1. It uses a custom formatting string to display the percentage to the Console. The {0:0.0%} substitution indicates you want a percentage with one decimal place.

Also: The second DisplayPercentage accepts two parameters and then passes the ratio of them to the other method. It casts to double.

Casts

Finally: GetPercentageString accepts a double containing a ratio and returns a percentage string using ToString().

ToString

Example 2. Here we convert two integers into a percentage manually with division and multiplication. Sometimes you can need raw percentages when you have percentages in the database stored in different formats.

```C# program that converts ratios

using System;

class Program
{
static void Main()
{
// We want to have 92.9% from these two numbers.
int valid = 92;
int total = 99;

// First multiply top by 100 then divide.
double percent = (double)(valid * 100) / total; // <-- Use cast

// This is the percent number.
Console.WriteLine(percent);
Console.WriteLine(Math.Floor(percent));
Console.WriteLine(Math.Ceiling(percent));
Console.WriteLine(Math.Round(percent, 1));
}
}

Output

92.9292929292929
92
93
92.9```  Casting to double. The double must be assigned to a value cast to double. If you omit the cast, your value will be rounded and probably useless. When casting to double, you do not need to surround the entire expression with parentheses.

Divide

The final four statements in the program display different forms of the percentage. Math.Floor rounds down to the nearest integer. Math.Ceiling rounds up to the nearest integer. And Math.Round rounds to a single decimal place.

Modulo. The percentage sign in the C# language has a use as the modulo operator. This forms an expression that will return the remainder of a division of the two operands. You can find more about the modulo operator.

Modulo

Tip: With modulo division, we can run an operation every N times. This has uses in many programs.

Summary. We saw two examples of using percentages in the C# language. First we saw how to format ratios as percentages with three different methods. Second, we saw how to get a percentage value directly with math, and then round it.