Créez un panier PDF avec IronPDF et des paramètres !
class Program
{
public static void Main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items [i]);
}
}
// take input from console
Console.WriteLine("Enter the cart items as comma seperated values");
var itemsString = Console.ReadLine();
// read the items
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
// add to cart
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("------------------------------------------------");
Console.WriteLine("Display Cart");
Console.WriteLine("------------------------------------------------");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}
Params C# (Comment ça marche pour les développeurs)
Kannapat Udonpant
mars 26, 2024
Partager:
Le mot-clé params en C# est une fonctionnalité puissante de .NET qui permet à une méthode d'accepter un nombre variable d'arguments. Cela peut simplifier considérablement la syntaxe lors de l'appel de méthodes nécessitant un nombre variable de paramètres. Dans ce guide complet, nous allons explorer le mot-clé params en C#, sa syntaxe, ses cas d'utilisation et ses meilleures pratiques. Dans la suite de cet article, nous présenterons leIronPDF bibliothèque deIron Software et expliquer comment utiliser le mot-clé params et IronPDF pour générer des PDF.
Qu'est-ce que le type d'argument C# ; Params ?
Dans le domaine du C#, les méthodes respectent généralement un ensemble prédéterminé de paramètres. Néanmoins, il existe des situations où l'on peut se trouver dans l'incertitude quant au nombre précis d'arguments destinés à une méthode. Le mot-clé "params" est une solution qui permet de spécifier un paramètre de méthode capable d'accueillir un tableau d'arguments. Cette fonctionnalité s'avère précieuse lorsque le développeur n'est pas sûr du nombre exact d'arguments à l'avance, facilitant le passage d'un nombre indéterminé ou optionnel de paramètres, tous du même type, au sein d'une déclaration de méthode.
public class ParamsExample
{
public void PrintMessages(params string [] messages)
{
foreach (var message in messages)
{
Console.WriteLine(message);
}
}
}
// Usage
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// more examples
public static void AddItemsToShoppingBasket(params string [] items)
{
// ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) // params int
{
// ....
}
public class ParamsExample
{
public void PrintMessages(params string [] messages)
{
foreach (var message in messages)
{
Console.WriteLine(message);
}
}
}
// Usage
class Program {
public static void main(){
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// more examples
public static void AddItemsToShoppingBasket(params string [] items)
{
// ....
}
public static void AddItemsSumToShoppingBasket(params int [] sum) // params int
{
// ....
}
Public Class ParamsExample
Public Sub PrintMessages(ParamArray ByVal messages() As String)
For Each message In messages
Console.WriteLine(message)
Next message
End Sub
End Class
' Usage
Friend Class Program
Public Shared Sub main()
Dim example = New ParamsExample()
example.PrintMessages("Hello", "World", "!")
End Sub
' more examples
Public Shared Sub AddItemsToShoppingBasket(ParamArray ByVal items() As String)
' ....
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) ' params int
' ....
End Sub
$vbLabelText $csharpLabel
la méthode "AddItemsToShoppingBasket" peut être invoquée avec un nombre variable d'arguments de type chaîne de caractères. Le mot-clé objet params simplifie la syntaxe de l'appel de méthode en permettant aux développeurs de passer les paramètres optionnels directement, sans créer explicitement un tableau d'entrée.
class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid with zero parameters default value
}
class Program {
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid with zero parameters default value
}
Friend Class Program
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() ' Valid with zero parameters default value
End Class
$vbLabelText $csharpLabel
Considérations et bonnes pratiques
Positionner le paramètre params à la fin de la liste des paramètres : Il est recommandé de placer le paramètre params à la fin de la liste des paramètres de la méthode. Cette pratique favorise la clarté et permet d'éviter toute confusion lors de l'appel d'une méthode. Les paramètres nécessitant des valeurs explicites doivent précéder les params pour une organisation efficace.
Spécifier explicitement les paramètres non paramétrés : Lors de l'invocation d'une méthode avec des paramètres, veiller à fournir explicitement des valeurs pour les paramètres non paramétriques. Cette pratique permet d'éviter toute ambiguïté et garantit l'invocation exacte de la méthode avec le nombre d'arguments requis.
Faites preuve de prudence pour éviter toute ambiguïté : La vigilance est de mise lors de l'utilisation de params dans des méthodes ayant plusieurs surcharges ou des paramètres du même type. Le compilateur peut avoir du mal à déterminer la méthode appropriée à invoquer, ce qui peut entraîner des erreurs d'ambiguïté.
Explorer d'autres approches : Bien que les paramètres soient pratiques, il convient d'envisager d'autres méthodes dans certains cas. En utilisant des collections telles que Listpeut être préférable pour améliorer les fonctionnalités ou lorsque le passage de paramètres nommés correspond à vos objectifs.
Appliquer judicieusement aux scénarios pertinents : Déployer judicieusement les params dans les scénarios où le nombre de paramètres est variable et peut fluctuer d'un appel de méthode à l'autre. Réserver son utilisation aux situations où le nombre de paramètres est imprévisible, en évitant de l'appliquer lorsque le nombre de paramètres est fixe et connu.
Tableau unidimensionnel pour le type de paramètre
AddItemsToShoppingBasket peut également être utilisé en appelant un tableau à une dimension.
// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}
// example
class Program {
public static void main()
{
var items = [] {"cold drink", "snack", "roll", }; // 1D string array
AddItemsToShoppingBasket(items); // works
AddItemsToShoppingBasket( "cold drink", "coke", "roll",); // same as above line
}
}
' example
Friend Class Program
Public Shared Sub main()
Dim items = () {"cold drink", "snack", "roll"} ' 1D string array
AddItemsToShoppingBasket(items) ' works
AddItemsToShoppingBasket("cold drink", "coke", "roll",) ' same as above line
End Sub
End Class
$vbLabelText $csharpLabel
Passer un tableau d'arguments de même type séparés par des virgules
AddItemsToShoppingBasket peut également être appelé en passant une liste/un tableau de variables dans l'appel de la méthode, comme ci-dessous.
// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks");
}
// example method signature
class Program {
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // comma separated values
AddItemsToShoppingBasket("snacks");
}
' example method signature
Friend Class Program
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") ' comma separated values
AddItemsToShoppingBasket("snacks")
End Class
$vbLabelText $csharpLabel
Transmettre un tableau du type défini
Le tableau doit contenir le même type que celui défini dans la méthode params, sinon l'erreur suivante est générée
// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error
AddItemsToShoppingBasket(2,3,4); // error as params type is string
// example
AddItemsToShoppingBasket("snacks",2,"burger"); // error
AddItemsToShoppingBasket(2,3,4); // error as params type is string
' example
AddItemsToShoppingBasket("snacks",2,"burger") ' error
AddItemsToShoppingBasket(2,3,4) ' error as params type is string
$vbLabelText $csharpLabel
Erreur de syntaxe car il y a une incompatibilité de type avec les paramètres définis dans la méthode.
Toujours le dernier paramètre de la méthode
Aucun paramètre supplémentaire n'est autorisé après le paramètre params dans une déclaration de signature de méthode, et un seul argument params est autorisé dans une déclaration de paramètres de méthode.
La signature de la méthode doit comporter des paramètres définis à la fin, aucun paramètre n'étant autorisé après. Définir ainsi conduit à des erreurs de compilation.
class program {
static void Main(string [] args){
// example 1
public static void AddItemsToShoppingBasket(double total, params string [] items)
{
// ....
} // This works
}
}
example 2
static void Main(string [] args){
public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
{
// ....
} // This works
}
// example 3 error scenario
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
{
// error
} // params keyword is defined as first parameter, needs to be at the last.
}
class program {
static void Main(string [] args){
// example 1
public static void AddItemsToShoppingBasket(double total, params string [] items)
{
// ....
} // This works
}
}
example 2
static void Main(string [] args){
public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
{
// ....
} // This works
}
// example 3 error scenario
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
{
// error
} // params keyword is defined as first parameter, needs to be at the last.
}
Friend Class program
Shared Sub Main(ByVal args() As String)
' example 1
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public static void AddItemsToShoppingBasket(double total, params string [] items)
' {
' ' ....
' } ' This works
End Sub
End Class
example 2 Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public static void AddItemsToShoppingBasket(double total, int total, params string [] items)
' {
' ' ....
' } ' This works
End Sub
' example 3 error scenario
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public static void AddItemsToShoppingBasket(params string [] items, decimal total, int total)
' {
' ' error
' } ' params keyword is defined as first parameter, needs to be at the last.
End Sub
$vbLabelText $csharpLabel
Un seul mot-clé params
Un seul paramètre params est autorisé dans la signature d'une méthode. Le compilateur lance une erreur si plus d'un mot-clé params est trouvé dans la signature de la méthode.
//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work.
}
}
//only one params keyword example
class Program {
static void Main(string [] args){
public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
{
} // Compiler error, This does not work.
}
}
'only one params keyword example
Friend Class Program
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public static void AddItemsToShoppingBasket(params string [] items, params string [] quantity)
'{
'} ' Compiler error, This does not work.
End Sub
End Class
$vbLabelText $csharpLabel
Vous pouvez ne passer aucun argument
Si une méthode n'a qu'un paramètre avec le mot-clé params, elle peut être appelée sans aucun argument comme ci-dessous et le compilateur ne lancera pas d'erreur.
AddItemsToShoppingBasket(); // Works
AddItemsToShoppingBasket(); // Works
AddItemsToShoppingBasket() ' Works
$vbLabelText $csharpLabel
Pour tout paramètre avec params, l'argument est considéré comme un paramètre optionnel et peut être appelé sans passer de paramètres.
Exemple de code
Créez une nouvelle application console. Ouvrez Visual Studio, créez un nouveau projet et sélectionnez le type d'application console.
Ajoutez maintenant le code ci-dessous.
class Program {
Console.WriteLine("Params demo");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] samples)
{
for (int i = 0; i < samples.Length; i++)
{
cart.Add(samples [i]);
}
}
// caller code
static void Main(string [] args) {
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
foreach (var item in cart)
{
Console.WriteLine(item);
}
}
}
class Program {
Console.WriteLine("Params demo");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] samples)
{
for (int i = 0; i < samples.Length; i++)
{
cart.Add(samples [i]);
}
}
// caller code
static void Main(string [] args) {
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
foreach (var item in cart)
{
Console.WriteLine(item);
}
}
}
Friend Class Program
Console.WriteLine("Params demo")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void AddItemsToShoppingBasket(params string [] samples)
'{
' for (int i = 0; i < samples.Length; i++)
' {
' cart.Add(samples [i]);
' }
'}
' caller code
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static void Main(string [] args)
'{
'Console.WriteLine("Enter the cart items as comma separated values");
'var itemsString = Console.ReadLine();
'if (itemsString != Nothing)
'{
' var items = itemsString.Split(",").ToArray();
' AddItemsToShoppingBasket(items);
'}
'AddItemsToShoppingBasket("Sample1", "Sample2");
'Console.WriteLine("-------------------------------------------------------");
'Console.WriteLine("Display Cart");
'foreach (var item in cart)
'{
' Console.WriteLine(item);
'}
'}
End Class
$vbLabelText $csharpLabel
Sortie
Présentation de IronPDF
La bibliothèque PDF IronPDF C# d'Iron Software est une bibliothèque polyvalente qui permet de lire, d'écrire et de gérer des documents PDF en C#. Il prend en charge tous les types de développement d'applications modernes comme les applications mobiles, les sites Web, les ordinateurs de bureau, Docker, etc. Il prend également en charge différents systèmes d'exploitation tels que Windows, Linux, Unix, etc. Il ne dépend pas des méthodes natives du système d'exploitation.
IronPDF excelle dans les domaines suivantsHTML vers PDFconversion, garantissant une préservation précise des mises en page et des styles originaux. C'est parfait pour créer des PDF à partir de contenus basés sur le web, tels que des rapports, des factures et de la documentation. Avec la prise en charge des fichiers HTML, des URL et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End Class
$vbLabelText $csharpLabel
Installation
La bibliothèque IronPDF peut être installée à l'aide du fichierNuGet avec la commande ci-dessous ou en utilisant le gestionnaire de paquets de Visual Studio.
dotnet add package IronPdf
dotnet add package IronPdf
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf
$vbLabelText $csharpLabel
Utilisation d'IronPDF pour générer un PDF
Nous allons maintenant utiliser IronPDF pour générer le document PDF à partir de l'exemple ci-dessus.
class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items [i]);
}
}
// take input from console
Console.WriteLine("Enter the cart items as comma seperated values");
var itemsString = Console.ReadLine();
// read the items
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
// add to cart
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("------------------------------------------------");
Console.WriteLine("Display Cart");
Console.WriteLine("------------------------------------------------");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}
class program
{
public static void main()
{
Console.WriteLine("IronPDF to generate the PDF document for Params Example");
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string [] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items [i]);
}
}
// take input from console
Console.WriteLine("Enter the cart items as comma seperated values");
var itemsString = Console.ReadLine();
// read the items
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
// add to cart
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("------------------------------------------------");
Console.WriteLine("Display Cart");
Console.WriteLine("------------------------------------------------");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}
Imports Microsoft.VisualBasic
Friend Class program
Public Shared Sub main()
Console.WriteLine("IronPDF to generate the PDF document for Params Example")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void AddItemsToShoppingBasket(params string [] items)
'{
' for (int i = 0; i < items.Length; i++)
' {
' cart.Add(items [i]);
' }
'}
' take input from console
Console.WriteLine("Enter the cart items as comma seperated values")
Dim itemsString = Console.ReadLine()
' read the items
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItemsToShoppingBasket(items)
End If
' add to cart
AddItemsToShoppingBasket("Sample1", "Sample2")
Console.WriteLine("------------------------------------------------")
Console.WriteLine("Display Cart")
Console.WriteLine("------------------------------------------------")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
' Create a new PDF document
Dim pdfDoc = New ChromePdfRenderer()
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
End Sub
End Class
$vbLabelText $csharpLabel
Dans le code ci-dessus, nous générons un document HTML pour les articles du panier, puis nous l'enregistrons en tant que document PDF à l'aide de la commandeIronPDF.
Sortie
Licence (essai gratuit disponible)
IronPDF nécessite une clé de licence pour fonctionner en production. Une clé d'essai peut être obtenue à partir de la page de licenceici. Placez la clé dans appsettings.json.
"IronPdf.LicenseKey": "your license key"
"IronPdf.LicenseKey": "your license key"
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"
$vbLabelText $csharpLabel
Indiquez votre adresse e-mail pour recevoir une licence d'essai à votre adresse e-mail.
Conclusion
Le mot-clé params en C# avec .NET 8 offre un moyen flexible de gérer les méthodes qui requièrent un nombre variable de paramètres. Il simplifie les appels de méthodes et rend le code plus lisible et plus facile à maintenir. Ensemble avecIronPDFil s'agit d'une excellente combinaison de compétences pour tout programmeur qui souhaite écrire un code propre.
Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.
< PRÉCÉDENT C# PostgreSQL (Comment ça marche pour les développeurs)
SUIVANT > Enums C# (Comment ça marche pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier