We Keep Coding

Calculating ticks from given year (Mathematical Approach)

I've been trying to convert a given date to ticks using the following formula and since I've just begun writing this function I do not yet consider the month and day values :
public static long DateToTicks(int year, int month, int day) {
var leapYears = (year - 1) / 4;
var result = ((year - 1) * 365 * OneDay.Ticks) + (leapYears * OneDay.Ticks);
return result;
}
The OneDay.Ticks is a constant here whose value is 3600 * 24 * 1000 * 10000.
The problem I have faced is that, when I calculate ticks from day zero (i.e. 0001-01-01, 0002-01-01) it works fine until I reach year 101 where I get an additional day! I compare my result against the value returned by the DateTime struct in .Net Core. For example:
var myResult = DateToTicks(100, 01, 01);
var dateTimeResult = new DateTime(100,01,01).Ticks;
Until this date, myResult == dateTimeResult is always true, but when I enter the next century I see that the result returned by DateTime struct is one day behind, and as I enter another century this value doubles.
However, I know that in 101 years, there are 25 leap years which means that I have to multiply 75 years by 365 and the rest by 366 and then add them together, and I cannot understand why my result is different from dot net's DateTime result.
What's the problem with my approach? Given that month and day would be not important (always set to 01).

since you dont seem to want to look at the c# code. I looked there for you - took me 1 minute
private static long DateToTicks(int year, int month, int day) {
if (year >= 1 && year <= 9999 && month >= 1 && month <= 12) {
int[] days = IsLeapYear(year)? DaysToMonth366: DaysToMonth365;
if (day >= 1 && day <= days[month] - days[month - 1]) {
int y = year - 1;
int n = y * 365 + y / 4 - y / 100 + y / 400 + days[month - 1] + day - 1;
return n * TicksPerDay;
}
}
throw new ArgumentOutOfRangeException(null, Environment.GetResourceString("ArgumentOutOfRange_BadYearMonthDay"));
}
and
public static bool IsLeapYear(int year) {
if (year < 1 || year > 9999) {
throw new ArgumentOutOfRangeException("year", Environment.GetResourceString("ArgumentOutOfRange_Year"));
}
Contract.EndContractBlock();
return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}
here is the direct link
https://referencesource.microsoft.com/#mscorlib/system/datetime.cs,891f8af5025ab2f3

Change your logic for leap year calculation to this and it works well:
var leapYears = ((year - 1) / 4) - (year / 400 > 0 ? ((year) / 100) - (((year) / 400)) : ((year - 1) / 100)) + (year % 100 == 0 && year % 400 != 0 ? 1 : 0) + (year == 100 || year == 200 || year == 300 ? -1 : 0);

A simple divide by 4 is not the correct way to determine a leap year.
Here is a way to test for a leap year:
The year can be evenly divided by 4;
If the year can be evenly divided by 100, it is NOT a leap year, unless;
The year is also evenly divisible by 400. Then it is a leap year.
So, 1900 is not a leap year, but 2000 is a leap year.

Determining the quarter that a date falls in when quarters are based on a random start date

Lets say I have a contract that has a start and end date of 2/1/2016 through 1/31/2017
The quarters are determined based on the start date of the contract so it is different then just using normal calendar quarters.
Q1: FEB MAR APR
Q2: MAY JUN JUL
Q3: AUG OCT SEPT
Q4: NOV DEC JAN
With normal calendar quarters I can simply do: (date.Month + 2) / 3;
How can I do it in this case?

Something more general like this?
var quarter = (((checkDate.Year * 12 + checkDate.Month - 1) - (startDate.Year * 12 + startDate.Month - 1)) / 3) % 4 + 1;
Here is an approach that would take the current day of month into account:
using System;
namespace ConsoleApplication1
{
class Contract
{
public DateTime StartDate { get; set; }
public int CurrentQuarter
{
get
{
var now = DateTime.Now.Date;
var month = (now.Year*12 + now.Month - 1) - (StartDate.Year*12 + StartDate.Month - 1);
if (now.Day < StartDate.Day) month--;
var quarter = (month / 3) + 1;
return quarter;
}
}
// ...
}
class Program
{
static void Main()
{
var contract = new Contract { StartDate = new DateTime(2016, 1, 12) };
Console.WriteLine("Current contract quarter is {0}", contract.CurrentQuarter);
}
}
}

