Dans cet article, vous apprendrez à créer, lire et modifier des feuilles de calcul Excel dans une application ASP.NET MVC. Pour cela, nous allons créer une application de feuille de calcul composée d’un contrôle de grille riche en fonctionnalités pour afficher et modifier des fichiers Excel, comme indiqué ci-dessous.

API .NET pour créer une application de feuille de calcul ASP.NET MVC

Afin de créer l’application de feuille de calcul dans ASP.NET MVC, nous utiliserons Aspose.Cells.GridJs. L’API vous permet de créer des applications Web pour afficher ou modifier rapidement et facilement des feuilles de calcul. De plus, vous pouvez importer les formats de fichier de feuille de calcul populaires (XLS, XLSX, XLSM, XLSB, CSV, SpreadsheetML, ODS) (en savoir plus). En outre, il fournit un moteur de calcul de formule puissant et riche pour calculer non seulement les fonctions intégrées, mais également les formules personnalisées. Vous pouvez installer Aspose.Cells.GridJs à partir de NuGet.

PM> Install-Package Aspose.Cells.GridJs

Étapes pour créer une application de feuille de calcul ASP.NET MVC

Voici les étapes pour créer une application de feuille de calcul Web dans ASP.NET MVC.

  1. Créez une nouvelle application Web ASP.NET Core (Model-View-Controller) dans Visual Studio.
  1. Installez Aspose.Cells.GridJs à partir de NuGet.
  1. Insérez le code suivant dans HomeController.cs.
