Is it reasonable to use Int64 instead of DateTime / TimeSpan in the Domain-level structures?

I have the following simple structure in my solution's domain project (.NET Framework):

public struct Candlestick
{
    public DateTime OpenTime;
    public DateTime CloseTime;
    public double Open;
    public double High;
    public double Low;
    public double Close;
    public double Volume;
}

In my business logic I have many methods that perform time-based search in big lists of Candlestick structures. For example:

public static int IndexOfFirst(this IReadOnlyList<Candlestick> data, DateTime from)
{
    if (data == null)
        throw new ArgumentNullException(nameof(data));

    int count = data.Count;
    if (count == 0) return -1;

    int fromIdx = 0;
    while (data[fromIdx].OpenTime < from)
    {
        if (++fromIdx == count)
        {
            return -1;
        }
    }

    return fromIdx;
}

Would it be generally a good idea to use the long (Int64) type for time variables in the Candlestick struct, so that the logic layer can operate faster with this structure? Also, I mean to keep the corresponding class on the application level (CandlestickVM in the view-model layer) with the time variables of the type DateTime.

To check my idea of using Int64, I ran a simple performance test on dotnetfiddle.net:

DateTime a = new DateTime(2023, 01, 01);
DateTime b = new DateTime(2023, 02, 01);

TimeSpan incr = new TimeSpan(1);
DateTime now = a;
Stopwatch sw = Stopwatch.StartNew();
while (now < b)
{
    now += incr;
}
sw.Stop();
Console.WriteLine($"It took {sw.Elapsed} to run the Date & Time test.");

long incr2 = incr.Ticks;
long now2 = a.Ticks;
long bticks = b.Ticks;
sw.Restart();
while (now2 < bticks)
{
    now2 += incr2;
}
sw.Stop();
Console.WriteLine($"It took {sw.Elapsed} to run the long test.");

The results is as the following:

It took 00:00:04.8027716 to run the Date & Time test.
It took 00:00:00.9261338 to run the long test.

Your code only operations with DateTime are comparisons, while your benchmark does adition. I made a simple benchmark using BenchmarkDtonet with comparisons only and here are the code and results:

[SimpleJob(RuntimeMoniker.Net70)]    
[RPlotExporter]
public class LongXDateTime
{
    [Params(1_000_000)]
    private int N;
    private DateTime[] Da;
    private DateTime[] Db;
    private long[] La;
    private long[] Lb;

    [GlobalSetup]
    public void Setup()
    {
        Da = new DateTime[N];
        Db = new DateTime[N];
        La = new long[N];
        Lb = new long[N];
        for (int i = 0; i < N; i++)
        {
            La[i] = Random.Shared.NextInt64(DateTime.MinValue.Ticks, DateTime.MaxValue.Ticks);
            Lb[i] = Random.Shared.NextInt64(DateTime.MinValue.Ticks, DateTime.MaxValue.Ticks);
            Da[i] = new DateTime(La[i]);
            Db[i] = new DateTime(Lb[i]);
        }
    }

    [Benchmark]
    public bool[] LongMethod()
    {
        bool[] result = new bool[La.Length];
        for(int i = 0; i < La.Length; i++)
        {
            result[i] = La[i] < Lb[i];
        }
        return result;
    }
    [Benchmark]
    public bool[] DateTimeMethod()
    {
        bool[] result = new bool[Da.Length];
        for (int i = 0; i < Da.Length; i++)
        {
            result[i] = Da[i] < Db[i];
        }
        return result;
    }
}

Result:

|         Method |          N |     Mean |     Error |    StdDev |
|--------------- |----------- |---------:|----------:|----------:|
|     LongMethod |    1000000 | 1.460 ms | 0.0253 ms | 0.0370 ms |
| DateTimeMethod |    1000000 | 1.467 ms | 0.0292 ms | 0.0380 ms |

So switching to long:

1. might not be relevant in terms of application performance
2. Is less readable
3. Is less safe, since you lose type safety

Also, recommend reading Eric Lippert Blog about performance