COMPARAISON AVEC D'AUTRES COMPOSANTS

Comparaison entre IronXL et GrapeCity Excel Viewer

Publié juin 9, 2022

L'utilisation de données Excel dans une situation de programmation avec un environnement .NET peut entraîner une série de problèmes, notamment en matière d'interopérabilité.

Excel est le tableur le plus utilisé au monde. Les utilisateurs sont à la fois des développeurs et le grand public, mais les développeurs sont plus susceptibles d'être intéressés par ce contenu. Au départ, les développeurs n'avaient pas beaucoup d'alternatives pour intégrer Excel dans leurs différentes applications. Cependant, la suite Office incluait VBA (Visual Basic pour les applications)qui vous permet de modifier n'importe quel produit Office pour l'adapter à vos besoins.

Les développeurs ont personnalisé leurs interactions avec les feuilles de calcul XLSX et leurs données, ainsi que leurs caractéristiques visuelles, à l'aide de VBA dans Excel.

Qu'est-ce que GrapeCity Documents pour Excel ?

GrapeCity Documents for Excel .NET Edition est un nouveau composant de feuille de calcul très performant et peu encombrant qui peut être utilisé dans des applications de serveur ou de bureau. Il fournit une API riche pour créer, manipuler, convertir et partager des feuilles de calcul compatibles avec Microsoft Excel. Vous pouvez également l'utiliser à partir de presque n'importe quelle application ou plateforme comme Angular, React ou Vue pour créer des styles personnalisés.

Il dispose d'une plateforme de BI intégrée de manière transparente, avec des tableaux de bord interactifs, des outils de planification et de distribution dans n'importe quelle application interne ou commerciale.

La plateforme BI intégrée de GrapeCity offre une exploration visuelle illimitée des données à grande vitesse, permettant à l'utilisateur de tous les jours de devenir axé sur les données et d'établir facilement des rapports sur des solutions comportant de nombreuses données à l'aide des rapports ad hoc et des tableaux de bord interactifs de la plateforme BI.

GcExcel .NET est compatible avec une variété de plateformes, y compris le Framework .NET, .NET Core et Mono, ce qui en fait le choix idéal pour tous vos besoins en matière de feuilles de calcul.

L'avantage de GcExcel .NET est que son API basée sur l'interface est modelée autour du paradigme de l'objet document d'Excel. Par conséquent, les utilisateurs peuvent importer, calculer, interroger, produire et exporter n'importe quel scénario de feuille de calcul à tout moment. En outre, les rapports complets, les tableaux de tri et de filtrage, les tableaux croisés dynamiques de tri et de filtrage, les graphiques, les lignes d'étincelles, les formats conditionnels et les rapports de tableau de bord, entre autres, peuvent être référencés dans les feuilles de calcul importées ou générées.

Que vous offre GrapeCity Documents pour Excel ?

Permet la création, la manipulation et la sérialisation de feuilles de calcul sur le serveur.
Faible empreinte mémoire.
Effectue des calculs complexes à l'aide du puissant moteur de calcul.
Document intuitif à grande vitesse ; l'intelligence économique intégrée.
Fournit des solutions complètes en matière de rapports.
Vous permet de contrôler entièrement vos documents à grande vitesse.
Génère des résultats dans une variété de formats, y compris .xlsx et ssjson.
Prise en charge de .NET Framework, .NET Core et Mono sur plusieurs plateformes.
Compatible avec les environnements Winforms, WPF, ASP .NET et autres.

GrapeCity Excel - caractéristiques remarquables

La dernière version 14.1 comporte de nombreuses nouvelles fonctionnalités intéressantes.

