mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2025-12-06 14:52:03 +01:00
Updated trunk
git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@2484 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
eifops
@@ -1,4 +1,4 @@
|
||||
[[Property:modification_date|Mon, 13 Dec 2021 12:42:51 GMT]]
|
||||
[[Property:modification_date|Thu, 27 Jun 2024 10:45:27 GMT]]
|
||||
[[Property:publication_date|Thu, 03 Jan 2019 18:00:43 GMT]]
|
||||
[[Property:uuid|146E241E-C367-4F16-9CCE-6F11E5F7860A]]
|
||||
[[Property:weight|1]]
|
||||
@@ -145,11 +145,12 @@ f (a_arg: INTEGER): BOOLEAN
|
||||
|
||||
This will have exactly the same effect as using <e>-- <Precursor></e> when <e>f</e> is made effective/redefined from a single parent. However, when making effective/redefining from multiple parents, then comments will come from the parent class declaration in <e>BASE</e>.
|
||||
|
||||
Again, because precursor comments do not affect compilation, they are not checked at compile time. Specifying an incorrect class will yield a warning message in [[EiffelStudio]]'s code browsing tools, to the effect:
|
||||
Again, because precursor comments do not affect compilation, they are not checked at compile time. Specifying an incorrect class will yield a warning message in [/doc/eiffelstudio/EiffelStudio EiffelStudio]'s code browsing tools, to the effect:
|
||||
|
||||
<e>
|
||||
-- Unable to retrieve the comments from redefinition of {CLASS_NAME}.
|
||||
</e>
|
||||
|
||||
=== Library Documentation Generation ===
|
||||
Precursor comments are supported in all code browsing/documentation facilities, whether it be the integrated [[Contract Viewer]], the [[Feature Relation Tool]] or the Eiffel documentation generation facilities. Using <e>-- <Precursor></e> will ensure the comments are brought up from a parent declaration.
|
||||
Precursor comments are supported in all code browsing/documentation facilities, whether it be the integrated [/doc/eiffelstudio/Contract_Editor_tool Contract Viewer
|
||||
], the [https://www.eiffel.org/doc/eiffelstudio/Feature_views Feature Relation Tool] or the Eiffel documentation generation facilities. Using <e>-- <Precursor></e> will ensure the comments are brought up from a parent declaration.
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
[[Property:modification_date|Fri, 08 Mar 2024 09:39:26 GMT]]
|
||||
[[Property:publication_date|Fri, 08 Mar 2024 09:36:54 GMT]]
|
||||
[[Property:title|Quick reference to the Eiffel programming language]]
|
||||
[[Property:link_title|Quick Reference]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|4f61365d-59f6-a394-678b-144bad8ec12f]]
|
||||
The Quick Reference to the Eiffel programming language provides an informal guide to the syntax and reserved words of the language. The Eiffel programming language is described in detail in the '''ISO/ECMA''' standard document, available [http://www.ecma-international.org/publications/standards/Ecma-367.htm online].
|
||||
The Quick Reference to the Eiffel programming language provides an informal guide to the syntax and reserved words of the language. The Eiffel programming language is described in detail in the '''ISO/ECMA''' standard document, available [https://ecma-international.org/publications-and-standards/standards/ecma-367/ online].
|
||||
|
||||
Sometimes there are differences between the language as defined by the standard and that which is implemented by Eiffel Software. These differences are documented in the online documentation.
|
||||
|
||||
@@ -10,6 +12,8 @@ So, the final authority on Eiffel as implemented by Eiffel Software is the conte
|
||||
|
||||
This reference is based on the June 2006 ISO/ECMA standard document.
|
||||
|
||||
See also the community contributed guide at [https://eiffel-guide.com/]
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Fri, 15 Mar 2024 12:43:00 GMT]]
|
||||
[[Property:publication_date|Fri, 15 Mar 2024 12:42:08 GMT]]
|
||||
[[Property:title|Two-Minute fact sheet]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|f672bfb8-ddea-beb1-eaa6-e374a6a6bc92]]
|
||||
@@ -14,7 +16,7 @@ Software produced with Eiffel is typically:
|
||||
|
||||
===Systems developed using Eiffel can be made portable across major industry platforms.===
|
||||
|
||||
*Windows NT/2000/XP/Vista including CLS compliance on Microsoft .NET
|
||||
*Windows 11, 10, Windows NT/2000/XP/Vista including CLS compliance on Microsoft .NET
|
||||
*Major Unix versions
|
||||
*Macintosh OS X
|
||||
*Linux
|
||||
@@ -50,7 +52,7 @@ Eiffel consists of:
|
||||
***Includes multiple and repeated inheritance
|
||||
***Safe and fully controllable
|
||||
**Genericity (generic classes), including constrained genericity
|
||||
**Platform independent concurrency ([[Concurrent programming with SCOOP|SCOOP]])
|
||||
**Platform independent concurrency ([[Concurrent programming with SCOOP|SCOOP]]) , except for .NET, where SCOOP is not yet supported
|
||||
*Widely recognized as simultaneously the simplest and most complete implementation of object-oriented concepts
|
||||
*Is clean, elegant, readable, easy to learn
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
[[Property:modification_date|Mon, 23 Jan 2023 09:14:48 GMT]]
|
||||
[[Property:modification_date|Tue, 13 Aug 2024 09:46:34 GMT]]
|
||||
[[Property:publication_date|Mon, 23 Jan 2023 09:14:48 GMT]]
|
||||
[[Property:title|ET: The Dynamic Structure: Execution Model]]
|
||||
[[Property:weight|-10]]
|
||||
@@ -298,7 +298,7 @@ This would be awkward. Infix and prefix notations solve the problem, reconciling
|
||||
end
|
||||
</code>
|
||||
|
||||
Such a feature has all the properties and prerogatives of both normal "identifier-dot" notation and infix notation. This allowing invoking <code>plus</code> using either notation: <code>i.plus (j)</code> or <code>i + j</code> . A feature such as <code>plus</code> allowing infix notation must be a function, and take exactly one argument.
|
||||
Such a feature has all the properties and prerogatives of both normal "identifier-dot" notation and infix notation. This allowes invoking <code>plus</code> using either notation: <code>i.plus (j)</code> or <code>i + j</code> . A feature such as <code>plus</code> allowing infix notation must be a function, and take exactly one argument.
|
||||
|
||||
Prefix notation is allowed as well. A function can be declared as <code>opposite alias "-" </code>, with no argument, permitting calls of the form <code>-3</code> rather than <code>(3).opposite</code> .
|
||||
|
||||
@@ -671,7 +671,7 @@ These attribute specializations are presented in the [[Void-safe programming in
|
||||
|
||||
Another special type of attribute supported by Eiffel Software's compiler is the '''transient attribute'''. When an instance of a class to which a transient attribute belongs is saved to persistent storage, the field for the transient attribute is not included. So, transient attributes are transient in the sense that they are part of the object at runtime, but not when the object is stored on disk.
|
||||
|
||||
This type of attribute has benefits when using the persistence mechanisms provided with EiffelStudio, like [http://eiffel.com/developers/learning_maps/Training/Maps/PersistenceCanPayOff/Serialization.html SED]. Because transient attributes are not stored, they need not be accounted for upon retrieval. So, objects stored before changes to a class that only affect transient attributes will still be retrievable using the new class definition (whereas, if non-transient attributes were changed, a mismatch would occur during retrieval).
|
||||
This type of attribute has benefits when using the persistence mechanisms provided with EiffelStudio, like [[Persistence, storage, and retrieval#With_the_SED_persistence_format|SED]]. Because transient attributes are not stored, they need not be accounted for upon retrieval. So, objects stored before changes to a class that only affect transient attributes will still be retrievable using the new class definition (whereas, if non-transient attributes were changed, a mismatch would occur during retrieval).
|
||||
|
||||
An attribute is marked as transient by including a note option in its declaration:
|
||||
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 102 KiB |
BIN
documentation/trunk/eiffelstudio/_images/tool-preferences.png
Normal file
BIN
documentation/trunk/eiffelstudio/_images/tool-preferences.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
@@ -14,9 +14,9 @@ This page will show you how to find all the keyboard shortcuts available in the
|
||||
|
||||
From the main menu select "Tools" -> "Preferences..."
|
||||
|
||||
<center> [[Image:/files/uploads/tool-preferences.png]] </center>
|
||||
<center> [[Image:tool-preferences]] </center>
|
||||
|
||||
|
||||
Now in the preference windows filter by "SHORTCUT", and you will see all the keyword shortcuts available.
|
||||
|
||||
<center> [[Image:/files/uploads/preference-all-shortcuts.png | 800px]] </center>
|
||||
<center> [[Image:preference-all-shortcuts | 800px]] </center>
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
[[Property:modification_date|Fri, 06 Oct 2023 15:12:07 GMT]]
|
||||
[[Property:publication_date|Tue, 26 Sep 2023 14:40:08 GMT]]
|
||||
[[Property:uuid|7D788D2D-73A3-4C2E-8E58-E7A5FB60A618]]
|
||||
[[Property:title|Release notes for EiffelStudio 23.09]]
|
||||
[[Property:link_title|23.09]]
|
||||
[[Property:weight|-9]]
|
||||
|
||||
==Compiler==
|
||||
* The major improvement with this version of EiffelStudio is the new compilation support for the '''.NETCore (net6.0, net7.0, ...)''' to '''Windows and unices (Linux, ...)'''. And only on Windows, the support for the .NET framework (v4.0). There are a few limitations that should be addressed in the next releases. Please check the documentation for details [https://www.eiffel.org/doc/version/23.09/uuid/fe8a6a7d-4590-0db2-d59a-307082b18ecc Eiffel for .NET].
|
||||
|
||||
* EiffelStudio for .NET makes it possible to develop applications that will deploy and run unchanged on a broad range of platforms, from desktops to Web-based applications on one side, and mobile platforms on the other.
|
||||
|
||||
==Graphical environment==
|
||||
* The execution output panel (debugger) has additional information such as the modified environment variables, and the timestamp for launched/stopped/quit events.
|
||||
* Added "Toggle comment" to comment/uncomment the current line/selection using the standard Ctrl+/ shortcut.
|
||||
* Improved the impact of the Zoom factor on EiffelStudio tools.
|
||||
* Added a few preferences on the editor and on the tools that make it possible to customize EiffelStudio to have almost a dark mode.
|
||||
|
||||
===Libraries===
|
||||
* Fixed issues related to the usage of IMMUTABLE strings in EiffelBase.
|
||||
* Fixed issues on LINEAR_SUBSET, TRAVERSABLE_SUBSET and SUBSET_STRATEGY_GENERIC in EiffelBase.
|
||||
* Made EiffelBase classes immune to default string/character size.
|
||||
* Gobo Libraries were updated to latest version.
|
||||
|
||||
===Warnings===
|
||||
* SCOOP is currently not supported by Eiffel .NET
|
||||
* For non Windows users, the Eiffel compiler is expecting the "dotnet" executable to be located inside "/usr/lib/dotnet" (a simple workaround is the create a symbolic link).
|
||||
* For Macos users on M1/M2 (arm) architecture, please read the specific [[Release notes for EiffelStudio 22.12 - macosx|notes about macosx]]
|
||||
----
|
||||
|
||||
See [https://dev.eiffel.com/EiffelStudio_23.09_Releases change log] for more details.
|
||||
@@ -0,0 +1,42 @@
|
||||
[[Property:modification_date|Fri, 14 Jun 2024 15:56:11 GMT]]
|
||||
[[Property:publication_date|Mon, 03 Jun 2024 09:41:04 GMT]]
|
||||
[[Property:uuid|65E6D99C-616E-4335-9667-EF7FD82DA920]]
|
||||
[[Property:title|Release notes for EiffelStudio 24.05]]
|
||||
[[Property:link_title|24.05]]
|
||||
[[Property:weight|-10]]
|
||||
|
||||
==Compiler==
|
||||
===Major Improvements===
|
||||
|
||||
* '''Enhanced .NETCore Compilation Support''': This version significantly enhances compilation support for .NETCore (versions net6.0, net7.0, and net8.0)
|
||||
** '''Partial Support for .NET Generic Methods''': Improved handling and compatibility with .NET generic methods.
|
||||
** '''PDB File Generation''': Enables debugging from external tools with generated Program Database (PDB) files.
|
||||
** '''Eiffel .NETCore Debugging''': Integrated debugging facilities for Eiffel .NETCore directly within EiffelStudio (currently available only on Windows).
|
||||
|
||||
===Known Limitations===
|
||||
* Some .Net limitations exist in the current release that will be addressed in future updates. For detailed information, please refer to the [https://www.eiffel.org/doc/version/23.09/uuid/fe8a6a7d-4590-0db2-d59a-307082b18ecc Eiffel for .NET documentation].
|
||||
|
||||
==Graphical environment==
|
||||
===New Features===
|
||||
* '''Composer Command Enhancements''': Eiffel 24.05 introduces new composer commands to streamline common editing operations:
|
||||
** '''Create Setter for an Attribute''': Easily generate setter methods for attributes.
|
||||
** '''Add New Creation Procedures''': Simplified process to add new creation procedures.
|
||||
** '''Remove Selected Feature''': Quickly remove selected features from your project.
|
||||
** ''Note: the shortcuts `Ctrl+Shift+E, Ctrl+S` means, press `Ctrl+Shift+E` then `Ctrl+S` (i.e 2 step shortcut)''
|
||||
* [Ctrl]+[Up] and [Ctrl]+[Down] to scroll up or down the editor by one line.
|
||||
** Additional commands will be available in future releases.
|
||||
|
||||
===New Authentication Method
|
||||
* '''Web Browser "Sign-in" Challenge''': Introduces a new authentication method using the "Sign-in" challenge via a web browser.
|
||||
|
||||
===Libraries===
|
||||
* Ensured EiffelBase, WEL, Vision2 libraries are supported by Eiffel .NETCore compilation.
|
||||
* Various bug fixes, and minor improvements.
|
||||
|
||||
===Warnings===
|
||||
* SCOOP is currently not supported by Eiffel .NET
|
||||
* For Macos users on M1/M2 (arm) architecture, please read the specific [[Release notes for EiffelStudio 22.12 - macosx|notes about macosx]]
|
||||
----
|
||||
|
||||
See [https://dev.eiffel.com/EiffelStudio_24.05_Releases change log] for more details.
|
||||
===
|
||||
@@ -1,4 +1,4 @@
|
||||
[[Property:modification_date|Sat, 11 Dec 2021 19:23:25 GMT]]
|
||||
[[Property:modification_date|Fri, 08 Mar 2024 09:28:01 GMT]]
|
||||
[[Property:publication_date|Sat, 11 Dec 2021 19:23:25 GMT]]
|
||||
[[Property:title|Linux]]
|
||||
[[Property:weight|4]]
|
||||
@@ -130,6 +130,10 @@ This probably means that the '''register''' program was not launched or did not
|
||||
|
||||
Once this is done, you can jump to the next section, [[#Using EiffelStudio|Using EiffelStudio]] .
|
||||
<span id="using"></span>
|
||||
|
||||
See the following video demonstrating how to activate EiffelStudio:
|
||||
* [https://www.youtube.com/watch?v=kjS3PQfe_Ig Activating EiffelStudio]
|
||||
|
||||
==Using EiffelStudio==
|
||||
|
||||
===Starting EiffelStudio===
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
[[Property:modification_date|Fri, 27 Jan 2023 19:53:59 GMT]]
|
||||
[[Property:modification_date|Mon, 24 Jun 2024 17:30:34 GMT]]
|
||||
[[Property:publication_date|Sat, 11 Dec 2021 21:57:25 GMT]]
|
||||
[[Property:title|Mac OS X]]
|
||||
[[Property:weight|5]]
|
||||
@@ -37,7 +37,16 @@
|
||||
|
||||
MacPorts is a tool that allows you to use many Unix applications on the Mac. Before we can proceed with the installation of EiffelStudio, we need to install the required dependencies of EiffeStudio. First, install [http://guide.macports.org/#installing MacPorts].
|
||||
|
||||
Now simply type (from a bash [http://guides.macrumors.com/Terminal terminal]):
|
||||
|
||||
==Installing EiffeStudio using MacPorts==
|
||||
Since we already install MacPorts, now simply type (from a bash [http://guides.macrumors.com/Terminal terminal]):
|
||||
<pre>
|
||||
sudo port install eiffelstudio
|
||||
</pre>
|
||||
|
||||
|
||||
==Installing EiffelStudio manually==
|
||||
An alternative option is to install each dependency by hand using macPorts.
|
||||
<pre>
|
||||
sudo port install pkgconfig
|
||||
sudo port install bzip2
|
||||
@@ -93,4 +102,40 @@ Alternatively, you can also start EiffelStudio from the command line by entering
|
||||
|
||||
If you are a new user to EiffelStudio, we recommend that you follow [[Introducing EiffelStudio|the EiffelStudio guided tour]].
|
||||
|
||||
<span id="registering"></span>
|
||||
==Registering the Enterprise Edition==
|
||||
|
||||
This step assumes you have followed the instructions in the [[#Setting up EiffelStudio|Setting up EiffelStudio]] section. Perform the following commands to start the registration process:
|
||||
<code>cd $ISE_EIFFEL
|
||||
./register</code>
|
||||
|
||||
A dialog asking for your '''Username''' and '''CD Key''' should appear as it does below:
|
||||
|
||||
<center> [[Image:56--unix-setup|Setup dialog]] </center>
|
||||
|
||||
Enter the information located inside the box that contains your copy of the EiffelStudio Enterprise Edition. Once the information is correct, the '''Register''' button will be enabled. Click '''Register''' to actually register EiffelStudio.
|
||||
|
||||
The first time you launch EiffelStudio, you will be asked for an activation key through the following dialog:
|
||||
|
||||
<center> [[Image:56--unix-registration|Registration dialog]] </center>
|
||||
|
||||
By clicking on the [http://activate.eiffel.com http://activate.eiffel.com] URL, a new web browser will appear with the requested fields automatically filled in with the appropriate information. Simply click '''Activate''' and a new page with an activation code will appear. Copy and paste the activation code in the first field and the '''Activate''' button should be enabled to let you activate your copy.
|
||||
|
||||
You can activate your copy up to three times. Once you have reached this threshold and need to reinstall your copy, contact Eiffel Software to request one more activation.
|
||||
|
||||
If no web browser appears, it is most likely because firefox is not installed on your machine or is not in your path. Instead you should manually launch a new web browser, go to the page [http://activate.eiffel.com http://activate.eiffel.com] , and enter the information manually. Then follow the above instructions as if the browser had been properly launched.
|
||||
|
||||
You may receive the following dialog when launching EiffelStudio:
|
||||
|
||||
<center> [[Image:56--unix-registration-error|Registration incomplete]] </center>
|
||||
|
||||
This probably means that the '''register''' program was not launched or did not succeed in storing data to the following file $'''ISE_EIFFEL'''/install/limand/.ec_license. To solve this, rerun the '''register''' program with a user account that has permissions to write at $'''ISE_EIFFEL'''/install/limand and enter your '''Username''' and '''CD Key'''.
|
||||
|
||||
Once this is done, you can jump to the next section, [[#Using EiffelStudio|Using EiffelStudio]] .
|
||||
<span id="using"></span>
|
||||
|
||||
See the following video demonstrating how to activate EiffelStudio:
|
||||
* [https://www.youtube.com/watch?v=kjS3PQfe_Ig Activating EiffelStudio]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
[[Property:modification_date|Tue, 02 Jul 2019 11:08:53 GMT]]
|
||||
[[Property:modification_date|Fri, 08 Mar 2024 09:26:49 GMT]]
|
||||
[[Property:publication_date|Tue, 02 Jul 2019 10:53:22 GMT]]
|
||||
[[Property:title|Windows]]
|
||||
[[Property:weight|9]]
|
||||
@@ -51,6 +51,9 @@ You may receive the following dialog when launching EiffelStudio:
|
||||
|
||||
This probably means that EiffelStudio was not properly installed using the '''setup.exe''' program. Uninstall EiffelStudio and rerun the installation procedure by making sure to launch '''setup.exe''' and enter your '''Username''' and '''CD Key'''.
|
||||
|
||||
See the following video demonstrating how to activate EiffelStudio:
|
||||
* [https://www.youtube.com/watch?v=TMktPk_9Hok Activating EiffelStudio on Windows]
|
||||
|
||||
== Installing EiffelStudio from the .7z archive ==
|
||||
Installing the GPL version using the 7z archive is an alternative, even if the recommended solution remains using the MSI installer.
|
||||
The procedure is quite similar to Linux, see [[Linux#Setting_up_EiffelStudio]]:
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Mon, 27 May 2024 08:42:15 GMT]]
|
||||
[[Property:publication_date|Mon, 27 May 2024 08:42:15 GMT]]
|
||||
[[Property:title|EiffelBase, Tables]]
|
||||
[[Property:weight|5]]
|
||||
[[Property:uuid|194a63a2-e440-18dc-c9d5-6959dbe169fb]]
|
||||
@@ -8,7 +10,9 @@ The idea behind hash tables is to try to emulate the data structure that provide
|
||||
<code>
|
||||
a.put (x, i)
|
||||
x := a.item (i)
|
||||
x := a @ i </code>
|
||||
|
||||
a [i] := x
|
||||
x := a [i] </code>
|
||||
|
||||
The first causes the value of a at index <eiffel>i</eiffel> to be <eiffel>x</eiffel>; the second (and the third, which is simply a syntactical variant) access the value at index <eiffel>i</eiffel> and assign it to <eiffel>x</eiffel>. With the usual computer architectures, these operations are very fast: because arrays items are stored contiguously in memory, a computer will need just one addition (base address plus index) and one memory access to perform a put or item. <br/>
|
||||
Not only are the operation times small; they are constant (or more precisely bounded by a constant). This is a great advantage over structures such as lists or trees which you must traverse at least in part to retrieve an item, so that access and modification times grow with the number of items. With an array, disregarding the influence of other factors such as memory paging, the time for a put or item is for all practical purposes the same whether the array has five items or five hundred thousand. These properties make arrays excellent data structures for keeping objects. Unfortunately, they are only applicable if the objects satisfy three requirements:
|
||||
@@ -55,6 +59,10 @@ The value of <eiffel>n</eiffel> indicates how many items the hash table is expec
|
||||
|
||||
It is useful, however, to use a reasonable upon creation: not too large to avoid wasting space, but not too small to avoid frequent applications of resizing, an expensive operation.
|
||||
|
||||
==Specific case of STRING_TABLE==
|
||||
Hash tables, used to store items identified by string keys that are compared with or without case sensitivity.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Thu, 04 Jan 2024 11:07:42 GMT]]
|
||||
[[Property:publication_date|Thu, 04 Jan 2024 11:07:42 GMT]]
|
||||
[[Property:title|Esql Sample]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|04d03117-fdb2-8b73-677f-9b1a0c333dc4]]
|
||||
@@ -36,7 +38,7 @@ Name: smith@HANDSON
|
||||
Password: mypass
|
||||
</code>
|
||||
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax ''<user>@<service> ''where ''<user>'' stands for the User Name and ''<service>'' stands for the Net Service Name. }}
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax `<user>@<service>` where `<user>` stands for the User Name and `<service>` stands for the Net Service Name. }}
|
||||
|
||||
|
||||
Then you can enter standard SQL queries to interact with your database, for instance:
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Thu, 04 Jan 2024 11:08:28 GMT]]
|
||||
[[Property:publication_date|Thu, 04 Jan 2024 11:08:28 GMT]]
|
||||
[[Property:title|Inserter Sample]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|fa0b8601-ca7a-b1cc-384d-f366be33ac40]]
|
||||
@@ -42,7 +44,7 @@ Name: smith@HANDSON
|
||||
Password: mypass
|
||||
</code>
|
||||
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax ''<user>@<service> ''where ''<user>'' stands for the User Name and ''<service>'' stands for the Net Service Name. }}
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax `<user>@<service>` where `<user>` stands for the User Name and `<service>` stands for the Net Service Name. }}
|
||||
|
||||
|
||||
Then you can insert a book in the database, for instance:
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Thu, 04 Jan 2024 11:06:50 GMT]]
|
||||
[[Property:publication_date|Thu, 04 Jan 2024 11:06:50 GMT]]
|
||||
[[Property:title|Selector Sample]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|3d608710-5537-04e4-fa89-a608ee6864cd]]
|
||||
@@ -42,7 +44,7 @@ Name: smith@HANDSON
|
||||
Password: mypass
|
||||
</code>
|
||||
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax ''<user>@<service> ''where ''<user>'' stands for the User Name and ''<service>'' stands for the Net Service Name. }}
|
||||
{{note|You must specify the Oracle User Name and Net Service Name with the syntax `<user>@<service>` where `<user>` stands for the User Name and `<service>` stands for the Net Service Name. }}
|
||||
|
||||
|
||||
Then you can select rows from this table with author's name, for instance:
|
||||
@@ -70,7 +72,7 @@ First publication:07/01/1992 12:00:00.0 AM
|
||||
Author? ('exit' to terminate):
|
||||
</code>
|
||||
|
||||
{{note|Enter ''exit'' to quit the application. }}
|
||||
{{note|Enter `exit` to quit the application. }}
|
||||
|
||||
==Under the Hood==
|
||||
|
||||
@@ -82,8 +84,3 @@ The whole sample code is contained in the root class:
|
||||
* SELECTOR for Oracle.
|
||||
* SELECTOR_ODBC for ODBC.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,11 +1,16 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 14:00:06 GMT]]
|
||||
[[Property:publication_date|Tue, 26 Sep 2023 19:18:02 GMT]]
|
||||
[[Property:title|Building a .NET application]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|a44736cf-41df-1679-9c6d-7b56f31d5f9a]]
|
||||
Eiffel for .NET has some specific functionality meant to leverage necessary aspects of the .NET Framework.
|
||||
Eiffel for .NET has some specific functionality meant to leverage necessary aspects of the .NET solution.
|
||||
|
||||
For that reason, the [[EiffelStudio: Project settings window|project settings]] for Eiffel for .NET introduces new options. These options include:
|
||||
|
||||
* Specifying whether the generated assembly should be an EXE or a DLL.
|
||||
* Choosing between generating verifiable or non verifiable IL code. Non verifiable IL code executes faster but requires high trust settings.
|
||||
* Specifying the .NET runtime (v4.0, net6.0, net7.0, ...)
|
||||
|
||||
* (For .NET Framework only: choosing between generating verifiable or non verifiable IL code. Non verifiable IL code executes faster but requires high trust settings.)
|
||||
|
||||
The Eiffel for .NET compiler generates a single assembly whose name is the name of the system as given in the [[System Options|system options of the project settings]] .
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
[[Property:modification_date|Fri, 29 Sep 2023 11:57:59 GMT]]
|
||||
[[Property:publication_date|Fri, 29 Sep 2023 11:57:59 GMT]]
|
||||
[[Property:title|Eiffel for ASP.NET Documentation]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|158e298e-e4b3-3246-651c-557f2f630957]]
|
||||
|
||||
{{Caution|This section concerns only Eiffel .NET Framework, and not .NETCore}}
|
||||
|
||||
CodeDom is a Microsoft .NET technology which allows representing source code programatically so that it may be rendered in different languages. The Eiffel CodeDom Provider is installed through Eiffel for ASP.NET which is available for download for free on the Eiffel Software web site ( [http://www.eiffel.com http://www.eiffel.com] ). <br/>
|
||||
The following documents cover different aspects of the Eiffel CodeDom Provider:
|
||||
* [[Writing ASP.NET pages in Eiffel|Writing ASP.NET pages in Eiffel]] covers topics related to writing Eiffel pages in ASP.NET.
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Mon, 25 Sep 2023 09:37:39 GMT]]
|
||||
[[Property:publication_date|Mon, 25 Sep 2023 09:37:39 GMT]]
|
||||
[[Property:title|Eiffel Class and Feature Names]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|16e4a231-7aae-4b37-52fd-67876cc222ad]]
|
||||
@@ -194,7 +196,7 @@ In order to use .NET types that include static members, a special syntax has bee
|
||||
my_window.set_text (my_window_title)
|
||||
.
|
||||
.
|
||||
feature {WINFORMS_APPLICATION}.run_form (my_window)
|
||||
{WINFORMS_APPLICATION}.run_form (my_window)
|
||||
end
|
||||
|
||||
</code>
|
||||
@@ -0,0 +1,105 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 12:50:47 GMT]]
|
||||
[[Property:publication_date|Mon, 02 Oct 2023 10:00:56 GMT]]
|
||||
[[Property:uuid|1838ECEC-F411-46C7-926B-204ED0ACD0C6]]
|
||||
[[Property:weight|20]]
|
||||
[[Property:title|Eiffel .NETCore execution]]
|
||||
[[Property:link_title|NETCore execution]]
|
||||
|
||||
|
||||
This document provide a quick overview on how to execute Eiffel.NetCore applications. It covers various aspects including the wrapper project, execution, publishing, debugging in VisualStudio, and known limitations
|
||||
|
||||
At the moment, the EiffelStudio '''debugger has no support''' Eiffel .NET Core.
|
||||
It is, however, possible to execute most of the Eiffel .NET Core application from the IDE using the `Run` command. The execution will be outside EiffelStudio.
|
||||
|
||||
The generated executable can not be executed by itself and requires to be launched using the `dotnet` tool from the command line.
|
||||
{{note|Use the command: `dotnet <app_name>` or `dotnet run <app_name>`.}}
|
||||
|
||||
== Wrapper project ==
|
||||
To help the user, the EiffelStudio compiler also generates a C# wrapper project (located in W_code or F_code directories). See the `wrapper_*.cs` and `wrapper_*.csproj` files.
|
||||
This simple C# '''wrapper''' project is simply a way to include and instantiate the Eiffel .NETCore code.
|
||||
|
||||
This "wrapper" project is useful for:
|
||||
* [[#Executing]] using profile
|
||||
* [[#Publishing|publishing]] the executable
|
||||
* [[#Debugging_in_VisualStudio|debugging]] using VisualStudio.
|
||||
* Working with any specific tool that requires a C# project
|
||||
|
||||
See the next sections for more information.
|
||||
|
||||
For an application named "app_netcore":
|
||||
* the C# code is quite simple:
|
||||
<code lang="cs">
|
||||
...
|
||||
public class wrap_app_netcore
|
||||
{
|
||||
public static void Main()
|
||||
{
|
||||
MAIN.Main();
|
||||
}
|
||||
}
|
||||
</code>
|
||||
Note: the `MAIN.Main()` is the main entry point of the Eiffel .NETCore application.
|
||||
|
||||
* the `wrap_app_netcore.csproj` file looks like:
|
||||
<code lang="xml">
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<OutputType>exe</OutputType>
|
||||
<TargetFramework>net6.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>disable</Nullable>
|
||||
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
|
||||
<GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
|
||||
<ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
|
||||
None
|
||||
</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Reference Include="app_netcore">
|
||||
<HintPath>app_netcore.exe</HintPath>
|
||||
</Reference>
|
||||
<Reference Include="EiffelSoftware.Runtime">
|
||||
<HintPath>Eiffelsoftware.Runtime.dll</HintPath>
|
||||
</Reference>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
</code>
|
||||
|
||||
==Execution==
|
||||
It is possible that an application requires additional setting (for example web APIs application), in this case the `dotnet run` tool can use a specific '''profile''' using the syntax `--launch-profile <NAME>`.
|
||||
|
||||
Read more about the `dotnet` tool, and especially the `run` command at [https://learn.microsoft.com/fr-fr/dotnet/core/tools/dotnet-run] .
|
||||
|
||||
==Publishing==
|
||||
The '''wrapper''' project is helpful to '''publish''' the executable to the current or other platforms, and have an executable that does not require the `dotnet` command.
|
||||
It is also possible to include all dependencies (i.e: self contained) to ease deployment on machine without any dotnet runtime installed.
|
||||
|
||||
{{note| use the `dotnet publish` tool on the generated wrapper project. See the documentation about `dotnet publish` at [https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-publish] .}}
|
||||
|
||||
==Debugging in VisualStudio==
|
||||
Even if EiffelStudio does not provide any support for debugging Eiffel .NETCore directly from the IDE.
|
||||
|
||||
It is possible to use, for instance, '''VisualStudio''' to debug the generated Eiffel .NETcore application thanks to the wrapper C# project.
|
||||
|
||||
A solution is to use the C# wrapper project generated by the Eiffel compiler (in W_code or F_code directory) within VisualStudio.
|
||||
* Open the C# `.csproj` file with VisualStudio (it includes the associated Eiffel output dll or exe)
|
||||
* Configure the Debugging profile
|
||||
* Launch the execution with VisualStudio, and debug.
|
||||
|
||||
==Limitations==
|
||||
In the current version, the EiffelStudio compiler will always generate a Microsoft.NET.Sdk C# wrapper project. But this is not always the expected type SDKs.
|
||||
|
||||
For instance when using ASP.NETCore, it is expected to use `Microsoft.NET.Sdk.Web`.
|
||||
|
||||
In such case, the generated `.csproj` file needs to be manually modified to set the expected SDK, and also the various package dependencies.
|
||||
|
||||
For instance:
|
||||
* replace the first line of the `.csproj` file by <code lang="xml"><Project Sdk="Microsoft.NET.Sdk.Web"></code>
|
||||
* and in the `<ItemGroup>` section, list the package references such as <code lang="xml"><PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.10" /></code>
|
||||
|
||||
This allows the application to be run and, if necessary, debugged using VisualStudio.
|
||||
|
||||
{{info|To learn more, check the Eiffel .NETCore examples at [[Eiffel .NET samples]].}}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 13:38:24 GMT]]
|
||||
[[Property:publication_date|Mon, 02 Oct 2023 10:22:20 GMT]]
|
||||
[[Property:uuid|AF5801CA-928B-4870-BCC4-53DCAB23AF96]]
|
||||
[[Property:weight|10]]
|
||||
[[Property:title|Workaround Eiffel .NET limitations]]
|
||||
[[Property:link_title|Workarounds]]
|
||||
|
||||
There are a [[Eiffel for .NET Integration|few limitations]] in the integration between Eiffel .NET and .NET solution.
|
||||
However, it is sometime possible to find workaround, a common technique is to use a C# facade project, and use it from the Eiffel .NET project.
|
||||
|
||||
See in the following section, a way to use a facade C# project to workaround the current limitation on ".NET generic" compilation (i.e the fact the Eiffel compiler does not support yet the .NET generics).
|
||||
|
||||
This technique can be adapted to bypass other limitations or annoyances.
|
||||
|
||||
==Using generic .NET classes through a facade==
|
||||
Currently, Eiffel does not support consuming generics from C# classes. This tutorial demonstrates a workaround for this limitation by creating a Facade for a `List<string>` in C#
|
||||
|
||||
===Creating a facade for the List type===
|
||||
A Facade simplifies access to complex components. In this case, we will create a Facade to manage a list of strings. The Facade will encapsulate the list's functionality and expose a more straightforward interface. Here's how you can do it:
|
||||
|
||||
<code lang="cs">
|
||||
using System.Collections;
|
||||
namespace ListOfString;
|
||||
|
||||
/// <summary>
|
||||
/// Facade for a List<string> that encapsulates the list's functionality and exposes a few methods
|
||||
/// </summary>
|
||||
public class ListOfString
|
||||
{
|
||||
// Private list of strings
|
||||
private List<string> _list;
|
||||
|
||||
// Constructor that initialize the list
|
||||
public ListOfString()
|
||||
{
|
||||
_list = new List<string>();
|
||||
}
|
||||
|
||||
// Add an item to the list
|
||||
public void Add(string item)
|
||||
{
|
||||
_list.Add(item);
|
||||
}
|
||||
|
||||
// Check if the list contains a specific item
|
||||
public bool Contains(string item)
|
||||
{
|
||||
return _list.Contains(item);
|
||||
}
|
||||
|
||||
// Remove a specific item from the list
|
||||
public void Remove(string item)
|
||||
{
|
||||
_list.Remove(item);
|
||||
}
|
||||
|
||||
public IList GetList()
|
||||
{
|
||||
return _list.ToList();
|
||||
}
|
||||
}
|
||||
</code>
|
||||
|
||||
===Creating a C# library===
|
||||
To consume the Facade in Eiffel, we need to create a C# library. I recommend following the tutorial on creating a class library with C# and .NET on Microsoft’s official site. You can access it [https://learn.microsoft.com/en-us/dotnet/core/tutorials/library-with-visual-studio?pivots=dotnet-7-0 here]. This tutorial guides you through the process of creating a class library using C# and .NET.
|
||||
|
||||
===Consuming the C# library from Eiffel===
|
||||
Finally, we need to consume the C# library from Eiffel.
|
||||
|
||||
Open the Eiffel configuration file (.ecf) of your project and add the following entry
|
||||
|
||||
<code><assembly name="ListOfString" location="$PATH_CS_LIB\ListOfString.dll"/></code>
|
||||
|
||||
|
||||
===Conclusion===
|
||||
By creating a Facade for a `List<string>` in C#, we can effectively consume C# generic features in Eiffel.
|
||||
Obviously, this approach can be extended to other generic types as well.
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
[[Property:modification_date|Mon, 23 Oct 2023 15:36:40 GMT]]
|
||||
[[Property:publication_date|Wed, 27 Sep 2023 19:33:07 GMT]]
|
||||
[[Property:title|Eiffel for .NET Integration]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|fe8a6a7d-4590-0db2-d59a-307082b18ecc]]
|
||||
==Differences between Eiffel and Eiffel for .NET==
|
||||
|
||||
===Limitation of Eiffel for .NET in version 23.09===
|
||||
|
||||
Most of the Eiffel mechanisms are supported in 23.09.
|
||||
|
||||
Eiffel for .NET supports:
|
||||
* Multiple Inheritance
|
||||
* Design By Contract
|
||||
* Exception handling
|
||||
* Genericity
|
||||
* Covariance
|
||||
* Compilation of any existing Eiffel libraries as long as it does not include C externals that call into the Eiffel Software C runtime
|
||||
* the [[Concurrent_programming_with_SCOOP|SCOOP]] capability is not support by the Eiffel.NET compiler
|
||||
|
||||
However, there are a few limitations that are described later in this documentation.
|
||||
|
||||
===Added to Eiffel and Eiffel for .NET===
|
||||
|
||||
The following syntax can be used to declare .NET custom attributes on Eiffel entities (features and classes):
|
||||
<code>
|
||||
empty: BOOLEAN
|
||||
note
|
||||
description: "Is Current empty?"
|
||||
metadata: create {OBSOLETE_ATTRIBUTE}.make ("Use `is_empty' instead") end
|
||||
obsolete
|
||||
"Use is_empty instead"
|
||||
do
|
||||
Result := is_empty
|
||||
end
|
||||
</code>
|
||||
|
||||
The previous example shows the declaration of the obsolete feature <code> empty </code> . The custom attribute defined by <code>OBSOLETE_ATTRIBUTE</code> is used to ensure that any consumer of the resulting assembly will see the feature as being obsolete. The custom attribute is defined in the <code>note</code> clause <code>metadata</code>. The definition consists of a creation expression that creates the custom attribute with the right parameters.
|
||||
|
||||
Using the <code>metadata</code> tag is the most general way of applying a custom attribute. There are however some variations that are explained below:
|
||||
*<code>metadata</code>: most general way, it applies a custom attribute to both the class and interface generated by the Eiffel compiler.
|
||||
*<code>class_metadata</code>: applies only to the class generated by the Eiffel compiler (mostly for advanced users).
|
||||
*<code>interface_metadata</code>: applies only to the interface generated by the Eiffel compiler (mostly for advanced users).
|
||||
*<code>property_metadata</code>: applies a custom attribute to the associated property generated by the Eiffel compiler for a query.
|
||||
*<code>assembly_metadata</code>: applies a custom attribute for the current assembly. It only works when present in the Eiffel system root class <code>note</code> clause.
|
||||
|
||||
==Differences between Eiffel for .NET and .NET==
|
||||
|
||||
===Covariance===
|
||||
The CLR (Common Language Runtime) does not support [[ET: Inheritance#Covariance and anchored declarations|covariance]] due to a different view of type safety (the issue is known known as a polymorphic [[ET: Inheritance#Catcalls|catcall]] in Eiffel). Catcalls are possible (although very rare) in Eiffel but not in .NET.
|
||||
|
||||
Eiffel for .NET implements a safe variant of covariance that will always perform a check on the types to avoid a catcall. So when a catcall is going to be performed a `Invalid Cast Exception` will be raised by the CLR instead of an unexpected behavior as is the default behavior in classic Eiffel (i.e., the behavior without catcall detection explicitly enabled).
|
||||
|
||||
Another advantage of Eiffel for .NET's implementation of covariance is that it can be easily understood by CLS-compliant consumer tools. These tools will actually benefit from the Eiffel for .NET covariance.
|
||||
|
||||
===Handling Eiffel and .NET genericity===
|
||||
As noted above, Eiffel for .NET fully supports the powerful genericity mechanism of the Eiffel language. The interface with .NET's own genericity mechanism is, however, not complete in version 23.09. Specifically:
|
||||
|
||||
* Generic classes in Eiffel will not yield generic classes in .NET. Instead, each generic derivation of a given Eiffel class will yield a different .NET class. So if we have a generic Eiffel class <code>LIST [G]</code>, the type <code>LIST [ANY]</code> will yield a .NET class <code>LIST_ANY</code>, and the type <code>LIST [INTEGER]</code> will yield a class <code>LIST_Int32</code> .
|
||||
|
||||
* If you want to use a generic .NET class (for example in C#), you have to use special techniques as described next.
|
||||
|
||||
{{Recommended|Read the [[Workaround Eiffel .NET limitations]] page to learn how to workaround such limitation. }}
|
||||
|
||||
===Enum types===
|
||||
Eiffel for .NET supports .NET enum types implicitly. From the point of view of Eiffel, they are just considered as expanded classes. The only difference is in the code generation. Eiffel for .NET cannot declare new enum types yet.
|
||||
|
||||
===ByRef===
|
||||
|
||||
Eiffel does not have the notion of `byref` argument passing. At the moment, Eiffel for .NET cannot call nor can it redefine a feature that has a byref argument.
|
||||
|
||||
=== Type with "init" only setters===
|
||||
Eiffel currently does not support the special `init` property that is only initialized in a block of code as part of the object initialization. More details can be found in the [https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-9.0/init C# 9.0 proposal]
|
||||
|
||||
Note: {{inline-info|this section is mostly for .NETCore 6.0 and above}}.
|
||||
|
||||
'''Workaround''':
|
||||
|
||||
A potential workaround is to create a C# library that uses a Factory pattern to build the required instance.
|
||||
|
||||
===Execution and publishing ===
|
||||
Currently the EiffelStudio debugger supports only the Eiffel .NET Framework application (i.e .Net framework v4.0).
|
||||
|
||||
For .NETCore (net6.0, net7.0, ...) it is not yet available within the EiffelStudio IDE.
|
||||
|
||||
{{recommended|Learn more how to publish, execute, debug, ... the Eiffel .NETCore application, with the [[Eiffel .NETCore execution]] page.}}
|
||||
|
||||
== Environment variables for .NETCore ==
|
||||
The Eiffel compiler sets a few environment variables available in the ECF files and allows to write ECF file without hardcoded version numbers.
|
||||
|
||||
* '''ISE_DOTNET_FRAMEWORK''': location of the default .NET runtime directory (parent of System.dll, System.Runtime.dll, ...)
|
||||
* '''ISE_DOTNET_PLATFORM''': for a .NET project it contains either "framework", or "netcore" to distinguish between .NET Framework (v4.0) and .NETCore solutions (net6.0, neet7.0, ...)
|
||||
* '''ISE_DOTNET_PACKS''': location to the .NETCore "packs" directory (parent of .NETCore '''reference'' runtimes)
|
||||
* '''ISE_DOTNET_PACKS''': location to the .NETCore "shared" directory (parent of .NETCore implementation runtimes)
|
||||
* '''ISE_DOTNET_TFM''': .NETCore TFM (Target Framework Moniker) , for instance "net6", "net7", ...
|
||||
* '''ISE_DOTNET_VERSION''': .NETCore runtime precise version number (for instance 7.0.11)
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 14:01:34 GMT]]
|
||||
[[Property:publication_date|Mon, 02 Oct 2023 14:01:34 GMT]]
|
||||
[[Property:title|The Eiffel for .NET language]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|ba6cd8d3-683c-4167-bdef-a0274c392f34]]
|
||||
@@ -5,7 +7,7 @@ This section focuses on defining Eiffel for .NET. The key requirement for Eiffel
|
||||
|
||||
Because not all Eiffel functionalities are present in .NET, the task of the Eiffel compiler is made more complicated since it has to emulate those mechanisms instead of reusing what .NET provides. For example the common language runtime of .NET does not support:
|
||||
* [[uuid:b8c10baa-4f50-adfe-a6f8-9cb56a8f1917#Multiple inheritance|multiple inheritance]]
|
||||
* [[uuid:b8c10baa-4f50-adfe-a6f8-9cb56a8f1917#Genericity|genericity]]
|
||||
* [[uuid:b8c10baa-4f50-adfe-a6f8-9cb56a8f1917#Genericity|genericity]] (only first versions of .NET)
|
||||
* [[uuid:b8c10baa-4f50-adfe-a6f8-9cb56a8f1917#Covariance|covariance]]
|
||||
* agents
|
||||
|
||||
10
documentation/trunk/solutions/dotnet/index.wiki
Normal file
10
documentation/trunk/solutions/dotnet/index.wiki
Normal file
@@ -0,0 +1,10 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 13:58:08 GMT]]
|
||||
[[Property:publication_date|Fri, 29 Sep 2023 12:07:01 GMT]]
|
||||
[[Property:title|.NET]]
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|55eda2f0-0c60-f08c-b141-913e31a49c2f]]
|
||||
|
||||
Eiffel supports compilation of .NETCore (net6.0, net7.0, ...) and .NET Framework (v4.0).
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
[[Property:modification_date|Tue, 26 Sep 2023 19:12:15 GMT]]
|
||||
[[Property:publication_date|Tue, 26 Sep 2023 19:11:02 GMT]]
|
||||
[[Property:title|.NET Installation instructions]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|64f7e3b1-f6ee-5cc4-1006-2fc4dfdaeae7]]
|
||||
EiffelStudio supports '''.NETCore''' and only on Windows the '''.NET Framework''' (v4.0) .
|
||||
Before being able to compile an Eiffel .NET project, you need to install .NETCore or the .NET Framework.
|
||||
|
||||
* '''.NETCore''': see [https://learn.microsoft.com/en-us/dotnet/core/install/] (net6.0 or net7.0 are recommended)
|
||||
|
||||
* '''.NET Framework (Windows only)''': see [https://learn.microsoft.com/en-us/dotnet/framework/install/] (you need to install either the .NET Framework, the .NET Framework SDK or Visual Studio .NET).
|
||||
|
||||
If you do not have any of those installed, any Eiffel .NET compilation will report an error because no .NET features support are installed.
|
||||
|
||||
14
documentation/trunk/solutions/dotnet/samples/index.wiki
Normal file
14
documentation/trunk/solutions/dotnet/samples/index.wiki
Normal file
@@ -0,0 +1,14 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 10:53:11 GMT]]
|
||||
[[Property:publication_date|Fri, 29 Sep 2023 12:02:25 GMT]]
|
||||
[[Property:title|Eiffel .NET samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|c1dbfdb5-c4d0-f674-d818-00d56c431c6e]]
|
||||
In this chapter you will find a series of examples that will permit to you to understand the bases of programming with Dotnet.
|
||||
|
||||
However, you should be familiar with Object-Oriented programming model. Almost all other examples can also be built for .NET if the dotnet target is choosen instead of classic.
|
||||
|
||||
{{Caution|Those examples were initially built for Eiffel .NET framework and may not work with .NETCore (net6.0, net7.0, ...) }}
|
||||
|
||||
{{Recommended|Visit the GitHub organization [https://github.com/EiffelNETCore] for more '''.NETCore examples''' (Machine Learning, ASP.NETCore, ...) using EiffelStudio .NET. }}
|
||||
|
||||
|
||||
@@ -1,5 +1,10 @@
|
||||
[[Property:modification_date|Mon, 02 Oct 2023 10:37:38 GMT]]
|
||||
[[Property:publication_date|Mon, 02 Oct 2023 10:37:38 GMT]]
|
||||
[[Property:title|Winform Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|24cbeb3c-ba2b-1fea-ccec-89600bbf3256]]
|
||||
|
||||
{{Caution|Those WinForm samples targets Eiffel .NET framework and are probably not compiling with .NETCore (net6.0, net7.0, ...) }}
|
||||
|
||||
The following examples are classified generally from the easiest to the most complex. So, some notions are introduced in the few first examples and will not be explained again in the more complex examples!
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
[[Property:modification_date|Thu, 27 Jun 2024 10:51:45 GMT]]
|
||||
[[Property:publication_date|Thu, 27 Jun 2024 10:51:45 GMT]]
|
||||
[[Property:title|Converting EiffelVision 2 Systems to Void-Safety]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|96e01318-700b-da6e-42d1-14fee219daf5]]
|
||||
==Introduction==
|
||||
|
||||
In order to convert systems that employ EiffelVision 2 (Vision2) to [[Void-safe Programming in Eiffel|void-safety]], some adjustments may be needed depending on its usage. This page describes the various usage scenarios of Vision2 that will need to be converted in order to adhere to void-safety.
|
||||
In order to convert systems that employ EiffelVision 2 (Vision2) to [[Void-safe programming in Eiffel|void-safety]], some adjustments may be needed depending on its usage. This page describes the various usage scenarios of Vision2 that will need to be converted in order to adhere to void-safety.
|
||||
<!--break-->
|
||||
==Inheritance Purely from an Interface Class==
|
||||
|
||||
@@ -82,5 +84,5 @@ The following steps are needed during the conversion:
|
||||
* Remove <eiffel>`make'</eiffel>, rename <eiffel>`initialize'</eiffel> to <eiffel>`make'</eiffel>, and make sure that any calls to Precursor do not override any settings set in <eiffel>`initialize'</eiffel>. The ordering may need to be changed in order to make the code void-safe. See <eiffel>EV_POPUP_WINDOW_IMP.make</eiffel> (Windows implementation) where the setting of <eiffel>`user_can_resize'</eiffel> is performed after the Precursor call so that is doesn't get overriden.
|
||||
|
||||
|
||||
{{SeeAlso|[[Void-Safe Programming in Eiffel]]}}
|
||||
{{SeeAlso|[[Void-safe programming in Eiffel]]}}
|
||||
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
[[Property:title|Eiffel for .NET Integration]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|fe8a6a7d-4590-0db2-d59a-307082b18ecc]]
|
||||
==Differences between Eiffel and Eiffel for .NET==
|
||||
|
||||
===Limitation of Eiffel for .NET in version 5. 5===
|
||||
|
||||
Most of the Eiffel mechanisms are supported in 5. 5. All missing features listed below are planned for addition in future releases:
|
||||
* No creation of Eiffel expanded class support
|
||||
* Partial implementation of generic conformance (same as what was supported up to and including the 4.2 release of the Eiffel development environment).
|
||||
|
||||
Eiffel for .NET supports:
|
||||
* Multiple Inheritance
|
||||
* Design By Contract
|
||||
* Exception handling
|
||||
* Genericity
|
||||
* Covariance
|
||||
* Compilation of any existing Eiffel libraries as long as it does not include C externals that call into the Eiffel Software C runtime
|
||||
|
||||
===Added to Eiffel and Eiffel for .NET===
|
||||
|
||||
The following syntax can be used to declare .NET custom attributes on Eiffel entities (features and classes):
|
||||
<code>
|
||||
empty: BOOLEAN
|
||||
note
|
||||
description: "Is Current empty?"
|
||||
metadata: create {OBSOLETE_ATTRIBUTE}.make_obsoleteattribute_1 ("Use `is_empty' instead") end
|
||||
obsolete
|
||||
"Use is_empty instead"
|
||||
do
|
||||
Result := is_empty
|
||||
end
|
||||
</code>
|
||||
|
||||
The previous example shows the declaration of the obsolete feature <code> empty </code> . The custom attribute defined by <code>OBSOLETE_ATTRIBUTE</code> is used to ensure that any consumer of the resulting assembly will see the feature as being obsolete. The custom attribute is defined in the <code>note</code> clause <code>metadata</code>. The definition consists of a creation expression that creates the custom attribute with the right parameters.
|
||||
|
||||
Using the <code>metadata</code> tag is the most general way of applying a custom attribute. There are however some variations that are explained below:
|
||||
*<code>metada</code>: most general way, it applies a custom attribute to both the class and interface generated by the Eiffel compiler.
|
||||
*<code>class_metadata</code>: applies only to the class generated by the Eiffel compiler (mostly for advanced users).
|
||||
*<code>interface_metadata</code>: applies only to the interface generated by the Eiffel compiler (mostly for advanced users).
|
||||
*<code>property_metadata</code>: applies a custom attribute to the associated property generated by the Eiffel compiler for a query.
|
||||
*<code>assembly_metadata</code>: applies a custom attribute for the current assembly. It only works when present in the Eiffel system root class <code>note</code> clause.
|
||||
|
||||
==Differences between Eiffel for .NET and .NET==
|
||||
|
||||
===Covariance===
|
||||
|
||||
The CLR (Common Language Runtime) does not support [[ET: Inheritance#Covariance and anchored declarations|covariance]] due to a type safety issue that full covariance implies (known as a polymorphic [[ET: Inheritance#Catcalls|catcall]] in Eiffel). Although very rare, catcalls are not suitable to .NET where safety is one of the primary goals.
|
||||
|
||||
Eiffel for .NET implements a safe variant of covariance that will always perform a check on the types to avoid a catcall. So when a catcall is going to be performed a `Invalid Cast Exception` will be raised by the CLR instead of an unexpected behavior as is the default behavior in classic Eiffel (i.e., the behavior without catcall detection explicitly enabled).
|
||||
|
||||
Another advantage of Eiffel for .NET's implementation of covariance is that it can be easily understood by CLS compliant consumer tools. These tools will actually benefit from the Eiffel for .NET covariance.
|
||||
|
||||
===Genericity===
|
||||
|
||||
The CLR does not support generics at all, so that the following Eiffel for .NET classes:
|
||||
* <code>LIST [ANY]</code>
|
||||
* <code>LIST [INTEGER]</code>
|
||||
|
||||
will actually be generated as:
|
||||
* <code>LIST_ANY</code>
|
||||
* <code>LIST_Int32</code>
|
||||
|
||||
Meaning that if one wants to reuse an Eiffel generic class from another language than Eiffel for .NET, one has to use either <code>LIST_ANY</code> or <code>LIST_Int32</code>.
|
||||
|
||||
===Enum types===
|
||||
|
||||
Eiffel for .NET supports .NET enum types implicitly. From the point of view of Eiffel, they are just considered as expanded classes. The only difference is in the code generation. Eiffel for .NET cannot declare new enum types yet.
|
||||
|
||||
===ByRef===
|
||||
|
||||
Eiffel does not have the notion of `byref` argument passing. At the moment, Eiffel for .NET cannot call nor can it redefine a feature that has a byref argument.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
[[Property:title|.NET]]
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|55eda2f0-0c60-f08c-b141-913e31a49c2f]]
|
||||
==.NET==
|
||||
|
||||
Eiffel support for Microsoft .NET.
|
||||
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
[[Property:title|.NET Installation instructions]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|64f7e3b1-f6ee-5cc4-1006-2fc4dfdaeae7]]
|
||||
Before installing the .NET components for Eiffel for .NET you need to install either the .NET Framework, the .NET Framework SDK or Visual Studio .NET. If you do not have any of those installed, the installation program will prompt you with a warning because no .NET features support will be installed.
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
[[Property:title|Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|c1dbfdb5-c4d0-f674-d818-00d56c431c6e]]
|
||||
In this chapter you will find a series of examples that will permit to you to understand the bases of programming with Dotnet.
|
||||
|
||||
However, you should be familiar with Object-Oriented programming model. Almost all other examples can also be built for .NET if the dotnet target is choosen instead of classic.
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
[[Property:modification_date|Wed, 20 Mar 2024 17:14:32 GMT]]
|
||||
[[Property:publication_date|Wed, 20 Mar 2024 15:13:54 GMT]]
|
||||
[[Property:uuid|5D7CBC54-D97A-4400-9335-9C8FB3CBE004]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:title|EiffelWeb framework]]
|
||||
@@ -8,7 +10,7 @@
|
||||
The EiffelWeb Framework provides a common framework to build easily web server application in Eiffel (portable on various connectors and platforms).
|
||||
|
||||
* Project on github: [https://github.com/EiffelWebFramework/EWF]
|
||||
* Associated website [http://www.eiffelweb.org/]
|
||||
* Associated website [https://eiffelweb.projects.eiffel.org/]
|
||||
* Latest documentation [https://github.com/EiffelWebFramework/EWF/blob/master/docs/workbook/workbook.md]
|
||||
* Gitter.im room [https://gitter.im/EiffelWebFramework/EWF]
|
||||
* Forum [https://groups.google.com/forum/#!forum/eiffel-web-framework]
|
||||
|
||||
Reference in New Issue
Block a user