Version imprimable
Est-il possible de transformer un projet créer sous Turbo Delphi Win 32 en projet Turbo Delphi .Net VCL ? Si oui, comment ???
Même Question de Turbo Win32 à Turbo .Net WinForms ?
Même Question de Turbo .Net VCL à Turbo .Net WinForms ?
Même Question de Turbo .Net VCL à Turbo C# ?
Même Question de Turbo .Net WinForms à Turbo C# ?
Merci beaucoup.
Oui c'est fait pour. Comment ? Par exemple en consultant les tutos mis à dispo sur le site :Citation:
Envoyé par jackfirst72
http://delphi.developpez.com/cours/?dom=.NET
Tu devras refaire les écrans, je ne me souviens pas avoir vu une aide à la migration de ce type.Citation:
Envoyé par jackfirst72
IdemCitation:
Envoyé par jackfirst72
Même chose + adaptation du langage, à moins de mixer les langages.Citation:
Envoyé par jackfirst72
Laurent,
Merci beaucoup pour ces précisions.
J'ai lu le tutoriel d'Olivier Dahan nommé "Migration d'applications VCL Win32 vers Delphi .NET (tutoriel en 2 parties)".
1.Est-ce que la seconde partie est disponible ?
2. Avez-vous entendu parler de "Chrome" sous Visual Studio ? Quel est votre avis à ce sujet car il me semble que ce soit une bonne solution pour les "Pascalistes" pour le futur ?
Merci d'avance.
Salut,
De rien.Citation:
Envoyé par jackfirst72
Oui, elle indiqué en fin de pageCitation:
Envoyé par jackfirst72
http://merlin.developpez.com/cours/d...tnet/portage2/
Oui, sur ce forum par l'intermédiaire de Merlin.Citation:
Envoyé par jackfirst72
Je suis en train de regarder ça (Chrome et autre produits de l'éditeur) mais je dispose de peu de temps en ce moment. J'envisage d'écrire une courte présentation de ce produit.Citation:
Envoyé par jackfirst72
Ma première impression est plutot favorable mais faut creuser le sujet.
Borland à fait le choix de favoriser la migration Win32-.NET qui est plutot réussi, pour l'éditeur Chrome j'ai l'impression que les concepteurs n'ont pas tenus compte d'un existant mais sont parti de zéro ou presque, le langage, de ce que j'ai vu, est trés proche du Delphi.
Qu'aurais donné Delphi .NET si Borland avais pris une orientation similaire ?
Exemples:
Il ya aussi qq syntaxes pour faciliter l'écriture :Citation:
Class Contracts
Chrome introduces two new language constructs to enable design by contract like features:
Pre-conditions and Post-conditions
Invariants
If a contract is not upheld, an assertion is generated. See assert for how assertions work and how to control when class contracts are enabled.
Pre-conditions and Post-conditions
Pre and post conditions are used to describe conditions that are required to be true when a method is called or after a method exits, respectively. They can be used to check for the validity of input parameters, results, or for the state of the object required by the method.
The "require" and "ensure" keywords will expand the method body to list the preconditions; both sections can contain a list of Boolean statements, separated by semicolons.
Examples:
method MyObject.DivideBy(aValue: Integer);
require
aValue <> 0;
begin
MyValue := MyValue/aValue;
end;
method MyObject.Add(aItem: ListItem);
require
assigned(aItem);
begin
InternalList.Add(aItem);
ensure
Count = old Count +1;
End;
method MyObject.DoWork(aValue);
require
Assigned(fMyWorker);
fMyValue > 0;
aValue > 0;
begin
//… do the work here
ensure
Assigned(fMyResult);
fMyResult.Value >= 5;
end;
The “old” scope prefix can be used in the “ensure” section for local variables and parameters to refer to the original values before the execution.
The compiler will add code to save these to local variables before executing the method body; “old” is supported for strings and value types.
Invariants
In contrast to pre and post conditions, Invariants are used to define a fixed state the object must fulfill at any given time. Invariants can be public or private.
Public invariants will be checked at the end of every public method (after the method’s "ensure" block, if present, has been checked) and if an invariant fails, an assertion is raised.
Private invariants will be checked at the end of every method call, public or private.
The idea behind this separation is that public invariants must not be met by private methods, so theoretically a public method can defer work to several private worker methods, and public invariants would only be checked after the public method finishes
Examples:
type
MyClass = class;
public
… some methods or properties
public invariants
fField1 > 35;
SomeProperty = 0;
SomeBoolMethod() and not (fField2 = 5);
private invariants
fField > 0;
end;
Note that both types of invariant sections have full access to all private fields of the class; the only difference is the method (and property) calls they apply to
If a class specifies invariants, all fields must be marked as private.
Custom Messages
By default, a generic assertion method is generated. For example, suppose that Method1 failed the following require:
require A > 10;
This would generate the following message: "Method1 assertion failed A > 10".
Custom messages can be generated instead by adding : 'your message' to the require, ensure or invariant statement, e.g.:
method MyObject.Add(aItem: ListItem);
require
assigned(aItem) : 'List Item for MyObject cannot be nil';
begin
InternalList.Add(aItem);
ensure
Count = old Count +1 : 'MyObject: Count logic error';
End;
Remarks
Note that not all elements of a class can be used inside invariants because some elements of a class (or the entire class system of your application) can be accessed and written to directly, without the knowledge of the class.
If, for example, your invariant were to depend on a public field*, other parts of your system would be able to modify this field directly, bypassing the invariant checking.
Elements that can be used in invariants are:
private fields.
properties
methods
*of course non-private fields are discouraged in general and you should always use private fields and - where needed - a property with a higher visibility to make the field accessible.
See Also
The "Invariants", "require", "ensure" and "old" keywords.
-Citation:
Exception Filters
Exception filters allow you to use more complex logic than just a type check
in your "except" blocks. Please refer to the VB documentation (yes, VB was the first language to expose this exciting .NET feature) for details.
Example:
try
// …
except
on E: SocketException where E.Errorcode = 10054 do begin
// connection was closed gracefully
end;
on E: Exception do begin
// any other error, including other SocketExceptions
end;
end;
-Citation:
Finalizers
Finalizers are defined with the finalizer keyword:
type
MyClass = class
public
…
finalizer;
end;
…
finalizer MyClass;
begin
… // cleanup goes here
end;
Optionally you can also add the name "Finalize" to the declaration, as in:
type
MyClass = class
public
…
finalizer Finalize;
end;
…
finalizer MyClass.Finalize;
begin
… // cleanup goes here
end;
Chrome will automatically create a try/finally block around the entire code body and call the inherited finalizer at the end.
Finalizers are always protected/override no matter where they are declared.
Finalizers automatically call "inherited finalizer;" (in a try/finally block), so there is no need to do this manually.
Notes
Only supply finalizers when they are really needed, as there is a performance penalty associated with them (garbage collector actually has to make two passes). Be particularly careful here if there are many object instances created, as the finalizer code will get called for each one.
Resources used by managed objects are reclaimed by the garbage collector. Any class that creates unmanaged resources (e.g. a socket, file, mutex etc), however needs to provide a Finalizer to free them if this needs to be done before the application terminates.
You should regard finalizer code as a request to free resources, as this will only happen on the next pass of the garbage collector. This, of course, is not good for things like files. Add the IDisposable interface in this case and free your file with the Dispose method.
Group
Class Members
et aussi ceciCitation:
The "using" statement
The using statement provides the combined functionality of "with" and a “try/finally” block to Dispose a resource automatically after using it.
Example:
using f := new FileStream(…) do begin
…
end;
The above code is equivalent to:
with f := new FileStream(…) do try
…
finally
if (f is Idisposable) then (f as IDisposable).Dispose();
end;
Important: the object in the "using" statement must be a construct that supports the standard .NET IDisposable interface.
.NET's Garbage Collector (GC) manages memory usage but does not handle resources such as file handles. In order to free files for others to access, you need to dispose of such objects. See Finalizers for more information
See Also
new with try Block statements Finalizers
Sample: PlayLister
Group
Code Constructs
...Citation:
The "matching" keyword
This keyword is used in two constructs:
for each matching
with matching
"for each matching"
The standard 'for each' loop requires that items belong to a common type, else an exception is raised. Consider the following code:
var
x: ArrayList;
begin
x := new ArrayList();
x.add('Test');
x.add(123);
for each S: String in x do
console.writeline(s);
end;
An exception is raised when it tries to read 123 from the arraylist. Supply 'matching' and processing is then restricted to items of the correct type, thus avoiding the exceptions:
for each matching S: String in x do
console.writeline(s);
This construct provides a nice way of iterating through collections of mixed object types.
"with matching"
A common requirement is to process an object instance only if it has been initialized, e.g.:
with p: MyClass := MyClass(getSomeValue()) do
if p <> nil then SomeRoutine
Using the matching keyword, this simplifies to:
with matching p: MyClass := MyClass(getSomeValue()) do SomeRoutine
Et bien la seule chose à dire est MERCI.
Tes informations sont très complètes.
J'aurais juste encore une question : les exemples que tu donnes en fin de "post" proviennent bien de "Chrome" et non pas Delphi .Net ?
Le langange de Delphi .Net a-t-il aussi évolué aussi bien que cela ?
Merci.
OuiCitation:
Envoyé par jackfirst72
La version 2006 permet de faire du .net 1.1 sans pb, Delphi .NET est compatible CLS, Chrome offre des facilités d'écriture et permet les class contract seule véritable évolution, à ce que j'ai vu. Chrome, étant basé sur le fx 2.0, offre déjà les génériques, pour BDS il faut attendre encore qq mois la nouvelle version, qui du peu que j'ai vu en beta test supportera les génériques sous Win32 mais rien n'est encore sûr. les prochaines évolutions seront peut être sur Linq...Citation:
Envoyé par jackfirst72
Ce qui serait intéressant de voir c'est si le code Delphi peut être porté sous Chrome.
En effet, cela aurait été ma prochaine question ! Car si cela était possible, on peut imaginer récupérer notre ancien code Delphi pour le porter sous Visual Studio via Chrome puis tenter une migration complète sous C# ? D'après vous, cela est-il du futur proche ??Citation:
Laurent Dardenne a écrit :
Ce qui serait intéressant de voir c'est si le code Delphi peut être porté sous Chrome.
Dans tous les cas, merci bien pour cet échange d'informations. Très utile.
Il y a une étape de trop à mon avis, si Chrome répond au besoin ce n'est pas nécessaire d'utiliser C#.Citation:
Envoyé par jackfirst72
dotNET est multi-langage. On peux mixer des assemblies réalisés dans différents langages, il faut juste que le partage de classe puisse se faire.
Je ne suis pas sûr d'avoir compris la question :?Citation:
Envoyé par jackfirst72
Rien n'empêche aujourd'hui de migrer une application Delphi directement vers C#.
Est-il possible de migrer une application Turbo Delphi .Net (VCL application) vers Chrome sous Visual Studio ? Il me semblait que non ... mais l'inverse me rendrait très :lol: voire vraiment :DCitation:
Laurent Dardenne a écrit :
... si Chrome répond au besoin ...
Je précise ma question : est-il déjà possible de migrer une application Turbo Delphi Win32 vers Visual Studio C# ?Citation:
Laurent Dardenne a écrit :
Je ne suis pas sûr d'avoir compris la question
Rien n'empêche aujourd'hui de migrer une application Delphi directement vers C#.
Si oui, comment ?
Si non, est-il possible de la faire depuis une application Turbo Delphi .Net (VCL application) ?
Si oui, comment ?
Merci d'avance de tes précieuses réponses.
J'ai pas encore pris le temps d'approfondir cet aspect.Citation:
Envoyé par jackfirst72
Oui, à la mano :mouarf:Citation:
Envoyé par jackfirst72
Pour les autres questions relire le début du post ;)
Merci encore de tes précisions.
Où puis-je trouver de la documentation pour la migration ... à la mano ... de Delphi Win32 ver s Visual Studio C# ?
Peux-tu à l'occasion jeter un oeil au sujet nommé "Delphi .Net et Mono" et me dire ce que tu en penses ?
A bientôt.
Un premier (petit) pas :http://laurent-dardenne.developpez.c...oDelphiDotNet/Citation:
Envoyé par jackfirst72
Mais comme il y a pas mal de différence entre les 2 plateformes, une réécriture complète n'est pas plus mal.
A voir ce produit payant :
"Delphi2CS is an assistant tool that converts Delphi source code to C#. "
http://www.netcoole.com/delphi2cs/
Il y a aussi Babelcode, regarde dans la FAQ Delphi.net
Pour DelphiCS, le produit semble intéressant mais nécessite du temps pour le tester. Il utilise des fichiers XML pour la correspondance entre les objets de la VCL et ceux du framework. Le code traduit semble de bonne qualité...
Pour Chrome il permet bien de construire des projets Mono sous VS 2005
Je te remercie à nouveau pour tes précisions vraiment utiles.
Je vais faire des recherches à propos de "Delphi2CS" et des compilations Chrome pour Mono et te tiendrai au courant.
Merci encore.