Architecture légère de l'API du tableur pour une meilleure efficacité
GcExcel .NET permet aux utilisateurs d'économiser une quantité considérable de temps, de mémoire de stockage et d'efforts en améliorant l'efficacité globale grâce à son architecture API légère qui peut être utilisée pour générer, charger, modifier, enregistrer et convertir des feuilles de calcul.
Pas de dépendance à l'égard de MS Excel
Pour travailler avec GcExcel .NET, les utilisateurs n'ont pas besoin d'installer MS Office Suite ou d'accéder à MS Excel sur leur système.
Créer une expérience interactive avec SpreadJS DSheets
GcExcel .NET peut être utilisé avec des feuilles de calcul pour une expérience de feuille de calcul totalement interactive et conviviale.
Déployer des applications avec des feuilles de calcul Excel dans le nuage
Avec GcExcel .NET, vous pouvez appliquer des déploiements basés sur le cloud et déployer vos applications sur Azure et AWS Lambda.
Formes et images
Avec l'API de feuille de calcul, vous pouvez insérer et personnaliser des formes et des images dans les cellules d'une feuille de calcul, appliquer une mise en forme, un remplissage en dégradé, configurer du texte, insérer des liens hypertextes, définir des points d'ajustement des formes, les grouper/dégrouper dans une feuille de calcul et déterminer la position et la taille d'une image.

Qu'est-ce qu'IronXL ?

IronXL est une bibliothèque C# qui facilite la lecture et l'édition des documents Microsoft Excel. IronXL. Excel est une bibliothèque logicielle .NET qui peut lire une variété de formats de feuilles de calcul. Il ne nécessite pas l'installation de Microsoft Excel et ne repose pas sur Interop.

IronXL est une API C# conviviale qui vous permet de lire, d'éditer et de générer des fichiers Excel dans .NET à une vitesse fulgurante. .NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS et Azure sont tous pris en charge par IronXL.

IronXL est une bibliothèque de feuilles de calcul Excel en C# pour .NET Core et .NET Framework.

L'ensemble des fonctionnalités d'IronXL

