mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-04-03 16:49:34 +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
@@ -11,10 +11,10 @@ The documentation is organized into virtual books. Each book covers an important
|
||||
|
||||
* [[Guide]] -- Guide to Eiffel Information
|
||||
* [[Why Eiffel?]] -- Why Eiffel?
|
||||
* [[Method]] -- The Eiffel Method and Language
|
||||
* [[Method|Method and Language]] -- The Eiffel Method and Language
|
||||
* [[EiffelStudio]] -- The EiffelStudio Interactive Development Environment
|
||||
* [[Solutions]] -- Eiffel Solutions, Technologies, and Class Libraries
|
||||
* [[Windows]] -- Eiffel with Microsoft Windows
|
||||
* [[Platform specifics]] -- Specific support for particular platforms, e.g., Microsoft Windows
|
||||
* [[Community]] -- Community Contributions
|
||||
|
||||
There are also important sources of information on Eiffel external to these documentation pages.
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
[[Property:title|EiffelCOM Class Reference]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|476f2bc7-9afa-125e-0b68-3e4fc30e97f4]]
|
||||
==View the [[ref:libraries/com/reference/index|EiffelCOM Class Reference]] ==
|
||||
|
||||
@@ -7,7 +7,7 @@ The EiffelCOM library includes the following clusters:
|
||||
* A [[Structures|Structures]] cluster includes wrappers for COM structures and additional data structures.
|
||||
* A [[ref:libraries/com/reference/index|Support]] cluster provides access to helper classes.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[About COM and Eiffel]] <br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] }}
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@ COM interfaces have several facets. First, an interface is a deferred, or an abs
|
||||
|
||||
==ECOM_INTERFACE==
|
||||
|
||||
For each interface listed in a type library, the EiffelCOM wizard generates a deferred class and two effective classes: a proxy of an interface pointer, or a client side class, and a stub of an interface pointer, or a server side class. The deferred interface class inherits from <eiffel>[libraries/com/reference/ecom_interface_chart.xml| ECOM_INTERFACE ]</eiffel> and has a deferred feature per each interface function. Both effective classes, or implemented interfaces, inherit from the deferred class and implement its functions. The functions of the interface proxy calls the underlying C layer, which in turn calls the COM component while the functions of the interface stub implement the component functionality.
|
||||
For each interface listed in a type library, the EiffelCOM wizard generates a deferred class and two effective classes: a proxy of an interface pointer, or a client side class, and a stub of an interface pointer, or a server side class. The deferred interface class inherits from [[ref:libraries/com/reference/ecom_interface_chart|<eiffel>ECOM_INTERFACE</eiffel>]] and has a deferred feature per each interface function. Both effective classes, or implemented interfaces, inherit from the deferred class and implement its functions. The functions of the interface proxy calls the underlying C layer, which in turn calls the COM component while the functions of the interface stub implement the component functionality.
|
||||
|
||||
[[ref:libraries/com/reference/ecom_interface_chart|ECOM_INTERFACE]] holds a pointer to the underlying COM interface.
|
||||
|
||||
@@ -19,7 +19,7 @@ which queries a COM component internally. Every interface proxy class inherits f
|
||||
|
||||
==ECOM_STUB==
|
||||
|
||||
[[ref:libraries/com/reference/ecom_stub_chart|ECOM_STUB]] inherits from [[ref:libraries/com/reference/ecom_interface_chart|ECOM_INTERFACE]] , and exposes the feature <code> [[ref:libraries/com/reference/ecom_stub_chart|create_item]] </code> which allows creating the underlying COM object.
|
||||
[[ref:libraries/com/reference/ecom_stub_chart|ECOM_STUB]] inherits from [[ref:libraries/com/reference/ecom_interface_chart|ECOM_INTERFACE]], and exposes the feature [[ref:libraries/com/reference/ecom_stub_chart|<code>create_item</code>]] which allows creating the underlying COM object.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -92,22 +92,22 @@ Many COM Automation servers have routines that take arguments with default value
|
||||
|
||||
For example, the following adds a new workbook to Excel. The default argument tells Excel to decide for itself how many worksheets to put in the new workbook:
|
||||
<code>
|
||||
class
|
||||
MY_EXCEL_APPLICATION
|
||||
class
|
||||
MY_EXCEL_APPLICATION
|
||||
|
||||
inherit
|
||||
APPLICATION_PROXY
|
||||
inherit
|
||||
APPLICATION_PROXY
|
||||
|
||||
ECOM_VARIANT_ACCESS
|
||||
ECOM_VARIANT_ACCESS
|
||||
|
||||
feature
|
||||
feature
|
||||
|
||||
add_workbook is
|
||||
local
|
||||
workbook: WORKBOOK_PROXY
|
||||
do
|
||||
workbook := workbooks.add (missing, 0)
|
||||
end
|
||||
add_workbook is
|
||||
local
|
||||
workbook: WORKBOOK_PROXY
|
||||
do
|
||||
workbook := workbooks.add (missing, 0)
|
||||
end
|
||||
</code>
|
||||
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ Platform: Windows <br/>
|
||||
|
||||
The EiffelCOM library provides support classes for the code generated by the EiffelCOM wizard. It has wrappings for standard COM data types such as VARIANT, SAFEARRAY, CURRENCY, DECIMAL, IUnknown, IDispatch, etc.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] }}
|
||||
|
||||
|
||||
|
||||
@@ -213,7 +213,7 @@ As information on any interface cannot be accessed dynamically, the description
|
||||
|
||||
==EiffelCOM==
|
||||
The idea in EiffelCOM is the way a component is accessed is implementation detail that the user should not have to deal with. Of course he should be able to choose what kind of access he wants to use but this choice should have no impact on the design of the Eiffel system itself. For that reason, the Eiffel code generated by the wizard follows the same architecture independently of the choice made for interface access and marshalling. The difference lies in the runtime where the actual calls to the components are implemented.
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] <br/>
|
||||
[[EiffelCOM: Introduction| Introduction]] <br/>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Coclass]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|7f91f9ce-e042-1d48-9d01-f9b794269ec4]]
|
||||
We have seen that interfaces can be perceived as views of a component. This conceptual representation actually maps the implementation of an EiffelCOM component since the coclass inherits from the interfaces and implements their deferred features. Indeed, interfaces are deferred classes with all features accessible from outside deferred. The coclass is an Eiffel class that inherits from these interfaces and implements all the features. This design is not specific to Eiffel though and can be found in other languages as well. The coclass defines the behavior of the interface functions. <br/>
|
||||
|
||||
==Class Object==
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|9cb19fc1-3d26-5752-6232-ea23f2668c32]]
|
||||
COM is a binary standard that describes how the component can communicate with the outer-world. The component communicates through well defined interfaces. Each interface is a specification of a group of properties and methods, and it does not contain the implementation of these routines but only their specification (signatures). The actual implementation lies in the coclass. There can be different implementations of a same interface in different coclasses. Finally, each coclass can be instantiated using a class object or class factory. These three notions will be discussed further in the forthcoming paragraphs.
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] <br/>
|
||||
[[EiffelCOM: Introduction| Introduction]] <br/>
|
||||
|
||||
@@ -9,7 +9,7 @@ The COM specification requires that any interface provides access to all interfa
|
||||
|
||||
The two other functions exposed by '''IUnknown''' are '''AddRef''' and '''Release'''. These functions should be called respectively when a client gets a reference on an interface or when it discards that reference. These two functions define the lifetime of the component: each interface keeps track of clients keeping a reference on them and when no clients have references anymore, the component can be unloaded from memory. You might start worrying thinking that this business of reference counting will imply lots of headaches, memory leaks, etc. and you would be right should you choose a low-level language to implement your components. Fortunately, you will never have to implement or use these functions in Eiffel: all the processing related to IUnknown is provided by the EiffelCOM runtime. Calls to '''QueryInterface''' are done "behind the scene" and only when needed. The lifetime of the component is also taken care of by the EiffelCOM runtime.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] <br/>
|
||||
[[EiffelCOM: Introduction| Introduction]] <br/>
|
||||
|
||||
@@ -10,7 +10,7 @@ One main difference with out-of-process components (other than the nature of the
|
||||
</div><div>
|
||||
==Out-of-process Components==
|
||||
These components are standard executable acting as servers that can be accessed locally or over a network. Typically used in a three tier client server architecture, the major difference with in-process servers (other than the module type - executable instead of DLL) is their lifetime. In-process components are typically loaded to achieve a specific task and unloaded just after while out-of-process components are servers supposed to run continuously. The EiffelCOM wizard allows to build clients for such servers in Eiffel. It also provides the ability to create such servers. </div>
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] <br/>
|
||||
[[EiffelCOM: Introduction| Introduction]] <br/>
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Deeper into COM]]
|
||||
[[Property:weight|6]]
|
||||
[[Property:uuid|f28ee911-1b15-260c-a290-540b9531113a]]
|
||||
The next paragraph gives some details on the COM internals. The understanding of these details are not required to use the EiffelCOM wizard but might help making better decisions when designing new EiffelCOM components.
|
||||
|
||||
==Apartments==
|
||||
|
||||
@@ -7,7 +7,7 @@ Briefly said, the Component Object Model is a Microsoft binary standard that est
|
||||
|
||||
The advantages of such an approach include an increased reusability (binary reuse), a better version management (COM standard implies that new component versions are compatible with the older ones) and a built-in runtime environment. The binary reuse aspect of COM added with the source reuse ability of Eiffel offer the developer an ideal platform to increase considerably their productivity.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] <br/>
|
||||
[[Generalities| Generalities]] <br/>
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
[[Property:uuid|32e79152-1e8f-43cd-e014-a83aab18e440]]
|
||||
==About COM and Eiffel==
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard|EiffelCOM wizard]] <br/>
|
||||
[[EiffelCOM Library| EiffelCOM library]] }}
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ To implement a client of the <eiffel>StringManipulator</eiffel> component open a
|
||||
|
||||
==Contracts==
|
||||
Contracts can be broken directly on the proxy in which case you will get a standard contract violation in the client. If contracts are broken on the server then the exception will be forwarded by the EiffelCOM runtime to the client. The feature replace_substring_user_precondition in <eiffel>MY_STRING_MANIPULATOR</eiffel> includes has some assertions.: Comment them out. Now the contract of the [[ref:libraries/base/reference/string_8_chart|<code>replace_substring </code>]] feature is wrong and erroneous calls can be made. Quick melt the changes and run the client. Enter some invalid numbers in the fields used to call this feature. After you click '''Replace''' you will see an error message box warning you that a precondition was violated on the server side. This demonstrates contracts `over the wire'. The precondition was violated in the server; this exception was caught by the EiffelCOM runtime and sent back to the client.
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[Creating a new COM component|Creating a new COM component]] <br/>
|
||||
[[Creating a new component from an Eiffel project|Creating a new component from an Eiffel Project]] }}
|
||||
|
||||
|
||||
@@ -36,7 +36,7 @@ where ''system_name'' is the name of the dll (e.g. string_manipulator). So to re
|
||||
cd $ISE_EIFFEL\examples\com\wizard\string_manipulator\generated\component\server\EIFGENs\default\W_code
|
||||
regsvr32 string_manipulator.dll</code>
|
||||
Once registered, follow the steps described in [[Accessing a COM component|Accessing a COM component]] to build the component's client.
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[Creating a new component from an Eiffel project|Creating a new component from an Eiffel Project]] <br/>
|
||||
[[Accessing a COM component|Accessing a COM component.]] }}
|
||||
|
||||
|
||||
@@ -33,7 +33,7 @@ You do not need to modify or implement any classes. The wizard produces a ready-
|
||||
{{tip|<br/>
|
||||
In most Eiffel systems functionality is spread out throughout the system. No single class exposes the full functionality of the system and can serve as a Facade to the outside world. Running the wizard on any such class would not be practical. Before starting the wizard write an Eiffel class that acts as a Facade and forwards client calls to the appropriate subsystems. Enter the Facade class name into '''Name of Eiffel facade class''' field. The wizard generates an IDL file from this class. }}
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[Creating a new COM component|Creating a new COM component]] <br/>
|
||||
[[Accessing a COM component|Accessing a COM component.]] }}
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ This chapter explains how to use the EiffelCOM wizard to create COM components a
|
||||
* [[Accessing a COM component|Accessing a COM component.]]
|
||||
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard Introduction|Introduction]] <br/>
|
||||
[[EiffelCOM Wizard Reference|EiffelCOM wizard reference]] }}
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@ The wizard generates code from a Type Library and additional information given b
|
||||
[[Image:introduction]]
|
||||
The wizard can automatically compile the generated C and Eiffel code. To produce a Type Library corresponding to a given IDL file the wizard relies on '''MIDL''', the Microsoft IDL compiler. You may also provide the wizard with a Type Library directly. The wizard can also be used to add a COM interface to an existing Eiffel project. For the rest of the manual a '''COM Definition File''' will refer to the input file given to the wizard (either an IDL file, a Type Library or an Eiffel project file).
|
||||
|
||||
{{seealso| '''See Also''': [[EiffelCOM Wizard Guided Tour|Guided Tour]] , [[EiffelCOM Wizard Reference|EiffelCOM wizard reference]] }}
|
||||
{{seealso|[[EiffelCOM Wizard Guided Tour|Guided Tour]] , [[EiffelCOM Wizard Reference|EiffelCOM wizard reference]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -64,7 +64,7 @@ end -- class ECOM_SERVER_COCLASS_IMP</code>
|
||||
|
||||
This class inherits from the generated Eiffel coclass and from <eiffel>ECOM_EXCEPTION</eiffel>. It redefines the feature <eiffel>coclass_feature</eiffel> from the generated coclass. This feature is part of the interface functions that can be called by clients of the component. Its implementation uses the feature<eiffel>trigger</eiffel> from <eiffel>ECOM_EXCEPTION</eiffel> to raise exceptions in case the feature cannot be executed normally (invalid argument). The EiffelCOM runtime catches the exception and maps it into an <eiffel>HRESULT</eiffel> that is sent back to the client.
|
||||
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ The '''Interface_proxy''' folder includes Eiffel classes wrapping interfaces tha
|
||||
[[Image:implemented-interface]]
|
||||
The '''Interface_stub''' folder includes Eiffel classes implementing interfaces that may be given to the component as an argument. These classes inherit from both the deferred interface class and [[ref:libraries/com/reference/ecom_stub_chart| <eiffel>ECOM_STUB</eiffel> ]] .
|
||||
[[Image:implemented-interface-server]]
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@ There are some rules that the facade class must follow for the COM wizard to be
|
||||
* The facade class should not contain any public attribute, only routines can be exported to COM clients.
|
||||
* The facade class must belong to a successfully compiled Eiffel project.
|
||||
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Accessing a COM component|Accessing a COM Component]] , [[Reusing a COM Component|Reusing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Accessing a COM component|Accessing a COM Component]] , [[Reusing a COM Component|Reusing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ The EiffelCOM Wizard generates code into the specified destination folder. The f
|
||||
* Optionally, the EiffelCOM Wizard may generate a '''idl''' folder which contains the IDL file generated from the Eiffel facade class if the project consists of adding a COM interface to an existing Eiffel project.
|
||||
* The '''Server''' folder includes files used to implement a COM component. Apart from the usual C++ folders, it also includes a '''Component''' folder which contains Eiffel classes corresponding to the component's coclasses and a '''Interface_stub''' folder which contains Eiffel classes wrapping interfaces that may be given as argument to the component. This last folder may also be useful when accessing a COM component. The '''Server''' folder also includes a ECF file which can be used to compile the generated system if the project consists of creating a new component.
|
||||
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@ Optionally, EiffelStudio can be opened on the generated system by clicking the c
|
||||
|
||||
{{note|The EiffelStudio button will only be enabled if the Eiffel code was compiled. }}
|
||||
|
||||
{{seealso| '''See Also''': [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@ The EiffelCOM Wizard allows the creation of Eiffel projects implementing or reus
|
||||
* [[Building a COM Component|Building a COM Component]] describes how to build a new COM component.
|
||||
* [[Wizards: Command Line Options|Command Line Options]] describes using the wizard from the command line.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Wizard Introduction|Introduction]] <br/>
|
||||
[[EiffelCOM Wizard Guided Tour|Guided Tour]] }}
|
||||
|
||||
|
||||
@@ -87,7 +87,7 @@ feature -- Basic Operations
|
||||
|
||||
end -- class COCLASS_CLIENT</code>
|
||||
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Building a COM Component|Reusing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Building a COM Component|Reusing a COM Component]] , [[Wizards: Command Line Options|Command Line Options]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -27,7 +27,7 @@ The list of options is the following:
|
||||
* '''--version, -v''': Print version information.
|
||||
* '''--help, -h''': Display help on how to use the EiffelCOM Wizard command line utility.
|
||||
|
||||
{{seealso| '''See Also''': [[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] }}
|
||||
{{seealso|[[How the EiffelCOM Wizard works|How the EiffelCOM Wizard Works]] , [[Generated Files|Generated Files]] , [[Class Hierarchy|Class Hierarchy]] , [[Eiffel Project Processing|Adding a COM Interface to an Eiffel Project]] , [[Reusing a COM Component|Accessing a COM Component]] , [[Building a COM Component|Building a COM Component]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
Type: Wizard <br/>
|
||||
Platform: Windows
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
{{seealso|<br/>
|
||||
[[EiffelCOM Library|EiffelCOM library]] }}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
[[Property:title|COM]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|993f5778-97c1-e113-31d7-61ae81c559fb]]
|
||||
==Microsoft COM==
|
||||
|
||||
Eiffel support for Microsoft COM.
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|Features]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|3f6c7915-7e08-fc2b-f25a-7d98dff38631]]
|
||||
==ResourceBench Features==
|
||||
* Parse any resource file (created by Microsoft Developer Studio or Borland Resource Workshop).
|
||||
* Show resources by using a tree view control.
|
||||
* Display some resource's informations.
|
||||
|
||||
@@ -6,11 +6,5 @@ Platform: Any <br/>
|
||||
Version: 5.4 <br/>
|
||||
Availability: Basic Package
|
||||
|
||||
See:
|
||||
* [[Features|What does ResourceBench do?]]
|
||||
* [[Tour|How to use ResourceBench]]
|
||||
* [[Troubleshooting|Troubleshooting]]
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Tour]]
|
||||
[[Property:weight|1]]
|
||||
[[Property:uuid|5990eda2-2eac-6a40-8e99-5a0c5e9fc15f]]
|
||||
1 - Launch the Resource Bench application. This small dialog box will appear for the initialization process:
|
||||
[[Image:retriev]]
|
||||
Then you get the main window of Resource Bench:
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
[[Property:title|Troubleshooting]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|775c2f23-7138-c830-4e14-4d9898043229]]
|
||||
If you have problems when you parse a resource file, you can first try to remove the grammar file (its name is "rb.gram"), and then re-launch Resource Bench. It creates again the grammar file to allow parsing resource files (on a Pentium 120 it takes less than one minute).
|
||||
|
||||
|
||||
|
||||
@@ -10,6 +10,6 @@ WEL is an encapsulation of the Win32 Application Programming Interface (API), an
|
||||
|
||||
==Getting started with WEL==
|
||||
|
||||
If you are new to WEL, then the best place to begin is the [[Tutorial|tutorial]] which is a series of samples demonstrating the development of a simple WEL system.
|
||||
If you are new to WEL, then the best place to begin is the [[WEL Tutorial|tutorial]], which consists of a series of samples demonstrating the development of a simple WEL system.
|
||||
Also take a look at [[WEL Common Concepts|WEL common concepts]] for details of some common concepts used in WEL programming.
|
||||
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
[[Property:title|WEL Class Reference]]
|
||||
[[Property:weight|3]]
|
||||
[[Property:uuid|a7745f7c-48e0-342b-8eeb-c0aad7553e29]]
|
||||
==View the [[ref:libraries/wel/reference/index|WEL Class Reference]]==
|
||||
|
||||
@@ -11,12 +11,12 @@ Each WEL library component implements a set of routines for processing the most
|
||||
|
||||
|
||||
An on_paint message corresponds to the Wm_paint message generated by Windows whenever it needs to re-paint a window, and if you look at the feature, you can see that the arguments are a [[ref:libraries/wel/reference/wel_paint_dc_chart|WEL_PAINT_DC]] and a[[ref:libraries/wel/reference/wel_rect_chart| WEL_RECT]] . which are relevant to this message. By redefining this feature (and others as required), your code will be able to respond appropriately to windows events.
|
||||
{{note| '''Note'''. See [[Tutorial Step 2|step2]] in the [[WEL Tutorial|tutorial]] for a simple demonstration involving the re-definition of <eiffel>on_left_button_down</eiffel>. }}
|
||||
{{note|. See [[Tutorial Step 2|step2]] in the [[WEL Tutorial|tutorial]] for a simple demonstration involving the re-definition of <eiffel>on_left_button_down</eiffel>. }}
|
||||
|
||||
|
||||
For different messages received by a control, the arguments will differ (sometimes there are none), but those arguments will always be relevant to the message. For example, on_menu_command from [[ref:libraries/wel/reference/wel_composite_window_chart|WEL_COMPOSITE_WINDOW]] has an <eiffel>INTEGER</eiffel> as an argument, the value of which is a unique menu identifier. <br/>
|
||||
|
||||
{{note| '''Note'''. Not all windows events have a corresponding `on_' message hook defined in WEL. If you wish to process a Windows message that does not correspond to one of the available features, you will need to redefine process_message. <br/>
|
||||
{{note|. Not all windows events have a corresponding `on_' message hook defined in WEL. If you wish to process a Windows message that does not correspond to one of the available features, you will need to redefine process_message. <br/>
|
||||
}}
|
||||
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user