Q:

Performant way to clear excessive old data in a text file

I have some text files that I need to be able to write to on the fly, and quite often. These files can get pretty big in size, but the text inside them can be completely different between two iterations.
This means that text can be shorter than it previously was. Which, if i wouldn't clear the old data first, would end up in a mix of the old data being appended at the end of my new data. As indicated by the MSDN docs.

If you overwrite a longer string (such as "This is a test of the OpenWrite method") with a shorter string (such as "Second run"), the file will contain a mix of the strings ("Second runtest of the OpenWrite method").

However the docs do not specify a way to remedy or even prevent this from happening.
Currently i'm doing the following:
File.WriteAllText(path, string.Empty);
using (Stream file = File.OpenWrite(path))
{
    file.Write(dataToWrite, 0, dataToWrite.Length);
}

Where i empty the contents of the existing file using File.WriteAllText(path, string.Empty) and then write the new contents to the file. 
However it feels like a waste to have to go over the entire file twice (First to clear it, and then to write the new data to it).
Is there a way where i can overwrite the old data with my new data, and only go over the "left over" data and clear that, without going over the entire file twice? 
It doesn't necessarily have to use Stream.Write. Any alternative that gets the job done and is faster is acceptable.

Results
After running 100.000 iterations of writing 2441 kb of data (and clearing all old data) 5 times on different machines, the following results came out:

My original method found above took 4.75589 ms on average.
Anderson Pimentel's answer using WriteAllBytes took 4.28946 ms on average.
fastest Dark Falcon's answer using file.Write and truncating took 4.14433 ms on average (and is the fastest/most consistent with this).
File.Delete the old file and creating a new file using FileStream.Write took 5.31883 ms on average.
MeJustAndrew's answer doing the above but multithreaded took 8.12726 ms on average. (Though i have to admit this could very well be because of poor implementation by me, I am in no way very experienced in multi threading)

note that these results apply to my implementation and hardware. Results may vary on different hardware. 

A:

I would recommend truncating the file:
using (FileStream file = File.OpenWrite(path))
{
    file.Write(dataToWrite, 0, dataToWrite.Length);
    file.SetLength(dataToWrite.Length);
}

You should test whether this performs better than writing a new file, deleting the old file, and renaming the new file to the old name.

