Manipulating DateTime values is one of the most common operations in any application. Have we ever asked ourselves how to extract the quarter of a given date value in C#? In this article, we are going to understand how we can derive the quarter and financial quarter from a given date in C#.

Let’s begin.Â

## Different Ways to Calculate the Quarter of a Given Date in C#

We can use different strategies to accomplish our goals.

Tip: In scenarios where we intend to perform a large number of calculations especially, we should consider using the DateOnly structure (.NET 6+) for calculations like these that donâ€™t require time-of-day, as it uses less memory.

Let’s explore some of them.

### Use Selection to Get the Quarter of a Given Date

First, we can use selection to calculate the quarter of a given date:

```public static int CalculateQuarterUsingSelection(DateTime inputDate)
{
if (inputDate.Month <= 3)
{
return 1;
}

if (inputDate.Month <= 6)
{
return 2;
}

if (inputDate.Month <= 9)
{
return 3;
}

return 4;
}```

Here, we use the `DateTime.Month` property to extract the month of the given date and use if statements to determine its quarter. We can also use a switch statement to accomplish the same objective.

### Array Lookup Technique

Besides that, we can store the quarters in an array and perform lookup operations to determine the quarter of a given date:

```public static int CalculateQuarterUsingArrayLookUp(DateTime inputDate)
{
int[] quarters = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4 };

return quarters[inputDate.Month - 1];
}```

We store the quarter values in an array and return them when we have the month of a given date.Â

### Division Technique for Quarter Calculations

Another method to find the quarter of a date is that we can divide the `DateTime.Month` property by three and use the `Math.Ceiling()` method to round up the result to the next full integer:

`return (int)Math.Ceiling(inputDate.Month / 3.0);`

We can further simplify the solution through direct integer division:

`return (inputDate.Month + 2) / 3;`

### Use LINQ to Get the Quarter of a Given Date

Finally, we can leverage LINQ to retrieve the quarter from a given date in C#. Let’s implement an example to learn how it works:

`return Enumerable.Range(1, 4).First(q => inputDate.Month <= q * 3);`

Here, we use `Enumerable.Range()` to create a sequence of numbers from one to four, representing the four quarters. Next, we apply a predicate function to each quarter and return the first element that satisfies the condition. In this case, we use the function `q => inputDate.Month <= q * 3` to check whether the `inputDate.Month` is less than or equal to the quarter multiplied by three and returns the quarter’s value if true.Â

Note that LINQ-based methods will generally be less efficient due to the overhead of the method calls and delegates.Â

### Time Zones and Leap Years

Leap years do not directly affect quarter calculations; they add an extra day to February. However, since we calculate the quarter based on months, the extra day still falls in February.

We can verify that when given a leap year date and a non-leap year date, we return the same quarter:

```var leapYearDate = new DateTime(2024, 2, 29);
var quarterLeapYear = CalculateQuarterMethods.CalculateQuarter(leapYearDate);
var nonLeapYearDate = new DateTime(2023, 2, 28);
var quarterNonLeapYear = CalculateQuarterMethods.CalculateQuarter(nonLeapYearDate);

Assert.AreEqual(quarterLeapYear, quarterNonLeapYear);```

Likewise, time zones affect the time of a given date and, hence, have a minimal effect on quarter calculations. Therefore, converting dates into common time zones or UTC is advisable to avoid inconsistencies.Â

## How to Get the Start and End of Quarter Dates

Sometimes, we may want to retrieve a given quarter’s start and end dates. Let’s implement an example to demonstrate how we can achieve our goal:

```public struct QuarterRange
{
public DateTime StartQuarterDate { get; set; }
public DateTime EndQuarterDate { get; set; }

public QuarterRange(DateTime startQuarterDate, DateTime endQuarterDate)
{
StartQuarterDate = startQuarterDate;
EndQuarterDate = endQuarterDate;
}
}

public static QuarterRange CalculateQuarterDates(DateTime inputDate)
{
var quarter = (int)Math.Ceiling(inputDate.Month / 3.0);
var startQuarterMonth = (quarter - 1) * 3 + 1;
var endQuarterMonth = startQuarterMonth + 2;
var daysInMonth = DateTime.DaysInMonth(inputDate.Year, endQuarterMonth);
var startQuarterDate = new DateTime(inputDate.Year, startQuarterMonth, 1);
var endQuarterDate = new DateTime(inputDate.Year, endQuarterMonth, daysInMonth);

return new QuarterRange (startQuarterDate, endQuarterDate);
}```

Here, we define a struct `QuarterRange` with the start and end of quarter dates. Next, we implement a function `CalculateQuarterDates()` that accepts a date as a parameter.

The first step is to calculate the quarter from the given `inputDate` and calculate the first month of that quarter.Â  For example, if the input date is the 30th of December 2023, the first month of that quarter is (4 – 1) * 3 + 1 = 10.

Next, we calculate the last month of the quarter by adding two to `startQuarterMonth`. Finally, we set the start date to the first day of `startQuarterMonth` and the end of the quarter date as the last date of `endQuarterMonth`, which we get from the `DateTime.DaysInMonth()` method. Our solution can prove that the start and end of quarter dates for the fourth quarter are the 1st of October and the 31st of December, respectively.Â

## How to Get the Fiscal Quarter of a Given Date in C#

Sometimes, we may want to get the fiscal quarter of a given date in C#. A fiscal calendar is a range of dates that defines a company’s annual reporting cycle, which may be different from the normal calendar year.

Let’s learn how to calculate the fiscal quarter from a given date, assuming the fiscal quarter starts from the 1st of April every year:

`return (int)Math.Ceiling(inputDate.Month / 3.0 + 2) % 4 + 1;`

For example, if the valueÂ  `inputDate` is the 12th of December, (12 / 3.0 + 2) = 6. The remainder from 6 % 4 is 2; hence, the result is 3.Â

However, in most cases, organizations have different fiscal calendars to suit their operational needs.

Let’s implement an example that accommodates this business need:

```public static int CalculateFiscalQuarterOffset(DateTime inputDate, DateTime fiscalYearStart)
{
var monthOffset = inputDate.Month - fiscalYearStart.Month;

if (inputDate.Month == fiscalYearStart.Month
&& inputDate.Day < fiscalYearStart.Day
|| inputDate.Month < fiscalYearStart.Month)
{
monthOffset--;
}

monthOffset = (monthOffset + 12) % 12;
var quarter = (monthOffset / 3) + 1;

return quarter;
}```

First, we subtract their `DateTime.Month` components to calculate the month offset between the given date and the fiscal year start date. Second, we check if the `inputDate` falls before the fiscal year start date within the same calendar year and decrease `monthOffset` if true. Third, we ensure that `monthOffset` ranges from 0 to 11 by adding 12 and getting the remainder after dividing by 12. It ensures that the result is a non-negative integer representing the number of months between the fiscal year start month and the input month.Â

Finally, we calculate the `quarter`Â by dividing the normalized `monthOffset` by 3 and adding 1 to it.Â

## ConclusionÂ

In this article, we learn how to calculate the quarter of a given date in C#. Are there any favorite techniques of yours that we missed? Let us know in the comments section below.Â