Catégorie: Delphi .NET

Cet article présente les Applications Windows Forms et Asp.Net avec Delphi PRISM, un environnement Delphi qui utilise l'environnement Visual Studio 2008.

Lisez la suite du tutoriel de John Colibri ici:
http://jcolibri.developpez.com/articles/delphi-prism/

Dans son message sur BDN, Tod Nielsen annonce que Borland va recentrer son activité sur les produits ALM (Application Life Management). Ils renforcent cette position par l'acquisition de Segue Software.

Dans le même temps Tod Nielsen annonce que Borland souhaite se séparer des outils de développement (Delphi, C++ Builder, C# Builder et JBuilder). La raison principale est que l'organisation nécessaire au développement des ces outils ainsi que le marché sont différents.

David Intersimone répond à cette annonce en indiquant que le développement des futures versions des IDE continue. Lui même resterait dans cette équipe et continuerait le suivi du développement des outils dans la nouvelle société. Il confirme que Borland avait prioritairement investi dans les outils ALM et que cette séparation pourrait être une chance pour les IDE d'être au centre de l'activité de la nouvelle société.

Le reprenneur de l'activité IDE n'est pas encore connu, le changement doit se faire dans le premier semestre de cette année.

Si vous souhaitez réagir ou simplement vous exprimer sur cette annonce vous pouvez le faire ici.

To Our Customers and Shareholders ( Tod Neilsen )
Borland plans separate company for its developer products ( David Intersimone )

Borland organise une journée de présentation de Delphi 2006 le 1er Décembre 2005 à Bruxelle en Belgique.

Voici l'adresse du site d'inscription :
http://info.borland.de/edm/EMEA/Invitation_Delphi_2006_Belgium_Web.html

Nous vous communiquerons par la suite les autres dates pour la France et la Suisse.

La nouvelle version de Borland Developer Studio est enfin annoncée !

Delphi 2006 fait partie intégrante de Borland Developer Studio regroupant Delphi Win32, Delphi .NET, C# mais aussi C++ Builder.

» Lire la suite!

Oracle a récemment annoncé la release de la version 10g R2 intégrant un runtime .NET.
Il est désormais possible d'utiliser le C# pour développer des procédures stockées en plus du PL/SQL et de JAVA.

Oracle propose un tutoriel sur la création d'une application NET utilisant Oracle Developer Tools (ODT) pour Visual Studio .NET.
Ainsi qu'une vidéo (+ de 50 mn) sur les nouveautés d'ODT et ODP.NET(Requière Windows Media Player 9 or supérieure).

Je suis en train d'étudier les classes ODP sous Delphi, elles sont aisées à manipuler mais parfois le comportement de base n'est pas assez documenté.
Par exemple la création d'une procédure stockée via un TMemo n'est pas possible car ce composant gére les fin de lignes par un retour chariot suivi d'un line feed.
J'ai passé un petit bout de temps à comprendre, merci le mode trace du client Oracle :-), qu'il fallait utiliser un StringBuilder !

 
procedure TForm1.CreateProcedureStockee; 
 // Crée la procédure stocké sur le serveur 
 (* 
Create or replace Procedure GetNameOfPresident( 
 Parametre_IN IN SCOTT.EMP.JOB%TYPE, 
 NomPresident_OUT OUT VARCHAR2) IS 
 
begin 
 Select ENAME INTO NomPresident_OUT from scott.emp where job=Parametre_IN; 
 NomPresident_OUT:=Parametre_IN||' = '||NomPresident_OUT; 
end; 
 
 *) 
var TextePrcStck : StringBuilder; 
 
begin 
 try 
  // Crée une procédure stockée 
  TextePrcStck:=StringBuilder.create; 
 
  // L'ajout de CR+LF en fin de chaîne n'est pas compatible (avec le parseur SQL sur le serveur Oracle ?), LF suffit. 
  TextePrcStck.Append('Create or replace Procedure GetNameOfPresident('+LF); 
  // La requête renvoie une seule ligne, Parametre_IN ne gére que 'PRESIDENT' 
  TextePrcStck.Append(' Parametre_IN IN SCOTT.EMP.JOB%TYPE,'+LF); 
  // La taille de la valeur de retour doit être supérieure à la taille du champ SCOTT.EMP.ENAME%TYPE 
  TextePrcStck.Append(' NomPresident_OUT OUT VARCHAR2) IS '+LF); 
 
  TextePrcStck.Append('begin'+LF); 
  TextePrcStck.Append(' Select ENAME INTO NomPresident_OUT from scott.emp where job=Parametre_IN;'+LF); 
  TextePrcStck.Append(' NomPresident_OUT:=Parametre_IN||'' = ''||NomPresident_OUT;'+LF); 
  TextePrcStck.Append('end;'+LF); 
  Commande.CommandText:= TextePrcStck.ToString; 
  Commande.ExecuteNonQuery; 
 
 except 
  on E:OracleException do 
  ShowOracleException(E.Errors); 
 end; 
end; 


Les exceptions d'ODP proposent de nombreuses informations utiles :

 
Procedure TForm1.ShowOracleException(Errors : OracleErrorCollection); 
var ErrorMessage : String; 
  Error : OracleError; 
begin 
 For Error in Errors do 
  begin 
  errorMessage:=''; 
  errorMessage:= Concat( errorMessage,'Source : '+error.Source+System.Environment.NewLine); 
  errorMessage:= Concat( errorMessage,'Message : '+error.Message+System.Environment.NewLine); 
  errorMessage:= Concat( errorMessage,'Number : '+error.Number.ToString+System.Environment.NewLine); 
  errorMessage:= Concat( errorMessage,'DataSource : '+error.DataSource+System.Environment.NewLine); 
  errorMessage:= Concat( errorMessage,'Procedure : '+error.&Procedure+System.Environment.NewLine); 
  MessageBox(0,errorMessage, 'Erreur',MB_OK ); 
  end; 
end; 


En revanche pour certains type d'appel sur le serveur le passage de paramètres n'est pas documenté j'aborderais ceci dans un prochain tutoriel ...

Pour ceux et celles qui souhaitent aborder les aspects sécurité de .NET voici un ouvrage complet en anglais consultable en ligne uniquement :
The .NET Developer's Guide to Windows Security par Keith Brown.

Les Chapitres :

The Big Picture
Security Context
Access Control
COM(+)
Network Security
Misc

Bonne lecture !

Pour les utilisateurs enregistrés de Delphi 2005, Borland propose en téléchargement gratuit une preview d'un compilateur en ligne de commande pour le Compact Framework .NET, disponible ici
Delphi 2005 for .NET Compact Framework Technology Preview

L'article suivant Delphi for .NET Compact Framework Preview Quickstart Guide vous indiquera la marche à suivre pour son installation et son utilisation.

Pour vos premiers tests vous pouvez vous appuyer sur l'émulateur de périphérique Windows CE.

Cette pré-version contient notamment les sources de l'unité Borland.Delphi.System.pas, on peut y voir que l'utilisation de directive de compilation conditionnelle de type {$IFDEF CF} permet de gérer trés facilement les différences entre les différentes plate-formes.

On peut aussi y constater l'utilisation d'un assistant de classe (class helper) sur la classe System.Array de la FCL, comme quoi leur utilisation n'est pas uniquement limitée au portage des classes de la VCL comme le laisse supposer la documentation.

Sous Oracle il est possible de mettre en place, coté client, un dispositif de reprise sur incident nommé Transparent Application Failover, acronyme TAF.

Cette technique est liée à la mise en place d'une redondance de base principalement par la mise en place de cluster (RAC) ou d'une base en StandBy.

Lors de mes tests avec le programme ...\ODP.NET\samples\TAF\src\TAF.cs proposé dans la distribution d'ODP, je rencontrais l'erreur TNS-12152 sur le poste client lorsque j'essayais de déclenchement un événement en arrêtant la base.

Evénement devant être pris en charge par le code suivant (classe OracleConnection.Failover) :

* This method is FailOver Callback method called when the
* connection to the database is severed. It is called several
* times in the process of re-establishing connection to the
* same or standby database.
**************/
public FailoverReturnCode OnFailover(object sender, OracleFailoverEventArgs eventArgs)
{
// check the Failover event that occurred and display appropriate message
switch(eventArgs.FailoverEvent)
{
// when failover begins
case FailoverEvent.Begin:
{
MessageBox.Show("Callback method called :Failover Begin");
lblStatus.Text="Callback method called :Failover Begin. Trying to reconnect, Please wait...";

break;
}

Voici un début de solution pour une machine hébergeant une instance. Dans un contexte de test, le serveur et client étant sur la même machine, cela semble suffisant.

Modifier le fichier TnsName.ora ainsi :

TEST =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = amd2800)(PORT = 1521))
(ADDRESS = (PROTOCOL = TCP)(HOST = amd2800)(PORT = 1521))
(failover = yes)
(load_balance = yes)
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = TEST.LTA)
(FAILOVER_MODE =
(TYPE = SELECT)
(METHOD = BASIC)
(RETRIES=100)
(DELAY=1)
)
)
)