You could use the same logic as you had been, just subtract out the starting month of the contract first. Of course, you'll need to account for dates in the next year, also. Those will always be negative if you just subtract months, so you can use a check for negative to indicate it's the next year, and compensate. So, for the example you gave:
var startMonth = 2;
var date = DateTime.Now; //Or whatever date to check
var monthDiff = date.Month - startMonth;
if (monthDiff < 0)
{
monthDiff += 12;
}
var quarter = (monthDiff + 3) / 3;

Try the following:
((date.Month + 10) / 3) % 4;

Getting Week number of year starting from April

I'm currently using this snippet:
private string GetCurrentWeek()
{
// Return a string to be used in the TextBox control on the Main Form
DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo;
int Year = DateTime.Now.Year;
int Month = DateTime.Now.Month;
int Day = DateTime.Now.Day;
DateTime Date1 = new DateTime(Year, Month, Day);
Calendar cal = dfi.Calendar;
return cal.GetWeekOfYear(Date1, dfi.CalendarWeekRule, dfi.FirstDayOfWeek).ToString();
}
To get the current week of the year. Which returns as expected. Though. This is starting from January. Which is doing what the code says. Though, I'm ideally looking for it to start from April. So week 1 would start on the 6th of April and Week 52 would be on April 5th (just like the UK Tax Year). I have sought the internet and google (perhaps using wrong keywords) but I'm unable to discover how to perform this task using C#

I'm assuming you want week 1 to begin on April 6th always, and be 7 days long, rather than having some rule like "Weeks always start on Mondays". Basically this is just a matter of:
Working out which tax year you're in
Finding the start of that tax year
Subtracting that date from the current date
Dividing the result by 7
For example:
DateTime today = DateTime.Today;
int taxYear = today.Month > 4 || today.Month == 4 && today.Day >= 6
? today.Year : today.Year - 1;
DateTime taxYearStart = new DateTime(taxYear, 4, 6);
TimeSpan elapsedTaxYear = today - taxYearStart;
int days = elapsedTaxYear.Days;
int taxYearWeek = (days / 7) + 1;
Of course, you could also use Noda Time:
// Usually inject this, using SystemClock.Instance for production
IClock clock = ...;
// For the UK, use DateTimeZoneProviders.Tzdb["Europe/London"];
DateTimeZone zone = ...;
// This will be simpler in Noda Time 2.0 with ZonedClock
LocalDate today = clock.Now.InZone(zone).LocalDateTime.Date;
int taxYear = today.Month > 4 || today.Month == 4 && today.Day >= 6
? today.Year : today.Year - 1;
LocalDate taxYearStart = new LocalDate(taxYear, 4, 6);
int days = Period.Between(taxYearStart, today, PeriodUnits.Days).Days;
int taxYearWeek = (days / 7) + 1;

How to calculate actual months difference (calendar year not approximation) between two given dates in C#?

Example: given two dates below, finish is always greater than or equal to start
start = 2001 Jan 01
finish = 2002 Mar 15
So from 2001 Jan 01 to the end of 2002 Feb
months = 12 + 2 = 14
For 2002 March
15/30 = 0.5
so grand total is 14.5 months difference.
It's very easy to work out by hand but how do I code it elegantly? At the moment I have the combination of a lot of if else and while loops to achieve what I want but I believe there are simpler solutions out there.
Update: the output needs to be precise (not approximation) for example:
if start 2001 Jan 01 and finish 2001 Apr 16, the output should be 1 + 1 + 1= 3 (for Jan, Feb and Mar) and 16 / 31 = 0.516 month, so the total is 3.516.
Another example would be if I start on 2001 Jul 5 and finish on 2002 Jul 10, the output should be 11 month up to the end of June 2002, and (31-5)/31 = 0.839 and 10/31 = 0.323 months, so the total is 11 + 0.839 + 0.323 = 12.162.
I extended Josh Stodola's code and Hightechrider's code:
public static decimal GetMonthsInRange(this IDateRange thisDateRange)
{
var start = thisDateRange.Start;
var finish = thisDateRange.Finish;
var monthsApart = Math.Abs(12*(start.Year - finish.Year) + start.Month - finish.Month) - 1;
decimal daysInStartMonth = DateTime.DaysInMonth(start.Year, start.Month);
decimal daysInFinishMonth = DateTime.DaysInMonth(finish.Year, finish.Month);
var daysApartInStartMonth = (daysInStartMonth - start.Day + 1)/daysInStartMonth;
var daysApartInFinishMonth = finish.Day/daysInFinishMonth;
return monthsApart + daysApartInStartMonth + daysApartInFinishMonth;
}

