Patrons de conception/Carte d'identité
Une carte d'identité garantit que chaque objet n'est chargé qu'une seule fois en conservant chaque objet chargé dans un dictionnaire.
La référence aux objets se fait par recherche à l'aide du dictionnaire.
Le chargement d'objets à partir d'une base de données peut cause de grands problèmes : Si vous ne faites pas attention, vous pouvez charger les données du même enregistrement de base de données dans deux objets différents.
Ensuite, lorsque vous les mettrez à jour, vous passerez un moment intéressant à écrire correctement les modifications dans la base de données.
Lié à cela, il y a un problème de performances évident.
Si vous chargez les mêmes données plus d'une fois, vous encourez un coût élevé en appels à distance.
Ainsi, ne pas charger deux fois les mêmes données ne contribue pas seulement à l'exactitude, mais peut également accélérer votre application.
Une carte d'identité conserve un enregistrement de tous les objets qui ont été lus à partir de la base de données dans une seule transaction commerciale.
Chaque fois que vous voulez un objet, vous vérifiez d'abord la carte d'identité pour voir si vous l'avez déjà.

Patrons de conception/Chargement différé

Pour charger des données d'une base de données en mémoire, il est pratique de concevoir les choses de sorte que lorsque vous chargez un objet d'intérêt, vous chargez également les objets qui lui sont liés.
Cela facilite le chargement pour le développeur utilisant l'objet, qui doit sinon charger explicitement tous les objets dont il a besoin.
Cependant, en conclusion logique, vous arrivez au point où le chargement d'un objet peut avoir pour effet de charger un grand nombre d'objets liés, ce qui nuit aux performances lorsque seuls quelques objets sont réellement nécessaires.
Un chargement différé interrompt ce processus de chargement pour le moment, laissant un marqueur dans la structure de l'objet de sorte que lorsque les données sont nécessaires, elles ne puissent être chargées que lorsqu'elles sont utilisées.
Si vous évitez de faire des choses, cela devient un gain quand il s'avère que vous n'avez pas du tout besoin de les faire.
Il existe quatre principales variétés de chargement différé/paresseux :
Ces approches varient quelque peu subtilement et comportent divers compromis.
Vous pouvez également utiliser des approches combinées.

Patrons de conception/Unité de travail
Une unité de travail maintient une liste des objets affectés par une transaction commerciale, coordonne l'écriture des modifications et la résolution des problèmes de concurrence.
Lorsque vous extrayez des données d'une base de données, il est important de garder une trace de ce que vous avez modifié ; sinon, ces données ne seront pas réécrites dans la base de données.
De même, vous devez insérer les nouveaux objets que vous créez et retirer tous les objets que vous supprimez.
Vous pouvez modifier la base de données à chaque modification de votre modèle d'objet, mais cela peut entraîner de nombreux appels de base de données très petits, ce qui finit par être très lent.
De plus, cela nécessite que vous ayez une transaction ouverte pour toute l'interaction, ce qui n'est pas pratique si vous avez une transaction commerciale qui s'étend sur plusieurs demandes.
La situation est encore pire si vous devez garder une trace des objets que vous avez lus afin d'éviter les lectures incohérentes.
Une unité de travail garde une trace de tout ce que vous faites au cours d'une transaction commerciale qui peut affecter la base de données.
Lorsque vous avez terminé, elle détermine tout ce qui doit être fait pour modifier la base de données à la suite de votre travail.

Tetris/Sommaire
Mathc initiation/c760
On utilise le terme de branche quand l'asymptote est une courbe.
<br>
Les fonctions pour les différents exemples :
<br>
Calculer la branche de l'équation de la forme y=ax**+bx+c :

Mathc initiation/h76a
Sommaire 
Installer ce fichier dans votre répertoire de travail.
/* Save as : fa.h */
double f(
double x)
 return( (-2.*pow(x,3)-3.*pow(x,2)+2.*x+5.)/(2.*x+3.) );
char feq[] = "(-2*x**3 - 3*x**2 + 2*x + 5)/(2*x+3)";
double fax2(
double x)
 return( ((-2.*pow(x,3)-3.*pow(x,2)+2.*x+5.)/(2.*x+3.))
 /pow(x,2));
char faxeq[] = "((-2*x**3 - 3*x**2 + 2*x + 5)/(2*x+3))/x**2";
double fbx(
double x)
 return( (((-2.*pow(x,3)-3.*pow(x,2)+2.*x+5.)/(2.*x+3.))+pow(x,2))
 /x );
