Read file while updating progress bar with coroutines

I'm trying to read a file line by line while I update a progress bar (two GUI textures with a float expansion in one of its width (maxWidth * currentPercentage)).

I have two implementations:

     public static string ThreadedFileRead(string path, Action<float> percAction)
     {
         FileInfo fileInfo = new FileInfo(path);
         StringBuilder sb = new StringBuilder();

         float length = fileInfo.Length;
         int currentLength = 0;

         using (StreamReader sr = new StreamReader(path))
         {
             while (!sr.EndOfStream)
             {
                 string str = sr.ReadLine();
                 sb.AppendLine(str);

                 // yield return str;

                 percAction(currentLength / length);
                 currentLength += str.Length;
                 Interlocked.Add(ref currentLength, str.Length);
             }

             percAction(1f);

             return sb.ToString();
         }
     }

Using the following implementation:

   // Inside a MonoBehaviour

   public void Start() 
   {
        string fileContents = "";
        StartCoroutine(LoadFileAsync(Application.dataPath + "/Data/file.txt", (s) => fileContents = s));
   }

   public IEnumerator LoadFileAsync(string path, Action<string> fin) 
   {
         string contents = "";

         lock (contents)
         {
             var task = Task.Factory.StartNew(() =>
             {
                 contents = F.ThreadedFileRead(path, (f) => currentLoadProgress = f);
             });

             while (!task.IsCompleted)
                 yield return new WaitForEndOfFrame();

             fin?.Invoke(contents);
         }
   }

But this blocks the current GUI (I don't know why).

I also used this:

     // Thanks to: https://stackoverflow.com/questions/41296957/wait-while-file-load-in-unity
     // Thanks to: https://stackoverflow.com/a/34378847/3286975
     [MustBeReviewed]
     public static IEnumerator LoadFileAsync(string pathOrUrl, Action<float> updatePerc, Action<string> finishedReading)
     {
         FileInfo fileInfo = new FileInfo(pathOrUrl);

         float length = fileInfo.Length;

         // Application.isEditor && ??? // Must review
         if (Path.IsPathRooted(pathOrUrl))
             pathOrUrl = "file:///" + pathOrUrl;

         /*

         using (var www = new UnityWebRequest(pathOrUrl))
         {
             www.downloadHandler = new DownloadHandlerBuffer();

             CityBenchmarkData.StartBenchmark(CityBenchmark.SendWebRequest);

             yield return www.SendWebRequest();

             CityBenchmarkData.StopBenchmark(CityBenchmark.SendWebRequest);

             while (!www.isDone)
             {
                 // www.downloadProgress
                 updatePerc?.Invoke(www.downloadedBytes / length); // currentLength / length
                 yield return new WaitForEndOfFrame();
             }

             finishedReading?.Invoke(www.downloadHandler.text);
         }

          */

         using (var www = new WWW(pathOrUrl))
         {
             while (!www.isDone)
             {
                 // www.downloadProgress
                 updatePerc?.Invoke(www.bytesDownloaded / length); // currentLength / length
                 yield return new WaitForEndOfFrame();
             }

             finishedReading?.Invoke(www.text);
         }
     }

With the following implementation:

   public IEnumerator LoadFileAsync(string path, Action<string> fin) 
   {
        yield return F.LoadFileAsync(path, (f) => currentLoadProgress = f, fin);
   }

The last code I shared has two parts:

• The commented part blocks also the main thread.

• The WWW class I used (it will be deprecated in a future) doesn't block the main thread, but it only displays two steps on the progress bar (like 25% and 70%).

I don't why this is happening and if there is a better approach for this.

So, any help (guidance) for this is welcome.