I gave an int answer before, and then realized what you asked for a more precise answer. I was tired, so I deleted and went to bed. So much for that, I was unable to fall asleep! For some reason, this question really bugged me, and I had to solve it. So here you go...
static void Main(string[] args)
{
decimal diff;
diff = monthDifference(new DateTime(2001, 1, 1), new DateTime(2002, 3, 15));
Console.WriteLine(diff.ToString("n2")); //14.45
diff = monthDifference(new DateTime(2001, 1, 1), new DateTime(2001, 4, 16));
Console.WriteLine(diff.ToString("n2")); //3.50
diff = monthDifference(new DateTime(2001, 7, 5), new DateTime(2002, 7, 10));
Console.WriteLine(diff.ToString("n2")); //12.16
Console.Read();
}
static decimal monthDifference(DateTime d1, DateTime d2)
{
if (d1 > d2)
{
DateTime hold = d1;
d1 = d2;
d2 = hold;
}
int monthsApart = Math.Abs(12 * (d1.Year-d2.Year) + d1.Month - d2.Month) - 1;
decimal daysInMonth1 = DateTime.DaysInMonth(d1.Year, d1.Month);
decimal daysInMonth2 = DateTime.DaysInMonth(d2.Year, d2.Month);
decimal dayPercentage = ((daysInMonth1 - d1.Day) / daysInMonth1)
+ (d2.Day / daysInMonth2);
return monthsApart + dayPercentage;
}
Now I shall have sweet dreams. Goodnight :)

What you want is probably something close to this ... which pretty much follows your explanation as to how to calculate it:
var startofd1 = d1.AddDays(-d1.Day + 1);
var startOfNextMonthAfterd1 = startofd1.AddMonths(1); // back to start of month and then to next month
int daysInFirstMonth = (startOfNextMonthAfterd1 - startofd1).Days;
double fraction1 = (double)(daysInFirstMonth - (d1.Day - 1)) / daysInFirstMonth; // fractional part of first month remaining
var startofd2 = d2.AddDays(-d2.Day + 1);
var startOfNextMonthAfterd2 = startofd2.AddMonths(1); // back to start of month and then to next month
int daysInFinalMonth = (startOfNextMonthAfterd2 - startofd2).Days;
double fraction2 = (double)(d2.Day - 1) / daysInFinalMonth; // fractional part of last month
// now find whole months in between
int monthsInBetween = (startofd2.Year - startOfNextMonthAfterd1.Year) * 12 + (startofd2.Month - startOfNextMonthAfterd1.Month);
return monthsInBetween + fraction1 + fraction2;
NB This has not been tested very well but it shows how to handle problems like this by finding well known dates at the start of months around the problem values and then working off them.
While loops for date time calculations are always a bad idea: see http://www.zuneboards.com/forums/zune-news/38143-cause-zune-30-leapyear-problem-isolated.html

Depending on how exactly you want your logic to work, this would at least give you a decent approximation:
// 365 days per year + 1 day per leap year = 1461 days every 4 years
// But years divisible by 100 are not leap years
// So 1461 days every 4 years - 1 day per 100th year = 36524 days every 100 years
// 12 months per year = 1200 months every 100 years
const double DaysPerMonth = 36524.0 / 1200.0;
double GetMonthsDifference(DateTime start, DateTime finish)
{
double days = (finish - start).TotalDays;
return days / DaysPerMonth;
}

One way to do this is that you'll see around quite a bit is:
private static int monthDifference(DateTime startDate, DateTime endDate)
{
int monthsApart = 12 * (startDate.Year - endDate.Year) + startDate.Month - endDate.Month;
return Math.Abs(monthsApart);
}
However, you want "partial months" which this doesn't give. But what is the point in comparing apples (January/March/May/July/August/October/December) with oranges (April/June/September/November) or even bananas that are sometimes coconuts (February)?
An alternative is to import Microsoft.VisualBasic and do this:
DateTime FromDate;
DateTime ToDate;
FromDate = DateTime.Parse("2001 Jan 01");
ToDate = DateTime.Parse("2002 Mar 15");
string s = DateAndTime.DateDiff (DateInterval.Month, FromDate,ToDate, FirstDayOfWeek.System, FirstWeekOfYear.System ).ToString();
However again:
The return value for
DateInterval.Month is calculated
purely from the year and month parts
of the arguments
[Source]