Charger, lire et modifier des données - à partir de XLS/XLSX/CSV/TSV
Sauvegarde et exportation - vers XLS/XLSX/CSV/TSV/JSON
Objets System.Data - Travailler avec des feuilles de calcul Excel en tant qu'objets System.Data.DataSet et System.Data.DataTable.
Formules - permet de travailler avec des formules Excel. Les formules sont recalculées chaque fois qu'une feuille est éditée.
Plages - Fiche de travail facile à utiliser ["A1:B10] syntaxe. Combinez et créez des gammes de manière intuitive.
Tri - Permet de trier les plages, les colonnes et les lignes.
Stylisation - Styles visuels des cellules, police, taille, motif d'arrière-plan, bordure, alignement et formats des nombres.

Installation des documents GrapeCity pour Excel

Afin d'utiliser GcExcel .NET dans une application .NET Core, ASP .NET Core ou .NET Framework (toute cible qui prend en charge le Standard .NET 2.0)pour ce faire, installez les paquets NuGet dans votre application en suivant les étapes suivantes :

Pour trouver et installer le package NuGet GrapeCity.Documents.Excel

Sélectionnez Gérer les paquets NuGet dans le menu contextuel des dépendances ou d'un projet dans l'explorateur de solutions.
Sélectionnez nuget.org dans la liste déroulante Source du paquet dans l'onglet Parcourir.
Dans l'onglet Parcourir, recherchez le paquet "GrapeCity.Documents.Excel" en tapant "grapecity.documents" ou "GrapeCity.Documents" dans la zone de texte de recherche en haut.
Cliquez sur Install pour installer le paquet GrapeCity.Documents.Excel et ses dépendances dans le projet. Une fois l'installation terminée, vérifiez le dossier NuGet dans votre explorateur de solutions et confirmez que le package GrapeCity.Documents.Excel a bien été ajouté aux dépendances de votre projet.

Installation de la bibliothèque C# d'IronXL

Vous pouvez télécharger et installer la bibliothèque IronXL en utilisant les méthodes suivantes :

Utilisation de Visual Studio avec les paquets NuGet.
Téléchargez directement le paquet NuGet.
Installation manuelle avec la DLL.
Examinons chacun d'entre eux de plus près.

Utilisation de Visual Studio avec les paquets NuGet

Visual Studio propose le gestionnaire de paquets NuGet pour installer les paquets NuGet dans vos projets. Vous pouvez y accéder par le menu Projet ou en cliquant avec le bouton droit de la souris sur votre projet dans l'explorateur de solutions.

Ensuite, à partir de l'onglet Parcourir -> rechercher IronXL.Excel -> Installer
Et nous avons terminé.

Utilisation de la console NuGet Package Manager

Une autre façon de télécharger et d'installer la bibliothèque Microsoft.Office.Interop.Excel C# est d'utiliser les étapes suivantes pour installer le paquet NuGet via l'Invite de commande du développeur.

Ouvrez l'invite de commande Developer - qui se trouve généralement dans le dossier Visual Studio.
Tapez la commande suivante :

PM> Install-Package Microsoft.Office.Interop.Excel

* Appuyez sur Enter.
* Cette opération permet de télécharger et d'installer le paquet.
* Rechargez votre projet Visual Studio et commencez à l'utiliser.

### Ajouter les directives d'utilisation nécessaires

1. Dans l'explorateur de solutions, cliquez avec le bouton droit de la souris sur le fichier Program.cs, puis cliquez sur Afficher le code.

2. Ajoutez les directives d'utilisation suivantes au début du fichier de code :

using Excel = Microsoft.Office.Interop.Excel ;


## Création de classeurs et de feuilles Excel

Un classeur est un fichier Excel qui contient de nombreuses lignes et colonnes de feuilles de calcul. La possibilité de créer un nouveau classeur et de nouvelles feuilles Excel est disponible dans les deux bibliothèques. Examinons le code étape par étape.

### Création de fichiers Excel à l'aide d'IronXL

Il n'y a rien de plus facile que de créer un nouveau classeur Excel à l'aide d'IronXL. Une seule ligne de code! Oui, vraiment. Ajoutez le code suivant à votre fonction statique void main dans le fichier Program.cs :

```cs
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Les deux XLS (ancienne version du fichier Excel) et XLSX (version actuelle et plus récente du fichier) peuvent être créés avec IronXL.

Et il est encore plus facile de créer une feuille de travail par défaut :

var worksheet = workbook.CreateWorkSheet("IronXL Features");

var worksheet = workbook.CreateWorkSheet("IronXL Features");

Dim worksheet = workbook.CreateWorkSheet("IronXL Features")

VB C#

Vous pouvez maintenant utiliser la variable de feuille de calcul pour définir les valeurs des cellules et faire pratiquement tout ce qu'un fichier Excel peut faire.

Création de fichiers Excel à l'aide d'une API Excel côté serveur GrapeCity excel

Documents de GrapeCity pour Excel (ou GcExcel) est une API Excel côté serveur qui vous permet de créer, charger, enregistrer, convertir, calculer, formater, analyser et exporter des feuilles de calcul dans n'importe quelle application Standard .NET. GcExcel peut être déployé sur Azure sans aucune dépendance Excel grâce à la prise en charge complète de .NET5 pour Windows, Linux et Mac.

GcExcel vous permet de créer et de générer des feuilles de calcul Excel côté serveur sans devoir utiliser MS Excel.

Créer un classeur avec GcExcel dans une fonction.
Retourner au côté client après avoir converti le classeur en JSON.
Dans cet exemple, nous allons simplement créer une feuille de calcul BidTracker.xlsx. Cet exemple présente des fonctionnalités supplémentaires côté serveur qui peuvent être programmées avec GcExcel.

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
Workbook workbook = CreateWorkbookByCaseName(caseName);
var ssjson = workbook.ToJson();
return Ok(ssjson);
}

        private Workbook CreateWorkbookByCaseName(string caseName)
        {
            switch (caseName)
            {
                case "BidTracker":
                    return GetBidTracker();
                default:
                    break;
            }

            return new Workbook();
        }
}

[HttpGet("{caseName}")]
public IActionResult GetSSJsonFromUseCase(string caseName)
{
Workbook workbook = CreateWorkbookByCaseName(caseName);
var ssjson = workbook.ToJson();
return Ok(ssjson);
}

        private Workbook CreateWorkbookByCaseName(string caseName)
        {
            switch (caseName)
            {
                case "BidTracker":
                    return GetBidTracker();
                default:
                    break;
            }

            return new Workbook();
        }
}

<HttpGet("{caseName}")>
Public Function GetSSJsonFromUseCase(ByVal caseName As String) As IActionResult
Dim workbook As Workbook = CreateWorkbookByCaseName(caseName)
Dim ssjson = workbook.ToJson()
Return Ok(ssjson)
End Function

		Private Function CreateWorkbookByCaseName(ByVal caseName As String) As Workbook
			Select Case caseName
				Case "BidTracker"
					Return GetBidTracker()
				Case Else
			End Select

			Return New Workbook()
		End Function
}

VB C#

Modifier les fichiers Excel

Les développeurs doivent être prudents lorsqu'ils commencent à modifier et à éditer des fichiers Excel en C#, car il peut être facile pour une erreur de modifier l'ensemble du document. Le fait de pouvoir compter sur des lignes de code simples et efficaces réduit le risque d'erreur et facilite la mise à jour ou la suppression de fichiers Excel par programmation. Aujourd'hui, nous allons passer en revue les procédures nécessaires pour éditer des fichiers Excel en C# avec précision et rapidité, en utilisant des fonctions testées.

Editer des fichiers Excel avec GrapeCity Excel

Commençons par utiliser GcExcel et Java pour résoudre ces problèmes.

On vous remet une feuille de calcul qui ressemble à ceci :

Tout d'abord, nous devons formater la feuille :

Modifiez les propriétés de police du titre de la feuille et de la cellule Revenu total.
Modifier les styles de tableau, de colonne de tableau et de cellule.
Voyons comment y parvenir en utilisant GcExcel et Java.
Étape 1 : Charger une feuille de calcul Excel existante
Ecrivez le code suivant pour charger une feuille de calcul existante dans votre classeur GcExcel :

Workbook workbook = new Workbook();
workbook.open("Event budget.xlsx");

Workbook workbook = new Workbook();
workbook.open("Event budget.xlsx");

Dim workbook As New Workbook()
workbook.open("Event budget.xlsx")

VB C#

Etape 2 : Obtenir la feuille de calcul que vous voulez modifier

IWorksheet worksheet = workbook.getActiveSheet();

IWorksheet worksheet = workbook.getActiveSheet();

Dim worksheet As IWorksheet = workbook.getActiveSheet()

VB C#

Étape 3 : Modifier les propriétés de la police des titres

Modifier les propriétés de police de B2 (taille de la police) et E4 (mettre en gras) des cellules :

//change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22);

//change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(true);

//change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22);

//change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(true);

'change range B2s font size.
worksheet.getRange("B2").getFont().setSize(22)

'change range E4s font style to bold.
worksheet.getRange("E4").getFont().setBold(True)

VB C#

Étape 4 : Modifier le style de la table

Définir les styles des quatre tables en fonction d'un style intégré.

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"));

worksheet.getTables().get("tblAdmissions").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblAds").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblVendors").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))
worksheet.getTables().get("tblItems").setTableStyle(workbook.getTableStyles().get("TableStyleLight10"))

VB C#

Étape 5 : Modifier le style de la plage de cellules

Modifier le style des cellules du revenu total. La fonction getInterior() d'une plage peut vous aider à définir les propriétés ThemeColor et TintAndShade. Vous pouvez également modifier la police de l'ensemble de la plage à l'aide de la fonction getFont() méthode. En outre, ce code permet de définir les bordures d'une série de cellules.

Étant donné que la feuille de calcul présente les données budgétaires, définissez le format des nombres d'une plage de cellules comme étant la devise.

//modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15);
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major);
worksheet.getRange("F4:G5").getFont().setSize(12);  worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None);
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00");

//modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15);
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major);
worksheet.getRange("F4:G5").getFont().setSize(12);  worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None);
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00");

'modify range F4:G5's cell style.
worksheet.getRange("F4:G5").getInterior().setThemeColor(ThemeColor.Light1)
worksheet.getRange("F4:G5").getInterior().setTintAndShade(-0.15)
worksheet.getRange("F4:G5").getFont().setThemeFont(ThemeFont.Major)
worksheet.getRange("F4:G5").getFont().setSize(12)
worksheet.getRange("F4:G5").getBorders().get(BordersIndex.InsideHorizontal).setLineStyle(BorderLineStyle.None)
worksheet.getRange("F5:G5").setNumberFormat("$#,##0.00")

VB C#

Étape 6 : Modifier les styles des colonnes du tableau

Les plages de colonnes du tableau étant différentes, définissez les propriétés ThemeColor, TintAndShade et NumberFormat sur une plage de colonnes différente du tableau.

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15);
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00");

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1);
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15);
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00");

worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setThemeColor(ThemeColor.Light1)
worksheet.getRange("F8:G11, F15:G18, F22:G25, F29:G33").getInterior().setTintAndShade(-0.15)
worksheet.getRange("E8:G11, E15:G18, E22:G25, E29:G33").setNumberFormat("$#,##0.00")

VB C#

Étape 7 : Enregistrer le fichier Excel

//save to an excel file
workbook.save("EventBudget.xlsx");

//save to an excel file
workbook.save("EventBudget.xlsx");

'save to an excel file
workbook.save("EventBudget.xlsx")

VB C#

Félicitations! Vous avez entièrement modifié le formatage du document. Exécutez l'application et votre feuille de calcul Excel se présente comme suit :

Éditer des fichiers Excel avec IronXL

Une fois IronXL installé, abordons le processus d'édition des fichiers Excel à l'aide de ce logiciel.

Modifier les valeurs de cellules spécifiques

Tout d'abord, nous verrons comment modifier les valeurs de certaines cellules d'une feuille de calcul Excel.

Pour ce faire, nous importons la feuille de calcul Excel à modifier et accédons à sa feuille de travail. Ensuite, nous pouvons apporter les modifications indiquées ci-dessous.

using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");//import Excel SpreadSheet
WorkSheet ws = wb.GetWorkSheet("Sheet1");//access specific workshet
ws.Rows [3].Columns [1].Value = "New Value";//access specific cell and modify its value
wb.SaveAs("sample.xlsx");//save changes
}

using IronXL;
static void Main(string [] args)
{
WorkBook wb = WorkBook.Load("sample.xlsx");//import Excel SpreadSheet
WorkSheet ws = wb.GetWorkSheet("Sheet1");//access specific workshet
ws.Rows [3].Columns [1].Value = "New Value";//access specific cell and modify its value
wb.SaveAs("sample.xlsx");//save changes
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") 'import Excel SpreadSheet
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") 'access specific workshet
ws.Rows (3).Columns (1).Value = "New Value" 'access specific cell and modify its value
wb.SaveAs("sample.xlsx") 'save changes
End Sub

VB C#

Voici des captures d'écran avant et après de la feuille de calcul Excel sample.xlsx :

Nous pouvons voir à quel point il est simple de modifier la valeur de la feuille de calcul Excel.

Si nécessaire, il existe également une autre façon de modifier la valeur d'une cellule spécifique par l'adresse de la cellule :

ws ["B4"].Value = "New Value"; //alternative way to access specific cell and apply changes

ws ["B4"].Value = "New Value"; //alternative way to access specific cell and apply changes

ws ("B4").Value = "New Value" 'alternative way to access specific cell and apply changes

VB C#

Modifier les valeurs d'une ligne complète

Il est assez simple de modifier les valeurs d'une ligne complète d'une feuille de calcul Excel avec une valeur statique.

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    ws.Rows [3].Value = "New Value";            
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    ws.Rows [3].Value = "New Value";            
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	ws.Rows (3).Value = "New Value"
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Voir les captures d'écran de l'exemple.xlsx ci-dessous :

Pour ce faire, nous pouvons également modifier la valeur d'une plage spécifique de la ligne, en utilisant la fonction de plage :

ws ["A3:E3"].Value = "New Value";

ws ["A3:E3"].Value = "New Value";

ws ("A3:E3").Value = "New Value"

VB C#

Éditer les valeurs des colonnes complètes

De la même manière que ci-dessus, nous pouvons facilement modifier des colonnes entières de la feuille de calcul Excel à l'aide d'une seule valeur.

using IronXL;static void Main(string [] args){    WorkBook wb = WorkBook.Load("sample.xlsx");    WorkSheet ws = wb.GetWorkSheet("Sheet1");    ws.Columns [1].Value = "New Value";    wb.SaveAs("sample.xlsx");}

using IronXL;static void Main(string [] args){    WorkBook wb = WorkBook.Load("sample.xlsx");    WorkSheet ws = wb.GetWorkSheet("Sheet1");    ws.Columns [1].Value = "New Value";    wb.SaveAs("sample.xlsx");}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	ws.Columns (1).Value = "New Value"
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Cela produira notre feuille de calcul sample.xlsx comme suit :

Éditer des lignes complètes avec des valeurs dynamiques

Grâce à IronXL, il est également possible d'éditer des lignes spécifiques avec des valeurs dynamiques. Cela signifie que nous pouvons modifier une ligne entière en attribuant des valeurs dynamiques à chaque cellule. Voyons l'exemple :

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Columns.Count(); i++)    {        
        ws.Rows [3].Columns [i].Value = "New Value "+i.ToString();    
    }            
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Columns.Count(); i++)    {        
        ws.Rows [3].Columns [i].Value = "New Value "+i.ToString();    
    }            
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For i As Integer = 0 To ws.Columns.Count() - 1
		ws.Rows (3).Columns (i).Value = "New Value " & i.ToString()
	Next i
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Dans le tableau ci-dessous, nous pouvons voir les captures d'écran de la feuille de calcul Excel sample.xlsx de cette sortie :

Éditer des colonnes complètes avec des valeurs dynamiques

Il est également facile d'éditer des colonnes spécifiques avec des valeurs dynamiques.

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Rows.Count(); i++)    {        
        if (i == 0) //it is for if our first column is used as a header            
            continue;        

        ws.Rows [i].Columns [1].Value = "New Value " + i.ToString();
    }    
    wb.SaveAs("sample.xlsx");
}

using IronXL;static void Main(string [] args){    
    WorkBook wb = WorkBook.Load("sample.xlsx");    
    WorkSheet ws = wb.GetWorkSheet("Sheet1");    
    for (int i = 0; i < ws.Rows.Count(); i++)    {        
        if (i == 0) //it is for if our first column is used as a header            
            continue;        

        ws.Rows [i].Columns [1].Value = "New Value " + i.ToString();
    }    
    wb.SaveAs("sample.xlsx");
}

Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For i As Integer = 0 To ws.Rows.Count() - 1
		If i = 0 Then 'it is for if our first column is used as a header
			Continue For
		End If

		ws.Rows (i).Columns (1).Value = "New Value " & i.ToString()
	Next i
	wb.SaveAs("sample.xlsx")
End Sub

VB C#

Avec le tableau des résultats de l'échantillon.xlsx ci-dessous :

Modifier des colonnes complètes avec des valeurs dynamiques

Il est également facile d'éditer des colonnes spécifiques avec des valeurs dynamiques.

using IronXL;static void Main(chaîne de caractères [] args){ WorkBook wb = WorkBook.Load("sample.xlsx"); Feuille de travail ws = wb.GetWorkSheet("Feuille 1); pour (int i = 0 ; i < ws.Rows.Count(); i++) { si (i == 0)//c'est pour le cas où notre première colonne est utilisée comme en-tête continuer ; ws.Rows [i]colonnes [1].Value = "Nouvelle valeur " + i.ToString(); } wb.SaveAs("sample.xlsx");}

Avec le tableau des résultats de l'échantillon.xlsx ci-dessous :

Convertir les feuilles de calcul en PDF, XML et JSON

Utilisez-vous une API Excel pour générer des feuilles de calcul dans des applications Java ? Lorsque vous travaillez avec des données, il arrive que vous ne souhaitiez pas les stocker dans une feuille de calcul Excel. Au lieu de cela, vous avez besoin d'un PDF.

Il y a plusieurs raisons pour lesquelles vous ne voudriez pas stocker des données dans une feuille de calcul Excel :

Vous avez besoin d'une préservation à long terme.
Vous n'avez pas installé Microsoft Office sur votre système, mais vous souhaitez tout de même imprimer ou distribuer vos feuilles de calcul Excel.
Vous devez partager votre feuille de calcul et conserver votre formatage. Vous avez besoin que vos feuilles de calcul Excel aient la même apparence lorsqu'elles sont ouvertes sur différents systèmes.

Utilisation de GrapeCity pour convertir des feuilles de calcul en PDF

Documents GrapeCity pour Excel, édition Java (GcExcel Java) est une API de feuille de calcul rapide et peu encombrante qui ne nécessite aucune dépendance à l'égard d'Excel. Avec une prise en charge complète sous Windows, Linux et MAC, vous pouvez générer, charger, modifier et enregistrer des feuilles de calcul, puis les convertir en PDF.

Voici les trois étapes pour convertir des feuilles de calcul en PDF dans des applications Java :

Charger une feuille de calcul Excel existante dans un classeur GcExcel
Ajouter PDFBox en tant que bibliothèque
Convertir la feuille de calcul en PDF
Etape 1 : Charger une feuille de calcul Excel existante dans un classeur GcExcel
Créer un objet classeur GcExcel et charger une feuille de calcul existante.

Workbook workbook=new Workbook();
workbook.open("FinancialKPI.xlsx");

Workbook workbook=new Workbook();
workbook.open("FinancialKPI.xlsx");

Dim workbook As New Workbook()
workbook.open("FinancialKPI.xlsx")

VB C#

Étape 2 : Ajouter PDFBox en tant que bibliothèque

GcExcel Java fait référence à PDFBox pour convertir les feuilles de calcul en PDF. PDFBox dépend également des paquets FontBox et Commons Logging.

Les étapes suivantes vous aideront à ajouter ces fichiers JAR en tant que bibliothèque à votre projet :

Télécharger le paquet - PDFBox, FontBox, Commons Loggings JAR files.
Sous le dossier "src" du projet, ajoutez un dossier "libs".
Copiez les trois fichiers JAR dans le dossier "libs".
Cliquez avec le bouton droit de la souris sur le dossier "libs" et choisissez l'option "Add as library".
Appuyez sur OK.
Note : Les étapes ci-dessus ne sont nécessaires que si le projet est un projet original de console Java. Si le projet est un projet Maven ou Gradle, il suffit d'ajouter la dépendance Java GcExcel. Maven ou Gradle téléchargera et installera automatiquement tous les JARs dépendants.
Dans certaines versions de Maven, il se peut que vous obteniez une erreur de dépendance lorsque vous ajoutez les fichiers JAR ci-dessus. Pour résoudre ce problème, ajoutez le noeud suivant avant les dépendances dans le fichier pom.xml :
```
<build>
<plugins>
    <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>vrai</extensions>
    </plugin>
</plugins>
</build>
```

Étape 3 : Convertir la feuille de calcul en PDF

Enregistrez la feuille de calcul au format PDF à l'aide du code suivant :

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf);

workbook.save("FinancialKPI.pdf", SaveFileFormat.Pdf)

VB C#

Votre PDF se présentera comme suit :

Utiliser IronXL pour convertir des feuilles de calcul en XML et JSON

Le code suivant montre comment exporter un fichier Excel vers un fichier XML ou JSON avec IronXL. Ajoutez le code suivant :

Inclure l'espace de noms :

using IronXL;

using IronXL;

Imports IronXL

VB C#

Ajouter les lignes suivantes :

    private void button4_Click(object sender, EventArgs e)    {        
        WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");        
        workbook.SaveAsJson("IronXL_Output.json");        
        workbook.SaveAsXml("IronXL_Output.xml");    
    }

    private void button4_Click(object sender, EventArgs e)    {        
        WorkBook workbook = WorkBook.Load("IronXL_Output.xlsx");        
        workbook.SaveAsJson("IronXL_Output.json");        
        workbook.SaveAsXml("IronXL_Output.xml");    
    }

Private Sub button4_Click(ByVal sender As Object, ByVal e As EventArgs)
		Dim workbook As WorkBook = WorkBook.Load("IronXL_Output.xlsx")
		workbook.SaveAsJson("IronXL_Output.json")
		workbook.SaveAsXml("IronXL_Output.xml")
End Sub

VB C#

Ici, un objet Workbook Excel existant est chargé puis exporté aux formats JSON et XML.

Licences et prix

Licences et prix d'IronXL

IronXL est une bibliothèque Excel C# ouvertement commerciale. Il est gratuit pour le développement et peut toujours faire l'objet d'une licence pour un déploiement commercial. Des licences sont proposées pour l'utilisation d'un seul projet, pour les développeurs individuels, les agences et les organisations multinationales, ainsi que pour la redistribution SaaS et OEM. Toutes les licences sont assorties d'une garantie de remboursement de 30 jours, d'un an d'assistance et de mises à jour du logiciel, d'une validité pour le développement, la mise en place et la production, ainsi que d'une licence permanente (achat unique). L'ensemble Lite commence à partir de $749.

Licences et prix de GrapeCity

D'autre part, GrapeCity Excel est également une bibliothèque Excel commerciale ; il n'offre pas de services gratuits. La tarification de GrapeCity Documents commence par un forfait de 999 $ par an. Ils proposent également un essai gratuit. Leurs licences sont divisées en quatre paquets :

Licence de développeur (1 développeur, 1 site)

Un (1) le développeur peut utiliser les documents GrapeCity en une seule fois (1) avec une licence de développeur (défini comme une adresse physique ou un immeuble de bureaux). Plusieurs sites sont considérés comme constituant un déploiement en nuage ; voir Licences Unlimited pour plus d'informations.

Licence développeur illimitée (1 développeur, nombre illimité de sites ou de nuages)

Un (1) le développeur peut utiliser les documents GrapeCity dans un nombre illimité de lieux (spécifié comme une adresse physique ou un immeuble de bureaux) ou dans le nuage avec une Developer License Unlimited.

Licence Unlimited Team (2-5 développeurs, emplacements ou clouds illimités)

Les documents de GrapeCity peuvent être utilisés par cinq personnes au maximum (5) des développeurs dans une infinité de lieux (spécifié comme une adresse physique ou un immeuble de bureaux) ou dans le nuage avec une License Unlimited.

Licence OEM et SaaS (6+ développeurs)

Pour ce faire, il suffit de contacter le service des ventes.

Conclusion

Dans les applications et les sites Web .NET, IronXL for .NET permet aux développeurs de lire, de produire et de modifier des fichiers Excel (et autres fichiers de tableurs). Les fichiers XLS/XLSX/CSV/TSV peuvent être lus et édités, et les exportations peuvent être sauvegardées en XLS/XLSX/CSV/TSV/JSON. Il est compatible avec le Framework .NET, .NET Core et Azure. Tout cela se fait sans avoir besoin de dépendances supplémentaires ou d'installer Microsoft Office. Si vous avez déjà eu l'impression qu'Excel entravait vos compétences en matière de gestion de bureau .NET, IronXL est là pour vous aider. C'est pourquoi nous avons créé le logiciel Bibliothèque C# pour Excelqui vous permet de lire, de générer et de modifier des fichiers Excel dans des applications et des sites Web .NET en tant que développeur performant.

GcExcel (Documents de GrapeCity pour Excel) est une API de tableur rapide et peu encombrante qui ne nécessite pas Excel. Vous pouvez générer, charger, modifier et convertir des feuilles de calcul dans .NET Framework, .NET Core, Mono et Xamarin avec une prise en charge complète de .NET Standard 2.0. Cette API de tableur peut être utilisée pour créer des applications pour le cloud, Windows, Mac et Linux. Grâce à son moteur de calcul sophistiqué et à son large éventail de fonctionnalités, vous n'aurez jamais à sacrifier la conception ou les exigences.

La licence Excel de GrapeCity commence à 995 $ par développeur, par rapport à $749 pour IronXL, qui vient avec l'avantage d'un plan multi-utilisateurs illimité et libre de droits, ce qui devient moins cher lorsque vous achetez pour un grand nombre de développeurs plutôt que GCexcel qui a un maximum de 6 utilisateurs sur ses plans ultra multi-utilisateurs.

IronXL est préféré à d'autres solutions C# en raison de son efficacité dans le traitement des documents Excel. IronXL se distingue également par ses méthodes opérationnelles qui favorisent des lignes de code plus courtes.

Iron Software offre actuellement à tous ses clients et utilisateurs la possibilité d'acquérir l'ensemble de la suite Iron Software en deux clics - pour le prix de seulement deux logiciels de la suite Iron Software, vous pouvez obtenir les cinq logiciels ainsi qu'une assistance ininterrompue.

< PRÉCÉDENT
Comparaison entre IronXL et ClosedXML

SUIVANT >
Comparaison entre IronXL et Syncfusion Excel