mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-04-08 11:09:24 +02:00
Author:admin
Date:2008-09-30T16:23:49.000000Z git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@65 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
@@ -1,5 +1,6 @@
|
||||
[[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.
|
||||
|
||||
For that reason, the [[EiffelStudio: Project settings window|project settings]] for Eiffel for .NET introduces new options. These options include:
|
||||
|
||||
@@ -32,7 +32,7 @@ This last setting will only appear for configurations other than the default con
|
||||
New configurations may be created by clicking the ''New'' button or the ''New'' entry in the ''File'' menu. The New Configuration dialog box asks for the name and the path of the configuration. It will create a file with the extension '''.ecd''' ('''E'''iffel '''C'''ode'''D'''om) with the specified name in the directory located at the specified path. Whenever one of the applications listed at the bottom of the New Configuration dialog loads the Eiffel CodeDom Provider, it will use this new configuration.
|
||||
==Configuration Properties==
|
||||
Double clicking on the configuration name in the configurations list, clicking the ''Properties'' button or choosing the ''Properties'' menu entry in the ''File'' menu will open the Configuration Properties dialog. This dialog gives the dates of creation and last modification of the configuration as well as the list of applications that use it if it's not the default configuration.
|
||||
{{seealso| '''See also:''' [[Configuration|Configuration]] , [[Logging|Logging]] }}
|
||||
{{seealso|[[Configuration|Configuration]] , [[Logging|Logging]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|eSplitter]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|2cf7249c-fd1e-b8e0-08ab-c2995b2b8227]]
|
||||
This tool comes in two flavors: a command line only utility ''esplit.exe'' and a graphical tool ''esplitter.exe''. Both applications achieve the same goal: to produce standard Eiffel source files ('''.e''' files) from Eiffel CodeDom Provider generated source files ('''.es''' files).
|
||||
==Command Line Utility (esplit.exe)==
|
||||
This utility is located in the ''Codedom\bin'' subfolder of the Eiffel for ASP.NET directory. The command line syntax is:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Eiffel for ASP.NET Tools and Administration]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|960d3d4b-33d0-327f-343d-ad9d5591f07a]]
|
||||
The Eiffel for ASP.NET delivery comes together with several tools:
|
||||
* [[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] allows administering the Eiffel CodeDom Provider.
|
||||
* [[eSplitter|ESplitter]] allows generating standard Eiffel source files ('''.e''' files) from Eiffel CodeDom Provider generated files ('''.es''') files.
|
||||
|
||||
@@ -8,7 +8,7 @@ The assemblies the tool will look into for the .NET type whose name was given in
|
||||
{{note|When adding an assembly and if the assembly has not been consumed (i.e. the XML names mapping files have not been generated in the Eiffel Metadata Cache) then the Name Mapper will consume the assembly, this may take a while. }}
|
||||
|
||||
|
||||
{{seealso| '''See also:''' [[Names Mappings|Names Mapping]] }}
|
||||
{{seealso|[[Names Mappings|Names Mapping]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
CodeDom stands for the '''Code Document Object Model'''. CodeDom allows for representing source code in an abstract data structure. Such a representation is called a '''CodeDom tree''' as the underlying data structure uses a tree paradigm. This abstract representation can then be generated into different programming languages. Each language vendor provides its implementation of the CodeDom interfaces, this implementation is called a '''CodeDom Provider'''. Programmers can then build tools that can work with many different languages without having to know about each one, instead they just delegate code generation to each CodeDom Provider.
|
||||
The CodeDom interfaces also expose types and methods that allow for parsing source code and creating the corresponding CodeDom. The current implementation of the Eiffel CodeDom Provider does not support parsing. Code generation is a much more popular useage of the CodeDom and the current version focuses on this aspect of the technology.
|
||||
|
||||
{{seealso| '''See also:''' [[Installation|Installation]] }}
|
||||
{{seealso|[[Installation|Installation]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -9,9 +9,9 @@ Another use of the CodeDom technology is via the WSDL utility. This utility is p
|
||||
Wsdl /language:"EiffelSoftware.CodeDom.CodeDomProvider, EiffelSoftware.CodeDom, Version=2.0.1.1402, Culture=neutral, PublicKeyToken=def26f296efef469"<br/>
|
||||
http://api.google.com/GoogleSearch.wsdl</code>
|
||||
|
||||
{{note| '''Note:''' The vesion number used above might differ depending on the version of the Eiffel CodeDom Provider dll installed on your system. }}
|
||||
{{note|The vesion number used above might differ depending on the version of the Eiffel CodeDom Provider dll installed on your system. }}
|
||||
|
||||
{{note| '''Note:''' The example above uses the Google web service, the corresponding URL is correct at the time of writing but there is no guarentee it won't change (or be removed) in the future. }}
|
||||
{{note|The example above uses the Google web service, the corresponding URL is correct at the time of writing but there is no guarentee it won't change (or be removed) in the future. }}
|
||||
This will generate a file with the extension '''.es''' which contains multiple Eiffel class definitions. Compiling this file will require using the CodeDom compiler (programmatically via the CodeDom <code>ICodeCompiler</code> interface) or using the [[eSplitter|eSplitter]] tool to generate standard Eiffel source files ('''.e''' files) that can then be compiled by the standard Eiffel compiler.
|
||||
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@ The association between applications and configurations as well as the actual se
|
||||
|
||||
{{note|The Eiffel for ASP.NET installation program will add a shortcut in the start menu to the Eiffel CodeDom Provider Manager. }}
|
||||
|
||||
{{seealso| '''See also:''' [[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] , [[Logging|Logging]] , [[Required Permissions|Required permissions]] }}
|
||||
{{seealso|[[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] , [[Logging|Logging]] , [[Required Permissions|Required permissions]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ Another interesting snippet member is the ''indexing clause snippet'' which must
|
||||
|
||||
==Eiffel Configuration==
|
||||
There are several Eiffel specific settings that can be set in the Eiffel CodeDom Provider which will affect the generated code as well as the CodeDom compiler behavior. These settings are covered in the [[Configuration|Configuration]] section.
|
||||
{{seealso| '''See also:''' [[eSplitter|eSplitter]] , [[Configuration|Configuration]] }}
|
||||
{{seealso|[[eSplitter|eSplitter]] , [[Configuration|Configuration]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -2,16 +2,4 @@
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|0b45f31f-83ea-6301-9017-7b78c6827772]]
|
||||
The Eiffel CodeDom Provider provides an implementation of the CodeDom Provider generation and compilation interfaces defined in the System.CodeDom namespace of the .NET Framework. This documentation includes the following sections:
|
||||
* [[About the Code Document Object Model (CodeDom)|About CodeDom]] introduces the basic concepts behing the CodeDom technology.
|
||||
* [[Installation|Installation]] describes the steps involved in installing the Eiffel CodeDom Provider.
|
||||
* [[Supported Constructs|Supported constructs]] lists the CodeDom constructs supported by the Eiffel CodeDom Provider.
|
||||
* [[Configuration|Configuration]] describes how to administer the Eiffel CodeDom Provider.
|
||||
* [[Logging|Logging]] describes the logging functionality of the Eiffel CodeDom Provider.
|
||||
* [[Required Permissions|Required permissions]] describes the permissions that must be granted to the process using the Eiffel CodeDom Provider.
|
||||
* [[Common Scenarios|Secnarios]] shows how the Eiffel CodeDom Provider can be used with different applications.
|
||||
* [[Eiffel Implementation|Eiffel implementation]] describes a few points of the Eiffel CodeDom Provider implementation that are specific to the Eiffel language.
|
||||
* [[Limitations|Limitations]] lists the limitations of the current Eiffel CodeDom Provider implementation.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@ Conversely, should the Eiffel Codedom Provider not be required anymore, running
|
||||
|
||||
{{note|The '''Eiffel for ASP.NET''' installation program will take care of registering and unregistering the Eiffel CodeDom Provider properly. }}
|
||||
|
||||
{{seealso| '''See also''': [[Supported Constructs|Supported constructs]] }}
|
||||
{{seealso|[[Supported Constructs|Supported constructs]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Limitations]]
|
||||
[[Property:weight|8]]
|
||||
[[Property:uuid|6d8ab90d-f051-5010-55df-218a020d9cb5]]
|
||||
==Generation Only==
|
||||
The current implementation of the Eiffel CodeDom Provider does not support parsing Eiffel source code to produce a CodeDom tree. Only code generation and compilation are supported in the current release.
|
||||
==Managed Code Only==
|
||||
|
||||
@@ -14,7 +14,7 @@ There are three types of events that can be logged: information events, warnings
|
||||
|
||||
==Log Location==
|
||||
All the Eiffel CodeDom Provider events are logged into the Windows '''System''' Log. This log can be viewed via the Windows administrative tool ''Event Viewer''. The source for the events raised by the Eiffel CodeDom Provider is ''Eiffel CodeDom Provider''. By default all the events are logged on the machine running the Eiffel CodeDom Provider but it is possible to change its configuration so that the events are logged on a different machine (see [[Required Permissions|Required permissions]] ).
|
||||
{{seealso| '''See also''': [[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] , [[Supported Constructs|Supported constructs]] , [[Required Permissions|Required permissions]] }}
|
||||
{{seealso|[[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] , [[Supported Constructs|Supported constructs]] , [[Required Permissions|Required permissions]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -4,11 +4,11 @@
|
||||
The account running the Eiffel CodeDom Provider might have restricted permissions such as when used through ASP.NET. This section aims at defining the security permissions required for the execution of the Eiffel CodeDom Provider.
|
||||
==Eiffel Metadata Cache==
|
||||
Both when generating and compiling source code, the Eiffel CodeDom Provider needs to read and write from and to the Eiffel Metadata Cache. This repository stores the mapping information between .NET and Eiffel names for both types and their members. By default the Eiffel Metadata Cache is located in the ''Assemblies'' subfolder of the Eiffel CodeDom Provider directory.
|
||||
{{note| '''Note:''' The Eiffel for ASP.NET installation program will grant read and write access to the Eiffel Metadata Cache folder for the ''ASPNET'' (default ASP.NET worker process account on Windows XP Professional) and the ''IIS_WPG'' (default ASP.NET worker process account on Windows Server 2003) accounts. }}
|
||||
{{note|The Eiffel for ASP.NET installation program will grant read and write access to the Eiffel Metadata Cache folder for the ''ASPNET'' (default ASP.NET worker process account on Windows XP Professional) and the ''IIS_WPG'' (default ASP.NET worker process account on Windows Server 2003) accounts. }}
|
||||
The path to the Eiffel Metadata Cache folder might be changed via the [[Eiffel CodeDom Provider Manager|Eiffel CodeDom Provider Manager]] , make sure the new folder can be read from and written to by the account running the process that uses the Eiffel CodeDom Provider.
|
||||
==Precompile Cache==
|
||||
The same requirements apply to the Precompile Cache folder. By default the Precompile Cache folder is located in the ''Precompile'' subfolder of the Eiffel CodeDom directory.
|
||||
{{note| '''Note:''' The Eiffel for ASP.NET installation program will grant read and write access to the Precompile Cache folder for the ''ASPNET'' (default ASP.NET worker process account on Windows XP Professional) and the ''IIS_WPG'' (default ASP.NET worker process account on Windows Server 2003) accounts. }}
|
||||
{{note|The Eiffel for ASP.NET installation program will grant read and write access to the Precompile Cache folder for the ''ASPNET'' (default ASP.NET worker process account on Windows XP Professional) and the ''IIS_WPG'' (default ASP.NET worker process account on Windows Server 2003) accounts. }}
|
||||
As with the Eiffel Metadata Cache folder, it is possible to change the location of the Precompile Cache folder but the process running the Eiffel CodeDom Provider must always have read and write access to the folder.
|
||||
==Logging==
|
||||
Logging requires registry read access as well as event log write access. By default, the ASP.NET worker process does not have these permissions. The easiest way to grant the required permissions to the ASP.NET worker process is by using ASP.NET impersonation. This mechanism allows the ASP.NET worker process to run under a different account. This is done by providing a ''web.config'' file in the root folder of the ASP.NET application. The content of the configuration file needs to include the following declaration:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Supported Constructs]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|99e15890-75a9-8b76-d0b6-b9be419be5ce]]
|
||||
Since not every language might support all the constructs CodeDom can represent, there needs to be a way for the CodeDom Provider to specify which constructs are supported and which ones are not. This is done through the <code>System.Codedom.Compiler.ICodeGenerator</code> interface using method <code>Supports</code>.<br/>
|
||||
This method takes a flag corresponding to the CodeDom contruct the caller is interested in and returns a boolean value indicating whether or not the construct is supported. In the Eiffel CodeDom Provider implementation there is a third category of constructs which will be reported as supported since the provider will generate valid Eiffel code for them but that should be distinguished from other "truly" supported constructs as the generated code will not correspond to the .NET equivalent of the construct.<br/>
|
||||
Let's take an example: Enum declarations are supported by the Eiffel CodeDom Provider because the generated Eiffel code will correctly make use of the values defined in the enum. However there is no such thing as an enum type in Eiffel so there won't be a corresponding .NET enum type in the generated assembly. Such constructs are said to be "non-roundtripable" because even if the Eiffel CodeDom Provider supported parsing source code, the corresponding CodeDom tree would not include the constructs like the initial CodeDom did.
|
||||
|
||||
@@ -9,7 +9,7 @@ Writing ASP.NET pages in Eiffel also requires to be familiar with the Eiffel lan
|
||||
The '''Samples''' folder of the Eiffel for ASP.NET delivery includes ASP.NET pages written in Eiffel. To run the samples you can either click on the corresponding link in the ''Start'' menu or open the page [http://localhost/EiffelSample http://localhost/EiffelSample] in your internet browser. Each sample comes with an extensively commented source code.
|
||||
{{note|The samples will only be available if IIS was installed prior to installing Eiffel for ASP.NET. }}
|
||||
|
||||
{{seealso| '''See also:''' [[Using Eiffel (to write ASP.NET pages)|Using Eiffel]] }}
|
||||
{{seealso|[[Using Eiffel (to write ASP.NET pages)|Using Eiffel]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ Without IIS, ASP.NET pages cannot be loaded and thus the samples will not be ins
|
||||
==ASP.NET Installation==
|
||||
Please consult the corresponding documentation (available online at [http://msdn.microsoft.com/asp.net/ http://msdn.microsoft.com/asp.net/] ) for configuring ASP.NET properly. In particular, be aware that by default ASP.NET is disabled on Windows 2003 Server.
|
||||
|
||||
{{seealso| '''See also:''' [[CodeDom: Getting Started|Getting Started]] }}
|
||||
{{seealso|[[CodeDom: Getting Started|Getting Started]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -2,11 +2,4 @@
|
||||
[[Property:weight|-1]]
|
||||
[[Property:uuid|7027e7f3-38e1-5e26-c936-20aea0e0c205]]
|
||||
Eiffel for ASP.NET allows running ASP.NET pages written in Eiffel. It should be installed on both the web server and the developer's machine. This documentation includes the following sections:
|
||||
* [[Eiffel for ASP.NET Installation|Installation]] describes the steps involved in installing Eiffel for ASP.NET.
|
||||
* [[CodeDom: Getting Started|Getting started]] lists resources that will help getting started with Eiffel for ASP.NET.
|
||||
* [[Using Eiffel (to write ASP.NET pages)|Using Eiffel]] lists a few points that are specific to using Eiffel for writing ASP.NET pages.
|
||||
* [[Names Mappings|Names mapping]] explains how to retrieve Eiffel identifiers from .NET ones.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -27,7 +27,7 @@ The steps to follow to retrieve the Eiffel identifier corresponding to a .NET me
|
||||
<code>Max_Occurs_String -> max_occurs_string</code>
|
||||
|
||||
Although these simplified steps will work in most cases there are certain .NET identifiers that require additional manipulation to be translated into Eiffel. The [[Name Mapper|Name Mapper]] utility should be used when such cases arise.
|
||||
{{seealso| '''See also:''' [[Name Mapper|Name Mapper]] }}
|
||||
{{seealso|[[Name Mapper|Name Mapper]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@ However if an instance of <eiffel>STRING</eiffel> is passed as an argument to an
|
||||
|
||||
==Compilation and Timeouts==
|
||||
Eiffel compilations can take longer than the default timeouts set in ASP.NET. In particular ASP.NET will run batch compilations on the entire directory that is being accessed by IIS each time the time stamp of that directory changes. If the batch compilation takes longer than the ''batchTimeout'' property defined in the machine wide configuration file (''machine.config'') then ASP.NET will start another compilation just for the requested file. This can be quite resource intensive for the Web server and thus it might be beneficial to increase the default value of 15 seconds for ''batchTimeout''.
|
||||
{{seealso| '''See also:''' [[Names Mappings|Names Mapping]] }}
|
||||
{{seealso|[[Names Mappings|Names Mapping]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Constructors and Creation Procedures]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|f06eb414-c284-902b-0481-3f00da82d47e]]
|
||||
This section deals with what happens when objects, that is runtime instances of types, get created and initialized. When a new instance is created, there is an opportunity to initialize the state of the instance. This is done with a constructor in .NET, and with a creation procedure in Eiffel.
|
||||
|
||||
==Eiffel Creation Procedures==
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[[Property:title|Eiffel Class and Feature Names]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|16e4a231-7aae-4b37-52fd-67876cc222ad]]
|
||||
Certain naming conventions are respected by Eiffel programmers. Although Eiffel is not case-sensitive, convention dictates the use of upper and lower case in particular situations. When you program in EiffelEnvision, you create new Eiffel classes, but you also use types from .NET assemblies. These .NET types are presented to you in a view that is consistent with Eiffel conventions.
|
||||
Certain naming conventions are respected by Eiffel programmers. Although Eiffel is not case-sensitive, convention dictates the use of upper and lower case in particular situations. When you program in Eiffel for .NET, you create new Eiffel classes, but you also use types from .NET assemblies. These .NET types are presented to you in a view that is consistent with Eiffel conventions.
|
||||
|
||||
==Eiffel Class Names==
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Eiffel for .NET Terminology]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|ab1ac480-e2d3-df5d-5f06-963899f1072d]]
|
||||
==Eiffel Terminology Defined for C# and VB.NET Programmers==
|
||||
|
||||
Eiffel programmers feel that it is important to have a set of precise terms with which to communicate about our method of software development. Like everything else in Eiffel, the use of certain terms is not accidental. They were chosen carefully to impart particular meaning. Many of the Terms that Eiffel programmers use are different from those used by developers using other object-oriented languages. But that does not mean that their meanings will be foreign to you. If you have some understanding of object-oriented technology, you will find that in many cases the Eiffel terms describe concepts with which you were already familiar, just under different names, and possibly with slightly different meanings.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|Eiffel Reserved Keywords]]
|
||||
[[Property:link_title|Eiffel reserved words]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|3b80ea3e-2ed1-adf6-ddf5-acd4e18c6d03]]
|
||||
There are 56 language keywords in Eiffel which cannot be used as developer defined identifiers in Eiffel class code.
|
||||
|
||||
==Eiffel Reserved Keywords==
|
||||
|
||||
@@ -1,5 +1,15 @@
|
||||
[[Property:title|Conventions]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|1f101597-06cd-b851-8cc1-e214b3eedb3e]]
|
||||
In this section, you'll find information about how the conventions that are normally used in Eiffel programming are affected by working in the presence of .NET.
|
||||
|
||||
Also, you'll find out how .NET types sometimes look a little different in the presence of Eiffel.
|
||||
|
||||
Because there are differences in the underlying object models upon which .NET and Eiffel have been designed, before .NET types can be made available to Eiffel developers, the assemblies in which they reside must be processed by a utility called the Eiffel Metadata Consumer. Fortunately, this all happens behind the scenes for you. You need only be aware that when you are looking at .NET types from within EiffelEnvision, you're seeing them through Eiffel-tinted lenses.
|
||||
|
||||
This is really the same thing that happens with other .NET languages with Visual Studio .NET support. For example, if you look at a constructor in a .NET type using the "ildasm" utility, the constructor will be named <code> .ctor </code>. But, if you're in C# and look at the same constructor in the Visual Studio .NET Object Browser, the constructor will have the same name as the type ...it's a C# convention. Likewise, the same constructor viewed in Visual Basic .NET will have the name <code> New </code> ...that's the Visual Basic .NET convention. So, when you use ENViSioN, you see things as presented using Eiffel Conventions.
|
||||
|
||||
Consider what happens when you look at .NET types using ENViSioN. When you look, for example at the type <code> System. EventArgs </code>, you will see it represented as an Eiffel class called <code> EVENT_ARGS </code>. The members of the .NET type will show up as features of the Eiffel class. Of course, you can also see the corresponding .NET names as they exist in the assembly metadata.
|
||||
|
||||
The documents in this section tell you what you need to know in order to use .NET types in Eiffel, and vice versa.
|
||||
|
||||
|
||||
@@ -65,7 +65,7 @@ In the following sample, we use these features of <code> STRING </code> to make
|
||||
end
|
||||
</code>
|
||||
|
||||
{{note| '''Note:''' As shown in the above example, it is necessary to apply <code> to_cil </code> to a manifest string if you are assigning it to a <code> System.String </code> or passing it as an argument where a <code> System.String </code> is called for. <br/>
|
||||
{{note|As shown in the above example, it is necessary to apply <code> to_cil </code> to a manifest string if you are assigning it to a <code> System.String </code> or passing it as an argument where a <code> System.String </code> is called for. <br/>
|
||||
This is expected to change in a future release. It shall become unnecesary to apply <code> to_cil </code> to manifest strings. Instead, whether a <code> STRING </code> or <code> System.String </code> is needed will be determined by the context in which the manifest string is being used, and the proper type of object will be generated. }}
|
||||
|
||||
===Other Similar Types===
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Type Organization]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|1837e091-695b-339c-f04f-cbfaea791a6c]]
|
||||
In any comprehensive object-oriented system, the act of programming results in creation of new data types. There must be a way of organizing these types and/or their static representation as classes. This section tells you how classes are organized in Eiffel and in .NET, and how these organization methods are used together.
|
||||
|
||||
==Eiffel Clusters==
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|Eiffel for .NET Limitations]]
|
||||
[[Property:link_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===
|
||||
|
||||
@@ -201,7 +201,7 @@ In this feature:
|
||||
* "INTEGER" (after the argument list) is the feature's type.
|
||||
* "do " introduces the implementation code.
|
||||
* "Result := an_attribute + an_int" is an instruction.
|
||||
{{warning| '''Note:'''This feature is a function. As a consequence the computation uses the keyword "Result" as an entity name for the value to be returned by the function }}
|
||||
{{note|This feature is a function. As a consequence the computation uses the keyword "Result" as an entity name for the value to be returned by the function }}
|
||||
|
||||
* "end" ends the feature declaration
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Design by Contract and Assertions]]
|
||||
[[Property:weight|5]]
|
||||
[[Property:uuid|41172f82-227a-96b1-2dad-624f04374ee0]]
|
||||
==Motivation: Concerning Correctness==
|
||||
|
||||
When you produce an element of software, how do you know that what you produced is correct?
|
||||
|
||||
@@ -26,7 +26,7 @@ class
|
||||
end
|
||||
</code>
|
||||
|
||||
Okay, so class SIMPLE is only interesting in its simplicity. Let's look at a more useful example:
|
||||
Okay, so class SIMPLE is only interesting in its simplicity. Let's look at an example that is more illustrative:
|
||||
<code>
|
||||
indexing
|
||||
description: Objects that model lists
|
||||
@@ -72,7 +72,7 @@ invariant
|
||||
before_constraint: before implies (active = first_element)
|
||||
after_constraint: after implies (active = last_element)
|
||||
</code>
|
||||
Here is a class that, although somewhat contrived, utilizes all of the required and optional parts of the class. Let's look at each part individually.
|
||||
Here is a class that, although completely contrived, utilizes all of the required and optional parts of the class. Let's look at each part individually.
|
||||
===Indexing===
|
||||
<code>
|
||||
indexing
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
[[Property:title|Eiffel for .NET Compliance]]
|
||||
[[Property:weight|9]]
|
||||
[[Property:uuid|1e19c2f0-995e-02c1-0588-c134a11e0003]]
|
||||
As of EiffelEnvision 2.6, Eiffel for ASP.NET 5.6 and EiffelStudio 5.7; Eiffel for .NET introduces the notion of '''Eiffel-Compliance'''. .NET specifies a number of language interopability rules in a [http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconwhatiscommonlanguagespecification.asp Common Language Specification-Compliance] specification. Eiffel for .NET supports all CLS-Compliant type and features in .NET but now additionally supports a number of non-CLS-compliant types and features. This is the purpose of the Eiffel-Compliant notion.
|
||||
As of Eiffel for ASP.NET 5.6 and EiffelStudio 5.7; Eiffel for .NET introduces the notion of '''Eiffel-Compliance'''. .NET specifies a number of language interoperability rules in a [http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconwhatiscommonlanguagespecification.asp Common Language Specification-Compliance] specification. Eiffel for .NET supports all CLS-Compliant type and features in .NET but now additionally supports a number of non-CLS-compliant types and features. This is the purpose of the Eiffel-Compliant notion.
|
||||
|
||||
The information contained within this page does not go into any depth on the Common Language Specification (CLS) or CLS-Compliance. For this information please see Microsoft's on-line documentation [http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconwhatiscommonlanguagespecification.asp What is the Common Language Specification?]
|
||||
|
||||
{{note|The information contained within this page does not go into any depth on the Common Language Specification (CLS) or CLS-Compliance. For this information please see Microsoft's on-line documentation [http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconwhatiscommonlanguagespecification.asp What is the Common Language Specification?] }}
|
||||
<span id="applicablity"></span>
|
||||
==Applicability==
|
||||
|
||||
@@ -11,7 +12,7 @@ The CLS states a number of rules .NET tools have to abide by to be CLS-compliant
|
||||
<span id="what_is_compliant"></span>
|
||||
==What is Eiffel-Compliant?==
|
||||
|
||||
As already state, anything CLS-compliant is Eiffel-compliant. Eiffel-Compliancy merely allows for exceptions so that non-CLS-compliant assemblies, types and members can be used in Eiffel for .NET.
|
||||
As already stated, anything CLS-compliant is Eiffel-compliant. Eiffel-Compliancy merely allows for exceptions so that non-CLS-compliant assemblies, types and members can be used in Eiffel for .NET.
|
||||
|
||||
The following list outlines the supported non-CLS-compliant types:
|
||||
* All unsigned numerical basic types such as <eiffel>System.UInt32</eiffel> as <eiffel>System.UInt64</eiffel>, represented by <eiffel>NATURAL_xx</eiffel>.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Event Programming with Agents]]
|
||||
[[Property:weight|7]]
|
||||
[[Property:uuid|ea9d7b9d-daa1-a415-628a-e3a2f935c12a]]
|
||||
In Eiffel there is a facility referred to as agents.
|
||||
|
||||
The implementation of agents is an advanced topic, but you do not have to understand the details of the implementation of agents to put agents to work for you. That is what you will learn in this section.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Exception Mechanism]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|84a159dd-4a19-af73-7b0b-0618a284142a]]
|
||||
==Motivation: Concerning Robustness==
|
||||
|
||||
The notion of software correctness that we saw in [[Design by Contract and Assertions|Design by Contract and Assertions]] is half of the formula for software reliability. Correctness covers what the software is supposed to do, that is, its specification.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Genericity]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|3a0bfe10-78e7-00eb-d9a0-b977d1fa352a]]
|
||||
We got a very short introduction to generic classes when we were looking at the formal generic part of class structure in [[Eiffel Classes|Eiffel Classes]] . That discussion left to the imagination the motivation and benefits for creating generic classes.
|
||||
|
||||
You will see that most of the generic classes model containers for multiple items and at least one of their formal generic parameters represents the type of items that are to be stored in the container. Some generic classes, like <code> LINKABLE </code>, care for only one instance of the type represented by their formal generic parameter.
|
||||
|
||||
@@ -1,18 +1,19 @@
|
||||
[[Property:title|Eiffel for .NET]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|446038d8-abd6-0a0d-2b90-94124e1ac810]]
|
||||
* [[Eiffel for.NET Language|Introduction]]
|
||||
* [[Eiffel Classes|Eiffel Classes]]
|
||||
* [[Adding Class Features|Adding Class Features]]
|
||||
* [[Inheritance|Inheritance]]
|
||||
* [[Genericity|Genericity]]
|
||||
* [[Design by Contract and Assertions|Design by Contract]]
|
||||
* [[Exception Mechanism|Exception Mechanism]]
|
||||
* [[Event Programming with Agents|Event Programming with Agents]]
|
||||
* [[Using Referenced Assemblies|Using Referenced Assemblies]]
|
||||
* [[Eiffel for .NET Compliance|Eiffel for .NET Compliance]]
|
||||
* [[Referenced Assembly Type and Feature Name Conversion|Referenced Assembly Type and Feature Name Conversion]]
|
||||
These pages contain documentation that describes the Eiffel programming language.
|
||||
|
||||
Eiffel is considered both a development methodology and a programming language.
|
||||
|
||||
Eiffel the methodology is a recipe for constructing quality software which is based on a small number of powerful concepts. Eiffel the programming language is a notation which is designed to support the methodology.
|
||||
|
||||
Eiffel for.NET is the Eiffel programming language made available in the .NET environment. Eiffel for.NET components can use and inherit from components in .NET assemblies that were produced using other.NET languages. And, programmers using other.NET languages can use and inherit from components in assemblies produced using Eiffel for.NET.
|
||||
|
||||
==Eiffel for.NET Conventions Documentation==
|
||||
|
||||
In Eiffel, as in other languages, certain conventions have evolved which constitute "the way things are done". Conventions provide consistency and therefore predictability and readability of software text.
|
||||
|
||||
When working in the.NET components, particularly when using components from .NET assemblies delivered from Microsoft or produced by other parties, the conventions of Eiffel are maintained in the view of these components. The first section, titled [[Conventions]], provides you with an understanding of Eiffel terminology, conventions , and how they work with .NET.
|
||||
|
||||
The remaining sections of this section are a reference for the Eiffel for .NET language. It is not a complete reference, though. Rather, it is intended to help you with the tasks that Eiffel programmers commonly encounter.
|
||||
|
||||
|
||||
@@ -192,7 +192,7 @@ The redefine part lists the names of effective features for which the producer o
|
||||
|
||||
So, in this example the implementation for <code> linear_representation </code>, for example, that <code> LINKED_QUEUE </code> would have inherited from <code> QUEUE </code> will not be used. Instead <code> LINKED_QUEUE </code> implements its own version of <code> linear_representation </code>.
|
||||
|
||||
{{note| '''Note:''' When a class implements a version of an inherited feature which was deferred in its parent, this is known as "effecting" the feature. Because features being effected are getting their first implementation, it is not necessary to list their names in the redefine part, or anywhere else in the inheritance part of the heir. }}
|
||||
{{note|When a class implements a version of an inherited feature which was deferred in its parent, this is known as "effecting" the feature. Because features being effected are getting their first implementation, it is not necessary to list their names in the redefine part, or anywhere else in the inheritance part of the heir. }}
|
||||
|
||||
===Select===
|
||||
<code>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[[Property:title|Referenced Assembly Type and Feature Name Conversion]]
|
||||
[[Property:weight|10]]
|
||||
[[Property:uuid|5d575090-35d9-f983-7308-172b1641173f]]
|
||||
The [[The Eiffel for .NET language|Eiffel for .NET language]] is Eiffel. It is not a variant of Eiffel that spawned a new language, as is '''C#''', or a dramatic evolution of Eiffel, such as '''Visual Basic .NET''' is to '''VB6'''. As Eiffel stands today, and will probably remain, Eiffel's conventions for class names and features names do not match that of the OO Pascal variants and the "Camel-casing" conventions recommended by Microsoft. Eiffel also does not support the notion of full quantified type names. The period (''''.'''') between namespace and type names is not valid Eiffel syntax. These naming convention rules pose a problem for maintaining the Eiffel language. To address this issue, when referencing .NET assemblies, all referenced assembly type names and feature names are converted into "Eiffel-case" when using Eiffel.
|
||||
The [[The Eiffel for .NET language|Eiffel for .NET language]] is Eiffel. It is not a variant of Eiffel that spawned a new language, as is '''C#''', or a dramatic evolution of Eiffel, such as '''Visual Basic .NET''' is to '''VB6'''. As Eiffel stands today, and will probably remain, Eiffel's conventions for class names and features names match neither that of the OO Pascal variants nor the "Camel-casing" conventions recommended by Microsoft. Eiffel also does not support the notion of full quantified type names. The period (''''.'''') between namespace and type names is not valid Eiffel syntax. These naming convention rules pose a problem for maintaining the Eiffel language. To address this issue, when referencing .NET assemblies, all referenced assembly type names and feature names are converted into "Eiffel-case" when using Eiffel.
|
||||
<span id="eiffel_case"></span>
|
||||
==What is Eiffel-Case?==
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[[Property:title|Using Referenced Assemblies]]
|
||||
[[Property:weight|8]]
|
||||
[[Property:uuid|acbe0407-b95e-6268-fc20-238f91df595e]]
|
||||
Eiffel for.NET is a first class citizen in the Microsoft.NET programming world. This means that if you are programming in Eiffel for.NET, say with ENViSioN!, you have full access to the thousands of software components in the .NET type libraries. But, that's not all. You also have full access to the thousands of components in the traditional Eiffel class libraries. And even that's not all. You have the ability to build software components which comply with.NET standards, so that they can be used by programmers using any other .NET language. Still not all. When you use Eiffel, you can choose to build software that will run under Microsoft.NET, but will be portable to other popular operating systems as well.
|
||||
Eiffel for.NET is a first class citizen in the Microsoft.NET programming world. This means that if you are programming in Eiffel for.NET, you have full access to the thousands of software components in the .NET type libraries. But, that's not all. You also have full access to the thousands of components in the traditional Eiffel class libraries. And even that's not all. You have the ability to build software components which comply with.NET standards, so that they can be used by programmers using any other .NET language. Still not all. When you use Eiffel, you can choose to build software that will run under Microsoft.NET, but will be portable to other popular operating systems as well.
|
||||
|
||||
Being an Eiffel for.NET programmer obviously put you in a very powerful position. How do you take advantage of it?
|
||||
|
||||
|
||||
@@ -13,5 +13,3 @@ We will see:
|
||||
* what is Eiffel on .NET
|
||||
* which Eiffel mechanisms have been implemented and which haven't.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Known issues]]
|
||||
[[Property:weight|4]]
|
||||
[[Property:uuid|78c6b5c1-a87b-805d-38bd-fe64cb4e7c0d]]
|
||||
==Eiffel issues==
|
||||
* Check here first for the [[Eiffel for .NET Limitations|Difference between Eiffel and Eiffel for .NET]] .
|
||||
* The root creation routine of the root class must not take any arguments. You can access the command line given to the application via the class <code> ARGUMENTS. </code>
|
||||
|
||||
@@ -1,11 +1,8 @@
|
||||
[[Property:title|.NET]]
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|55eda2f0-0c60-f08c-b141-913e31a49c2f]]
|
||||
* [[.NET Installation instructions|Installation instructions]]
|
||||
* [[Building a .NET application|Building a .NET application]]
|
||||
* [[The Eiffel for .NET language|Eiffel for .NET language description]]
|
||||
* [[Samples|Samples]]
|
||||
|
||||
|
||||
==.NET==
|
||||
|
||||
Eiffel support for Microsoft .NET.
|
||||
|
||||
|
||||
|
||||
@@ -3,6 +3,3 @@
|
||||
[[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,5 +1,6 @@
|
||||
[[Property:title|ADO.NET Sample]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|45d24893-63d0-c2a9-9f62-ead08ca4b901]]
|
||||
This sample consist of a command line showing how to interact with a database.
|
||||
|
||||
The DataReader object is somewhat synonymous with a read-only/forward-only cursor over data. The DataReader API supports flat as well as hierarchical data. A DataReader object is returned after executing a command against a database. The format of the returned DataReader object is different from a recordset. For example, you might use the DataReader to show the results of a search list in a web page.
|
||||
|
||||
@@ -1,8 +1,5 @@
|
||||
[[Property:title|ADO .NET Samples]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|b58f17b4-57b0-ffe9-3160-86d95512f900]]
|
||||
* [[ADO.NET Sample|Ado]]
|
||||
|
||||
|
||||
|
||||
ADO .NET is the data access technology of Microsoft .NET.
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
=The Calculator Sample=
|
||||
|
||||
This sample consists of a command line reverse Polish notation (RPN) calculator.
|
||||
{{note| '''Note:''' A RPN calculator works slightly differently from standard calculators. It consists of a stack of numbers. Operations are applied to the two numbers on top of the stack. The result is then put on top of the stack so that it can be used in the next operation. This sample refers to the top of the stack as ''Accumulator''. }}
|
||||
{{note|A RPN calculator works slightly differently from standard calculators. It consists of a stack of numbers. Operations are applied to the two numbers on top of the stack. The result is then put on top of the stack so that it can be used in the next operation. This sample refers to the top of the stack as ''Accumulator''. }}
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -80,7 +80,7 @@ Next operation?
|
||||
|
||||
You may use the operation <code> 0 </code> to clear the stack at any time. You may use <code> q </code> to quit the program.
|
||||
|
||||
{{tip| '''Tip:''' You can use the command <code> ? </code> to display the list of available operations. }}
|
||||
{{tip|You can use the command <code> ? </code> to display the list of available operations. }}
|
||||
|
||||
==Under the Hood==
|
||||
|
||||
|
||||
@@ -1,8 +1,5 @@
|
||||
[[Property:title|Console Samples]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|3f2c704c-9784-06a5-4cad-02ad58433b2c]]
|
||||
* [[Calculator: console|Calculator]]
|
||||
|
||||
|
||||
|
||||
Console application samples.
|
||||
|
||||
|
||||
@@ -5,30 +5,3 @@ In this chapter you will find a series of examples that will permit to you to un
|
||||
|
||||
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.
|
||||
|
||||
==Console sample==
|
||||
* [[Calculator: console|Calculator]]
|
||||
|
||||
==Threads Samples==
|
||||
* [[Pools|Pools]]
|
||||
* [[Timers|Timers]]
|
||||
|
||||
==ADO.NET sample==
|
||||
* [[ADO.NET Sample|ADO.NET]]
|
||||
|
||||
==Windows Form samples==
|
||||
|
||||
The following samples are classified from the easiest to the most complex one. So, some notions are introduced in the few first samples and will not be explained again in the complex samples!
|
||||
* [[Simple Hello world form sample|Hello world form]]
|
||||
* [[Message Box|Message box]]
|
||||
* [[Date Time Picker|Calendar and dates]]
|
||||
* [[Progress bar sample|Progress bar]]
|
||||
* [[Menus|Adding Menu to a Form]]
|
||||
* [[MDI|Writing MDI Applications]]
|
||||
* [[Tree view|Tree view]]
|
||||
* [[Calculator: winform|Calculator]]
|
||||
* [[GDI plus - text|Text (gdi plus)]]
|
||||
* [[Simple data binding|Simple data binding]]
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,9 +1,5 @@
|
||||
[[Property:title|Threads Samples]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|62e36a4c-0afd-e143-9a1f-98eab4022e6b]]
|
||||
* [[Pools|Pools]]
|
||||
* [[Timers|Timers]]
|
||||
|
||||
|
||||
|
||||
Samples using .NET threading technology.
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Pools]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|ace044b0-1fb7-22a0-6c18-880281ed3b6d]]
|
||||
This sample demonstrates use of the <eiffel>THREAD_POOL</eiffel> (ThreadPool) class. The sample queues up an asynchronous method call that is executed by a thread from the thread pool managed by the Common Language Runtime. The method "does some work" and then sets an event indicating that the work has finished. The main thread waits on the event and then exits.
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Timers]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|325ac6e6-9660-891c-2605-dbeb621649f0]]
|
||||
This sample consist in a command line demonstrating the use of the <eiffel>TIMER</eiffel> (Timer) class to generate a periodic callback to a method. The sample creates a <eiffel>TIMER</eiffel> object and passes to it a delegate object. When the <eiffel>TIMER</eiffel> fires, the delegate is invoked, and a static method is called asynchronously by a worker thread in the thread pool.
|
||||
|
||||
==Compiling==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Calculator: winform]]
|
||||
[[Property:weight|-8]]
|
||||
[[Property:uuid|9d064b1c-e109-35e8-70d5-73feec59fca1]]
|
||||
<div>
|
||||
[[Image:calculator|Calculator]]
|
||||
</div>
|
||||
|
||||
@@ -25,7 +25,9 @@ After launching the application, you will see a window displayed with a similar
|
||||
|
||||
Clicking on the "Change font" button and a change font dialog box will appear. [[Image:change-font-dialog|change font dialog box]] .
|
||||
|
||||
Clicking on the "Change color" button and a dialog_box will appear. [[Image:dotnet-samples--date-time-picker-change-color-dlg|dialog box]] It will permit you to customize the color appearance of the calendar though a color dialog box [[Image:dotnet-samples--date-time-picker-change-color-dlg|color dialog box]] .
|
||||
Clicking on the "Change color" button and a dialog_box will appear. [[Image:dotnet-samples--date-time-picker-change-color-dlg|dialog box]]
|
||||
|
||||
It will permit you to customize the color appearance of the calendar though a color dialog box [[Image:dotnet-samples--date-time-picker-change-color-dlg|color dialog box]] .
|
||||
|
||||
|
||||
|
||||
@@ -49,10 +51,3 @@ This sample contains the following classes:
|
||||
|
||||
This sample is translated from the example located in the QuickStart\winforms\samples\controlReference\dateTimePicker sub-directory of the .NET Framework SDK samples directory of Microsoft Visual Studio .NET.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -36,10 +36,3 @@ This sample contains the following class:
|
||||
|
||||
This sample is translated from the example located in the QuickStart\winforms\samples\gdiplus subdirectory of the .NET Framework SDK samples directory of Microsoft Visual Studio.NET.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,17 +1,5 @@
|
||||
[[Property:title|Winform Samples]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|24cbeb3c-ba2b-1fea-ccec-89600bbf3256]]
|
||||
The following examples are classified from the easiest to the most complex one. So, some notions are introduced in the few first examples and will not be explained again in the complex examples!
|
||||
==Getting started==
|
||||
* [[Simple Hello world form sample|Hello world form]]
|
||||
* [[Message Box|Message box]]
|
||||
* [[Menus|Adding Menu to a Form]]
|
||||
* [[MDI|Writing MDI Applications]]
|
||||
|
||||
==Building applications==
|
||||
* [[Calculator: winform|Calculator]]
|
||||
* [[GDI plus - text|Text (gdi plus)]]
|
||||
|
||||
|
||||
|
||||
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,5 +1,6 @@
|
||||
[[Property:title|MDI]]
|
||||
[[Property:weight|-9]]
|
||||
[[Property:uuid|d1cb553c-8394-9f27-4d75-8d69f8582e49]]
|
||||
<div>
|
||||
[[Image:mdi|Hello world form]]
|
||||
</div>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|MDI Details]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|f39b5ac5-64ae-781d-8d43-305954ae8d28]]
|
||||
Multiple Document Interface (MDI) applications have a single, primary window (the parent window) that contains a set of windows within its client region (child windows). Each child window is a form that is constrained to appear only within the parent. Children typically share the menu bar, tool bar, and other parts of the parent's interface. Secondary windows like dialog boxes are not constrained to the parent window's client region.
|
||||
|
||||
==Creating an MDI Application==
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Menus]]
|
||||
[[Property:weight|-10]]
|
||||
[[Property:uuid|5a32fed4-0b46-51f8-a6b6-fc3eac70a844]]
|
||||
<div>
|
||||
[[Image:menu-principal|Hello world form]]
|
||||
</div>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Menu Details]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|81ae03a0-387d-f776-17b9-f4a83c49b75f]]
|
||||
Windows Forms supports menus and context menus. Main menus are displayed on a menu bar that is located immediately below the title bar of a form. The menu bar contains top-level menu items that are used to group related submenu items. For example, by clicking a '''File''' top-level menu item, you can display menu items that are related to file operations. Menu items typically appear as commands for your application (such as '''New''' and '''Open'''),but they can also appear as separator bars and submenu items. You can display a check mark next to a menu item to display the state of a command or a the state of a feature in your application. In Windows Forms, main menus are represented by the '''MainMenu''' control.
|
||||
|
||||
Context menus can be displayed for a specific control or area of your form. They are typically accessed by clicking the right mouse button. In Windows Forms, context menus are represented by the '''ContextMenu''' control.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Message Box]]
|
||||
[[Property:weight|-11]]
|
||||
[[Property:uuid|cbc37679-43b0-99b8-b8c7-1be8be49882e]]
|
||||
<div>
|
||||
[[Image:hello-world|Hello world form]] <br/>
|
||||
[[Image:message-box|Hello world form]]
|
||||
|
||||
@@ -39,10 +39,3 @@ This sample contains the following classes:
|
||||
|
||||
This sample is translated from the example located in the QuickStart\winforms\samples\controlReference\ProgressBar sub-directory of the .NET Framework SDK samples directory of Microsoft Visual Studio .NET.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -46,10 +46,3 @@ This sample contains the following class:
|
||||
|
||||
This sample is translated from the example located in the QuickStart\winforms\samples\dataBinding subdirectory of the .NET Framework SDK samples directory of Microsoft Visual Studio.NET.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Simple Hello world form sample]]
|
||||
[[Property:weight|-12]]
|
||||
[[Property:uuid|f4f924a5-20a2-403b-ee1d-a39c77fbb8fd]]
|
||||
<div>
|
||||
[[Image:simple-hello-world|Hello world form]]
|
||||
</div>
|
||||
|
||||
@@ -40,10 +40,3 @@ This sample contains the following classes:
|
||||
|
||||
This sample is translated from the example located in the QuickStart\winforms\samples\ControlReference\TreeView subdirectory of the .NET Framework SDK samples directory of Microsoft Visual Studio .NET.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user