C# Bindings
The C# Bindings layer provides seamless access to the HOOPS Exchange C API, ensuring developers can use the API effectively in a C# environment.
This Direct API is defined within the Exchange.Direct namespace and its definitions are located in the following files:
- Structures
- Direct Memory Layout Compatibility;
- Call Bindings
- 1:1 Mapping to the C API;
- Constant Values and Enumerators
- Predefined values for communicating with HOOPS Exchange API.
- Integral Numeric Types
- Base numeric types corresponding to C API Type Definitions.
Structures
Bindings to the C structures are provided using C# structs.
All C# structures have the same name as their C counterparts and are located inside the Direct namespace.
All fields of a structure are initialized with the default values of their respective types.
Since HOOPS Exchange requires specific values, use API.Initialize to prepare the structure:
A3DRWParamsExportXMLData export_params;
API.Initialize(out export_params);
export_params.m_bExportMetadata = true;
export_params.m_bExportTransformations = true;
export_params.m_bExportColorMaterial = true;
export_params.m_bExportProductInformationByFormat = false;
A3DRWParamsExportXMLData export_params = A3D_MAKE_DATA(A3DRWParamsExportXMLData);
export_params.m_bExportMetadata = A3D_TRUE;
export_params.m_bExportTransformations = A3D_TRUE;
export_params.m_bExportColorMaterial = A3D_TRUE;
export_params.m_bExportProductInformationByFormat = A3D_FALSE;
To see how numeric types are mapped between C and C#, refer to Integral Numeric Types. See also C# Array Wrapper about manipulating C-style arrays.
The C# structures ensure a direct mapping to their C equivalent. Thus, all structures are defined with LayoutKind.Sequential and CharSet.Ansi layout attributes. This allows a reference to a C# structure instance to be interpreted as a pointer to its C equivalent.
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public unsafe struct A3DRWParamsExportXMLData
{
// ...
}
Note that the bindings structures directly requires an unsafe context.
Call Bindings
Like structures, all functions from the C API are available in C# via the Direct.API namespace, with the exception of experimental functions, which follow a separate opt-in convention (see Extending HOOPS Exchange).
The following example shows how to call the A3DAsmModelFileExportToXMLFile function:
public static A3DStatus ExportToXml(IntPtr modelFile, string outputFile)
{
A3DRWParamsExportXMLData export_params;
API.Initialize(out export_params);
export_params.m_bExportMetadata = true;
export_params.m_bExportTransformations = true;
export_params.m_bExportColorMaterial = true;
export_params.m_bExportProductInformationByFormat = false;
uint mapSize = 0;
IntPtr mapXmlIds = IntPtr.Zero;
IntPtr mapPo = IntPtr.Zero;
return API.A3DAsmModelFileExportToXMLFile(
modelFile,
ref export_params,
outputFile,
out mapSize,
out mapXmlIds,
out mapPo
);
}
A3DStatus export_to_xml(A3DAsmModelFile* model_file, A3DUTF8Char* output_file)
{
A3DRWParamsExportXMLData export_params;
A3D_INITALIZE_DATA(A3DRWParamsExportXMLData, export_params);
export_params.m_bExportMetadata = A3D_TRUE;
export_params.m_bExportTransformations = A3D_TRUE;
export_params.m_bExportColorMaterial = A3D_TRUE;
export_params.m_bExportProductInformationByFormat = A3D_FALSE;
A3DUns32 map_size = 0;
unsigned int map_xml_ids = 0;
A3DEntity** map_po = 0;
return API.A3DAsmModelFileExportToXMLFile(
model_file,
&export_params,
output_file,
&map_size,
&map_xml_ids,
&map_po
);
}
- Parameter types are translated to C# types (see Integral Numeric Types).
- The C#
stringtype can be passed directly as a function parameter, as it is marshaled using UnmanagedType.LPUTF8Str. - All entities handle types, such as
A3DAsmModelFile*, are passed asIntPtr. - Data types, such as
A3DRWParamsExportXMLDataare passed usingref. This allows the C binaries to interpret them as C structure pointers. - Write parameters are passed to the functions using
outkeyword.
All C# functions are declared as function delegates that are assigned upon loading the library.
These delegate functions are located in the all-static API class under the Direct namespace:
public class API
{
// ...
public delegate A3DStatus PFA3DAsmModelFileExportToXMLFile(
IntPtr pA3DAsmModelFile,
ref A3DRWParamsExportXMLData pParamsExportData,
[MarshalAs(UnmanagedType.LPUTF8Str)]
string pcXMLFileName,
out uint uMapSize,
out IntPtr puMapXmlIds,
out IntPtr ppMapProductOccurrences
);
public static PFA3DAsmModelFileExportToXMLFile A3DAsmModelFileExportToXMLFile = null;
}
Experimental functions, such as A3DAsmModelFileComputeTessellation2(), are the exception: their delegates are declared in their own opt-in class instead of API, and must be bound explicitly by the caller rather than being assigned automatically when the library loads.
See Extending HOOPS Exchange for more information.
Constant Values
Constant values exposed by the HOOPS Exchange C API are available in C# through the Direct.Constant static class.
This includes constants passed as structure fields, function parameters or returns from function calls:
A3DHLRCurveData curve_data;
API.Initialize(out curve_data);
curve_data.m_cType = Constants.A3D_HLR_TYPE_SECTION;
A3DHLRCurveData curve_data = A3D_MAKE_DATA(A3DHLRCurveData);
curve_data.m_cType = A3D_HLR_TYPE_SECTION;
Enumerators
All enumerator types are available under the Direct namespace and can be used the same way as in the C API:
A3DRWParamsExportJTData export_data = A3D_MAKE_DATA(A3DRWParamsExportJTData);
export_data.m_eJTVersion = kA3D_JT95;
export_data.m_eWriteGeomTessMode = kA3DWriteGeomAndTess;
A3DRWParamsExportJTData export_data;
API.Initialize(out export_data);
export_data.m_eJTVersion = A3DEJTVersion.kA3D_JT95;
export_data.m_eWriteGeomTessMode = A3DEWriteGeomTessMode.kA3DWriteGeomAndTess;
Integral Numeric Types
HOOPS Exchange C API typedefs map to standard integral numeric types in C#.
The table below provides the mapping between these types:
| HE C Types | C# | Notes |
|---|---|---|
A3DBool |
bool |
Can be either true or false |
A3DPtr |
IntPtr |
Integer large enough to hold a pointer |
A3DVoid |
void |
|
A3DInt8 |
byte |
Unsigned 8-bit integer |
A3DUns8 |
||
A3DInt16 |
short |
Signed 16-bit integer |
A3DUint16 |
ushort |
Unsigned 16-bit integer |
A3DInt32 |
int |
Signed 32-bit integer |
A3DUns32 |
uint |
Unsigned 32-bit integer |
For more information about manipulating C-style arrays using the C# bindings API, see C# Array Wrapper.
Conclusion
This section introduced the core C# Bindings layer of the HOOPS Exchange API, providing a direct mapping to the C API. With access to functions, structures, enumerations, and constants, this layer forms the foundation for CAD data manipulation in C#.
By understanding how to use this layer—such as structure initialization, function invocation, and type mappings—you can confidently work with the low-level elements of HOOPS Exchange. This knowledge is essential for building robust CAD applications and serves as a stepping stone to exploring higher-level abstractions provided in subsequent sections, like the Library Loader and Wrapper Classes.