.NET Framework (se prononce « point NET ») est un framework logiciel développé par Microsoft qui s'exécute principalement sur Microsoft Windows.
Prise en charge de .NET dans la plateforme de données InterSystems.
Bonjour à tous et a toutes,
Nous sommes heureux d'annoncer le nouveau concours de programmation en ligne InterSystems :
🏆 Concours InterSystems sur .Net, Java, Python et JavaScript 🏆
Durée : du 22 septembre au 12 octobre 2025
Prix : 12 000 $
(3).jpg)
InterSystems IRIS fournit un environnement de développement d'applications complet pour créer des applications sophistiquées à forte intensité de données et d'analyses qui connectent les silos de données et d'applications. Il est conçu pour fonctionner avec toutes les technologies de développement courantes de manière ouverte et basée sur des normes et prend en charge la programmation côté serveur et côté client.
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur le moyen de se connecter aux InterSystems Cloud Services à partir de votre application .NET à l'aide de l'InterSystems ADO.NET Managed Provider.
Pour parler des différentes bases de données et des différents modèles de données qui existent, on doit premièrement comprendre ce qui est une base de données et comment les utiliser.
Une base de données est une collection organisée de données stockées et accessibles par voie électronique. Elle permet de stocker et de retrouver des données structurées, semi-structurées ou des données brutes souvent en rapport avec un thème ou une activité.
Au cœur de chaque base de données se trouve au moins un modèle utilisé pour décrire ses données. Et selon le modèle sur lequel elle est basée, elle peut avoir des caractéristiques un peu différentes et stocker différents types de données.
Pour inscrire, retrouver, modifier, trier, transformer ou imprimer les informations de la base de données on utilise un logiciel qui s’appelle système de gestion de base de données (SGBD, en anglais DBMS pour Database management system).
La taille, les capacités et les performances des bases de données et de leurs SGBD respectifs ont augmenté de plusieurs ordres de grandeur. Ces augmentations de performances ont été rendues possibles par les progrès technologiques dans différents domaines, tels que les domaines des processeurs, de la mémoire informatique, du stockage informatique et des réseaux informatiques. Le développement ultérieur de la technologie des bases de données peut être divisé en quatre générations basées sur le modèle ou la structure des données : navigation, relationnel, objet et post-relationnel.
Ceci est un client fhir simple en c# pour s'exercer avec les ressources fhir et les requêtes CRUD vers un serveur fhir.
Notez que pour la majeure partie, l'autocomplétion est activée.
Assurez-vous que git et Docker desktop sont installé.
Si vous travaillez à l'intérieur du conteneur, ces modules sont déjà installés.
Si ce n'est pas le cas, utilisez nugget pour installer Hl7.Fhir.R4, nous allons utiliser Model et Rest à partir de celui-ci :
Hl7.Fhir.Model
Clone/git tire le repo dans n'importe quel répertoire local, par exemple comme indiqué ci-dessous :
git clone https://github.com/LucasEnard/fhir-client-net.git
Ouvrez le terminal dans ce répertoire et lancez :
docker build .
Ce référentiel est prêt pour VS Code.
Ouvrez le dossier fhir-client-net cloné localement dans VS Code.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Vous pouvez être à l'intérieur du conteneur avant de coder si vous le souhaitez.
Pour cela, il faut que docker soit activé avant d'ouvrir VSCode.
Ensuite, dans VSCode, lorsque vous y êtes invité ( coin inférieur droit ), rouvrez le dossier à l'intérieur du conteneur afin de pouvoir utiliser les composants python qu'il contient.
La première fois que vous effectuez cette opération, cela peut prendre plusieurs minutes, le temps que le conteneur soit préparé.
Si vous n'avez pas cette option, vous pouvez cliquer dans le coin inférieur gauche et cliquer sur press reopen in container puis sélectionner From Dockerfile
En ouvrant le dossier à distance, vous permettez à VS Code et à tous les terminaux que vous ouvrez dans ce dossier d'utiliser les composants c# dans le conteneur.
Si vous y êtes invité (coin inférieur droit), installez les extensions recommandées.
Pour réaliser cette présentation, vous aurez besoin d'un serveur FHIR.
Vous pouvez soit utiliser le vôtre, soit vous rendre sur le site InterSystems free FHIR trial et suivre les étapes suivantes pour le configurer.
En utilisant notre essai gratuit, il suffit de créer un compte et de commencer un déploiement, puis dans l'onglet Overview vous aurez accès à un endpoint comme https://fhir.000000000.static-test-account.isccloud.io que nous utiliserons plus tard.
Ensuite, en allant dans l'onglet d'informations d'identification Credentials, créez une clé api et enregistrez-la quelque part.
C'est maintenant terminé, vous avez votre propre serveur fhir pouvant contenir jusqu'à 20 Go de données avec une mémoire de 8 Go.
La présentation pas à pas du client se trouve à /Client.cs.
Le code est divisé en plusieurs parties, et nous allons couvrir chacune d'entre elles ci-dessous.
Dans cette partie, nous connectons notre client à notre serveur en utilisant Fhir.Rest.
// Partie 1
// Creation of an htpclient holding the api key of the server as an header
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("x-api-key", "api-key");
var settings = new FhirClientSettings
{
Timeout = 0,
PreferredFormat = ResourceFormat.Json,
VerifyFhirVersion = true,
// PreferredReturn can take Prefer.ReturnRepresentation or Prefer.ReturnMinimal to return the full resource or an empty payload
PreferredReturn = Prefer.ReturnRepresentation
};
// Création de notre client en utilisant une correcte url
var client = new FhirClient("url",httpClient,settings);
Afin de vous connecter à votre serveur, vous devez modifier la ligne :
httpClient.DefaultRequestHeaders.Add("x-api-key", "api-key");
Et cette ligne aussi :
var client = new FhirClient("url",httpClient,settings);
L'url' est un point de terminaison tandis que l'"api-key" est la clé d'api pour accéder à votre serveur.
Notez que si vous n'utilisez pas un serveur InterSystems, vous pouvez vérifier comment autoriser vos accès si nécessaire.
Comme ça, nous avons un client FHIR capable d'échanger directement avec notre serveur.
Dans cette partie, nous créons un Patient en utilisant Fhir.Model et nous le complétons avec un HumanName, en suivant la convention FHIR, use et family sont des chaînes et given est une liste de chaînes. De la même manière, un patient peut avoir plusieurs HumanNames, donc nous devons mettre notre HumanName dans une liste avant de le mettre dans notre patient nouvellement créé.
// Partie 2
// Building a new patient and setting the names
var patient0 = new Patient();
patient0.Name.Add(new HumanName().WithGiven("GivenName").AndFamily("FamilyName"));
// Creation of our client in the server
// It is to be noted that using SearchParams you can check if an equivalent resource already exists in the server
// For more information https://docs.fire.ly/projects/Firely-NET-SDK/client/crud.html
var created_pat = client.Create<Patient>(patient0);
Console.Write("Partie 2 : Identifiant du patient nouvellement créé : ");
Console.WriteLine(created_pat.Id);
Après cela, nous devons sauvegarder notre nouveau Patient sur notre serveur en utilisant notre client.
Notez que si vous lancez Client.cs plusieurs fois, plusieurs Patients ayant le nom que nous avons choisi seront créés.
C'est parce que, suivant la convention FHIR, vous pouvez avoir plusieurs Patients avec le même nom, seul l' id est unique sur le serveur.
Vérifier la documentation pour avoir plus d'information.
Il est à noter qu'en utilisant SearchParams vous pouvez vérifier si une ressource équivalente existe déjà sur le serveur avant de la créer.
Pour plus d'information https://docs.fire.ly/projects/Firely-NET-SDK/client/crud.html
Nous conseillons donc de commenter la ligne après le premier lancement.
Dans cette partie, nous avons un client qui recherche un patient nommé d'après celui que nous avons créé précédemment.
// Part 3
// This gets all the Patient having the exact name "FamilyName" and we take the first one
// Note that if you have multiple patients with the same name, you will get only the first one
// We advise to use the id, the names, and any other informations for the SearchParams to be sure to get the right patient
var q = new SearchParams().Where("name:exact=FamilyName");
Bundle bund = client.Search<Patient>(q);
patient0 = bund.Entry[0].Resource as Patient;
Console.Write("Part 3 : Name of the patient we found by searching : ");
Console.WriteLine(patient0.Name[0]);
// Creation of our patient telecom, here a phone number
patient0.Telecom.Add(new ContactPoint(new ContactPoint.ContactPointSystem(),new ContactPoint.ContactPointUse(),"1234567890"));
// Change the given name of our patient
patient0.Name[0].Given = new List<string>() { "AnotherGivenName" };
Console.Write("Part 3 : Name of the changed patient : ");
Console.WriteLine(patient0.Name[0]);
Console.Write("Part 3 : Phone of the changed patient : ");
Console.WriteLine(patient0.Telecom[0].Value);
// Update the patient
var update_pat = client.Update<Patient>(patient0);
Une fois que nous l'avons trouvé, nous ajoutons un numéro de téléphone à son profil et nous changeons son prénom en un autre.
Maintenant nous pouvons utiliser la fonction de mise à jour de notre client pour mettre à jour notre patient sur le serveur.
Dans cette section, nous voulons créer une observation pour notre patient. Pour ce faire, nous avons besoin de son identifiant, qui est son identifiant unique.
A partir de là, nous remplissons notre observation et ajoutons comme sujet, l'identifiant de notre Patient.
// Part 4
// Building of our new observation
Observation obsv = new Observation {
Value = new Quantity(70, "kg"),
Code = new CodeableConcept {
Coding = new List<Coding> {
new Coding {
System = "http://loinc.org",
Code = "29463-7",
Display = "Body weight"
}
}},
Category = new List<CodeableConcept> {
new CodeableConcept {
Coding = new List<Coding> {
new Coding {
System = "http://snomed.info/sct",
Code = "276327007",
Display = "Body weight"
}
}
}},
Status = new ObservationStatus {},
Subject = new ResourceReference {
Reference = "Patient/" + update_pat.Id}
};
// Creation of our observation in the server
var new_obsv = client.Create<Observation>(obsv);
Console.Write("Part 4 : Id of the observation : ");
Console.WriteLine(new_obsv.Id);
Ensuite, nous enregistrons notre observation à l'aide de la fonction create.
Si vous avez suivi ce parcours, vous savez maintenant exactement ce que fait Client.cs, vous pouvez le lancer et vérifier votre Patient et votre Observation nouvellement créés sur votre serveur.
Pour le lancer, ouvrez un terminal VSCode et entrez :
dotnet run
Vous devriez voir des informations sur le Patient créé et son observation.
Si vous utilisez un serveur Intersystems, allez à API Deployement, autorisez-vous avec la clé api et d'ici vous pouvez OBTENIR par id le patient et l'observation que nous venons de créer.
Ce référentiel est prêt à être codé dans VSCode avec les plugins InterSystems.
Ouvrez Client.cs pour commencer à coder ou utiliser l'autocomplétion.
Un dockerfile pour créer un dot net env pour que vous puissiez travailler.
Utilisez docker build . pour construire et rouvrir votre fichier dans le conteneur pour travailler à l'intérieur de celui-ci.
Fichier de paramètres
Fichier de configuration si vous voulez déboguer
Dans cet article, je vais vous montrer comment vous pouvez facilement conteneuriser les passerelles .Net/Java.
Pour notre exemple, nous allons développer une intégration avec Apache Kafka.
Et pour interopérer avec le code Java/.Net, nous utiliserons PEX.
Notre solution fonctionnera entièrement dans docker et ressemblera à ceci :
Tout d'abord, nous allons développer l'opération Java pour envoyer des messages dans Kafka. Le code peut être écrit dans l'IDE de votre choix et il peut ressembler à ceci.
En bref :
Maintenant, plaçons-le dans Docker !
Voici notre dockerfile :
FROM openjdk:8 AS builder
ARG APP_HOME=/tmp/app
COPY src $APP_HOME/src
COPY --from=intersystemscommunity/jgw:latest /jgw/*.jar $APP_HOME/jgw/
WORKDIR $APP_HOME/jar/
ADD https://repo1.maven.org/maven2/org/apache/kafka/kafka-clients/2.5.0/kafka-clients-2.5.0.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar .
ADD https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar .
WORKDIR $APP_HOME/src
RUN javac -classpath $APP_HOME/jar/*:$APP_HOME/jgw/* dc/rmq/KafkaOperation.java && \
jar -cvf $APP_HOME/jar/KafkaOperation.jar dc/rmq/KafkaOperation.class
FROM intersystemscommunity/jgw:latest
COPY --from=builder /tmp/app/jar/*.jar $GWDIR/
Allons-y ligne par ligne et voyons ce qui se passe ici (je suppose que vous connaissez les constructions docker à plusieurs niveaux) :
FROM openjdk:8 AS builder
Notre image de départ est JDK 8.
ARG APP_HOME=/tmp/app
COPY src $APP_HOME/src
Nous copions nos sources du dossier /src dans le dossier /tmp/app.
COPY --from=intersystemscommunity/jgw:latest /jgw/*.jar $APP_HOME/jgw/
Nous copions les sources de la passerelle Java dans le dossier /tmp/app/jgw.
WORKDIR $APP_HOME/jar/
ADD https://repo1.maven.org/maven2/org/apache/kafka/kafka-clients/2.5.0/kafka-clients-2.5.0.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar .
ADD https://repo1.maven.org/maven2/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar .
ADD https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar .
WORKDIR $APP_HOME/src
RUN javac -classpath $APP_HOME/jar/*:$APP_HOME/jgw/* dc/rmq/KafkaOperation.java && \
jar -cvf $APP_HOME/jar/KafkaOperation.jar dc/rmq/KafkaOperation.class
Maintenant toutes les dépendances sont ajoutées et javac/jar est appelé pour compiler le fichier jar. Pour un projet concret, il est préférable d'utiliser maven ou gradle.
FROM intersystemscommunity/jgw:latest
COPY --from=builder /tmp/app/jar/*.jar $GWDIR/
Et enfin, les jars sont copiés dans l'image de base jgw (l'image de base se charge également du démarrage de la passerelle et des tâches connexes).
Vient ensuite le service .Net qui recevra les messages de Kafka. Le code peut être écrit dans l'IDE de votre choix et il peut ressembler à ceci.
En bref :
Maintenant, plaçons-le dans Docker !
Voici notre dockerfile :
FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build
ENV ISC_PACKAGE_INSTALLDIR /usr/irissys
ENV GWLIBDIR lib
ENV ISC_LIBDIR ${ISC_PACKAGE_INSTALLDIR}/dev/dotnet/bin/Core21
WORKDIR /source
COPY --from=store/intersystems/iris-community:2020.2.0.211.0 $ISC_LIBDIR/*.nupkg $GWLIBDIR/
# copier csproj et restaurer en tant que couches distinctes
COPY *.csproj ./
RUN dotnet restore
# copier et publier l'application et les bibliothèques
COPY . .
RUN dotnet publish -c release -o /app
# étape/image finale
FROM mcr.microsoft.com/dotnet/core/runtime:2.1
WORKDIR /app
COPY --from=build /app ./
# Configurations pour démarrer le serveur passerelle
RUN cp KafkaConsumer.runtimeconfig.json IRISGatewayCore21.runtimeconfig.json && \
cp KafkaConsumer.deps.json IRISGatewayCore21.deps.json
ENV PORT 55556
CMD dotnet IRISGatewayCore21.dll $PORT 0.0.0.0
Allons-y ligne par ligne :
FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build
Nous utilisons le SDK complet .Net Core 2.1 pour construire notre application.
ENV ISC_PACKAGE_INSTALLDIR /usr/irissys
ENV GWLIBDIR lib
ENV ISC_LIBDIR ${ISC_PACKAGE_INSTALLDIR}/dev/dotnet/bin/Core21
WORKDIR /source
COPY --from=store/intersystems/iris-community:2020.2.0.211.0 $ISC_LIBDIR/*.nupkg $GWLIBDIR/
Copiez .Net Gateway NuGets de l'image Docker officielle d'InterSystems dans notre image de constructeur
# copier csproj et restaurer comme couches distinctes
COPY *.csproj ./
RUN dotnet restore
# copier et publier l'application et les bibliothèques
COPY . .
RUN dotnet publish -c release -o /app
Construisez notre bibliothèque.
# étape/image finale
FROM mcr.microsoft.com/dotnet/core/runtime:2.1
WORKDIR /app
COPY --from=build /app ./
Copiez les dll de la bibliothèque dans le conteneur final que nous exécuterons réellement.
# Configurats pour démarrer le serveur Gateway
RUN cp KafkaConsumer.runtimeconfig.json IRISGatewayCore21.runtimeconfig.json && \
cp KafkaConsumer.deps.json IRISGatewayCore21.deps.json
Actuellement, la passerelle .Net doit charger toutes les dépendances au démarrage, nous lui faisons donc connaître toutes les dépendances possibles.
ENV PORT 55556
CMD dotnet IRISGatewayCore21.dll $PORT 0.0.0.0
Démarrez la passerelle sur le port 55556 en écoutant sur toutes les interfaces.
Et voilà, c'est tout !
Voici un docker-compose complet pour que tout fonctionne (y compris Kafka et Kafka UI pour voir les messages).
Pour exécuter la démo, vous dever :
git clone https://github.com/intersystems-community/pex-demo.git cd pex-demo docker-compose pull docker-compose up -d
Avis important : Les bibliothèques Java Gateway et .Net Gateway DOIVENT provenir de la même version que le client InterSystems IRIS.