Le fichier TnsName.ora doit contenir l'adresse du serveur de secours, ici il s'agit du même serveur.

Donc le message suivant :

TNS-12152 TNS:unable to send break message

indique une tentative d'émission d'un message de reprise vers le second serveur (StandBy) ou noeud dans un environnement RAC. La modification du fichier TnsName.ora est suffisante dans ce cas pour déclencher l'événement sur le client ODP.

Pour ceux et celles qui souhaiteraient approfondir le SDK .NET Microsoft met à disposition le fichier Shared Source Common Language Infrastructure 1.0 Release qui contient le code source de l'implémentation du runtime pour le CLI. Le fichier date de mai 2002 mais son contenu reste très intéressant.

L'ensemble décompressé occupe 116 Mg sur le disque dont une dizaine concernant les fichiers sources :

..\sscli_20021101\sscli\clr\src\bcl\system\reflection
..\sscli_20021101\sscli\clr\src\bcl\system\resources
..\sscli_20021101\sscli\clr\src\bcl\system\runtime
..\sscli_20021101\sscli\clr\src\bcl\system\security
..\sscli_20021101\sscli\clr\src\bcl\system\text
..\sscli_20021101\sscli\clr\src\bcl\system\threading
..\sscli_20021101\sscli\clr\src\bcl\system\activator.cs
..\sscli_20021101\sscli\clr\src\bcl\system\appdomain.cs
..\sscli_20021101\sscli\clr\src\bcl\system\applicationexception.cs
..\sscli_20021101\sscli\clr\src\bcl\system\argiterator.cs
..\sscli_20021101\sscli\clr\src\bcl\system\argumentexception.cs
..\sscli_20021101\sscli\clr\src\bcl\system\array.cs
..\sscli_20021101\sscli\clr\src\bcl\system\asynccallback.cs
..\sscli_20021101\sscli\clr\src\bcl\system\attribute.cs
...