char fbxeq[] = "(((-2*x**3 - 3*x**2 + 2*x + 5)/(2*x+3))+x**2)/x";
double fc(
double x)
 return( (((-2.*pow(x,3)-3.*pow(x,2)+2.*x+5.)/(2.*x+3.))+pow(x,2)) );
char fceq[] = "((-2*x**3 - 3*x**2 + 2*x + 5)/(2*x+3))+x**2";
double fax2bxc(
double x)
 return( -pow(x,2)+1 );
char fax2bxceq[] = "-x**2+1";
/* ------------------------------------ */
 Déclaration des fichiers h.

Mathc initiation/c76b
Sommaire 
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c01b.c */
int main(void)
double i;
double (*P_f)(double x);
 P_f = fax2;
 clrscrn();
 printf(" The curve y = ax**2 + bx + c (a!=0) \n\n\n" 
 " is a branch of the curve of f at +oo if \n\n\n\n" 
 " lim f(x) \n" 
 " x->+oo ---- = a \n" 
 " x**2 \n\n\n" 
 " lim [f(x)-ax**2] \n" 
 " and x->+oo --------- = b \n" 
 " x \n\n\n" 
 " lim [f(x)-ax**2-bx] = c \n" 
 " and x->+oo \n\n\n"); 
 stop();
 clrscrn();
 printf(" f : x-> %s\n\n\n", feq);
 printf(" lim f(x) \n");
 printf(" Compute : x->+oo ---- = a \n");
 printf(" x**2 \n\n\n");
 for(i=1; i<10; i+=1)
 printf(" L1(%.0e) = %-10.0e || L1(%.0e) = %.0e\n",
 i*100, (*P_f)(i*100),
 i*1000000000, (*P_f)(i*1000000000) );

printf(" \n\n"
 "With the computation we arrive at the "
 "following conjecture : a = %+.1f \n\n", 
 (*P_f)(i*1000000000)); 
 stop();
 return 0;
/* ------------------------------------ */
Exemple de sortie écran :
 The curve y = ax**2 + bx + c (a!=0) 
 is a branch of the curve of f at +oo if 
 lim f(x) 
 x->+oo ---- = a 
 x**2 
 lim [f(x)-ax**2] 
 and x->+oo --------- = b 
 x 
 lim [f(x)-ax**2-bx] = c 
 and x->+oo 
 Press return to continue. 
 f : x-> (-2*x**3 - 3*x**2 + 2*x + 5)/(2*x+3)
 lim f(x) 
 Compute : x->+oo ---- = a 
 x**2 
 L1(1e+02) = -1e+00 || L1(1e+09) = -1e+00
 L1(2e+02) = -1e+00 || L1(2e+09) = -1e+00
 L1(3e+02) = -1e+00 || L1(3e+09) = -1e+00
 L1(4e+02) = -1e+00 || L1(4e+09) = -1e+00
 L1(5e+02) = -1e+00 || L1(5e+09) = -1e+00
 L1(6e+02) = -1e+00 || L1(6e+09) = -1e+00
 L1(7e+02) = -1e+00 || L1(7e+09) = -1e+00
 L1(8e+02) = -1e+00 || L1(8e+09) = -1e+00
 L1(9e+02) = -1e+00 || L1(9e+09) = -1e+00
With the computation we arrive at the following conjecture : a = -1.0 
 Press return to continue.

Mathc initiation/c76c
Sommaire 
Installer et compiler ces fichiers dans votre répertoire de travail.
/* Save as : c01c.c */
int main(void)
double i;
double (*P_f)(double x);
 P_f = fbx;
 clrscrn();
 printf(" The curve y = ax**2 + bx + c (a!=0) \n\n\n" 
 " is a branch of the curve of f at +oo if \n\n\n\n" 
 " lim f(x) \n" 
 " x->+oo ---- = a \n" 
 " x**2 \n\n\n" 
 " lim [f(x)-ax**2] \n" 
 " and x->+oo --------- = b \n" 
 " x \n\n\n" 
 " lim [f(x)-ax**2-bx] = c \n" 
 " and x->+oo \n\n\n"); 
 stop();
 clrscrn();
 printf(" f : x-> %s\n\n\n", feq);
 printf(" Compute : lim [f(x)-ax**2] \n");
 printf(" x->+oo --------- = b (with a=1) \n");
 printf(" x \n\n\n");
 for(i=1; i<10; i+=1)
 printf(" L2(%.0e) = %-10.0e || L2(%.0e) = %.0e\n",
 i*100, (*P_f)(i*100),
 i*1000000000, (*P_f)(i*1000000000) );