Re-Evaluate value of constant FieldExpression on each invoke

If i follow your example correctly, your Refresh method doesn't seem to update the values - it picks whatever expression you assigned to it and reevaluates it over and over.

So what it seems you are missing is the actual update to fromDate, toDate in your timerCallback. I assume you have reasons to use an expression there, but if not - a simple delegate might actually do the job with a bit less code (and performance penalty):

public class Item
{
    public Func<DateTime, DateTime, object> callbackFunc { get; set; } // to illustrate alternative point
    public Expression<Func<object>> callback { get; set; }

    public void Refresh()
    {
        Refresh(callback);
    }

    public void RefreshFunc(DateTime fromDate, DateTime toDate) // alternative execution path - see timerCallback()
    {
        callbackFunc(fromDate, toDate);
    }
    

    public void Refresh(Expression<Func<object>> callback)
    {
        //your code with no change where
    }
}

class Program
{
    public static object PrintDateTimes(DateTime fromDate, DateTime toDate)
    {
        Console.WriteLine($"PrintDateTimes:\t{fromDate.ToLongTimeString()} - {toDate.ToLongTimeString()} :: {Program.StartDateTimeString}");
        return 0;
    }

    public static string StartDateTimeString;
    private static Timer timer;

    public static void Main()
    {
        DateTime now = DateTime.Now;
        DateTime fromDate = now.AddHours(-0.5);
        DateTime toDate = now.AddHours(1);

        Program.StartDateTimeString = now.ToLongTimeString();

        Item item = new Item();

        // this is important
        AssignCallback(fromDate, toDate, item);

        timer = new Timer(timerCallback, item, Timeout.Infinite, Timeout.Infinite);

        timer.Change(0, Timeout.Infinite);
        while (true) ;
    }

    public static void AssignCallback(DateTime fromDate, DateTime toDate, Item item)
    {
        item.callback = () => Program.PrintDateTimes(fromDate, toDate);
    }
    private static void timerCallback(object state)
    {
        Item i = state as Item;
        // update the dates
        DateTime now = DateTime.Now;
        DateTime fromDate = now.AddHours(-0.5);
        DateTime toDate = now.AddHours(1);
        // call refresh delegate - you proably don't even need to wrap it in a method: i.callbackFunc(toDate, fromDate)
        i.RefreshFunc(fromDate, toDate);

        // or use your old method, but update the expression so it gets new values
        //AssignCallback(fromDate, toDate, i); // i'm not sure if you can do this in your actual code, but this basically reassigns the expression so it works
        //i.Refresh();

        Console.WriteLine("Refresh at:\t" + now.ToLongTimeString());

        timer.Change(TimeSpan.FromSeconds(3), Timeout.InfiniteTimeSpan);
    }
}

Here

public static void AssignCallback(DateTime fromDate, DateTime toDate, Item item)
{
    item.callback = () => Program.PrintDateTimes(fromDate, toDate);
}

Local variables are captured inside lambda, which means they are promoted by compiler to fields of some compiler-generated class. That's why you have FieldExpression, and it's not constant. However, you do not update those (field-promoted) variables fromDate and toDate anywhere, so their value stays constant between executions indeed.

If you remove AssignCallback and do the same directly inside main:

item.callback = () => Program.PrintDateTimes(fromDate, toDate);

Then it's still FieldExpression, but you can update fromDate and toDate, and this change will be reflected. For example:

while (true) {
    Console.ReadKey();
    fromDate = DateTime.Now.AddHours(-0.5);
    toDate = DateTime.Now.AddHours(1);
}

Then each time you press the button in console - local (captured) variables will be updated, and next invocation of your callback will reflect that.

There is no other way to "refresh" those dates if you pass them directly as DateTime. You cannot know it was initialized as DateTime.Now.AddHours(-0.5), all you have is (already calculated) DateTime value. In your case it's better to make it explicit that your callback expects not DateTime value, but a way to get such value. For example:

public static void AssignCallback(Func<DateTime> fromDate, Func<DateTime> toDate, Item item) {
    item.callback = () => Program.PrintDateTimes(fromDate(), toDate());
}

And then:

public static void Main() {
    Func<DateTime> fromDate = () => DateTime.Now.AddHours(-0.5);
    Func<DateTime> toDate = () => DateTime.Now.AddHours(1);

    Program.StartDateTimeString = DateTime.Now.ToLongTimeString();

    Item item = new Item();

    // this is important
    AssignCallback(fromDate, toDate, item);

    timer = new Timer(timerCallback, item, Timeout.Infinite, Timeout.Infinite);

    timer.Change(0, Timeout.Infinite);
    Console.ReadKey();
}

Then it's quite clear what's going on at least.