Delphi.NET - Documentation
Welcome to the documentation of the Delphi.NET project. The particular chapters of this documentation serve the purpose to describe the usage of Delphi.NET and its integral parts, so .NET functionality can be utilized within Delphi.

Project description
Since Borland does not yet offer support for Microsoft's .NET framework, Delphi.NET will provide an interface between Borland's Delphi development environment and .NET. The project currently consists of the following three sub-projects:
DotNetExec
DotNetExec is the core of Delphi.NET - it is a Delphi interface ("DotNetExec.pas") that calls a real .NET Object via the COM interoperability feature of .NET, facilitating the exchange of data between the .NET and COM worlds. Descriptions of the every single public function in this unit can be gathered from following chapters.

Delphi.NET class library
To provide access to some useful code-snippets and classes, the Delphi.NET projects has an additional class library, which is available via the Sourceforge-CVS of the project.

Delphi.NET utility programs
The Delphi.NET package comes with some additional programs that facilitate the development of .NET-supported Delphi-applications. These Tools are mainly code generators.

Delphi.NET sample applications
To provide further clarification, the Delphi.NET Project includes a growing number of sample projects utilizing the .NET techniques and/or aspects (like ADO.NET) within Delphi.

These three aspects of the Delphi.NET project will be developed and improved as much as possible while addressing any potential problems. Ideally, the project should follow the same path towards native support of .NET within Delpi as Borland (http://www.borland.com/dotnet/), by providing tools and examples of developing .NET projects with Delphi.


Delphi.NET class library
To provide access to some useful code-snippets and classes, the Delphi.NET projects has an additional class library, which is available via the Sourceforge-CVS of the project.


DotNetExec
DotNetExec is the core of Delphi.NET - it is a Delphi interface ("DotNetExec.pas") that calls a real .NET Object via the COM interoperability feature of .NET, facilitating the exchange of data between the .NET and COM worlds. Descriptions of the every single public function in this unit can be gathered from following chapters.

Chapters
DotNetExec Installation-guide
The following document while guide you through the installation process of DotNetExec and its integration into the Delphi developement environment.

DotNetExec flow-chart
To communicate with .NET respective .NET-assemblies, the part of DotNetExec that is included in the Delphi application, i.e. DotNetExec.pas, calls the assembly DotNetExec.dll (source: DotNetExec.cs) via the COM Interop Wrapper that belongs to the .NET-framework. This certain DLL solely consists of managed code and accesses other .NET-classes by the reflection feature of .NET. Relevant data are transported from the .NET-world back to COM-World by the mentioned COM Interop Wrapper.

DotNetExec function reference
This document contains an overview of all public functions of the DotNetExec (DotNetExec.pas) unit.


DotNetExec flow-chart
To communicate with .NET respective .NET-assemblies, the part of DotNetExec that is included in the Delphi application, i.e. DotNetExec.pas, calls the assembly DotNetExec.dll (source: DotNetExec.cs) via the COM Interop Wrapper that belongs to the .NET-framework. This certain DLL solely consists of managed code and accesses other .NET-classes by the reflection feature of .NET. Relevant data are transported from the .NET-world back to COM-World by the mentioned COM Interop Wrapper.

Flow-chart


DotNetExec Installation-guide
The following document while guide you through the installation process of DotNetExec and its integration into the Delphi developement environment.

Registration:

In order to use DotNetExec in your own programs, the file DotNetExec.dll has to be present in the program directory or in the shared assembly directory. This file represents the connection between .NET reflection and COM by means of the COM Callable Wrapper.

To make the DLL accessible for COM the type library "DotnetExec.tlb" has to registered with the system once in advance. You can use either the Delphi tool TREGSVR or the program REGASM from the .Net framework.

Hence to prepare the file DotNetExec.dll for COM access the following steps are necessary:

1. Register DotNetExec.tlb by either TREGSVR (calling sequence: TREGSVR DotNetExec.tlb) or REGASM (calling sequence: REGASM DotNetExec.dll /tlb:DotNetExec.tlb).

2. Make sure that the DLL is in the calling program's directory.

Delphi import:

Since the DLL file is now known to the system it can be imported using the menu entry "Project/Import Type Library...". Simply select the list entry DotNet Invocation and push the "Create unit" button. Since the created file mscorelib_TLB.pas is buggy, copy the file mscorlib_TLB.pas included in the DotNetExec distribution to the Delphi Import directory or fixes the minor bugs manually.

Subsequently the unit DotNetExec.pas can be linked to our own projects. Summarizing we get the following procedure:

1. Import DotNet Invocation type library to Delphi (Create unit)

2. Correct the created file mscorlib_TLB.pas in the Delphi import directory or replace it by the version included in the distribution. After this somehow complicated installation the unit DotNetExec is available.


DotNetExec function reference
This document contains an overview of all public functions of the DotNetExec (DotNetExec.pas) unit.

Available functions
Functions: NETAssignEventHandler | NETCreate | NETGetArrayElement | NETGetCollectionAsStrings | NETGetCollectionElement | NETGetField | NETGetProperty | NETGetStaticField | NETInvokeMethod | NETInvokeStaticMethod | NETSetEnumProperty | NETSetField | NETSetProperty

NETAssignEventHandler
Description [Experimental state]
Syntax function NETAssignEventHandler (
aRefObject: TNETObject,
sEventName: String,
ptrHandler: Integer,
aStorages: array of PNETObject,
pResultStorage: TNETObject
) : TNETObject;

Parameters
  • aRefObject

  • sEventName

  • ptrHandler

  • aStorages

  • pResultStorage
Return value

NETCreate
Description | Creates an instance of a .NET class accessible by its namespace or its assembly file.
Syntax function NETCreate (
sNamespace: string,
sAssembly: string,
sClassName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
  • sNamespace
    Determines the namespace containing the class to be instantiated. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sAssembly
    Determines the assembly file containing the class to be instantiated. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sClassName
    Contains the name of the class to instantiate. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

  • aParameters
    contains all parameters to the constructor used to instantiate the class. The constructor is determined by the types of the given elements of aParameters. To assign value(s) to this parameter in Delphi you can simply use a construct with square brackets, like, e.g., ['one', 2, false].
Return value | On success this is an instance of the desired class accessible via the data type TNETObject.

NETGetArrayElement
Description | Simplifies reading an element from an array. Instead of using methods of the array object this function can be used as a short cut.
Syntax function NETGetArrayElement (
aArray: TNETObject,
aIndices: array of Integer = []
) : TNETObject; overload;

Parameters
  • aArray
    contains the array from which an element is to be read.

  • aIndices
    contains an element for each dimension index of the array. For an one-dimensional array, this could be, e.g., [27], for a four-dimensional on the other hand for example [3,12,1,4].
Return value | is the value of the array element. Since it is of type TNETObject, the array can contain elements of arbitrary type.

NETGetCollectionAsStrings
Description | Simplifies the conversion of an array return type of a function ("collection") to an array of strings. Hereby arrays of arbitry types return by methods of .NET objects can be converted to arrays of strings.
Syntax function NETGetCollectionAsStrings (
aRefObject: TNETObject,
sCollectionMethod: String,
aParameters: array of const = []
) : TNETObject;

Parameters
  • aRefObject
    contains the object whose method returns the array to be converted.

  • sCollectionMethod
    contains the name of the method returning the array to be converted.

  • aParameters
    contains all parameters for the method to be called. If it is an overloaded method, the correct implementation is determined by the types of the array elements.
Return value | is an array object with elements of type string.

NETGetCollectionElement
Description
Syntax function NETGetCollectionElement (
aRefObject: TNETObject,
sCollectionMethod: String,
intIndex: Integer,
aParameters: Array of const = []
) : TNETObject;

Parameters
  • aRefObject

  • sCollectionMethod

  • intIndex

  • aParameters
Return value

NETGetField
Description
Syntax function NETGetField (
aRefObject: TNETObject,
sFieldName: String
) : TNETObject;

Parameters
  • aRefObject

  • sFieldName
Return value

NETGetProperty
Description | Determines the value of a property of a .NET object.
Syntax function NETGetProperty (
aRefObject: TNETObject,
sPropertyName: string,
aIndices: array of const = []
) : TNETObject;

Parameters
  • aRefObject
    contains the object whose property is to be determined.

  • sPropertyName
    contains the name of the property to be determined.

  • aIndices
    contains indices used to describe a parametric property. Remark: In most cases properties aren't parametrized, hence this parameter can be omitted.
Return value | On success this is the value of the property.

NETGetStaticField
Description
Syntax function NETGetStaticField (
sNamespace: String,
sAssembly: String,
sClassName: String,
sFieldName: String
) : TNETObject;

Parameters
  • sNamespace
    determines the namespace containing the desired class. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sAssembly
    determines the assembly file containing the desired class. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sClassName
    contains the name of the method's class. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

  • sFieldName
Return value

NETInvokeMethod
Description | Calls a method of a .NET object with arbitrary parameters.
Syntax function NETInvokeMethod (
aRefObject: TNETObject,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
  • aRefObject
    contains the object (resp. the corresponding TNETObject) whose method should be called.

  • sMethodName
    contains the name of the method to be called.

  • aParameters
    contains all the parameters of that method in an array. If it is an overloaded method then the correct implementation is determined by the types of the array elements.
Return value | On success this is the method's return value. Subsequently this value can be used as a usual OleVariant variable.

NETInvokeStaticMethod
Description | Calls a method of a .NET class (static method) with arbitrary parameters, where the class is determined either by its assembly file or its namespace.
Syntax function NETInvokeStaticMethod (
sNamespace: string,
sAssembly: string,
sClassName: string,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
  • sNamespace
    determines the namespace containing the desired class. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sAssembly
    determines the assembly file containing the desired class. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

  • sClassName
    contains the name of the method's class. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

  • sMethodName
    contains the name of the method to be called.

  • aParameters
    contains all parameters to be passed to the class method. If we deal with an overloaded method then the right implementation is determined by the types of the elements of this array.
Return value | On success this is the value returned by the called method. This value can be treated like an ordinary OleVariant variable.

NETSetEnumProperty
Description
Syntax procedure NETSetEnumProperty (
aRefObject: TNETObject,
sPropertyName: String,
sEnumMember: TNETObject
)

Parameters
  • aRefObject

  • sPropertyName

  • sEnumMember

NETSetField
Description
Syntax procedure NETSetField (
aRefObject: TNETObject,
sFieldName: String,
aValue: TNETObject
)

Parameters
  • aRefObject

  • sFieldName

  • aValue

NETSetProperty
Description Sets a property of a .NET object to a given value.
Syntax procedure NETSetProperty (
aRefObject: TNETObject,
sPropertyName: String,
aValue: TNETObject,
aIndices: array of const = []
)

Parameters
  • aRefObject
    contains the object whose property is to be set.

  • sPropertyName
    contains the name of the property to be set.

  • aValue
    contains the new value of the property. Since this parameter has the type "TNETObject", it can by of an arbitrary OLE compatible data type.

  • aIndices
    contains indices used to describe a parametric property. Remark: In most cases properties aren't parametric, hence usually the value '[]' should be passed.

See also
  • DotNetExec


NETAssignEventHandler
[Experimental state]

function NETAssignEventHandler (
aRefObject: TNETObject,
sEventName: String,
ptrHandler: Integer,
aStorages: array of PNETObject,
pResultStorage: TNETObject
) : TNETObject;

Parameters
aRefObject: TNETObject

sEventName: String

ptrHandler: Integer

aStorages: array of PNETObject

pResultStorage: TNETObject

Return value: TNETObject

Remarks

Example

program EventDemonstration;

uses DotNetExec, ActiveX, Dialogs;

type
  TButtonEventClass = class(TObject)
  published
    procedure OnClick(intArgCount, intReserved:Integer); stdcall;
  public
    FEventParamSender, FEventParamE : TNETObject
  end;

var
    netWindow, netButton : TNETObject;
    aButtonEvents        : TButtonEventClass;

procedure TButtonEventClass.OnClick(intArgCount, intReserved:Integer);
begin
    ShowMessage( 'sender: '#13#10 + NETInvokeMethod(aButtonEvents.FEventParamSender, 'ToString') );
    ShowMessage( 'e: '#13#10 + NETInvokeMethod(aButtonEvents.FEventParamE, 'ToString') );
end;

begin
    CoInitialize(nil);
    aButtonEvents := TButtonEventClass.Create;
    netWindow := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Form');
    netButton := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Button');
    NETSetProperty(netButton, 'Text', 'Test');
    NETInvokeMethod( NETGetProperty(netWindow, 'Controls'), 'Add', [netButton] );
    NETAssignEventHandler(netButton, 'Click', Integer(aButtonEvents.ClassType.MethodAddress('OnClick')),
        [@aButtonEvents.FEventParamSender, @aButtonEvents.FEventParamE], nil);
    NETInvokeMethod(netWindow, 'ShowDialog');
    aButtonEvents.Free;
end.

See also
  • Delphi .NET class generator


NETCreate
Creates an instance of a .NET class accessible by its namespace or its assembly file.

function NETCreate (
sNamespace: string,
sAssembly: string,
sClassName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
sNamespace: string
Determines the namespace containing the class to be instantiated. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sAssembly: string
Determines the assembly file containing the class to be instantiated. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sClassName: string
Contains the name of the class to instantiate. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

aParameters: array of const = []
contains all parameters to the constructor used to instantiate the class. The constructor is determined by the types of the given elements of aParameters. To assign value(s) to this parameter in Delphi you can simply use a construct with square brackets, like, e.g., ['one', 2, false].

Return value: TNETObject
On success this is an instance of the desired class accessible via the data type TNETObject.

Remarks

There are no remarks for this function at the moment.

Example
This example code demonstrates the usage of the NETCreate function. netXmlDoc will take up an instance of the System.Xml.XmlDocment class contained in the "C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll" assembly.

var netXmlDoc : TNETObject;
begin
    netXmlDoc := NETCreate('',
        'C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll',
        'System.Xml.XmlDocument', []);
end;


NETGetArrayElement
Simplifies reading an element from an array. Instead of using methods of the array object this function can be used as a short cut.

function NETGetArrayElement (
aArray: TNETObject,
aIndices: array of Integer = []
) : TNETObject; overload;

Parameters
aArray: TNETObject
contains the array from which an element is to be read.

aIndices: array of Integer = []
contains an element for each dimension index of the array. For an one-dimensional array, this could be, e.g., [27], for a four-dimensional on the other hand for example [3,12,1,4].

Return value: TNETObject
is the value of the array element. Since it is of type TNETObject, the array can contain elements of arbitrary type.

function NETGetArrayElement (
aArray: TNETObject,
intIndex: Integer
) : TNETObject; overload;

Parameters
aArray: TNETObject
contains the array from which an element is to be read.

intIndex: Integer
provides a short cut for one-dimensional arrays. Instead of passing in [10], we can simply use 10.

Return value: TNETObject
is the value of the array element. Since it is of type TNETObject, the array can contain elements of arbitrary type.

Remarks

There are no remarks for this function at the moment.

Example
This example code reads an element from an two-dimensional array that is stored in the variable netArray and pops up a message box with its value.

ShowMessage( NETGetArray(netArray, [1, 4]) );


NETGetCollectionAsStrings
Simplifies the conversion of an array return type of a function ("collection") to an array of strings. Hereby arrays of arbitry types return by methods of .NET objects can be converted to arrays of strings.

function NETGetCollectionAsStrings (
aRefObject: TNETObject,
sCollectionMethod: String,
aParameters: array of const = []
) : TNETObject;

Parameters
aRefObject: TNETObject
contains the object whose method returns the array to be converted.

sCollectionMethod: String
contains the name of the method returning the array to be converted.

aParameters: array of const = []
contains all parameters for the method to be called. If it is an overloaded method, the correct implementation is determined by the types of the array elements.

Return value: TNETObject
is an array object with elements of type string.

Remarks

There are no remarks for this function at the moment.

Example
This sample outputs all the methods of an assembly, whose reflection-representation is stored in the variable netAssembly.

var netMethods: TNETObject;
begin
    netMethods := NETGetCollectionAsStrings(netAssembly, 'GetMethods', []);
    for intLoop := 0 to (NETGetProperty(netMethods, 'Length', []) - 1) do
        ShowMessage( NETGetArrayElement(netMethods, intLoop) );
end;


NETGetCollectionElement

function NETGetCollectionElement (
aRefObject: TNETObject,
sCollectionMethod: String,
intIndex: Integer,
aParameters: Array of const = []
) : TNETObject;

Parameters
aRefObject: TNETObject

sCollectionMethod: String

intIndex: Integer

aParameters: Array of const = []

Return value: TNETObject

Remarks


NETGetField

function NETGetField (
aRefObject: TNETObject,
sFieldName: String
) : TNETObject;

Parameters
aRefObject: TNETObject

sFieldName: String

Return value: TNETObject

Remarks

See also
  • NETSetField


NETGetProperty
Determines the value of a property of a .NET object.

function NETGetProperty (
aRefObject: TNETObject,
sPropertyName: string,
aIndices: array of const = []
) : TNETObject;

Parameters
aRefObject: TNETObject
contains the object whose property is to be determined.

sPropertyName: string
contains the name of the property to be determined.

aIndices: array of const = []
contains indices used to describe a parametric property. Remark: In most cases properties aren't parametrized, hence this parameter can be omitted.

Return value: TNETObject
On success this is the value of the property.

Remarks

There are no remarks for this function at the moment.

Example
This example loads an assembly representation object (netAssembly) and displays its location path via the NETGetPropery function.

var netAssembly: TNETObject;
begin
    netAssembly := NETInvokeClassMethod('mscorlib', '', 'Assembly', 'LoadFrom',
    ['C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll']);

    ShowMessage('Location: ' + NETGetProperty(netAssembly, 'Location', []) );
end;

See also
  • NETSetProperty


NETGetStaticField

function NETGetStaticField (
sNamespace: String,
sAssembly: String,
sClassName: String,
sFieldName: String
) : TNETObject;

Parameters
sNamespace: String
determines the namespace containing the desired class. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sAssembly: String
determines the assembly file containing the desired class. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sClassName: String
contains the name of the method's class. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

sFieldName: String

Return value: TNETObject

Remarks

Example

NETGetStaticField('mscorlib', '', 'System.Byte', 'MaxValue');

See also
  • NETGetField


NETInvokeMethod
Calls a method of a .NET object with arbitrary parameters.

function NETInvokeMethod (
aRefObject: TNETObject,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
aRefObject: TNETObject
contains the object (resp. the corresponding TNETObject) whose method should be called.

sMethodName: string
contains the name of the method to be called.

aParameters: array of const = []
contains all the parameters of that method in an array. If it is an overloaded method then the correct implementation is determined by the types of the array elements.

Return value: TNETObject
On success this is the method's return value. Subsequently this value can be used as a usual OleVariant variable.

Remarks

There are no remarks for this function at the moment.

Example
This example code creates an XML processing instruction node for an XML document by calling the CreateProcessingInstruction method of the System.Xml.XmlDocument class (assume that the netXmlDoc variable is an instance of the System.Xml.XmlDocument class).

var netXmlInstr: TNETObject;
begin
    netXmlInstr := NETInvokeMethod(netXmlDoc, 'CreateProcessingInstruction',
    ['xml', 'version="1.0"']);
end;

See also
  • NETInvokeStaticMethod


NETInvokeStaticMethod
Calls a method of a .NET class (static method) with arbitrary parameters, where the class is determined either by its assembly file or its namespace.

function NETInvokeStaticMethod (
sNamespace: string,
sAssembly: string,
sClassName: string,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameters
sNamespace: string
determines the namespace containing the desired class. Remark: If a value for "sNamespace" is given, then an empty string has to be passed to the parameter "sAssembly" since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sAssembly: string
determines the assembly file containing the desired class. .NET assemblies typically have the extensions DLL, EXE, or MCL. Remark: If a value for "sAssembly" is given then an empty string has to be passed to "sNamespace", since a class is localized either exclusively by its namespace or exclusively by its assembly file.

sClassName: string
contains the name of the method's class. Remark: The class name has to be given completely, i.e., including the namespace (e.g., "System.Xml.XmlDocument").

sMethodName: string
contains the name of the method to be called.

aParameters: array of const = []
contains all parameters to be passed to the class method. If we deal with an overloaded method then the right implementation is determined by the types of the elements of this array.

Return value: TNETObject
On success this is the value returned by the called method. This value can be treated like an ordinary OleVariant variable.

Remarks

There are no remarks for this function at the moment.

Example
This sample code creates an instance of the System.Reflection.Assembly class by calling its static method "LoadFrom". The returned object is stored in the netAssembly variable.

var netAssembly: TNETObject;
begin
    netAssembly := NETInvokeClassMethod('mscorlib', '',
    'Assembly', 'LoadFrom', ['C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll']);
end;

See also
  • NETInvokeMethod


NETSetEnumProperty

procedure NETSetEnumProperty (
aRefObject: TNETObject,
sPropertyName: String,
sEnumMember: TNETObject
)

Parameters
aRefObject: TNETObject

sPropertyName: String

sEnumMember: TNETObject

Remarks

Example

var netWMain : TNETObject;
begin
    netWMain := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Form');
    NETSetEnumProperty(netWMain, 'SizeGripStyle', 'Show');
    NETInvokeMethod(netWMain, 'ShowDialog');
end;

See also
  • NETGetProperty


NETSetField

procedure NETSetField (
aRefObject: TNETObject,
sFieldName: String,
aValue: TNETObject
)

Parameters
aRefObject: TNETObject

sFieldName: String

aValue: TNETObject

Remarks

There are no remarks for this function at the moment.

See also
  • NETGetField
  • NETSetProperty


NETSetProperty
Sets a property of a .NET object to a given value.

procedure NETSetProperty (
aRefObject: TNETObject,
sPropertyName: String,
aValue: TNETObject,
aIndices: array of const = []
)

Parameters
aRefObject: TNETObject
contains the object whose property is to be set.

sPropertyName: String
contains the name of the property to be set.

aValue: TNETObject
contains the new value of the property. Since this parameter has the type "TNETObject", it can by of an arbitrary OLE compatible data type.

aIndices: array of const = []
contains indices used to describe a parametric property. Remark: In most cases properties aren't parametric, hence usually the value '[]' should be passed.

Remarks

There are no remarks for this function at the moment.

Example
In this example, the contant of an XML document (netXmlDoc) is set.

NETSetProperty(netXmlDoc, 'InnerXml', [],
'Person APerson A');

See also
  • NETGetProperty


Delphi.NET sample applications
To provide further clarification, the Delphi.NET Project includes a growing number of sample projects utilizing the .NET techniques and/or aspects (like ADO.NET) within Delphi.

Chapters


Delphi.NET utility programs
The Delphi.NET package comes with some additional programs that facilitate the development of .NET-supported Delphi-applications. These Tools are mainly code generators.

Utilities
Delphi .NET class generator
The Delphi Class Generator is a tool capable of producing Delphi wrapper classes for .NET Objects. Essentially, class- and method bodies are called and their parameters are implemented via DotNetExec. These Delphi classes can be used more easily than direct DotNetExec calls and allow one to benefit from the syntax completion of Delphi. The classes produced are of either the TObject or TComponent parent type. With the latter, .NET events can simply be handled via the Object Inspector. For a full understanding, see the respective documentation. Additionally, a small example has been included ("classgen_smtp") that can be used as a wrapper class.

ASP.NET WebService generator
The ASP.NET WebService generator is a tool which is able to publish the methods and properties of an COM object as an ASP.NET-WebService (file extension: ".asmx"). In conjunction with an ASP.NET-enabled web server, typically the IIS, users can access the functionality of the COM object via HTTP/SOAP that way.

In this manner, the tool offers a way to develop WebServices in Delphi that can utilize the special capabilities of ASP.NET (most obvious, the automaticly generated help page ;-). Since COM-objects aren't tied to Delphi, they can of course be written in any other language as well.

The tool's also able to create wrapper WebServices for usual .NET assemblies. That makes sense for example, if their content isn't explicitly declared to run as a WebService and to make up leeway isn't possible offhand.


ASP.NET WebService generator
The ASP.NET WebService generator is a tool which is able to publish the methods and properties of an COM object as an ASP.NET-WebService (file extension: ".asmx"). In conjunction with an ASP.NET-enabled web server, typically the IIS, users can access the functionality of the COM object via HTTP/SOAP that way.

In this manner, the tool offers a way to develop WebServices in Delphi that can utilize the special capabilities of ASP.NET (most obvious, the automaticly generated help page ;-). Since COM-objects aren't tied to Delphi, they can of course be written in any other language as well.

The tool's also able to create wrapper WebServices for usual .NET assemblies. That makes sense for example, if their content isn't explicitly declared to run as a WebService and to make up leeway isn't possible offhand.

Chapters


Delphi .NET class generator
The Delphi Class Generator is a tool capable of producing Delphi wrapper classes for .NET Objects. Essentially, class- and method bodies are called and their parameters are implemented via DotNetExec. These Delphi classes can be used more easily than direct DotNetExec calls and allow one to benefit from the syntax completion of Delphi. The classes produced are of either the TObject or TComponent parent type. With the latter, .NET events can simply be handled via the Object Inspector. For a full understanding, see the respective documentation. Additionally, a small example has been included ("classgen_smtp") that can be used as a wrapper class.

Chapters


Delphi.NET - Dokumentation
Willkommen zur Dokumentation des Delphi.NET-Projekts. Die einzelnen Kapitel dieser Dokumentation sollen den Einsatz von Delphi.NET und seinen einzelnen Bestandteile beschreiben, so dass eine effektive Verwendung von .NET-Funktionalität in Delphi möglich ist.

Beschreibung des Projektes
Delphi.NET soll eine Schnittstelle zwischen Borlands Entwicklungsumgebung Delphi und dem .NET-Framework von Microsoft schaffen, solange Delphi noch keine native Unterstützung für .NET bietet.
DotNetExec
DotNetExec ist der Kern von Delphi.NET - es ist eine Delphi-Unit ("DotNetExec.pas"), welche über die COM-Interoperabilitätsfähigkeiten von .NET ein reines .NET-Objekt ("DotNetExec.cs") aufruft, welches in der Lage ist, Daten zwischen der.NET- und COM- Welt auszutauschen. Beschreibungen zu den einzelnen öffentlichen Funktionen dieser Unit können dieser Dokumentation entnommen werden.

Delphi.NET Klassenbibliothek
Um einen Zugriff auf nützliche Codeschnippsel und Klassen bereitzustellen, verfügt das Delphi.NET-Projekt über eine zusätzliche Klassenbibliothek, welche über das Sourceforge-CVS des Projekts erhältlich ist.

Delphi.NET Hilfsprogramme
Dem Delphi.NET-Paket liegen einige zusätzliche Programme bei, mit deren Hilfe die Entwicklung von .NET-gestützten Delphi-Anwendungen vereinfacht wird. Diese Tools stellen zumeist Codegeneratoren o.ä. dar.

Delphi.NET-Beispielanwendungen
Das Delphi.NET-Projekt enthält zusätzlich eine stetig wachsende Ansammlung von Beispiel-Projekten, welche die Benutzung spezieller .NET-Techniken oder -Aspekten (beispielsweise ADO.NET) mit Delphi verdeutlicht.

All diese Teilbereiche sollten so weit wie möglich weiterentwickelt und verbessert werden, um möglichst vielen Problemstellungen gewachsen zu sein. Idealerweise sollte das Projekt auch nach der Einführung der nativen .NET-Unterstützung von Delphi (http://www.borland.com/dotnet/) weitergeführt werden, um Tools und Beispiele für die .NET-Entwicklung mit Delphi anzubieten.


Delphi.NET-Beispielanwendungen
Das Delphi.NET-Projekt enthält zusätzlich eine stetig wachsende Ansammlung von Beispiel-Projekten, welche die Benutzung spezieller .NET-Techniken oder -Aspekten (beispielsweise ADO.NET) mit Delphi verdeutlicht.

Kapitel


Delphi.NET Klassenbibliothek
Um einen Zugriff auf nützliche Codeschnippsel und Klassen bereitzustellen, verfügt das Delphi.NET-Projekt über eine zusätzliche Klassenbibliothek, welche über das Sourceforge-CVS des Projekts erhältlich ist.


DotNetExec
DotNetExec ist der Kern von Delphi.NET - es ist eine Delphi-Unit ("DotNetExec.pas"), welche über die COM-Interoperabilitätsfähigkeiten von .NET ein reines .NET-Objekt ("DotNetExec.cs") aufruft, welches in der Lage ist, Daten zwischen der.NET- und COM- Welt auszutauschen. Beschreibungen zu den einzelnen öffentlichen Funktionen dieser Unit können dieser Dokumentation entnommen werden.

Kapitel
DotNetExec Installationsbeschreibung
Diese Beschreibung führt Sie durch die Installationsvorgang von DotNetExec und zeigt, wie es in die Delphi-Entwicklungsumgebung integriert werden kann.

DotNetExec-Flussdiagramm
Um mit .NET bzw. .NET-Assemblies kommunizieren zu können, ruft der in die Delphi-Anwendung eingebunde Teil von DotNetExec, DotNetExec.pas, über den zum .NET-Framework gehörenden COM Interop Wrapper die Assemblierung DotNetExec.dll (Quelle: DotNetExec.cs) auf. Bei dieser DLL-Datei handelt es sich um eine aus rein verwaltetem Code bestehende Assemblierung, welche über das Reflection-Feature von .NET auf andere .NET-Klassen etc. zugreift und über den COM Interop Wrapper Daten aus der .NET-Welt zur COM-Welt übertragen lässt.

DotNetExec Funktionsreferenz
Dieses Dokument enthält einen Überlick über alle öffentlichen Funktionen der DotNetExec-Unit (DotNetExec.pas).


DotNetExec-Flussdiagramm
Um mit .NET bzw. .NET-Assemblies kommunizieren zu können, ruft der in die Delphi-Anwendung eingebunde Teil von DotNetExec, DotNetExec.pas, über den zum .NET-Framework gehörenden COM Interop Wrapper die Assemblierung DotNetExec.dll (Quelle: DotNetExec.cs) auf. Bei dieser DLL-Datei handelt es sich um eine aus rein verwaltetem Code bestehende Assemblierung, welche über das Reflection-Feature von .NET auf andere .NET-Klassen etc. zugreift und über den COM Interop Wrapper Daten aus der .NET-Welt zur COM-Welt übertragen lässt.

Flussdiagramm


DotNetExec Installationsbeschreibung
Diese Beschreibung führt Sie durch die Installationsvorgang von DotNetExec und zeigt, wie es in die Delphi-Entwicklungsumgebung integriert werden kann.

Registrierung:

Um DotNetExec aus eigenen Programmen heraus nutzen zu können, muss auf jeden Fall die Datei DotNetExec.dll im Programmverzeichnis oder im Shared-Assembly-Verzeichnis vorhanden sein. Diese Datei stellt quasi als Brückenkopf die Verbindung zwischen .NET-Reflexion und COM über den COM Callable Wrapper her.

Um die DLL für COM zugreifbar zu machen, muss zuvor einmalig die Typenbibliothek "DotNetExec.tlb" im System registriert werden. Dafür kann entweder das Delphi-Tool TREGSVR oder auch das Programm REGASM des .NET-Frameworks verwendet werden. Um also die Datei DotNetExec.dll für den COM-Zugriff einzurichten müssen folgende Schritte beachtet werden:

1. DotNetExec.tlb wahlweise über TREGSVR (Auruf: TREGSVR DotNetExec.tlb) oder REGASM (Aufruf: REGASM DotNetExec.dll /tlb:DotNetExec.tlb) registrieren. 2. Sicherstellen, dass sich die DLL im Verzeichnis des aufrufenden Programmes befindet.

Delphi-Import:

Da die DLL-Datei nun dem System bekannt ist, kann Sie über den Menüpunkt Projekt/Typbibliothek importieren... nach Delphi importiert werden. Dazu wählt man lediglich den Listeneintrag DotNet Invocation aus und betätigt den "Unit anlegen"-Button. Da die nun erzeugte Datei mscorelib_TLB.pas fehlerhaft ist, kopiert man anschließend die mit DotNetExec mitgelieferte Datei mscorlib_TLB.pas in das Delphi-Import-Verzeichnis oder passt die kleinen Fehler selbst an.

Ab sofort kann die Unit DotNetExec.pas nun in eigene Projekte eingebunden werden; es ergibt sich zusammengefasst also folgende Vorgehensweise:

1. Typbibliothek DotNet Invocation in Delphi importieren (Unit anlegen).

2. Die im Imports-Verzeichnis von Delphi erzeugte Datei mscorlib_TLB.pas korrigieren oder durch die mit DotNetExec mitgelieferte Version ersetzen. Nach dieser etwas umständlichen Installation kann die Unit DotNetExec.pas aber verwendet werden.


DotNetExec Funktionsreferenz
Dieses Dokument enthält einen Überlick über alle öffentlichen Funktionen der DotNetExec-Unit (DotNetExec.pas).

Verfügbare Funktionen
Funktionen: NETAssignEventHandler | NETCreate | NETGetArrayElement | NETGetCollectionAsStrings | NETGetCollectionElement | NETGetField | NETGetProperty | NETGetStaticField | NETInvokeMethod | NETInvokeStaticMethod | NETSetEnumProperty | NETSetField | NETSetProperty

NETAssignEventHandler
Beschreibung | [Experimentell] Weist einem Ereignis eines .NET-Objekts eine Ereignisbehandlungs-Routine innerhalb des Delphi-Codes zu.
Syntax function NETAssignEventHandler (
aRefObject: TNETObject,
sEventName: String,
ptrHandler: Integer,
aStorages: array of PNETObject,
pResultStorage: TNETObject
) : TNETObject;

Parameter
  • aRefObject
    enthält das Objekt, welches das zu verknüpfende Ereignis auslöst.

  • sEventName
    enthält die Bezeichnung des abzufangenden Ereignisses (z.B. Click etc.).

  • ptrHandler
    enthält die Adresse der Behandlungsfunktion. Diese muss die folgende Signatur besitzen: procedure(intArgCount, intReserved:Integer); stdcall; Die Adresse einer Funktion erhält man, indem man einen Pointer auf diesselbe mittels Typenumwandlung in einen Integerwert umwandelt: Integer(ptrFunction) Ein solcher Pointer kann leicht ermittelt werden, wenn sich die entsprechende Funktion beispielsweise in einer DLL (dann kann der Pointer über die Windows-API-Funktion GetProcAddress() erhalten werden) oder in einer Klasse befindet. In letzterem Fall kommt man mit der Standardmethode MethodAddress() an den Pointer.

  • aStorages
    ein Array von Zeigern auf TNETObject-Variablen. In diese Variablen werden beim Auslösen des Ereignisses die Parameter des Ereignisses in der angegebenen Reihenfolge geschrieben. Hat das Ereignis beispielsweise die Form public delegate void EventHandler(object sender, EventArgs e) und somit zwei Parameter, so muss das "aStorage"-Argument von "NETAssignEventHandler" wie folgt aussehen: [ <Pointer auf TNETObject-Variable die das Argument "sender" aufnehmen soll>, <Pointer auf TNETObject-Variable die das Argument "e" aufnehmen soll> ] Wird das Ereignis nun ausgelöst und die Behandlungsroutine aufgerufen, so enthält die Variable, auf die das erste Element des aStorage-Arrays zeigt, das sender-Argument, die, auf die das zweite zeigt, das e-Argument.

  • pResultStorage
    enthält einen Zeiger auf eine TNETObject-Variable, die beim Auslösen des Ereignisses den Rückgabewert erhält. Dieser Parameter ist nur dann von Bedeutung, wenn die Ereignisbehandlungsfunktion auch wirklich einen Wert zurückgibt, wie beispielsweise public delegate bool DrawImageAbort(IntPtr callbackdata) In solch einem Fall sollte beim Aufruf von NETAssignEventHandler ein Pointer auf eine entsprechende Variable übergeben werden. Wird nun das Ereignis ausgelöst und die Delphi-Behandlungsroutine aufgerufen, so sollte diese bei Ihrem Abschluss einen Wert in dieser Variable hinterlegt haben. Handelt es sich bei dem Ereignis um ein solches, das keinen Rückgabewert erfordert, wie z.B. public delegate void EventHandler(object sender, EventArgs e) muss als pResultStorage-Parameter nil übergeben werden
Rückgabewert | Instanz einer dynamisch erzeugten Ereignisweiterleitungs-Assembly (s. Bemerkungen)

NETCreate
Beschreibung | Erzeugt eine Instanz einer .NET-Klasse, auf die über ihren Namensraum oder ihre Assemblierungsdatei zugegriffen wird.
Syntax function NETCreate (
sNamespace: string,
sAssembly: string,
sClassName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
  • sNamespace
    gibt den Namensraum an, in dem sich die zu instanziierende Klasse befindet. Bemerkung: Wenn für sNamespace ein Wert angegeben wird, muss als Parameter sAssembly ein leerer String übergeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sAssembly
    gibt die Assemblierungsdatei ("Assembly") an, in der die zu instanziierende Klasse enthalten ist. .NET-Assemblies haben typischerweise die Dateiendung DLL, EXE oder MCL. Bemerkung: Wenn für sAssembly ein Wert angegeben wird, muss als Parameter sNamespace ein leerer String übergeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sClassName
    gibt den Name der zu instanziierenden Klasse an. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

  • aParameters
    enthält als Array alle Aufrufparameter des Konstruktors, der für die Erzeugung der Klasseninstanz aufgerufen werden soll. Anhand der Dateitypen der einzelnen Array-Elemente wird der geeignete Konstruktor ermittelt. Um in Delphi diesem Parameter einen Wert bzw. Werte zuzuweisen, benutzt man einfach eine Konstruktion mit eckigen Klammern, wie beispielsweise ['eins', 2, false].
Rückgabewert | ist bei Erfolg eine Instanz der gewünschten Klasse, auf welche in Form des Datentyps TNETObject zugegriffen werden kann.

NETGetArrayElement
Beschreibung | Vereinfacht das Auslesen eines Elements aus einem Array. Anstatt Methoden des Array-Objekts einzusetzen, kann abkürzend diese Funktion verwendet werden.
Syntax function NETGetArrayElement (
aArray: TNETObject,
aIndices: array of Integer = []
) : TNETObject; overload;

Parameter
  • aArray

  • aIndices
    enthält als Array einen Indexwert für jede Dimension des Arrays, auf das zugegriffen werden soll. Bei eindimensionalen Arrays lautet dieser Parameter also beispielsweise [27], dagegen bei vierdimensionalen etwa so [3, 12, 1, 4].
Rückgabewert | ist der Wert des ausgelesenen Arrayelements. Da der Rückgabewert vom Datentyp TNETObject ist, kann das Array beliebigen Feldtyps sein.

NETGetCollectionAsStrings
Beschreibung | Vereinfacht die Umwandlung eines Array-Rückgabewerts einer Funktion ("Collection") in ein String-Array. Damit können Arrays beliebigen Datentyps, die von Methoden von .NET-Objekten zurückgegeben werden, in Arrays von Zeichenketten konvertiert werden.
Syntax function NETGetCollectionAsStrings (
aRefObject: TNETObject,
sCollectionMethod: String,
aParameters: array of const = []
) : TNETObject;

Parameter
  • aRefObject
    enthält das Objekt, dessen Methode aufgerufen werden soll, welche das umzuwandelnde Array zurückgibt.

  • sCollectionMethod
    gibt den Namen der Methode an, die den zu konvertierenden Array zurückliefert.

  • aParameters
    enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.
Rückgabewert | ist ein Array-Objekt mit Elementen des Typs string.

NETGetCollectionElement
Beschreibung | Liest ein einzelnes Element aus einem Array aus, welches als Ergebnis eines Funktionsaufrufes zurückgegeben wurde (Collection).
Syntax function NETGetCollectionElement (
aRefObject: TNETObject,
sCollectionMethod: String,
intIndex: Integer,
aParameters: Array of const = []
) : TNETObject;

Parameter
  • aRefObject
    gibt das Objekt an, das die Funktion zum Zurückgeben des auszulesenden Arrays enthält.

  • sCollectionMethod
    Name der Methode, die das auszulesende Array zurückgibt.

  • intIndex
    Index des zu ermittelnden Arrayelements

  • aParameters
    gibt sämtliche Aufrufparameter an, mit denen die Funktion, welche das auszulesende Array zurückgibt, aufgerufen werden soll.
Rückgabewert | Wert des ausgelesenen Array-Elements

NETGetField
Beschreibung | Liest ein Feld aus einem Objekt aus.
Syntax function NETGetField (
aRefObject: TNETObject,
sFieldName: String
) : TNETObject;

Parameter
  • aRefObject
    enthält das Objekt, dessen Feld ausgelesen werden soll.

  • sFieldName
    gibt den Namen des auszulesenden Feldes an.
Rückgabewert | Momentaner Wert des Feldes

NETGetProperty
Beschreibung | Ermittelt den Wert einer Eigenschaft eines .NET-Objekts.
Syntax function NETGetProperty (
aRefObject: TNETObject,
sPropertyName: string,
aIndices: array of const = []
) : TNETObject;

Parameter
  • aRefObject
    enthält das Objekt, dessen Eigenschaft ausgelesen werden soll.

  • sPropertyName
    enthält den Namen der Eigenschaft, die ausgelesen werden soll.

  • aIndices
    enthält Indexparameter, die verwendet werden sollen, um eine parametrisierte Eigenschaft auszulesen. Bemerkung: In den meisten Fällen sind Eigenschaften nicht parametrisiert, so dass für diesen Parameter meist kein Wert zu übergeben ist.
Rückgabewert | ist bei Erfolg der Wert der ausgelesenen Eigenschaft.

NETGetStaticField
Beschreibung | Ermittelt den Wert eines statischen Feldes eines Objektes, also eines Klassenfeldes.
Syntax function NETGetStaticField (
sNamespace: String,
sAssembly: String,
sClassName: String,
sFieldName: String
) : TNETObject;

Parameter
  • sNamespace
    gibt den Namensraum der gewünschten Klasse an. Bemerkung: Wird für sNamespace ein Wert übergeben, muss als Parameter sAssembly eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sAssembly
    gibt den Namen der Assemblierungsdatei an, welche die gewünschte Klasse beinhaltet. Bemerkung: Wird für sAssembly ein Wert übergeben, muss als Parameter sNamespace eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sClassName
    gibt den Namen der Klasse an, deren Methode aufgerufen werden soll. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

  • sFieldName
    gibt den Namen des statischen Feldes an, dessen Wert ermittelt werden soll.
Rückgabewert | gibt den ermittelten Wert des gewünschten statischen Feldes an.

NETInvokeMethod
Beschreibung | Ruft eine Methode eines .NET-Objekts mit beliebigen Parametern auf.
Syntax function NETInvokeMethod (
aRefObject: TNETObject,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
  • aRefObject
    enthält das Objekt (bzw. die TNETObject-Variable), dessen Methode aufgerufen werden soll.

  • sMethodName
    enthält den Namen der Methode, die ausgeführt werden soll.

  • aParameters
    enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.
Rückgabewert | ist bei Erfolg der von der aufgerufenen Methode zurückgelieferte Wert. Der zurückgegebene Wert kann anschließend wie eine gewöhnliche OleVariant-Variable behandelt werden.

NETInvokeStaticMethod
Beschreibung | Ruft eine Methode einer .NET-Klasse (statische Methode) mit beliebigen Parametern auf, wobei die Klasse wahlweise über ihre Assemblierungsdatei oder ihren Namensraum lokalisiert wird.
Syntax function NETInvokeStaticMethod (
sNamespace: string,
sAssembly: string,
sClassName: string,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
  • sNamespace
    gibt den Namensraum der gewünschten Klasse an. Bemerkung: Wird für sNamespace ein Wert übergeben, muss als Parameter sAssembly eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sAssembly
    gibt den Namen der Assemblierungsdatei an, welche die gewünschte Klasse beinhaltet. Bemerkung: Wird für sAssembly ein Wert übergeben, muss als Parameter sNamespace eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

  • sClassName
    gibt den Namen der Klasse an, deren Methode aufgerufen werden soll. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

  • sMethodName
    enthält den Namen der Methode, die ausgeführt werden soll.

  • aParameters
    enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.
Rückgabewert | ist bei Erfolg der von der aufgerufenen Methode zurückgelieferte Wert. Der zurückgegebene Wert kann anschließend wie eine gewöhnliche OleVariant-Variable behandelt werden.

NETSetEnumProperty
Beschreibung Weist einer Objekteigenschaft vom Typ einer Enumeration (d.h. eines von "System.Enum" abgeleiteten Datentyps) einen Wert zu.
Syntax procedure NETSetEnumProperty (
aRefObject: TNETObject,
sPropertyName: String,
sEnumMember: TNETObject
)

Parameter
  • aRefObject
    enthält das Objekt, dessen Eigenschaft gesetzt werden soll.

  • sPropertyName
    gibt den Name der zu setzenden Eigenschaft an.

  • sEnumMember
    enthält den String-Bezeichner des zu setzenden Enumerationswertes.

NETSetField
Beschreibung Setzt den Wert eines Objektfeldes.
Syntax procedure NETSetField (
aRefObject: TNETObject,
sFieldName: String,
aValue: TNETObject
)

Parameter
  • aRefObject
    enthält das Objekt, dessen Feld gesetzt werden soll.

  • sFieldName
    gibt den Namen des zu setzenden Feldes an.

  • aValue
    enthält den neu zu setzenden Wert des Feldes.

NETSetProperty
Beschreibung Setzt eine Eigenschaft eines .NET-Objekts auf einen bestimmten Wert.
Syntax procedure NETSetProperty (
aRefObject: TNETObject,
sPropertyName: String,
aValue: TNETObject,
aIndices: array of const = []
)

Parameter
  • aRefObject
    enthält das Objekt, dessen Eigenschaft gesetzt werden soll.

  • sPropertyName
    gibt den Namen der Eigenschaft an, deren Wert gestezt werden soll.

  • aValue
    gibt den Wert an, den die bezeichnete Eigenschaft erhalten soll. Da dieser Parameter vom Typ TNETObject ist, kann er ein beliebigen OLE-kompatiblen Datentyp sein.

  • aIndices
    enthält Indexparameter, die verwendet werden sollen, um eine parametrisierte Eigenschaft zu beschreiben. Bemerkung: In den meisten Fällen sind Eigenschaften nicht parametrisiert, so dass für diesen Parameter meist der Wert [] zu übergeben ist.

Siehe auch
  • DotNetExec


NETAssignEventHandler
[Experimentell] Weist einem Ereignis eines .NET-Objekts eine Ereignisbehandlungs-Routine innerhalb des Delphi-Codes zu.

function NETAssignEventHandler (
aRefObject: TNETObject,
sEventName: String,
ptrHandler: Integer,
aStorages: array of PNETObject,
pResultStorage: TNETObject
) : TNETObject;

Parameter
aRefObject: TNETObject
enthält das Objekt, welches das zu verknüpfende Ereignis auslöst.

sEventName: String
enthält die Bezeichnung des abzufangenden Ereignisses (z.B. Click etc.).

ptrHandler: Integer
enthält die Adresse der Behandlungsfunktion. Diese muss die folgende Signatur besitzen:

procedure(intArgCount, intReserved:Integer); stdcall;

Die Adresse einer Funktion erhält man, indem man einen Pointer auf diesselbe mittels Typenumwandlung in einen Integerwert umwandelt:

Integer(ptrFunction)

Ein solcher Pointer kann leicht ermittelt werden, wenn sich die entsprechende Funktion beispielsweise in einer DLL (dann kann der Pointer über die Windows-API-Funktion GetProcAddress() erhalten werden) oder in einer Klasse befindet. In letzterem Fall kommt man mit der Standardmethode MethodAddress() an den Pointer.

aStorages: array of PNETObject
ein Array von Zeigern auf TNETObject-Variablen. In diese Variablen werden beim Auslösen des Ereignisses die Parameter des Ereignisses in der angegebenen Reihenfolge geschrieben. Hat das Ereignis beispielsweise die Form

public delegate void EventHandler(object sender, EventArgs e)

und somit zwei Parameter, so muss das "aStorage"-Argument von "NETAssignEventHandler" wie folgt aussehen:

[ <Pointer auf TNETObject-Variable die das Argument "sender" aufnehmen soll>, <Pointer auf TNETObject-Variable die das Argument "e" aufnehmen soll> ]

Wird das Ereignis nun ausgelöst und die Behandlungsroutine aufgerufen, so enthält die Variable, auf die das erste Element des aStorage-Arrays zeigt, das sender-Argument, die, auf die das zweite zeigt, das e-Argument.

pResultStorage: TNETObject
enthält einen Zeiger auf eine TNETObject-Variable, die beim Auslösen des Ereignisses den Rückgabewert erhält. Dieser Parameter ist nur dann von Bedeutung, wenn die Ereignisbehandlungsfunktion auch wirklich einen Wert zurückgibt, wie beispielsweise

public delegate bool DrawImageAbort(IntPtr callbackdata)

In solch einem Fall sollte beim Aufruf von NETAssignEventHandler ein Pointer auf eine entsprechende Variable übergeben werden. Wird nun das Ereignis ausgelöst und die Delphi-Behandlungsroutine aufgerufen, so sollte diese bei Ihrem Abschluss einen Wert in dieser Variable hinterlegt haben. Handelt es sich bei dem Ereignis um ein solches, das keinen Rückgabewert erfordert, wie z.B.

public delegate void EventHandler(object sender, EventArgs e)

muss als pResultStorage-Parameter nil übergeben werden

Rückgabewert: TNETObject
Instanz einer dynamisch erzeugten Ereignisweiterleitungs-Assembly (s. Bemerkungen)

Bemerkungen
  • Die Variablen, auf die in "aStorages" und "pResultStorage" verwiesen wird, sollten, wie im Beispiel gezeigt, Klassenfelder sein, da es sonst zu sonderbaren Problemen und Fehlfunktionen kommt.

  • Die Standardparameter einer aufgerufenen Wrapper-Funktion

    procedure(intArgCount, intReserved:Integer); stdcall;

    haben folgende Bedeutungen: intArgCount: Anzahl der Argumente des Ereignisses; Im Beispiel: 2 intReserved: Reserviert bzw. nicht benötigt; Wert kann ignoriert werden

  • Will man innerhalb einer Ereignisbehandlungsroutine auf TNETObject-Felder, die sich im gleichen Objekt befinden und zur Ereignisparameter-Aufnahme dienen, zugreifen, so muss der Name des Objektes vorangestellt werden (s. Beispiel)

  • Zur Funktionsweise: Um eine Ereignis an Delphi weiterleiten zu können, erzeugt DotNetExec beim Aufruf von NETAssignEventHandler eine dynamische Assembly, welche Funktionen enthält, die die Daten über unverwalteten Code an Delphi weiterreichen.

Beispiel
Dieses Beispiel erzeugt ein einfaches Fenster mit einem Knopf, bei dessen Betätigung die an das Click-Ereignis übergebenen Parameter als Message-Boxen ausgegeben werden.

program EventDemonstration;

uses DotNetExec, ActiveX, Dialogs;

type
  TButtonEventClass = class(TObject)
  published
    procedure OnClick(intArgCount, intReserved:Integer); stdcall;
  public
    FEventParamSender, FEventParamE : TNETObject
  end;

var
    netWindow, netButton : TNETObject;
    aButtonEvents        : TButtonEventClass;

procedure TButtonEventClass.OnClick(intArgCount, intReserved:Integer);
begin
    ShowMessage( 'sender: '#13#10 + NETInvokeMethod(aButtonEvents.FEventParamSender, 'ToString') );
    ShowMessage( 'e: '#13#10 + NETInvokeMethod(aButtonEvents.FEventParamE, 'ToString') );
end;

begin
    CoInitialize(nil);
    aButtonEvents := TButtonEventClass.Create;
    netWindow := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Form');
    netButton := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Button');
    NETSetProperty(netButton, 'Text', 'Test');
    NETInvokeMethod( NETGetProperty(netWindow, 'Controls'), 'Add', [netButton] );
    NETAssignEventHandler(netButton, 'Click', Integer(aButtonEvents.ClassType.MethodAddress('OnClick')),
        [@aButtonEvents.FEventParamSender, @aButtonEvents.FEventParamE], nil);
    NETInvokeMethod(netWindow, 'ShowDialog');
    aButtonEvents.Free;
end.

Siehe auch
  • Delphi .NET-Klassengenerator


NETCreate
Erzeugt eine Instanz einer .NET-Klasse, auf die über ihren Namensraum oder ihre Assemblierungsdatei zugegriffen wird.

function NETCreate (
sNamespace: string,
sAssembly: string,
sClassName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
sNamespace: string
gibt den Namensraum an, in dem sich die zu instanziierende Klasse befindet. Bemerkung: Wenn für sNamespace ein Wert angegeben wird, muss als Parameter sAssembly ein leerer String übergeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sAssembly: string
gibt die Assemblierungsdatei ("Assembly") an, in der die zu instanziierende Klasse enthalten ist. .NET-Assemblies haben typischerweise die Dateiendung DLL, EXE oder MCL. Bemerkung: Wenn für sAssembly ein Wert angegeben wird, muss als Parameter sNamespace ein leerer String übergeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sClassName: string
gibt den Name der zu instanziierenden Klasse an. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

aParameters: array of const = []
enthält als Array alle Aufrufparameter des Konstruktors, der für die Erzeugung der Klasseninstanz aufgerufen werden soll. Anhand der Dateitypen der einzelnen Array-Elemente wird der geeignete Konstruktor ermittelt. Um in Delphi diesem Parameter einen Wert bzw. Werte zuzuweisen, benutzt man einfach eine Konstruktion mit eckigen Klammern, wie beispielsweise ['eins', 2, false].

Rückgabewert: TNETObject
ist bei Erfolg eine Instanz der gewünschten Klasse, auf welche in Form des Datentyps TNETObject zugegriffen werden kann.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieser Beispielcode veranschaulich die Benutzung der NETCreate-Funktion. Die Variable netXmlDoc nimmt eine Instanz der Klasse System.Xml.XmlDocument auf, welche sich in der Assemblierungsdatei "C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll" befindet.

var netXmlDoc : TNETObject;
begin
    netXmlDoc := NETCreate('',
        'C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll',
        'System.Xml.XmlDocument', []);
end;


NETGetArrayElement
Vereinfacht das Auslesen eines Elements aus einem Array. Anstatt Methoden des Array-Objekts einzusetzen, kann abkürzend diese Funktion verwendet werden.

function NETGetArrayElement (
aArray: TNETObject,
aIndices: array of Integer = []
) : TNETObject; overload;

Parameter
aArray: TNETObject

aIndices: array of Integer = []
enthält als Array einen Indexwert für jede Dimension des Arrays, auf das zugegriffen werden soll. Bei eindimensionalen Arrays lautet dieser Parameter also beispielsweise [27], dagegen bei vierdimensionalen etwa so [3, 12, 1, 4].

Rückgabewert: TNETObject
ist der Wert des ausgelesenen Arrayelements. Da der Rückgabewert vom Datentyp TNETObject ist, kann das Array beliebigen Feldtyps sein.

function NETGetArrayElement (
aArray: TNETObject,
intIndex: Integer
) : TNETObject; overload;

Parameter
aArray: TNETObject

intIndex: Integer
verkürzt die Angabe eines eindimensionalen Array-Indexes auf einen einfachen Integer-Wert. Die Arrayangabe [10] kann beispielsweise durch 10 angegeben werden.

Rückgabewert: TNETObject
ist der Wert des ausgelesenen Arrayelements. Da der Rückgabewert vom Datentyp TNETObject ist, kann das Array beliebigen Feldtyps sein.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieses Beispiel liest ein Element aus einem zweidimensionalen Array, welches in der Variable netArray abgelegt ist und gibt dessen Wert per ShowMessage als einfache Message-Box aus.

ShowMessage( NETGetArray(netArray, [1, 4]) );


NETGetCollectionAsStrings
Vereinfacht die Umwandlung eines Array-Rückgabewerts einer Funktion ("Collection") in ein String-Array. Damit können Arrays beliebigen Datentyps, die von Methoden von .NET-Objekten zurückgegeben werden, in Arrays von Zeichenketten konvertiert werden.

function NETGetCollectionAsStrings (
aRefObject: TNETObject,
sCollectionMethod: String,
aParameters: array of const = []
) : TNETObject;

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Methode aufgerufen werden soll, welche das umzuwandelnde Array zurückgibt.

sCollectionMethod: String
gibt den Namen der Methode an, die den zu konvertierenden Array zurückliefert.

aParameters: array of const = []
enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.

Rückgabewert: TNETObject
ist ein Array-Objekt mit Elementen des Typs string.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieses Beispiel gibt in einer Schleife alle Methoden einer Assemblierung, deren Reflection-Repräsentation in der Variable netAssembly gespeichert ist, aus.

var netMethods: TNETObject;
begin
    netMethods := NETGetCollectionAsStrings(netAssembly, 'GetMethods', []);
    for intLoop := 0 to (NETGetProperty(netMethods, 'Length', []) - 1) do
        ShowMessage( NETGetArrayElement(netMethods, intLoop) );
end;


NETGetCollectionElement
Liest ein einzelnes Element aus einem Array aus, welches als Ergebnis eines Funktionsaufrufes zurückgegeben wurde (Collection).

function NETGetCollectionElement (
aRefObject: TNETObject,
sCollectionMethod: String,
intIndex: Integer,
aParameters: Array of const = []
) : TNETObject;

Parameter
aRefObject: TNETObject
gibt das Objekt an, das die Funktion zum Zurückgeben des auszulesenden Arrays enthält.

sCollectionMethod: String
Name der Methode, die das auszulesende Array zurückgibt.

intIndex: Integer
Index des zu ermittelnden Arrayelements

aParameters: Array of const = []
gibt sämtliche Aufrufparameter an, mit denen die Funktion, welche das auszulesende Array zurückgibt, aufgerufen werden soll.

Rückgabewert: TNETObject
Wert des ausgelesenen Array-Elements

Bemerkungen

NETGetCollectionElement ist eine Funktion, die das aufrufen einer nicht-statischen Methode und das darauffolgende Auslesen eines Array-Elements aus dem Rückgabewert verkürzt, indem nur noch eine Funktion aufgerufen werden muss.


NETGetField
Liest ein Feld aus einem Objekt aus.

function NETGetField (
aRefObject: TNETObject,
sFieldName: String
) : TNETObject;

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Feld ausgelesen werden soll.

sFieldName: String
gibt den Namen des auszulesenden Feldes an.

Rückgabewert: TNETObject
Momentaner Wert des Feldes

Bemerkungen
  • Werte von Feldern eines Enumerationstyps werden als Zahlenwert zurückgegeben.

Siehe auch
  • NETSetField


NETGetProperty
Ermittelt den Wert einer Eigenschaft eines .NET-Objekts.

function NETGetProperty (
aRefObject: TNETObject,
sPropertyName: string,
aIndices: array of const = []
) : TNETObject;

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Eigenschaft ausgelesen werden soll.

sPropertyName: string
enthält den Namen der Eigenschaft, die ausgelesen werden soll.

aIndices: array of const = []
enthält Indexparameter, die verwendet werden sollen, um eine parametrisierte Eigenschaft auszulesen. Bemerkung: In den meisten Fällen sind Eigenschaften nicht parametrisiert, so dass für diesen Parameter meist kein Wert zu übergeben ist.

Rückgabewert: TNETObject
ist bei Erfolg der Wert der ausgelesenen Eigenschaft.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieses Beispiel lädt über .NET-Reflection ein Objekt zur Repräsentation der Assemblierung (netAssembly) und zeigt deren Pfad mittels der NETGetProperty-Funktion an.

var netAssembly: TNETObject;
begin
    netAssembly := NETInvokeClassMethod('mscorlib', '', 'Assembly', 'LoadFrom',
    ['C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll']);

    ShowMessage('Location: ' + NETGetProperty(netAssembly, 'Location', []) );
end;

Siehe auch
  • NETSetProperty


NETGetStaticField
Ermittelt den Wert eines statischen Feldes eines Objektes, also eines Klassenfeldes.

function NETGetStaticField (
sNamespace: String,
sAssembly: String,
sClassName: String,
sFieldName: String
) : TNETObject;

Parameter
sNamespace: String
gibt den Namensraum der gewünschten Klasse an. Bemerkung: Wird für sNamespace ein Wert übergeben, muss als Parameter sAssembly eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sAssembly: String
gibt den Namen der Assemblierungsdatei an, welche die gewünschte Klasse beinhaltet. Bemerkung: Wird für sAssembly ein Wert übergeben, muss als Parameter sNamespace eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sClassName: String
gibt den Namen der Klasse an, deren Methode aufgerufen werden soll. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

sFieldName: String
gibt den Namen des statischen Feldes an, dessen Wert ermittelt werden soll.

Rückgabewert: TNETObject
gibt den ermittelten Wert des gewünschten statischen Feldes an.

Bemerkungen

Die Werte von statischen Feldern können nicht verändert werden.

Beispiel
Liest den in der Klasse "System.Byte" gespeicherten maximal zulässigen Wert für eine Variable des Typs "Byte" aus.

NETGetStaticField('mscorlib', '', 'System.Byte', 'MaxValue');

Siehe auch
  • NETGetField


NETInvokeMethod
Ruft eine Methode eines .NET-Objekts mit beliebigen Parametern auf.

function NETInvokeMethod (
aRefObject: TNETObject,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
aRefObject: TNETObject
enthält das Objekt (bzw. die TNETObject-Variable), dessen Methode aufgerufen werden soll.

sMethodName: string
enthält den Namen der Methode, die ausgeführt werden soll.

aParameters: array of const = []
enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.

Rückgabewert: TNETObject
ist bei Erfolg der von der aufgerufenen Methode zurückgelieferte Wert. Der zurückgegebene Wert kann anschließend wie eine gewöhnliche OleVariant-Variable behandelt werden.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieser Beispielcode erzeugt eine XML-Processing-Instructruction für ein XML-Dokument, in dem die Methode CreateProcessingInstruction der .NET-Klasse System.Xml.XmlDocument aufgerufen wird (in diesem Beispiel stellt die Variable netXmlDoc eine Instanz dieser Klasse dar).

var netXmlInstr: TNETObject;
begin
    netXmlInstr := NETInvokeMethod(netXmlDoc, 'CreateProcessingInstruction',
    ['xml', 'version="1.0"']);
end;

Siehe auch
  • NETInvokeStaticMethod


NETInvokeStaticMethod
Ruft eine Methode einer .NET-Klasse (statische Methode) mit beliebigen Parametern auf, wobei die Klasse wahlweise über ihre Assemblierungsdatei oder ihren Namensraum lokalisiert wird.

function NETInvokeStaticMethod (
sNamespace: string,
sAssembly: string,
sClassName: string,
sMethodName: string,
aParameters: array of const = []
) : TNETObject;

Parameter
sNamespace: string
gibt den Namensraum der gewünschten Klasse an. Bemerkung: Wird für sNamespace ein Wert übergeben, muss als Parameter sAssembly eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sAssembly: string
gibt den Namen der Assemblierungsdatei an, welche die gewünschte Klasse beinhaltet. Bemerkung: Wird für sAssembly ein Wert übergeben, muss als Parameter sNamespace eine leere Zeichenkette angegeben werden, da eine Klasse entweder ausschließlich durch ihren Namensraum oder ausschließlich über ihre Assemblierungsdatei lokalisiert wird.

sClassName: string
gibt den Namen der Klasse an, deren Methode aufgerufen werden soll. Bemerkung: Der Klassenname muss vollständig, d.h. mit einschließlich des Namensraumes, angegeben werden (z.B. System.Xml.XmlDocument).

sMethodName: string
enthält den Namen der Methode, die ausgeführt werden soll.

aParameters: array of const = []
enthält als Array alle Parameter, mit denen die bezeichnete Objektmethode aufgerufen werden soll. Handelt es sich um eine überladene Methode, wird anhand der Elementtypen des Arrays die geeignete Überladung ermittelt und ausgeführt.

Rückgabewert: TNETObject
ist bei Erfolg der von der aufgerufenen Methode zurückgelieferte Wert. Der zurückgegebene Wert kann anschließend wie eine gewöhnliche OleVariant-Variable behandelt werden.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
Dieser Beispielcode erzuegt eine Instanz der Klasse System.Reflection.Assembly, indem es die statische Methode "LoadFrom" derselben aufruft. Das zurückgegebene Objekt wird in der Variable netAssembly abgespeichert.

var netAssembly: TNETObject;
begin
    netAssembly := NETInvokeClassMethod('mscorlib', '',
    'Assembly', 'LoadFrom', ['C:\WINDOWS\Microsoft.NET\Framework\v1.0.3328\System.Xml.dll']);
end;

Siehe auch
  • NETInvokeMethod


NETSetEnumProperty
Weist einer Objekteigenschaft vom Typ einer Enumeration (d.h. eines von "System.Enum" abgeleiteten Datentyps) einen Wert zu.

procedure NETSetEnumProperty (
aRefObject: TNETObject,
sPropertyName: String,
sEnumMember: TNETObject
)

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Eigenschaft gesetzt werden soll.

sPropertyName: String
gibt den Name der zu setzenden Eigenschaft an.

sEnumMember: TNETObject
enthält den String-Bezeichner des zu setzenden Enumerationswertes.

Bemerkungen

Zum Ermitteln von Werten von Enumerationseigenschaften kann NETGetProperty() verwendet werden; dieses liefert jedoch die numerische Repräsentation des Enumerationswertes zurück - nicht die String-Form.

Beispiel
Zeigt ein Fenster mit einem Grip in der rechten unteren Ecke an.

var netWMain : TNETObject;
begin
    netWMain := NETCreate('System.Windows.Forms', '', 'System.Windows.Forms.Form');
    NETSetEnumProperty(netWMain, 'SizeGripStyle', 'Show');
    NETInvokeMethod(netWMain, 'ShowDialog');
end;

Siehe auch
  • NETGetProperty


NETSetField
Setzt den Wert eines Objektfeldes.

procedure NETSetField (
aRefObject: TNETObject,
sFieldName: String,
aValue: TNETObject
)

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Feld gesetzt werden soll.

sFieldName: String
gibt den Namen des zu setzenden Feldes an.

aValue: TNETObject
enthält den neu zu setzenden Wert des Feldes.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Siehe auch
  • NETGetField
  • NETSetProperty


NETSetProperty
Setzt eine Eigenschaft eines .NET-Objekts auf einen bestimmten Wert.

procedure NETSetProperty (
aRefObject: TNETObject,
sPropertyName: String,
aValue: TNETObject,
aIndices: array of const = []
)

Parameter
aRefObject: TNETObject
enthält das Objekt, dessen Eigenschaft gesetzt werden soll.

sPropertyName: String
gibt den Namen der Eigenschaft an, deren Wert gestezt werden soll.

aValue: TNETObject
gibt den Wert an, den die bezeichnete Eigenschaft erhalten soll. Da dieser Parameter vom Typ TNETObject ist, kann er ein beliebigen OLE-kompatiblen Datentyp sein.

aIndices: array of const = []
enthält Indexparameter, die verwendet werden sollen, um eine parametrisierte Eigenschaft zu beschreiben. Bemerkung: In den meisten Fällen sind Eigenschaften nicht parametrisiert, so dass für diesen Parameter meist der Wert [] zu übergeben ist.

Bemerkungen

Zu diesem Thema sind momentan keine Bemerkungen vorhanden.

Beispiel
In diesem Beispiel wird der Inhalt eines XML-Dokuments (netXmlDoc) gesetzt.

NETSetProperty(netXmlDoc, 'InnerXml', [],
'Person APerson A');

Siehe auch
  • NETGetProperty


Delphi.NET Hilfsprogramme
Dem Delphi.NET-Paket liegen einige zusätzliche Programme bei, mit deren Hilfe die Entwicklung von .NET-gestützten Delphi-Anwendungen vereinfacht wird. Diese Tools stellen zumeist Codegeneratoren o.ä. dar.

Hilfsprogramme
Delphi .NET-Klassengenerator
Der Delphi-Klassengenerator ist ein Tool, welches Delphi-Wrapperklassen für .NET-Objekte erzeugen kann. Im Wesentlichen werden Klassen- und Methodenrümpfe erzeugt, welche die Aufrufe samt Parameter via DotNetExec ausführen. Diese erzeugten Delphiklassen können komfortabler benutzt werden, als direkte DotNetExec-Aufrufe, u.a. da man auch auf die Syntaxvervollständigung von Delphi zurückgreifen kann. Die erzeugten Klassen sind wahlweise vom Vorfahrenstyp "TObject" oder "TComponent" - bei letzterem können .NET-Ereignisse einfach mittels des Objektinspektors behandelt werden. Um eine Vorstellung von den erzeugten Klassen zu erhalten, kann die entsprechende Dokumentation eingesehen werden. Außerdem ist eine kleine Beispielanwendung ("classgen_smtp") vorhanden, welche Gebrauch von solch einer Wrapperklasse macht.

ASP.NET WebService-Generator
Der ASP.NET WebService-Genenerator ist ein Tool, welches die Methoden und Eigenschaften eines COM-Objekts als ASP.NET-WebService (Endung ".asmx") veröffentlicht. In Verbindung mit einem ASP.NET-fähigen Web-Server, typischerweise den IIS, können Benutzer so über HTTP/SOAP auf die Funktionalität des COM-Objekts zugreifen.

Auf diese Weise bietet das Tool einen Weg, in Delphi WebServices zu entwickeln, welche die Vorteile von ASP.NET (als Offensichtlichstes die automatisch generierte Hilfeseite ;-) nutzen können. Da COM-Objekte nicht an Delphi gebunden sind, können diese selbstverständlich auch in einer anderen Sprache geschrieben werden.

Das Tool vermag zusätzlich, auch Wrapper-WebServices für gewöhnliche .NET-Assemblies zu erzeugen. Dies ist beispielsweise sinnvoll, wenn deren Inhalt nicht explizit als WebService definiert wurde und ein Nachholen dieses nicht ohne Weiteres möglich ist.


ASP.NET WebService-Generator
Der ASP.NET WebService-Genenerator ist ein Tool, welches die Methoden und Eigenschaften eines COM-Objekts als ASP.NET-WebService (Endung ".asmx") veröffentlicht. In Verbindung mit einem ASP.NET-fähigen Web-Server, typischerweise den IIS, können Benutzer so über HTTP/SOAP auf die Funktionalität des COM-Objekts zugreifen.

Auf diese Weise bietet das Tool einen Weg, in Delphi WebServices zu entwickeln, welche die Vorteile von ASP.NET (als Offensichtlichstes die automatisch generierte Hilfeseite ;-) nutzen können. Da COM-Objekte nicht an Delphi gebunden sind, können diese selbstverständlich auch in einer anderen Sprache geschrieben werden.

Das Tool vermag zusätzlich, auch Wrapper-WebServices für gewöhnliche .NET-Assemblies zu erzeugen. Dies ist beispielsweise sinnvoll, wenn deren Inhalt nicht explizit als WebService definiert wurde und ein Nachholen dieses nicht ohne Weiteres möglich ist.

Kapitel


Delphi .NET-Klassengenerator
Der Delphi-Klassengenerator ist ein Tool, welches Delphi-Wrapperklassen für .NET-Objekte erzeugen kann. Im Wesentlichen werden Klassen- und Methodenrümpfe erzeugt, welche die Aufrufe samt Parameter via DotNetExec ausführen. Diese erzeugten Delphiklassen können komfortabler benutzt werden, als direkte DotNetExec-Aufrufe, u.a. da man auch auf die Syntaxvervollständigung von Delphi zurückgreifen kann. Die erzeugten Klassen sind wahlweise vom Vorfahrenstyp "TObject" oder "TComponent" - bei letzterem können .NET-Ereignisse einfach mittels des Objektinspektors behandelt werden. Um eine Vorstellung von den erzeugten Klassen zu erhalten, kann die entsprechende Dokumentation eingesehen werden. Außerdem ist eine kleine Beispielanwendung ("classgen_smtp") vorhanden, welche Gebrauch von solch einer Wrapperklasse macht.

Kapitel