Télécharger un fichier de n'importe quel type dans Asp.Net MVC en utilisant FileResult?

Je me suis fait suggérer d'utiliser FileResult pour permettre aux utilisateurs de télécharger des fichiers depuis mon application Asp.Net MVC. Mais les seuls exemples que je puisse trouver concernent toujours les fichiers image (en spécifiant le type de contenu image / jpeg).

Mais que faire si je ne connais pas le type de fichier? Je veux que les utilisateurs puissent télécharger à peu près n'importe quel fichier à partir de la zone de fichiers de mon site.

J'avais lu une méthode pour le faire (voir un article précédent pour le code), qui fonctionne vraiment bien, sauf pour une chose: le nom du fichier qui apparaît dans la boîte de dialogue Enregistrer sous est concaténé à partir du chemin d'accès au fichier avec des traits de soulignement ( folder_folder_file.ext). De plus, il semble que les gens pensent que je devrais retourner un FileResult au lieu d'utiliser cette classe personnalisée que j'avais trouvée BinaryContentResult.

Quelqu'un connaît-il la "bonne" façon de faire un tel téléchargement dans MVC?

EDIT: J'ai obtenu la réponse (ci-dessous), mais je pensais juste que je devrais publier le code de travail complet si quelqu'un d'autre est intéressé:

public ActionResult Download(string filePath, string fileName)
{
    string fullName = Path.Combine(GetBaseDir(), filePath, fileName);

    byte[] fileBytes = GetFile(fullName);
    return File(
        fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName);
}

byte[] GetFile(string s)
{
    System.IO.FileStream fs = System.IO.File.OpenRead(s);
    byte[] data = new byte[fs.Length];
    int br = fs.Read(data, 0, data.Length);
    if (br != fs.Length)
        throw new System.IO.IOException(s);
    return data;
}

Vous pouvez simplement spécifier le type MIME générique d'octet-stream:

public FileResult Download()
{
    byte[] fileBytes = System.IO.File.ReadAllBytes(@"c:\folder\myfile.ext");
    string fileName = "myfile.ext";
    return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName);
}

Le framework MVC le supporte nativement. Le contrôleur System.Web.MVC.Controller.File fournit des méthodes pour renvoyer un fichier par nom / flux / tableau .

Par exemple, en utilisant un chemin d'accès virtuel au fichier, vous pouvez effectuer les opérations suivantes.

return File(virtualFilePath, System.Net.Mime.MediaTypeNames.Application.Octet,  Path.GetFileName(virtualFilePath));

Si vous utilisez .NET Framework 4.5, vous utilisez alors le MimeMapping.GetMimeMapping (chaîne FileName) pour obtenir le type MIME pour votre fichier. C'est ainsi que je l'ai utilisé dans mon action.

return File(Path.Combine(@"c:\path", fileFromDB.FileNameOnDisk), MimeMapping.GetMimeMapping(fileFromDB.FileName), fileFromDB.FileName);

Phil Haack a un bel article où il a créé une classe de résultat d'action de téléchargement de fichier personnalisé. Il vous suffit de spécifier le chemin virtuel du fichier et le nom sous lequel il sera enregistré.

Je l'ai utilisé une fois et voici mon code.

        [AcceptVerbs(HttpVerbs.Get)]
        public ActionResult Download(int fileID)
        {
            Data.LinqToSql.File file = _fileService.GetByID(fileID);

            return new DownloadResult { VirtualPath = GetVirtualPath(file.Path),
                                        FileDownloadName = file.Name };
        }

Dans mon exemple, je stockais le chemin physique des fichiers, j'ai donc utilisé cette méthode d'assistance - que j'ai trouvée quelque part dont je ne me souviens pas - pour la convertir en chemin virtuel

        private string GetVirtualPath(string physicalPath)
        {
            string rootpath = Server.MapPath("~/");

            physicalPath = physicalPath.Replace(rootpath, "");
            physicalPath = physicalPath.Replace("\\", "/");

            return "~/" + physicalPath;
        }

Voici la classe complète tirée de l'article de Phill Haack

public class DownloadResult : ActionResult {

    public DownloadResult() {}

    public DownloadResult(string virtualPath) {
        this.VirtualPath = virtualPath;
    }

    public string VirtualPath {
        get;
        set;
    }

    public string FileDownloadName {
        get;
        set;
    }

    public override void ExecuteResult(ControllerContext context) {
        if (!String.IsNullOrEmpty(FileDownloadName)) {
            context.HttpContext.Response.AddHeader("content-disposition", 
            "attachment; filename=" + this.FileDownloadName)
        }

        string filePath = context.HttpContext.Server.MapPath(this.VirtualPath);
        context.HttpContext.Response.TransmitFile(filePath);
    }
}

Merci à Ian Henry !

Si vous avez besoin d'obtenir un fichier de MS SQL Server, voici la solution.

public FileResult DownloadDocument(string id)
        {
            if (!string.IsNullOrEmpty(id))
            {
                try
                {
                    var fileId = Guid.Parse(id);

                    var myFile = AppModel.MyFiles.SingleOrDefault(x => x.Id == fileId);

                    if (myFile != null)
                    {
                        byte[] fileBytes = myFile.FileData;
                        return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, myFile.FileName);
                    }
                }
                catch
                {
                }
            }

            return null;
        }

Où AppModel est EntityFrameworkmodèle et MyFiles présente la table dans votre base de données. FileData est varbinary(MAX)dans la table MyFiles .

son simple donne juste votre chemin physique dans directoryPath avec le nom de fichier

public FilePathResult GetFileFromDisk(string fileName)
{
    return File(directoryPath, "multipart/form-data", fileName);
}

   public ActionResult Download()
        {
            var document = //Obtain document from database context
    var cd = new System.Net.Mime.ContentDisposition
    {
        FileName = document.FileName,
        Inline = false,
    };
            Response.AppendHeader("Content-Disposition", cd.ToString());
            return File(document.Data, document.ContentType);
        }

if (string.IsNullOrWhiteSpace (fileName)) return Content ("filename not present");

        var path = Path.Combine(your path, your filename);

        var stream = new FileStream(path, FileMode.Open);

        return File(stream, System.Net.Mime.MediaTypeNames.Application.Octet, fileName);

GetFile doit fermer le fichier (ou l'ouvrir dans une utilisation). Ensuite, vous pouvez supprimer le fichier après la conversion en octets - le téléchargement se fera sur ce tampon d'octets.

    byte[] GetFile(string s)
    {
        byte[] data;
        using (System.IO.FileStream fs = System.IO.File.OpenRead(s))
        {
            data = new byte[fs.Length];
            int br = fs.Read(data, 0, data.Length);
            if (br != fs.Length)
                throw new System.IO.IOException(s);
        }
        return data;
    }

Donc, dans votre méthode de téléchargement ...

        byte[] fileBytes = GetFile(file);
        // delete the file after conversion to bytes
        System.IO.File.Delete(file);
        // have the file download dialog only display the base name of the file            return File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, Path.GetFileName(file));