Salut tout le monde !

Parfois, lorsqu’on conçoit une méthode de classe et qu’on y ajoute de plus en plus de fonctionnalités utiles, le nombre de paramètres peut rapidement atteindre 10, voire plus.

Cela devient alors assez difficile pour les utilisateurs de ces méthodes utiles de se rappeler de la position des paramètres importants, et il devient très facile de se tromper en inversant des valeurs entre paramètres.

Voici un exemple d’une telle méthode (j’ai demandé à GPT de me créer une méthode avec 20 paramètres) :

ClassMethod GenerateReportWith20Params(
    pTitle As %String = "",
    pAuthor As %String = "",
    pDate As %String = "",            // ex. 2025-09-03
    pCompany As %String = "",
    pDepartment As %String = "",
    pVersion As %String = "1.0",
    pFormat As %String = "pdf",      // pdf|html|docx
    pIncludeCharts As %Boolean = 1,
    pIncludeSummary As %Boolean = 1,
    pIncludeAppendix As %Boolean = 0,
    pConfidentiality As %String = "Public",
    pLanguage As %String = "en",
    pReviewers As %String = "",      // CSV, ex. "Alice,Bob"
    pApprover As %String = "",
    pLogoPath As %String = "",
    pWatermarkText As %String = "",
    pColorScheme As %String = "default",
    pPageSize As %String = "A4",
    pOrientation As %String = "Portrait",
    pOutputPath As %String = "report.pdf"
) As %Status
{
    // implémentation
}

Magnifique, n’est-ce pas ? :)

Et voici un exemple d’utilisation, en ne fournissant que les paramètres 1, 2, 5, 13 et 19 :

Do ##class(Report.Generator).GenerateReport(
    "Rapport Financier Annuel",   // 1 : pTitle
    "Jane Doe",                   // 2 : pAuthor
    ,,                            // 3–4 sautés
    "Finance",                    // 5 : pDepartment
    ,,,,,,,                       // 6–12 sautés
    "Alice,Bob",                  // 13 : pReviewers
    ,,,,,                         // 14–18 sautés
    "Landscape"                   // 19 : pOrientation
    // 20 (pOutputPath) omis -> valeur par défaut utilisée
)

Une soupe de virgules.

Il existe bien sûr plusieurs manières d’atténuer ce problème. C’est là, par exemple, que l’approche JSON peut être très utile. J’ai découvert cette utilisation dans la très utile bibliothèque bdb-sql-utils de @Benjamin De Boe, par exemple ici, où les paramètres sont fournis sous forme de JSON puis analysés dans la méthode :

do ##class(bdb.sql.InferSchema).BuildAll("/tmp/data-dump/*.csv", { "verbose": 1, "targetSchema": "MySchema" })

J’ai trouvé ça très malin et j’ai utilisé la même approche dans la bibliothèque csvgen, où j’ai introduit la méthode Gen() (alias de Generate()), qui accepte 6 paramètres raisonnables au lieu de 11.

Signature de Generate :

/// génère une classe à partir d’un CSV arbitraire. Toutes les propriétés sont VARCHAR(250)
/// fncsv - chemin vers le fichier CSV
/// dlm - délimiteur
/// pguessTypes - tentative de deviner les types
/// pclass - nom de la classe (si non fourni, il sera généré et renvoyé par référence)
/// recordCount - nombre d’enregistrements créés (renvoyé par référence)
/// pverbose=1 - affiche des commentaires dans le terminal
/// pappend=0 - ajoute les données à une classe existante si activé
/// ploaddata=1 - utilise LOAD DATA si disponible
/// pheader=1 - saute la première ligne (entête)
/// pkey - si renseigné, définit une colonne comme clé primaire
ClassMethod Generate(fncsv As %String, dlm As %String = ",", ByRef pclass As %String, ByRef prowtype As %String, pguessTypes As %Boolean = 1, Output recordsCount As %Integer, pverbose As %Boolean = 1, pappend As %Boolean = 0, ploaddata As %Boolean = 1, pheader As %Boolean = 1, pkey As %String = "") As %Status

Signature de Gen :

///  do ##class(community.csvgen).Gen("/tmp/data-dump/file.csv",,"package.class",,{ "verbose": 1, "guessTypes": 1, "append": 0, "LoadData": 1, "header": 1, "primaryKey": "colname" },.recordsCount)
ClassMethod Gen(fncsv As %String, dlm As %String = ",", ByRef pclass As %String, ByRef prowtype As %String, qualifiers As %String = "", Output recordsCount As %Integer)

À l’intérieur de la méthode, le JSON est analysé dans une variable clé-valeur, ce qui permet de traiter les paramètres de manière plus souple :

ClassMethod FlattenQualifiers(ByRef qf, obj As %DynamicObject, prefix As %String = "") [ Internal, Private ]
{
    set iterator = obj.%GetIterator()
    while iterator.%GetNext(.key, .value) {
        set sub = $s(prefix="":$$$LOWER(key), 1:prefix_"."_$$$LOWER(key))
        if $isobject(value) {
            do ..FlattenQualifiers(.qf, value, sub)
        } else {
            set qf(sub) = value
        }
    }
}

Et voici un exemple d’appel, lorsque l’on veut définir une clé primaire :

Appel de Generate :

set status=##class(community.csvgen).Generate(fn,",",.pclass,.prowtype,1,.tResults,,,,,"name")

Je dois taper 5 virgules avant de pouvoir fournir le paramètre voulu.

Appel de Gen :

set status=##class(community.csvgen).Gen(fn,",",.pclass,.prowtype,{"verbose":1,"primarykey":"name"},.tResults)

Ici, je fournis uniquement les paramètres dont j’ai besoin, et il est clair de voir ce qui est spécifié. C’est pourquoi je voulais partager cette expérience avec vous, formidable communauté de développeurs InterSystems !

Encore merci à @Benjamin De Boe et à JSON, qui rendent la vie plus simple pour les développeurs ObjectScript !

Bon codage à tous !