public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return RedirectToRoute("default",
          new { controller = "GridJs2", action = "List" });
        }

        public IActionResult Privacy()
        {
            return Redirect("https://about.aspose.app/legal/privacy-policy");
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
  1. Créez une nouvelle classe nommée TestConfig.cs dans le dossier Models et ajoutez le code suivant (modifiez les chemins de dossier en fonction de votre environnement).
public class TestConfig
{
    ///<summary>
    /// le répertoire qui contient les fichiers du classeur
    ///</summary>
    internal static String ListDir = @"D:\tmpdel\storage\wb";
    ///<summary>
    /// répertoire temp pour stocker les fichiers
    ///</summary>
    internal static String TempDir = @"D:\tmpdel\storage\wb\tmp\";
}
  1. Créez une nouvelle classe nommée LocalFileCache.cs dans le dossier Models et ajoutez le code suivant.
/* Add the following namespaces as well.
using Aspose.Cells.GridJs;
using System.IO;
*/

public class LocalFileCache : GridCacheForStream
{

    ///<summary>
    /// Implémentez cette méthode pour enregistrer le cache, enregistrez le flux dans l'objet cache avec l'identifiant de la clé.
    ///</summary>
    ///<param name="s"> le flux source</param>
    ///<param name="uid"> il clé d'identification.</param>
    public override void SaveStream(Stream s, String uid)
    {
        String filepath = Path.Combine(Config.FileCacheDirectory + Path.DirectorySeparatorChar + "streamcache", uid.Replace('/', '.'));
        using (FileStream fs = new FileStream(filepath, FileMode.Create))
        {
            s.Position = 0;
            s.CopyTo(fs);
        }

    }

    ///<summary>
    /// Implémentez cette méthode pour charger le cache avec la clé uid, retournez le flux de l'objet cache.
    ///</summary>
    ///<param name="uid"> l'identifiant de la clé</param>
    ///<returns> le flux du cache</returns>
    public override Stream LoadStream(String uid)
    {
        String filepath = Path.Combine(Config.FileCacheDirectory + Path.DirectorySeparatorChar + "streamcache", uid.Replace('/', '.'));
        FileStream fs = new FileStream(filepath, FileMode.Open);
        return fs;
    }
    ///<summary>
    /// implémenter l'url dans action controller pour récupérer le fichier
    ///</summary>
    ///<param name="uid"> l'identifiant de la clé</param>
    ///<returns></returns>
    public override String GetFileUrl(string uid)
    {
        return "/GridJs2/GetFile?id=" + uid;
    }

}
  1. Créez un nouveau contrôleur nommé GridJs2Controller.cs et ajoutez le code suivant.
/* Add the following namespaces as well.
System.IO;
System.Collections;
System.Threading;
Microsoft.AspNetCore.StaticFiles;
Aspose.Cells.GridJs;
*/


[Route("[controller]/[action]")]
[ApiController]
public class GridJs2Controller : Controller
{

    public ActionResult List()
    {
        //this.ViewBag.list = nouvelle liste<object> ();
        ArrayList dirlistsss = new ArrayList();
        ArrayList filelistsss = new ArrayList();

        DirectoryInfo dir = new DirectoryInfo(TestConfig.ListDir);

        //trouver des fichiers sous le répertoire
        FileInfo[] fi = dir.GetFiles();
        foreach (FileInfo f in fi)
        {
            String fname = f.FullName.ToString();
            dirlistsss.Add(fname);
            filelistsss.Add(Path.GetFileName(fname));
        }
        //  Afficher les données.
        ViewBag.dirlist = dirlistsss;
        ViewBag.filelist = filelistsss;
        return View("~/Views/Home/list.cshtml");
    }

    // OBTENIR : /GridJs2/DetailJson?filename=
    public ActionResult DetailFileJson(string filename)
    {


        String file = Path.Combine(TestConfig.ListDir, filename);

        return DetailJson(file);
    }



    private ActionResult DetailJson(string path)
    {
        GridJsWorkbook wbj = new GridJsWorkbook();


        try
        {
            GridInterruptMonitor m = new GridInterruptMonitor();
            wbj.SetInterruptMonitorForLoad(m, 50 * 1000);
            Thread t1 = new Thread(new ParameterizedThreadStart(InterruptMonitor));
            t1.Start(new object[] { m, 90 * 1000 });




            using (FileStream fs = new FileStream(path, FileMode.Open))
            {
                wbj.ImportExcelFile(fs, GridJsWorkbook.GetGridLoadFormat(Path.GetExtension(path)));
            }

        }
        catch (Exception ex)
        {

            if (ex is GridCellException)
            {
                return Content(wbj.ErrorJson(((GridCellException)ex).Message + ((GridCellException)ex).Code), "text/plain", System.Text.Encoding.UTF8);
            }
            return Content(wbj.ErrorJson(ex.Message), "text/plain", System.Text.Encoding.UTF8);
        }
        //return File(stream, "application/octet-stream", "streamfile");
        return Content(wbj.ExportToJson(), "text/plain", System.Text.Encoding.UTF8);
    }
    private static void InterruptMonitor(object o)
    {
        object[] os = (object[])o;
        try
        {
            Thread.Sleep((int)os[1]);

            ((GridInterruptMonitor)os[0]).Interrupt();
        }
        catch (ThreadInterruptedException e)
        {
            Console.WriteLine("Succeeded for load in give time.");
        }
    }
    [HttpPost]
    // message : /GridJs2/UpdateCell
    public ActionResult UpdateCell()
    {

        string p = HttpContext.Request.Form["p"];
        string uid = HttpContext.Request.Form["uid"];
        GridJsWorkbook gwb = new GridJsWorkbook();
        String ret = gwb.UpdateCell(p, uid);

        return Content(ret, "text/plain", System.Text.Encoding.UTF8);
    }


    // OBTENIR : /GridJs2/Xspreadtml
    public ActionResult Xspreadtml(String filename)
    {
        return Redirect("~/xspread/index.html?file=" + filename);
    }

    // OBTENIR : /GridJs2/Image?uid=&id=

    public FileResult Image()
    {

        string fileid = HttpContext.Request.Query["id"];
        string uid = HttpContext.Request.Query["uid"];

        return new FileStreamResult(GridJsWorkbook.GetImageStream(uid, fileid), "image/png");
    }

    //si vous utilisez GridCacheForStream, vous devez définir cette API
    // OBTENIR : /GridJs2/ImageUrl?uid=&id=
    public JsonResult ImageUrl(string id, string uid)
    {


        return new JsonResult(GridJsWorkbook.GetImageUrl(uid, id, "."));

    }
    private string GetMimeType(string FileName)
    {
        string contentType;
        new FileExtensionContentTypeProvider().TryGetContentType(FileName, out contentType);
        return contentType ?? "application/octet-stream";
    }




    // OBTENIR : /GridJs2/GetFile?id

    public FileResult GetFile(string id)
    {

        string fileid = id;
        string mimeType = GetMimeType(fileid);

        return File(GridJsWorkbook.CacheImp.LoadStream(fileid), mimeType, fileid.Replace('/', '.'));
    }


    ///<summary>
    /// télécharger un fichier
    ///</summary>
    ///<returns></returns>
    [HttpPost]

    public JsonResult Download()
    {

        string p = HttpContext.Request.Form["p"];
        string uid = HttpContext.Request.Form["uid"];
        string filename = "123.xlsx";

        GridJsWorkbook wb = new GridJsWorkbook();
        wb.MergeExcelFileFromJson(uid, p);



        GridInterruptMonitor m = new GridInterruptMonitor();
        wb.SetInterruptMonitorForSave(m);
        Thread t1 = new Thread(new ParameterizedThreadStart(InterruptMonitor));
        t1.Start(new object[] { m, 30 * 1000 });
        try
        {
            wb.SaveToCacheWithFileName(uid, filename, null);
        }
        catch (Exception ex)
        {

            if (ex is GridCellException)
            {
                return Json(((GridCellException)ex).Message + ((GridCellException)ex).Code);
            }
        }
        if (filename.EndsWith(".html"))
        {
            filename += ".zip";
        }
        String fileurl = GridJsWorkbook.CacheImp.GetFileUrl(uid + "/" + filename);
        return new JsonResult(fileurl);
    }


}
  1. Insérez le code suivant dans la fonction Configure de Startup.cs et définissez le chemin du fichier de licence (get a license for free).
/* Add the following namespace as well.
using Aspose.Cells.GridJs;
*/

License l = new License();
LocalFileCache mwc = new LocalFileCache();
GridJsWorkbook.CacheImp = mwc;
l.SetLicense(@"D:\licenses\Conholdate.Total.Product.Family.lic");
  1. Insérez le code suivant dans Views/Home/index.cshtml.
@{
    ViewData["Title"] = "Home Page";
}
  1. Créez une nouvelle vue nommée list.cshtml sous le dossier Views/Home/ et insérez le code suivant.
<div id="body" style="  width: 800px; height: 800px; border: 1px solid; overflow-y: scroll; SCROLLBAR-BASE-COLOR: #8ccc8c;">
    @foreach (var item in ViewBag.filelist)
    {
        <a href="Xspreadtml?filename=@item" target="_blank"><em> @item   </em>  </a> <br />
    }
</div>
  1. Téléchargez le dossier xspread depuis GitHub et placez-le dans le dossier wwwroot, comme indiqué ci-dessous.
  1. Assurez-vous que le numéro de port spécifié dans wwwroot/xspread/index.html est le même que le numéro de port du projet.

  2. Créez l’application et exécutez-la dans votre navigateur préféré.

Démo - Créer ou modifier des fichiers Excel dans ASP.NET MVC

Voici la démonstration du tableur ASP.NET MVC que nous venons de créer.

Télécharger le code source

Vous pouvez télécharger le code source complet du tableur à partir de GitHub.

Obtenez une licence gratuite

Vous pouvez utiliser Aspose.Cells.GridJs sans limitation d’évaluation à l’aide d’une licence temporaire.

Conclusion

Dans cet article, vous avez appris à créer une application de feuille de calcul ASP.NET MVC avec une gamme de fonctionnalités pour créer et modifier Excel et d’autres fichiers de feuille de calcul. Vous pouvez personnaliser cette application ou l’intégrer dans votre propre application Web. Si vous avez des questions, n’hésitez pas à poster sur notre forum.

Voir également