Just improved Josh's answer
static decimal monthDifference(DateTime d1, DateTime d2)
{
if (d1 > d2)
{
DateTime hold = d1;
d1 = d2;
d2 = hold;
}
decimal monthsApart = Math.Abs((12 * (d1.Year - d2.Year)) + d2.Month - d1.Month - 1);
decimal daysinStartingMonth = DateTime.DaysInMonth(d1.Year, d1.Month);
monthsApart = monthsApart + (1-((d1.Day - 1) / daysinStartingMonth));
// Replace (d1.Day - 1) with d1.Day incase you DONT want to have both inclusive difference.
decimal daysinEndingMonth = DateTime.DaysInMonth(d2.Year, d2.Month);
monthsApart = monthsApart + (d2.Day / daysinEndingMonth);
return monthsApart;
}

The answer works perfectly and while the terseness of the code makes it very small I had to break everything apart into smaller functions with named variables so that I could really understand what was going on... So, basically I just took Josh Stodola's code and Hightechrider's mentioned in Jeff's comment and made it smaller with comments explaining what was going on and why the calculations were being made, and hopefully this may help someone else:
[Test]
public void Calculate_Total_Months_Difference_Between_Two_Dates()
{
var startDate = DateTime.Parse( "10/8/1996" );
var finishDate = DateTime.Parse( "9/8/2012" ); // this should be now:
int numberOfMonthsBetweenStartAndFinishYears = getNumberOfMonthsBetweenStartAndFinishYears( startDate, finishDate );
int absMonthsApartMinusOne = getAbsMonthsApartMinusOne( startDate, finishDate, numberOfMonthsBetweenStartAndFinishYears );
decimal daysLeftToCompleteStartMonthPercentage = getDaysLeftToCompleteInStartMonthPercentage( startDate );
decimal daysCompletedSoFarInFinishMonthPercentage = getDaysCompletedSoFarInFinishMonthPercentage( finishDate );
// .77 + .26 = 1.04
decimal totalDaysDifferenceInStartAndFinishMonthsPercentage = daysLeftToCompleteStartMonthPercentage + daysCompletedSoFarInFinishMonthPercentage;
// 13 + 1.04 = 14.04 months difference.
decimal totalMonthsDifference = absMonthsApartMinusOne + totalDaysDifferenceInStartAndFinishMonthsPercentage;
//return totalMonths;
}
private static int getNumberOfMonthsBetweenStartAndFinishYears( DateTime startDate, DateTime finishDate )
{
int yearsApart = startDate.Year - finishDate.Year;
const int INT_TotalMonthsInAYear = 12;
// 12 * -1 = -12
int numberOfMonthsBetweenYears = INT_TotalMonthsInAYear * yearsApart;
return numberOfMonthsBetweenYears;
}
private static int getAbsMonthsApartMinusOne( DateTime startDate, DateTime finishDate, int numberOfMonthsBetweenStartAndFinishYears )
{
// This may be negative i.e. 7 - 9 = -2
int numberOfMonthsBetweenStartAndFinishMonths = startDate.Month - finishDate.Month;
// Absolute Value Of Total Months In Years Plus The Simple Months Difference Which May Be Negative So We Use Abs Function
int absDiffInMonths = Math.Abs( numberOfMonthsBetweenStartAndFinishYears + numberOfMonthsBetweenStartAndFinishMonths );
// Subtract one here because we are going to use a perecentage difference based on the number of days left in the start month
// and adding together the number of days that we've made it so far in the finish month.
int absMonthsApartMinusOne = absDiffInMonths - 1;
return absMonthsApartMinusOne;
}
/// <summary>
/// For example for 7/8/2012 there are 24 days left in the month so about .77 percentage of month is left.
/// </summary>
private static decimal getDaysLeftToCompleteInStartMonthPercentage( DateTime startDate )
{
// startDate = "7/8/2012"
// 31
decimal daysInStartMonth = DateTime.DaysInMonth( startDate.Year, startDate.Month );
// 31 - 8 = 23
decimal totalDaysInStartMonthMinusStartDay = daysInStartMonth - startDate.Day;
// add one to mark the day as being completed. 23 + 1 = 24
decimal daysLeftInStartMonth = totalDaysInStartMonthMinusStartDay + 1;
// 24 / 31 = .77 days left to go in the month
decimal daysLeftToCompleteInStartMonthPercentage = daysLeftInStartMonth / daysInStartMonth;
return daysLeftToCompleteInStartMonthPercentage;
}
/// <summary>
/// For example if the finish date were 9/8/2012 we've completed 8 days so far or .24 percent of the month
/// </summary>
private static decimal getDaysCompletedSoFarInFinishMonthPercentage( DateTime finishDate )
{
// for septebmer = 30 days in month.
decimal daysInFinishMonth = DateTime.DaysInMonth( finishDate.Year, finishDate.Month );
// 8 days divided by 30 = .26 days completed so far in finish month.
decimal daysCompletedSoFarInFinishMonthPercentage = finishDate.Day / daysInFinishMonth;
return daysCompletedSoFarInFinishMonthPercentage;
}

