How to verify same creation time in C# after copy file from source to target

Question

How to verify same creation time in C# after copy file from source to target

Pip 265

Hi,

I'm using C# in .NET 10.

1.How to write a function VerifySameCreationTime that verify verify same creation time in C#, as results of input file that pass operation of copy to output path.

2.In this case the creation time is change but modified time not change , why ?

3.This what Chat GPT suggest, is it ok? I need tolerance? if yes how i know how much?

Thanks,

  var inputCreation = File.GetCreationTimeUtc(inputPath);
  var outputCreation = File.GetCreationTimeUtc(outputPath);

  logger?.Debug($"VerifySameCreationTime: InputCreationUtc={inputCreation:o}, OutputCreationUtc={outputCreation:o}");

  // Allow a small tolerance to account for filesystem timestamp resolution and clock skew
  var tolerance = TimeSpan.FromSeconds(2);
  var outputIsNewer = outputCreation - inputCreation > tolerance;

RLWA32 52,256 Reputation points

2026-02-19T20:55:36.85+00:00

@Pip, If you want the file creation time of the output from your copy operation to be identical to that of the input file you could use File.SetCreationTimeUTC to set it yourself after the copy operation has completed.

Answer accepted by question author

0 additional answers

Your answer

RLWA32 52,256 Reputation points

2026-02-19T20:55:36.85+00:00

@Pip, If you want the file creation time of the output from your copy operation to be identical to that of the input file you could use File.SetCreationTimeUTC to set it yourself after the copy operation has completed.

Answer 1

Marcin Policht 81,705 MVP Volunteer Moderator

When you copy a file, the behavior of creation and modified timestamps depends on the API used and the underlying file system. On Windows NTFS, when you copy a file using typical APIs like File.Copy, the new file gets a new creation time (the moment the copy is created), but the last write time (modified time) is usually preserved from the source file. That is why you see the creation time change but the modified time remain the same. Creation time represents when that specific file entry was created in that filesystem location, not when the content was originally created.

If your goal is to verify that the copy operation preserved the original creation time, you need to be aware that File.Copy does not guarantee preservation of creation time. If you require it to match, you must explicitly set it after copying:

File.Copy(inputPath, outputPath, overwrite: true);

var inputCreation = File.GetCreationTimeUtc(inputPath);
File.SetCreationTimeUtc(outputPath, inputCreation);

To implement a function VerifySameCreationTime, you should compare the UTC timestamps and optionally allow a tolerance to account for filesystem timestamp resolution differences. Different filesystems have different timestamp precision. NTFS supports 100-nanosecond resolution, but other filesystems (for example FAT) have 2-second resolution for certain timestamps. Network shares and cross-platform copies can also introduce truncation.

One potential implementation would be:

public static bool VerifySameCreationTime(string inputPath, string outputPath, TimeSpan? tolerance = null)
{
    var inputCreation = File.GetCreationTimeUtc(inputPath);
    var outputCreation = File.GetCreationTimeUtc(outputPath);

    var allowedDrift = tolerance ?? TimeSpan.Zero;

    return Math.Abs((outputCreation - inputCreation).Ticks) <= allowedDrift.Ticks;
}

Whether you need tolerance depends on your environment. If both files are on NTFS on the same machine and you explicitly set the creation time, you usually do not need tolerance. If files may reside on FAT, SMB shares, Linux filesystems, or cloud-mounted storage, you should allow tolerance.

How much tolerance to use depends on the lowest precision filesystem you expect. If FAT is involved, up to 2 seconds is reasonable. If only NTFS is involved, you can often use zero or a very small tolerance like a few milliseconds. If you do not control the storage backend, I'd consider 1–2 seconds to be a pragmatic safe value.

The snippet ChatGPT suggested:

var tolerance = TimeSpan.FromSeconds(2);
var outputIsNewer = outputCreation - inputCreation > tolerance;

is not sufficient to verify “same creation time” because it only checks whether the output is significantly newer. It does not check the absolute difference in both directions.

