Native Types

PDF for offline use:
Related Articles:

Let us know how you feel about this.


0/250
Thanks for the feedback!

last updated: 2016-01

Overview

At the core of the difference, both Mac and iOS APIs use an architecture-specific data types that are always 32 bit on 32 bit platforms and 64 bit on 64 bit platforms.

For example, Objective-C maps the NSInteger data type to int32_t on 32 bit systems and to int64_t on 64 bit systems.

To match this behavior, on our unified API, we are replacing the previous uses of int (which in .NET is defined as always being System.Int32) to a new data type: System.nint. You can think of the "n" as meaning "native", so the native integer type of the platform.

With these new data types, the same source code is compiled for 32 bits, 32 bit and 64 bits or 64 bits, depending on your compilation flags.

New Data Types

The following table shows the changes in our data types to match this new 32/64 bit world:

Native Type 32-bit backing type 64-bit backing type
System.nint System.Int32 (int) System.Int64 (long)
System.nuint System.UInt32 (uint) System.UInt64 (ulong)
System.nfloat System.Single (float) System.Double (double)

We chose those names to allow your C# code to look more or less the same way that it would look today.

Implicit and Explicit Conversions

The design of the new data types is intended to allow a single C# source file to naturally use 32 or 64 bit storage depending on the host platorm and the compilation settings.

This required us to design a set of implicit and explicit conversions to and from the platform-specific data types to the .NET integral and floating point data types.

Implicit conversions operators are provided when there is no possibility for data loss (32 bit values being stored on a 64 bit space).

Explicit conversions operators are provided when there is a potential for data loss (64 bit value is being stored on a 32 or potentially 32 storage location).

int, uint and float are all implicitly convertible to nint, nuint and nfloat as 32 bits will always fit in 32 or 64 bits.

nint, nuint and nfloat are all implicitly convertible to long, ulong and double as 32 or 64 bit values will always fit in 64 bit storage.

You must use explicit conversions from nint, nuint and nfloat into int, uint and float since the native types might hold 64 bits of storage.

You must use explicit conversions from long, ulong and double into nint, nuint and nfloat since the native types might only be able to hold 32 bits of storage.

CoreGraphics Types

The point, size and rectangle data types that are used with CoreGraphics use 32 or 64 bits depending on the device they are running on. When we originally bound the iOS and Mac APIs we used existing data structures that happened to match the sizes of the host platform (The data types in System.Drawing).

When moving to Unified, you will need to replace instances of System.Drawing with their CoreGraphics counterparts as shown in the following table:

Old Type in System.Drawing New Data Type CoreGraphics Description
RectangleF CGRect Holds floating point rectangle information.
SizeF CGSize Holds floating point size information (width, height)
PointF CGPoint Holds a floating point, point information (X, Y)

The old data types used floats to store the elements of the data structures, while the new one uses System.nfloat.

Xamarin Workbook

If it's not already installed, install the Xamarin Workbooks app first. The workbook file should download automatically, but if it doesn't, just click to start the workbook download manually.