This solution calculates whole months and then adds the partial month based on the end of the time period. This way it always calculates full months between the dates' day-of-month and then calculates the partial month based on the number of remaining days.
public decimal getMonthDiff(DateTime date1, DateTime date2) {
// Make parameters agnostic
var earlyDate = (date1 < date2 ? date1 : date2);
var laterDate = (date1 > date2 ? date1 : date2);
// Calculate the change in full months
decimal months = ((laterDate.Year - earlyDate.Year) * 12) + (laterDate.Month - earlyDate.Month) - 1;
// Add partial months based on the later date
if (earlyDate.Day <= laterDate.Day) {
decimal laterMonthDays = DateTime.DaysInMonth(laterDate.Year, laterDate.Month);
decimal laterPartialMonth = ((laterDate.Day - earlyDate.Day) / laterMonthDays);
months += laterPartialMonth + 1;
} else {
var laterLastMonth = laterDate.AddMonths(-1);
decimal laterLastMonthDays = DateTime.DaysInMonth(laterLastMonth.Year, laterLastMonth.Month);
decimal laterPartialMonth = ((laterLastMonthDays - earlyDate.Day + laterDate.Day) / laterLastMonthDays);
months += laterPartialMonth;
}
return months;
}

The calculation below is one that is according the way the Dutch Tax Authority wants months calculated. This means that when the starts day is for example feb 22, march 23 should be result in something above 1 and not just something like 0.98.
private decimal GetMonthDiffBetter(DateTime date1, DateTime date2)
{
DateTime start = date1 < date2 ? date1 : date2;
DateTime end = date1 < date2 ? date2 : date1;
int totalYearMonths = (end.Year - start.Year) * 12;
int restMonths = end.Month - start.Month;
int totalMonths = totalYearMonths + restMonths;
decimal monthPart = (decimal)end.Day / (decimal)start.Day;
return totalMonths - 1 + monthPart;
}`

This should get you where you need to go:
DateTime start = new DateTime(2001, 1, 1);
DateTime finish = new DateTime(2002, 3, 15);
double diff = (finish - start).TotalDays / 30;

the framework as a TimeSpan object that is a result of subtracting two dates.
the subtraction is already considering the various option of February(28/29 days a month) so in my opinion this is the best practice
after you got it you can format it the way you like best
DateTime dates1 = new DateTime(2010, 1, 1);
DateTime dates2 = new DateTime(2010, 3, 15);
var span = dates1.Subtract(dates2);
span.ToString("your format here");

private Double GetTotalMonths(DateTime future, DateTime past)
{
Double totalMonths = 0.0;
while ((future - past).TotalDays > 28 )
{
past = past.AddMonths(1);
totalMonths += 1;
}
var daysInCurrent = DateTime.DaysInMonth(future.Year, future.Month);
var remaining = future.Day - past.Day;
totalMonths += ((Double)remaining / (Double)daysInCurrent);
return totalMonths;
}

Determine if it has been 6 months since birthday in c#

My application needs to adjust a clients current age by +0.5 if it has been 6 months since their last birthday.
The code should look something like this, but how many ticks would there be in 6 months?
if (DateTime.Today - dateOfBirth.Date > new TimeSpan(6))
{
adjust = 0.5M;
}
else
{
adjust = 0M;
}
Thanks in advance

EDIT: You know what, actually? Since clearly what you really need is just to display the user's age to within 6 months, this is what you should really do.
static decimal GetApproximateAge(DateTime dateOfBirth) {
TimeSpan age = DateTime.Now - dateOfBirth;
/* a note on the line below:
* treating 182.5 days as equivalent to 6 months,
* reasoning that this will provide acceptable accuracy
* for ages below ~360 years
*
* (result will be 1 day off for roughly every 4 years;
* for a calculation of half-years to be inaccurate
* would take 4 [years] * ~90 [days] = ~360)
*/
// get age in units of 6 months
// desired behavior is not to add 0.5 until
// a full six months have elapsed since the user's last birthday --
// using Math.Floor to ensure this
double approxAgeInHalfYears = Math.Floor(age.TotalDays / 182.5);
// now convert this to years
// did it this way to restrict age to increments of 0.5
double approxAgeInYears = approxAgeInHalfYears * 0.5;
return Convert.ToDecimal(approxAgeInYears);
}
The above code includes a big comment explaining its own shortcomings, helpfully pointed out by David.
Now, here's yet another option. It's kind of ugly because it uses a loop; but it's also more rock-solid since it utilizes the DateTime.AddMonths method, which has the advantage of having already been tested and documented by Microsoft.
static decimal GetApproximateAge(DateTime dateOfBirth) {
DateTime now = DateTime.Now;
int birthYear = dateOfBirth.Year;
int lastYear = now.Year - 1;
// obviously, if the user's alive, he/she had a birthday last year;
// therefore he/she is at least this old
int minimumAgeInYears = lastYear - birthYear;
// now the question is: how much time has passed since then?
double actualAgeInYears = (double)minimumAgeInYears;
// for every six months that have elapsed since the user's birthday
// LAST year, add 0.5 to his/her age
DateTime birthDateLastYear = new DateTime(lastYear, 1, 1)
.AddDays(dateOfBirth.DayOfYear);
DateTime comparisonDate = birthDateLastYear
.AddMonths(6);
while (comparisonDate < now) {
actualAgeInYears += 0.5;
comparisonDate = comparisonDate.AddMonths(6);
}
return Convert.ToDecimal(actualAgeInYears);
}
This idea that people have been suggesting of checking dateOfBirth.AddMonths(6) is wrong. Since dateOfBirth is a DateTime, it represents the user's birth date, not their birth day.
What you want to check is if six months have elapsed since the user's last birthday--not the date they were born. Here's one way to do that:
DateTime lastBirthDay = GetLastBirthday(dateOfBirth);
if (DateTime.Today > lastBirthDay.AddMonths(6))
{
adjust = 0.5M;
}
else
{
adjust = 0M;
}
DateTime GetLastBirthday(DateTime dateOfBirth)
{
int currentYear = DateTime.Now.Year;
int birthMonth = dateOfBirth.Month;
int birthDay = dateOfBirth.Day;
// if user was born on Feb 29 and this year is NOT a leap year,
// we'll say the user's birthday this year falls on Feb 28
if (birthMonth == 2 && birthDay == 29 && !IsLeapYear(currentYear))
birthDay = 28;
DateTime birthdayThisYear = new DateTime(
currentYear,
birthMonth,
birthDay
);
if (DateTime.Today > birthdayThisYear)
return birthdayThisYear;
else
return birthdayThisYear.AddYears(-1);
}
bool IsLeapYear(int year) {
return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

Why not if (dateOfBirth.Date.AddMonths(6) < DateTime.Today) instead?

long ticks = new DateTime(0).AddMonths(6).Ticks;
TimeSpan ts = new TimeSpan(ticks);

if (dateOfBirth.Date.AddMonths(6) < DateTime.Today)
{
age += 0.5;
}

I think you might be overcomplicating things:
DateTime displayDate = User.BirthDate; // User.BirthDate is a mock for however you get the birth date
if(DateTime.Now.AddMonths(-6) > displayDate)
{
// More than 6 Months have passed, so perform your logic to add .5 years
}

Something like this?
if (DateTime.Now.AddMonths(-6) > dateofBirth.Date)
{
dateOfBirth = dateOfBirth.AddMonths(6);
}

I think you actually want to know if it is half a year since their last birthday not six months (since months vary in length).
int daysDiff = DateTime.Now.DayOfYear - dayofBirth.DayOfYear;
if (daysDiff <0) daysDiff += 365;
double adjust = daysDiff > 365/2 ? 0.5 : 0.0;

DateTime today = DateTime.Today;
DateTime lastBirthday = dateOfBirth.Date.AddYears(today.Year - dateOfBirth.Year);
if (lastBirthday > today) lastBirthday = lastBirthday.AddYears(-1);
if (today > lastBirthday.AddMonths(6))
adjust = 0.5M;
else
adjust = 0M;