If the above response helps answer your question, remember to "Accept Answer" so that others in the community facing similar issues can easily find the solution. Your contribution is highly appreciated.

hth

Marcin

Pip 265 Reputation points

2026-02-19T21:48:13.5333333+00:00

Hi Marcin,

If I need to check that the files have different time of creation (VerifyDifferentCreationTime), how does your implementation change,

do need a tolerance?

The copy operation done in NuGet package inside that I used.

I give input file path and out file path

Thank in advance,
Marcin Policht 81,705 Reputation points MVP Volunteer Moderator

2026-02-20T12:10:26.25+00:00
If you need to verify that the files have different creation times, you should still think in terms of tolerance, but invert the logic. Instead of checking whether the absolute difference is less than or equal to tolerance, you check whether it is greater than tolerance.

You generally still need tolerance for the same reasons as before. Filesystem timestamp precision, truncation, network shares, or cross-platform behavior can cause small differences even when times are logically “the same”. Without tolerance you risk false positives where two effectively identical timestamps differ by a few milliseconds or by rounding.

One possible implementation would look like this:

public static bool VerifyDifferentCreationTime( string inputPath, string outputPath, TimeSpan? tolerance = null) { var inputCreation = File.GetCreationTimeUtc(inputPath); var outputCreation = File.GetCreationTimeUtc(outputPath); var allowedDrift = tolerance ?? TimeSpan.Zero; return Math.Abs((outputCreation - inputCreation).Ticks) > allowedDrift.Ticks; }

If you are copying on NTFS on the same machine and you are not manually setting creation time after copy, then the creation times should be different, and you could use TimeSpan.Zero. If the NuGet package performs additional operations such as copying metadata, using platform APIs that preserve timestamps, or if the copy happens across filesystems, using a small tolerance like one or two seconds is likely safer.

If the above response helps answer your question, remember to "Accept Answer" so that others in the community facing similar issues can easily find the solution. Your contribution is highly appreciated.

hth

Marcin
Pip 265 Reputation points

2026-02-20T20:42:12.72+00:00

Hi Marcin,

I do not make the copy, the NuGet do the copy operation.

1.So, in this case , no ,matter if my computer is NTFS, FAT, or SMB shares ,

I need to use a small tolerance like one or two seconds is likely safer ?

2,Why in NTFS , no tolerance needed ,but on FAT, or SMB shares is needed ?

3.How do you know to measure the tolerance ?

Thanks in advance,
Marcin Policht 81,705 Reputation points MVP Volunteer Moderator

2026-02-21T00:39:42.8033333+00:00

Yep - using a small tolerance such as one or two seconds is likely the safer choice. It protects you from filesystem precision differences and metadata normalization that may occur during the copy.

On NTFS, timestamps are stored with 100-nanosecond resolution, and Windows APIs preserve that precision. If both files are on the same NTFS volume and no cross-system translation happens, timestamps can match exactly, so no tolerance is typically required. On FAT, creation and write times have coarse resolution, in the range of a couple of seconds. SMB shares and other network or cross-platform filesystems may truncate or round timestamps to their own precision, so a value like 12:00:00.900 may become 12:00:00 or 12:00:02, creating small differences even when logically equal.

You determine tolerance based on the lowest timestamp resolution in the path between source and destination. If FAT may be involved, 2 seconds is a safe upper bound. If only NTFS locally, zero or a few milliseconds is enough. If unsure, 1–2 seconds is a pragmatic approach (rather than something you dynamically measure).

If the above response helps answer your question, remember to "Accept Answer" so that others in the community facing similar issues can easily find the solution. Your contribution is highly appreciated.

hth

Marcin
Pip 265 Reputation points

2026-02-21T10:23:53.5866667+00:00

I used 1 second is a pragmatic approach (rather than something you dynamically measure).

Thank you vey much on elaboration in this issue.

Share via

How to verify same creation time in C# after copy file from source to target

0 additional answers

Your answer