Vous y trouverez également qq sources sur les outils tels que IL-Dasm, peverify,...

Bonne lecture.

J'ai ces derniers temps traduit quelques entrées de la FAQ C# vers la FAQ Delphi .NET et je me suis aperçus que les énumérations sous .NET qui me semblaient être un type de donnée différent, se manipule de la même manière qu'une énumération déclarée sous Delphi. Donc rien de transcendant en soit, il faut juste le savoir.

 
Type 
  Couleurs = (Bleu,Blanc,Noir,Rouge,Vert); 
 
  Conteneur= (Carton= 52, Valise= 137);  
 
  [FlagsAttribute]  
  DroitsFichier = (Aucun= 1, 
  Lecture = 2, 
  Ecriture= 4, 
  Effacement= 8, 
  All=15); 
 
 //Alias, facilite l'écriture 
 TEnvFolder = Environment.SpecialFolder; 


Le type couleur est une énumération mappée sur System.Enum de type Byte.

Conteneur est aussi une énumération de type Byte, ici la modification de la valeur de 137 en 257 modifiera le type sous jacent en Integer. Il ne semble pas possible comme en C# de préciser le type de base de l'énumération en dehors de cette construction.

DroitsFichier est une énumération particuliére, l'ajout de l'attibut [FlagsAttribute] indique que cette énumération est traitée comme un champ de bits, c'est-à-dire un ensemble d'indicateurs. L'affectation se fait avec l'opérateur or :

 
 Resultat := Lecture or Ecriture; 
 Writeln(TObject(Resultat)); 
 Writeln(Format('Resultat=%s',TObject(Resultat))); 


