Normalizing `DateTime` values to strings

TimeSpan.FromMinutes(1) and TimeSpan.FromHours(1) are much easier to read than new TimeSpan(0, 1, 0) and new TimeSpan(1, 0, 0).

Consider using multiple return statements, instead of just the one.

Stick to the naming conventions: change the parameter DateTime to dateTime, and the variable TimeDifference to timeDifference.

It's a good idea to document that this is relative to UTC time, otherwise users might get strange behaviour like this:

var twoHoursAgo = DateTime.Now.AddHours(-2);
Console.WriteLine(twoHoursAgo.ToNormalizedString());

Just now

Your method has so many parameters that I'd consider replacing them by properties and create a NormalizationParameters class for it, what if you just wanted to change one of them? You'd need to set all the others to the left first. see @RobH's comment

class NormalizationParameters
{
    public DateTime? Reference { get; set; }
    public string DateFormat { get; set; } = "MMM d, yyyy";
    public string TimeFormat { get; set; } = "h:mm tt";
    public string PreDateString { get; set; } = "";
    public string PreTimeString { get; set; } = "at";
    public bool CapitalizeModifiers { get; set; } = true;
}

public static string ToNormalizedString(this DateTime value, Action<NormlizeParameters> setParameters = null)
{
    var parameters = new NormalizationParameters();
    setParameters?.Invoke(parameters);
}

DateTime.Now.ToNormalizedString(p => { p.dateFormat = "abc"; p.timeFormat = "abc" });

Wouldn't it be far easier to use a function that capitalizes the first letter of a sentence instead of always having that conditional operator (?:)?

static string UppercaseFirst(string s)
{
    if (string.IsNullOrEmpty(s))
    {
        return string.Empty;
    }
    return char.ToUpper(s[0]) + s.Substring(1);
}

Don't use "", instead use string.Empty. Even better: use string.Format() instead of concatenating strings.

preDateString and preTimeString aren't good names, not in the least because they contain the word "String". Wouldn't datePrefix and timePrefix be better?

You could capitalize only at the end of your method, assuming that it'll always be the first char that'd capitalized.

Then, you could use string interpolation for more readability.

You have 2 variables that start with a capital letter, that's not good according to naming conventions.

Your check about the reference can be simplified alot using ?? operator since Nullable<T> can be casted to T if T != null.

DateTime referenceDateTime = reference ?? DateTime.UtcNow;

Overall, this gives us something like this :

public static string ToNormalizedString(DateTime dateTime, DateTime? reference = null, string dateFormat = "MMM d, yyyy", string timeFormat = "h:mm tt", string preDateString = "", string preTimeString = "at", bool capitalizeModifiers = true)
{
    string result = String.Empty;

    DateTime referenceDateTime = reference ?? DateTime.UtcNow;

    if (dateTime.Date == referenceDateTime.Date)
    {
        TimeSpan timeDifference = referenceDateTime - dateTime;

        if (timeDifference < new TimeSpan(0, 1, 0))
        {
            result = "just now";
        }
        else if (timeDifference < new TimeSpan(0, 2, 0))
        {
            result = "about a minute ago";
        }
        else if (timeDifference < new TimeSpan(1, 0, 0))
        {
            result = $"about {Math.Ceiling(timeDifference.TotalMinutes)} minutes ago";
        }
        else
        {
            result = $"about {Math.Ceiling(timeDifference.TotalHours)} hours ago";
        }
    }
    else if (dateTime.Date.AddDays(1) == referenceDateTime.Date)
    {
        result = $"yesterday at {dateTime.ToString(timeFormat)}";
    }
    else if (dateTime.Date.AddDays(7) > referenceDateTime.Date)
    {
        //Use of String interpolation is questionable here.
        result = preDateString + dateTime.DayOfWeek + (timeFormat == "" ? "" : " " + preTimeString + " " + dateTime.ToString(timeFormat));
    }
    else
    {
        //Use of String interpolation is questionable here.
        result = preDateString + dateTime.ToString(dateFormat) + (timeFormat == "" ? "" : " " + preTimeString + " " + dateTime.ToString(timeFormat));
    }

    if (capitalizeModifiers)
    {
        StringBuilder sb = new StringBuilder(result);
        sb[0] = Char.ToUpper(sb[0]);
        result = sb.ToString();
    }

    return result;
}

Now, let's get funky. I don't know if this'll suit you, but you could make a kind of dictionary to match your conditions with the corresponding text. Which gives us something like that :

public static string ToNormalizedString2(DateTime dateTime, DateTime? reference = null, string dateFormat = "MMM d, yyyy", string timeFormat = "h:mm tt", string preDateString = "", string preTimeString = "at", bool capitalizeModifiers = true)
{
    string result = String.Empty;

    DateTime referenceDateTime = reference ?? DateTime.UtcNow;

    //Note that it should be initialized only once for performance, thanks @Caleth
    List<Tuple<Func<bool>, string>> conditionWithMatchingString = new List<Tuple<Func<bool>, string>>()
    {
        new Tuple<Func<bool>, string>(() => dateTime.Date == referenceDateTime.Date && (referenceDateTime - dateTime) < new TimeSpan(0, 1, 0), "just now"),
        new Tuple<Func<bool>, string>(() => dateTime.Date == referenceDateTime.Date && (referenceDateTime - dateTime) < new TimeSpan(0, 2, 0), "about a minute ago"),
        new Tuple<Func<bool>, string>(() => dateTime.Date == referenceDateTime.Date && (referenceDateTime - dateTime) < new TimeSpan(1, 0, 0), $"about {Math.Ceiling((referenceDateTime - dateTime).TotalMinutes)} minutes ago")
        //etc
    };

    foreach (Tuple<Func<bool>, string> tuple in conditionWithMatchingString)
    {
        if (tuple.Item1())
        {
            result = tuple.Item2;
            break;
        }
    }

    if (capitalizeModifiers)
    {
        StringBuilder sb = new StringBuilder(result);
        sb[0] = Char.ToUpper(sb[0]);
        result = sb.ToString();
    }

    return result;
}

I'll be 100% honest, I'm not sure this solution is better, since the tuple initialization can be long on a single line. But maybe this can guide you to a better idea!

There are things I didn't talk about because other answers did explain it very well.