In questo articolo imparerai come creare, leggere e modificare fogli di calcolo Excel in un’applicazione ASP.NET MVC. Per questo, creeremo un’applicazione per fogli di calcolo composta da un controllo griglia ricco di funzionalità per visualizzare e modificare i file Excel, come mostrato di seguito.

API .NET per creare un’applicazione per fogli di calcolo ASP.NET MVC

Per creare l’applicazione del foglio di calcolo in ASP.NET MVC, utilizzeremo Aspose.Cells.GridJs. L’API consente di creare applicazioni basate sul Web per visualizzare o modificare documenti di fogli di calcolo in modo rapido e semplice. Inoltre, puoi importare i più diffusi formati di file di fogli di calcolo (XLS, XLSX, XLSM, XLSB, CSV, SpreadsheetML, ODS) (leggi di più). Inoltre, fornisce un potente e ricco motore di calcolo delle formule per calcolare non solo le funzioni integrate ma anche formule personalizzate. È possibile installare Aspose.Cells.GridJs da NuGet.

PM> Install-Package Aspose.Cells.GridJs

Passaggi per creare un’applicazione per fogli di calcolo ASP.NET MVC

Di seguito sono riportati i passaggi per creare un’applicazione per fogli di calcolo basata sul Web in ASP.NET MVC.

  1. Creare una nuova app Web ASP.NET Core (Model-View-Controller) in Visual Studio.
  1. Installa Aspose.Cells.GridJs da NuGet.
  1. Inserisci il codice seguente in 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. Crea una nuova classe denominata TestConfig.cs nella cartella Modelli e aggiungi il codice seguente (modifica i percorsi delle cartelle in base al tuo ambiente).
public class TestConfig
{
    ///<summary>
    /// la directory che contiene i file della cartella di lavoro
    ///</summary>
    internal static String ListDir = @"D:\tmpdel\storage\wb";
    ///<summary>
    ///temp directory per memorizzare i file
    ///</summary>
    internal static String TempDir = @"D:\tmpdel\storage\wb\tmp\";
}
  1. Crea una nuova classe denominata LocalFileCache.cs nella cartella Modelli e aggiungi il codice seguente.
/* Add the following namespaces as well.
using Aspose.Cells.GridJs;
using System.IO;
*/

public class LocalFileCache : GridCacheForStream
{

    ///<summary>
    /// Implementa questo metodo per salvare la cache, salva il flusso nell'oggetto cache con l'id della chiave.
    ///</summary>
    ///<param name="s"> il flusso di origine</param>
    ///<param name="uid"> lui chiave id.</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>
    /// Implementa questo metodo per caricare la cache con la chiave uid, restituire il flusso dall'oggetto cache.
    ///</summary>
    ///<param name="uid"> l'identificativo della chiave</param>
    ///<returns> il flusso dalla 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>
    /// implementa l'URL nel controller di azione per ottenere il file
    ///</summary>
    ///<param name="uid"> l'identificativo della chiave</param>
    ///<returns></returns>
    public override String GetFileUrl(string uid)
    {
        return "/GridJs2/GetFile?id=" + uid;
    }

}
  1. Crea un nuovo controller denominato GridJs2Controller.cs e aggiungi il codice seguente.
/* 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 = nuovo elenco<object> ();
        ArrayList dirlistsss = new ArrayList();
        ArrayList filelistsss = new ArrayList();

        DirectoryInfo dir = new DirectoryInfo(TestConfig.ListDir);

        //trova i file nella directory
        FileInfo[] fi = dir.GetFiles();
        foreach (FileInfo f in fi)
        {
            String fname = f.FullName.ToString();
            dirlistsss.Add(fname);
            filelistsss.Add(Path.GetFileName(fname));
        }
        //  Visualizza dati.
        ViewBag.dirlist = dirlistsss;
        ViewBag.filelist = filelistsss;
        return View("~/Views/Home/list.cshtml");
    }

    // OTTIENI: /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]
    // messaggio: /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);
    }


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

    // OTTIENI: /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");
    }

    //se usi GridCacheForStream devi impostare questa API
    // OTTIENI: /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";
    }




    // OTTIENI: /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>
    /// download file
    ///</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. Inserisci il codice seguente nella funzione Configura di Startup.cs e imposta il percorso del file di licenza (ottieni una licenza gratis).
/* 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. Inserisci il codice seguente in Views/Home/index.cshtml.
@{
    ViewData["Title"] = "Home Page";
}
  1. Crea una nuova vista denominata list.cshtml nella cartella Views/Home/ e inserisci il codice seguente.
<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. Scarica la cartella xspread da GitHub e posizionala nella cartella wwwroot, come mostrato di seguito.
  1. Assicurati che il numero di porta specificato in wwwroot/xspread/index.html sia lo stesso del numero di porta del progetto.

  2. Crea l’applicazione ed eseguila nel tuo browser preferito.

Demo: crea o modifica file Excel in ASP.NET MVC

Quella che segue è la dimostrazione dell’applicazione per fogli di calcolo ASP.NET MVC che abbiamo appena creato.

Scarica il codice sorgente

È possibile scaricare il codice sorgente completo dell’applicazione per fogli di calcolo da GitHub.

Ottieni una licenza gratuita

Puoi utilizzare Aspose.Cells.GridJs senza limitazioni di valutazione utilizzando una licenza temporanea.

Conclusione

In questo articolo, hai imparato come creare un’applicazione per fogli di calcolo ASP.NET MVC con una gamma di funzionalità per creare e modificare Excel e altri file di fogli di calcolo. Puoi personalizzare questa applicazione o integrarla nella tua applicazione web. In caso di domande, non esitare a postare sul nostro forum.

Guarda anche