Il est possible d'affecter une valeur en utilisant une chaîne de caractères, contenant des noms identiques au nom de valeur déclarée de l'énumération :

 
 NouveauDroit:='Ecriture,Effacement'; 
 Resultat:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),NouveauDroit)); 
 Writeln(TObject(Resultat)); 


Les énumérations de FCL peuvent donc être manipulée directement :

 
 //Environment.SpecialFolder 
 //Obtenir une chaîne à partir d'une valeur de type énumération 
 Folder:=TEnvFolder.ApplicationData; 
 Writeln(TObject(Folder)); 
 
 Write('Accés direct ='); 
 Writeln(TObject(TEnvFolder.ApplicationData)); 
 
 Writeln(Ord(TEnvFolder.ApplicationData)); 
 
 Writeln(TObject(Succ(TEnvFolder.ApplicationData))); 
 Folder:=Succ(Succ(TEnvFolder.ApplicationData)); 
 Writeln(TObject(Folder)); 
 
 Folder:=Pred(Folder); 
 Writeln(TObject(Folder)); 
 
 Writeln(TObject(Low(TEnvFolder.ApplicationData))); 
 Writeln(TObject(High(TEnvFolder.ApplicationData))); 


Les itérateurs sont possibles sur les énumérations :

 
 // Affiche les valeurs possibles de l'énumération 
 for Chaine in Enum.GetNames(typeof(Environment.SpecialFolder)) do 
  begin 
  Write(Chaine+','); 
  end; 


Il est égalemment possible, au travers de la classe EnumBuilder, de construire dynamiquement une énumération à l'intérieur d'un assembly dynamique.
Exemple :

 
 EnumCreate(Thread.GetDomain, AssemblyBuilderAccess.Run); 


avec

 
procedure EnumCreate(myAppDomain : AppDomain ; access : AssemblyBuilderAccess ); 
var myAssemblyName : AssemblyName; 
  myFieldBuilder1, 
  myFieldBuilder2 : FieldBuilder; 
  valeur1, 
  valeur2 : Integer; 
 
begin 
  // Affecte un nom pour l'assembly. 
  myAssemblyName:=AssemblyName.Create; 
  myAssemblyName.Name:='EmittedAssembly'; 
 
  // Crée l'assembly dynamique. 
  myAssemblyBuilder:=myAppDomain.DefineDynamicAssembly(myAssemblyName,access); 
 
  // Crée dynamiquement un module non-persistant (Run) 
  // Définit et représente un module. Pour obtenir une instance de ModuleBuilder, appelez DefineDynamicModule. 
  myModuleBuilder:= myAssemblyBuilder.DefineDynamicModule('EmittedModule','EmittedModule.mod'); 
 
  // Définit un type d'énumération qui est un type valeur avec un champ non statique unique appelé value__ du type spécifié. 
  myEnumBuilder:= myModuleBuilder.DefineEnum('MyNamespace.MyEnum',TypeAttributes.Public, typeof(Integer)); 
 
  valeur1:=1; 
  valeur2:=2; 
 
  // Exception ArgumentException 
  //" La constante ne correspond pas au type défini." 
  // myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(1)); 
  // myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(2)); 
 
  myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(Integer(1))); 
  myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(Integer(2))); 
 
  { ou bien : 
  myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(valeur1)); 
  myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(valeur2)); 
  } 
  myEnumBuilder.CreateType; 
end; 


On peut donc sous .NET construire à la volée du code persistant ou non. Pratique !
La suite dans un prochain article ...