If you want to capture the return event, you'll have to submit the original request yourself over AJAX.  Which means JavaScript will have to be ultimately responsible for downloading the file, instead of the browser via the [`Content-Disposition: attachment` header][3].

In your controller, instead of returning a `FileActionResult`, you can [convert the file into a Base64String][4] and return that like this:




    Byte[] bytes = File.ReadAllBytes("path");

    if (Request.IsAjaxRequest())
    {
        var file64 = Convert.ToBase64String(bytes);
        return Json( new {File = file64, MimeType = mimeType, FileName = fileName});
    }
    else
    {
        // return file - should just auto download
        return File(bytes, mimeType, fileName);
    }

Then in your AJAX handler, you can [use HTML5/Javascript to generate and save a file][5] using [base64 encoding][6] like this:



    $(":submit").on("click", function(e) {
        e.preventDefault();
        var $form = $(this).closest('form');

        // disable buttons
        var $btns = $(":submit").addClass("disabled");
        
        $.ajax({
            type: $form.attr("method"),
            url: $form.attr("action"),
            data: $form.serializeArray(),
            success: function (data) {

                var pom = document.createElement('a');
                pom.setAttribute('href', 'data:' + data.MimeType + ';base64,' + data.File);
                pom.setAttribute('download', data.FileName);

                if (document.createEvent) {
                    var event = document.createEvent('MouseEvents');
                    event.initEvent('click', true, true);
                    pom.dispatchEvent(event);
                }
                else {
                    pom.click();
                }

                // reset buttons
                $btns.removeClass("disabled");
            },
            error: function (jqXHR, textStatus, errorThrown) {
                console.log(jqXHR);
            }
        });
    });

### IE / Edge Support

For [IE /Edge][9], you'll need to use [`window.navigator.msSaveBlob`][7]. If you're sending back a base64 string, you'll also need to [Creating a Blob from a base64 string in JavaScript][8]

**Further Reading**:

* [Returning a file to View/Download in ASP.NET MVC][1]
* [ASP.NET MVC Controller FileContent ActionResult called via AJAX][2]

[1]: https://stackoverflow.com/q/5826649/1366033
[2]: https://stackoverflow.com/q/2240869/1366033
[3]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
[4]: https://stackoverflow.com/a/25919641/1366033
[5]: https://stackoverflow.com/a/18197511/1366033
[6]: https://stackoverflow.com/q/16996319/1366033
[7]: https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/samples/hh779016(v=vs.85)
[8]: https://stackoverflow.com/q/16245767/1366033
[9]: https://stackoverflow.com/q/48754185/1366033

In my controller I have an `ActionResult` which returns a File.



 

    [HttpPost]
    public ActionResult ExportCSV(ReportResultViewModel model)   
    {     
        var content = "hello,world";
        return File(Encoding.UTF8.GetBytes(content),"text/csv","export.csv");
    }


In my view, when I post to this ActionResult, I display a modal saying "please wait".


    
    
    <div class="modal fade" id="pleaseWaitDialog" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
        <div class="modal-dialog">
            <div class="modal-content" style="background: #EBF3EB;">
                <div class="modal-header">
                    <h1>Please wait...</h1>
                </div>
                <div class="modal-body">
                    <div id="loader"></div>
                </div>
           </div>
        </div>
    </div>
    @using (Html.BeginForm("ExportCSV", "Reporting", FormMethod.Post, new { name = "back", id = "back", style = "width:100%" }))
    {
         @Html.HiddenFor(m => m.A)
         @Html.HiddenFor(m => m.LOT)
         @Html.HiddenFor(m => m.OF)
         @Html.HiddenFor(m => m.THINGS)
                                
         <input type="submit" data-toggle="modal" data-target="#pleaseWaitDialog" value="Export CSV" style="width: 100%; background: #fff" class="btn btn-default"  />
    }

I want to hide it when the file is finally returned to the page.

Is there a way to detect client side (with JavaScript maybe) when the file arrives so I can hide the modal?

Handling ASP.NET MVC FileResult returned


The long answer is 'yes'!

Full credit to Raymond Chen's article [**Combining two files into one while preserving line history**][1]:

Imagine you had two files: `fruits` & `veggies`

[![git blame for both fruits and veggies][2]][2]

> The naïve way of combining the files would be to do it in a single commit, but you'll lose line history on one of the files (or both)
>
> You could tweak the `git blame` algorithms with options like `-M` and `-C` to get it to try harder, but in practice, you don’t often have control over those options (eg. the git blame may be performed on a server)
>
> ### The trick is to use a `merge` with two forked branches
>
> * In one branch, we rename `veggies` to `produce`.
> * In the other branch, we rename `fruits` to `produce`.
>
>```bash
>git checkout -b rename-veggies
>git mv veggies produce
>git commit -m "rename veggies to produce"
>```
>
>```bash
>git checkout -
>git mv fruits produce
>git commit -m "rename fruits to produce"
>```
>
> Then merge the first into the second
>
>```bash
>git merge -m "combine fruits and veggies" rename-veggies
>```
>
>This will generate a merge conflict - that's okay - now take the changes from each branch's Produce file and combine into one - here's a simple concatenation (but resolve the merge conflict however you please):
>
>```bash
>cat "produce~HEAD" "produce~rename-veggies" >produce
>git add produce
>git merge --continue
>```
>
> ***The resulting `produce` file was created by a merge, so git knows to look in both parents of the merge to learn what happened.***  
>
> [![git blame for produce][3]][3]
>
> And that’s where it sees that each parent contributed half of the file, and it also sees that the files in each branch were themselves created via renames of other files, so it can chase the history back into both of the original files.
>
> Each line should be correctly attributed to the person who introduced it in the original file, whether it’s fruits or veggies. People investigating the produce file get a more accurate history of who last touched each line of the file.
>
> For best results, your rename commit should be a pure rename. Resist the temptation to edit the file’s contents at the same time you rename it. A pure rename ensure that git’s rename detection will find the match. If you edit the file in the same commit as the rename, then whether the rename is detected as such will depend on git’s “similar files” heuristic.

Checkout [the full article][1] for a full step by step breakdown and more explanations

---

Originally, I had thought this might be [a use case][4] for [`git merge-file`][5] doing something like this:

```bash
>produce echo #empty
git merge-file fruits produce veggies --union -p > produce
git rm fruits veggies
git add produce
git commit -m "combine fruits and veggies"
```

However, all this does is help simulate the merge diffing algorithm against two different files - the end output when committed is identical to if the file had been updated manually and the resulting changes manually committed


  [1]: https://devblogs.microsoft.com/oldnewthing/20190514-00/?p=102493
  [2]: https://i.stack.imgur.com/sIiBQ.png
  [3]: https://i.stack.imgur.com/idgVB.png
  [4]: https://stackoverflow.com/q/9862173/1366033
  [5]: http://schacon.github.io/git/git-merge-file.html

Imagine that you have two files in a git repository, say `A.txt` and `B.txt`.

Is it possible to concat the two files into a third one `A+B.txt`, removing the original `A.txt` and `B.txt` and committing it all, so the history is still preserved? 

That is, if I asked `git log --follow A+B.txt` I would know that the content originated from the `A.txt` and `B.txt` files?

I've tried to separate the files into two different branches and then merging them into a new file (while removing the old ones), but to no avail.