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 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 )

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.

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

Une partie de ECO III sera accessible dés la version Professionnel alors qu’il fallait avant acquérir la version Entreprise minimum. Cette évolution améliore encore les facilités d’utilisation du framwork ECO III plur un développement plus rapide.

Les nouveautés princiapales de Delphi 2006 sont :
· Nouvelles fonctions de productivité IDE – Le système de « modèles réels » permet aux utilisateurs de parcourir les champs et d’insérer des points de n’importe quel modèle et au nouvel éditeur « Barre de changement » indiquant les lignes modifiées et celles de la session sauvegardée.
· Bibliothèque étendue de composants (VCL – Visual Component Library) – La nouvelle bibliothèque VCL de Delphi 2006 est équipée d’une interface graphique de développement et d’une large gamme de composants d’interface utilisateur. Les nouveaux principes de « conception en direct » permettent de faire glisser les lignes, marges et éléments de garnissage, de gérer les alignements avec le texte et intègrent de nouveaux panneaux de contrôle Flux et Grille (avec modèles de formulaires HTML et tableaux).
· Intégration étendue aux outils de gestion du cycle de vie (ALM) – Delphi 2006 permet de prendre le contrôle de l’intégralité du cycle de développement grâce à une parfaite intégration aux outils Borland comme StarTeam (gestion du changement et des configurations), Together (modélisation) et CaliberRM (gestion des besoins) ; l’IDE Delphi bénéficie désormais d’une intégration native intégrale avec StarTeam et Caliber.

Delphi 2006 sera disponible en trois version : Professionnel, Entreprise et Architecte. Pour connaitre les différents éléments livrés en fonctions des versions il faut se rendre ici.

Notez qu’il sera possible de commander Delphi 2006 dés le 17 octobre, avec une remise de 15% pour toute commande passée avant le premier décembre. Delphi sera livré dés le début de décembre.

L’annonce de Borland US pour Delphi 2006 est disponible ici

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 !

Les exceptions d’ODP proposent de nombreuses informations utiles :

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 …

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.

Les Chapitres :

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

Bonne lecture !

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.

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.

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 …