Want to use SmartPointers in Delphi? Use the Spring4D one: it is unit tested and optimised

A while ago, there was a nice discussion on smart pointers at [WayBack] Smart Pointers – Generics vrs non-generic implementastion – RTL and Delphi Object Pascal – Delphi-PRAXiS [en].

Conclusion from that:

• many people think that reference counted interfaces are the same as Smart Pointers
  (basically Smart Pointers are the next level and of course they are based on reference counting)
• there are a lot of Smart Pointer implementations, but few have a test suite, nor are optimised , nor easy to use
• The combo Shared/IShared<T>/TShared<T> from Spring4D has all of the above advantages
• in order to optmise Smart Pointer implementations, you really have to well know the effects of modern Delphi language constructs on the compiler in various target platforms

The discussion mentioned above includes both feature and speed comparisons.

I was a bit amazed that at CodeRage 2018, Marco Cantu introduced yet another smart pointer implementation: one worse than existing implementations, and one with only basic demonstration code, leaving out a test suite.

There have many posts on my blog about smart pointers (see the list below), but Spring4D smart pointer implementation has been around for such a long time that any well respected Delphi developer by now should use them. The source is at  Shared/IShared (search for {$REGION 'Shared smart pointer'} at the current repository).

This list below on my Smart Pointer related blog posts might not be fully complete, but at least mentions that by now you should be using Spring4D.

• Delphi: using IInterface to restore cursor at end of mehod (prelude to a memento that executes any code at end of method). which mentions Smart Pointers as the next level of such IInterface usage.
• Some great reads from Barry Kelly, which lists a series of great posts that document compiler internals, and explains why they cannot be changed because so much code relies on them
• If you were using Managed / IManaged in Spring4D, be aware they got renamed to Shared / IShared
• How and when are variables referenced in Delphi’s anonymous methods captured? – Stack Overflow
• Spring4D – Shared, Weak references
• Smart Pointers code that compiles in FPC and Delphi

Some comments on the CodeRage 2018 demos

The code is at [WayBack] github.com/marcocantu/DelphiSessions/tree/master/DelphiLanguageCodeRage2018

First a few generic comments:

• With the exception of a few places, none of the demos really explain what they are after, nor indicate where the video or slides can be found. This is not OK for people after the conference bumping into them, and having to find their way back to the original meaning.
• There are duplicated identical files in some of the directories. I think a seasoned Delphi evangelist should should emphasise on good naming and structure next to the actual topic they are after. Fresh Delphi users see these demos and – through their subconscious mind – think this is the organisation to go with. This leads to confirmation bias, which makes it harder to properly educate later on.
• All of the demos use a VCL application plus form to show a language concept. That feels like a lot of overhead, and a missed chance to combine good Delphi language language use with for instance unit testing with DUnit or DUnitX, or even to condense each demo in a simple console application.
• Having some random TForm## class names looks very sloppy, giving the wrong signal to developers.

Some comments per demo:

1. 01_GenericMethod: GenericForm.pas
   • I like the Result := GetTypeName (TypeInfo (T)); bit as it shows what the compiler can actually get from a generic type.
   • The demo would be much simpler when TGenericFunction was a record type instead of a class type.
   • No instance is needed: this could work with class methods (for the class type) or static class methods (for the record type) just as well.
   • The demo should emphasise that generic methods are still not possible with global methods that are outside of a type.
   • The demo should have shown more on the compiler type inference is shown. That would have given valuable insight on where the inference would have worked and where it would have failed.
   • For the “these are all wrong”, the compiler error should have been added as comment to the code so people can understand the errors they might run into when using generic methods.
2. 02_SmartPointers:
   • SmartPointerClass.pas
     • Does not explain why it works
     • Given that there are no unit tests, and only a few test cases, you have no idea when it works or fails
   • SmartPointers_MainForm.pas
     • The “implicit create” demo does not indicate if procedure TSmartPointer<T>.Create; or constructor TSmartPointer<T>.Create(AValue: T); is called implicitly.
     • The demo parts should have shown which parts of SmartPointerClass.pas are being demoed. It looks like only shows creation and assignment to the TSmartPointer<T> based variable and how to obtain the content using the Value property, but actually class operator TSmartPointer<T>.Implicit(smart: TSmartPointer<T>): T; is shown as well.
3. 03_WeakIntfRef: WeakIntfRef_Form.pas
   • Having expanded Intf and Ref to Interface and Reference would have made the aim much clearer.
   • The demo name suggests  WeakIntfRefAttribute or WeakRefAttribute , but the attribute is in fact WeakAttribute which got [Archive.is] template documentation in XE3, but never an update on the real use, apart from a try to “document through a demo” (see below).
   • Only one aspect of WeakAttribute is shown, which fails without WeakAttribute as well: two objects having interface references to each other in the same scope will fail either way.
   • Contrary to the name, the demo also shows how to use UnsafeAttribute which got a [Archive.is] template documentation in XE3, which [Archive.is] got slightly improved in Delphi XE4, only indicating the use of functions results, but nothing added ever since, nor explaining why/how it is considered dangerous.
     

     To set the unsafe attribute on a function result, use this syntax:

     [Result: Unsafe] function ReturnUnsafe: TObject;
     

     Warning: UnsafeAttribute should be only used outside the System unit. It is considered dangerous and its use is not recommended.

   •  Way better documentationWeakRefAttribute and UnsafeAttribute of is at[WayBack] Owl’s perspective: DelphiのRTLで定義済の属性 with a great Google translate below.
4. 04_InlineVars: InlineVarsForm.pas
   • I like most demos
   • The inference demos should describe which type is actually inferred (for instance by showing the TypeInfo on the variable)
   • Demo Test8 does not explain if the const construct is permitted or not.
5. 05_InlineVarSpeed: InlineWeird.pas
   • This demo should actually explain the measurement differences.
   • In addition, this could have been way shorter by refactoring out all but the loop and the actual method calls into common code.
6. 06_MoreTypeInference: mtiForm.pas
   • Since it is more advanced inference, the inferred types should be shown, especially since procedure TForm15.Button1Click(Sender: TObject); is clearly wrong indicating // dynamic array of objects, but the code demonstrating the inferred type  is confined to at least array of TComponent.
   • I have no idea why procedure TForm15.Button2Click(Sender: TObject); is in this demo: it has nothing to do with type inference.
   • Most demo’s show correct lifetime management using a try … finally construct, but procedure TForm15.Button2Click(Sender: TObject); does not. Odd.
7. 07_BlockScope: BlockScope_Form.pas
   • This demo has the same SmartPointerClass.pas unit as 02_SmartPointers. Sloppy.
   • The demo shows that inline var declarations can be inside a begin … end block, but does not show if implicit finalization of Smart Pointers is indeed local to that block, or extended to the method.
     So basically this does not show anything more than procedure Test5; // scope limited to local block in InlineVarsForm.pas.
     Luckily the thread mentioned above has a great example that does show, which I have quoted further below.
8. 07_MissingAttribute:
   • Should have bene numbered 08 (small thing, but – like the duplicate files – it gives fresh developers the idea sloppiness is ok)
   • MissingAttribute_Form.pas:
     • I like that this emphasises {$WARN UNKNOWN_CUSTOM_ATTRIBUTE ERROR}, as it got introduced in Delphi 10.3 Rio, but is not documented (see [Archive.is] site:docwiki.embarcadero.com “UNKNOWN_CUSTOM_ATTRIBUTE” – Google Search and [WayBack] Search results for “UNKNOWN_CUSTOM_ATTRIBUTE” – RAD Studio API Documentation, [Archive.is] site:docwiki.embarcadero.com W1074 – Google Search, [WayBack] Search results for “W1074” – RAD Studio)
       It means you do not need this Delphi tip of the day: {$WARN UNSUPPORTED_CONSTRUCT ERROR} for W1025 any more.
       Note that the documentation still indicates that W1025 has been documented since at least Delphi 2007 ([WayBack] x1025: Unsupported language feature: ‘%s’) as a C++ header translation issue, and still is ([WayBack] X1025 Unsupported language feature: ‘%s’ (Delphi) – RAD Studio).
       

Note I have not watched the above session, as the Embarcadero Academy Terms of Use (which are required to view most CodeRage 2018 sessions) disallow me to use any of that information on my blog: [WayBack/Archive.is] Terms of Use | Embarcadero Academy quote

Use License

1. Permission is granted to temporarily download one copy of any downloadable materials on the School’s website for personal, non-commercial transitory viewing only. This is the grant of a license, not a transfer of title, and under this license you may not:
   1. 1. modify or copy the materials;
      2. use the materials for any commercial purpose, or for any public display (commercial or non-commercial);
      3. attempt to decompile or reverse engineer any software contained on the School’s web site;
      4. remove any copyright or other proprietary notations from the materials; or
      5. transfer the materials to another person or ‘mirror’ the materials on any other server.
2. This license shall automatically terminate if you violate any of these restrictions and may be terminated by Company at any time. Upon terminating your viewing of these materials or upon the termination of this license, you must destroy any downloaded materials in your possession whether in electronic or printed format.

Document through employee blogs outside your company

I think it is not a wise decision to document some new features only outside your own company domain, but on blogs of employees. That is not where your clients search first, so you should get that kind of documentation inside your domain as soon as possible after it gets published outside your domain.

So I like that it is there at all, but dislike it is not on the docwiki: [WayBack] New Delphi 10.3 Warning “Unknown Custom Attribute” (W1074).

Document through demo

Since Delphi XE6, [Archive.is] System.WeakAttribute – RAD Studio API Documentation however points to [Archive.is] RTL.AttributesAndRTTI Sample – RAD Studio Code Examples which leads to [WayBack] RAD Studio Demo Code / Code / [r2029] /branches/RadStudio_XE6/Object Pascal/RTL/AttributesAndRTTI.

As of Delphi RIO [WayBack] System.WeakAttribute – RAD Studio API Documentation, the link in [WayBack] RTL.AttributesAndRTTI Sample – RAD Studio Code Examples is broken ([WayBack] Page not found – SourceForge.net), as nobody bothered to create a new [WayBack] radstudiodemos branch on SourceForge, but the Delphi version rename hobbits did rename everything on the page from Tokyo to Rio.

This means the demo is now inside [WayBack] RADStudio10.3Demos/Object Pascal/RTL/AttributesAndRTTI/rtti_browser at master · Embarcadero/RADStudio10.3Demos · GitHub, which has no Rio in the URL name, so if the docwiki is fixed, the next mass search/replace there will miss it again.

Anyway: 10.3 Rio demos are at [WayBack] GitHub – Embarcadero/RADStudio10.3Demos: Delphi and C++Builder Demos for Embarcadero RAD Studio version 10.3 Rio

via: “{$WARN UNKNOWN_CUSTOM_ATTRIBUTE ERROR}” – Google Search

Block scope actually frees Smart Pointers at the end of the block

type
  TFoo = class(TInterfacedObject)
  public
    constructor Create;
    destructor Destroy; override;
  end;

constructor TFoo.Create;
begin
  inherited Create;
  Writeln('Foo Create');
end;

destructor TFoo.Destroy;
begin
  Writeln('Foo Destroy');
  inherited;
end;

procedure Test;
begin
  Writeln('procedure begin');
  Writeln('before inner scope begin');
  begin
    Writeln('after inner scope begin');
    var ref: IInterface := TFoo.Create;
    Writeln('before inner scope end');
  end;
  Writeln('after inner scope end');
  Writeln('something');
  Writeln('procedure end');
end;

Results with following output

 

procedure begin
before inner scope begin
after inner scope begin
Foo Create
before inner scope end
Foo Destroy
after inner scope end
something
procedure end

[WayBack] Owl’s perspective: DelphiのRTLで定義済の属性

Google translated is [Archive.is] Delphi RTL defined attributes:

September 3, 2014

Delphi RTL defined attributes

Although it is anattribute function included in the new RTTI added in Delphi 2010, although there are differences depending on the version of Delphi, there are some predefined attributes in RTL.However, there is no proper description in these help for these predefined attributes. I tried to find out that ( I have not examined XE 6 / XE 7 because it is not available, but I think that there is not much difference between existing ones and XE 5I confirmed about Delphi XE 6 / XE 7 / XE 8/10 Seattle / 10.1 Berlin).

• • System unit

    TCustomAttribute

    [2010..10.2 Tokyo] When newly defining the root class attribute of the custom attribute, derive it from TCustomAttribute

    WeakAttribute [Weak]

    [XE 3 … 10.2 Tokyo] Indicates “weak” reference to prevent situations where ARC such as circular reference can not destroy objects
    10 Seattle and earlier NEXTGEN compiler only Note: Compiler attributes – RAD Studio
    Reference: weak reference (automatic reference count with Delphi mobile compiler)

    UnsafeAttribute [Unsafe]

    [XE 3 … 10.2 Tokyo] Prevent discard by ARC in situations where the reference count is 0, such as when generating objects
    10 Seattle and earlier NEXTGEN compiler only Note: Compiler attributes – RAD Studio
    Note: Unsafe attribute (automatic reference count in Delphi mobile compiler)
    Reference: Delphi language for mobile development (white paper)

    RefAttribute [Ref]

    [XE 3 … 10.2 Tokyo] Forcibly pass constant parameters by reference According to help RefAttribute is a new feature of XE 4 , but actually it can also be used with XE 3 Reference: Compiler attribute – RAD Studio
    Reference: Constant parameter (parameter (Delphi))

    VolatileAttribute [Volatile]

    [XE4..10.2 Tokyo] Do not optimize for fields that may be rewritten by threads, such as copying values ​​to registers or other temporary memory areas when generating code
    10 Seattle and earlier NEXTGEN compiler only Note: Compiler attributes – RAD Studio
    Note: New attributes of the Delphi compiler (new functions in Delphi XE 4 and C ++ Builder XE 4)
    Reference: volatile (compiler attribute)

    StoredAttribute [Stored]

    [XE 7 .. 10.2 Tokyo] See System.Classes.StoredAttribute

    HPPGENAttribute [HPPGEN]

    [XE8..10.2 Tokyo] Information used when generating hpp file for C ++ Builder, but it is unknown in details

    HFAAttribute [HFA]

    [XE 8 .. 10.2 Tokyo] It seems there is information on pageId = 86770118 (what it is) but details unknown ( For internal use only. with comment)Override RTTI HFA information generated for record type / array type for ARM 64 platform

    AlignAttribute [Align]

    [10 Seattle … 10.2 Tokyo] It seems to specify the alignment of objects in memory, but with For internal use only.

• • System.Classes unit

    ComponentPlatformsAttribute [ComponentPlatforms(<params>)]

    [XE2..10.2 Tokyo] To specify the platform (Word value) that specifies the platform on which the component operates, specify the logical sum of the following constants defined in System.Classes

    • pidWin32 [XE2..10.2 Tokyo]
    • pidWin64 [XE2..10.2 Tokyo]
    • pidOSX32 [XE2..10.2 Tokyo]
    • pidiOSSimulator [XE3..10.2 Tokyo]
    • pidAndroid [XE3..10.2 Tokyo]
    • pidLinux32 [XE3..10.2 Tokyo]
    • pidiOSDevice32 [XE8..10.2 Tokyo], pidiOSDevice [XE3..10.2 Tokyo]
    • pidLinux64 [XE8..10.2 Tokyo]
    • pidWinNX32 [XE3..10.2 Tokyo]
    • pidWinIoT32 [XE8..10.2 Tokyo] (“Embedded IoT (Internet of Things) Windows w / Intel Galileo”)
    • pidiOSDevice64 [XE8..10.2 Tokyo]
    • pidWinARM [10 Seattle..10.2 Tokyo]
    • pidOSX64 [10.1 Berlin..10.2 Tokyo], pidOSXNX64 [10.1 Berlin..10.2 Tokyo]
    • pidLinux32Arm [10.1 Berlin..10.2 Tokyo]
    • pidLinux64Arm [10.1 Berlin..10.2 Tokyo]
    • pidAndroid64 [10.1 Berlin..10.2 Tokyo]

    TDefaultAttributeBase

    [XE 3 .. 10.2 Tokyo] DefaultAttribute / NoDefaultAttribute inherited from

    DefaultAttribute [Default(<param>)]

    [XE 3 … 10.2 Tokyo] Property storage designator Parameters equivalent to default have default values ​​(Boolean type, AnsiChar type, Char type, Integer type, Cardinal type, Int64 type, UInt 64 type, String type, Extended type One of them)

    NoDefaultAttribute [NoDefault]

    [XE3..10.2 Tokyo] Property storage designator Equivalent designation for nodefault

    StoredAttribute [Stored(<param>)]

    [XE3..XE7] Property storage Specify the name of a boolean value (False | True) or a storage handler (a method that returns a Boolean value without a Boolean property or parameter) for the specified parameter equivalent to stored (Moving to System unit after XE 8)

    ObservableMemberAttribute [ObservableMember(<param>)]

    [XE3..10.2 Tokyo] In LiveBinding compliant component, specify the member name used by the LiveBinding component to generate expressions as parameters

• • System.JSON.Serializers Unit

    JsonConverterAttribute [JsonConverter<param>]

    [10.2 Tokyo] Specifying the converter to be used with TJsonSerializer

    JsonIgnoreAttribute [JsonIgnore]

    [10.2 Tokyo] Specifying members to ignore with TJsonSerializer

    JsonNameAttribute [JsonName<param>]

    [10.2 Tokyo] Explicitly specify key names with TJsonSerializer

    JsonInAttribute [JsonIn]

    [10.2 Tokyo] When TJsonMemberSerialization.In is specified as the parameter of the JsonSerialize attribute, it is targeted for serialization / deserialization by TJsonSerializer

    JsonObjectHandlingAttribute [JsonObjectHandling<param>]

    [10.2 Tokyo] Specify handling of members of class type when deserializing with TJsonSerializer Specify one of the following values ​​from the enumeration type TJsonObjectHandling

    • Auto [10.2 Tokyo]
    • Reuse [10.2 Tokyo]
    • Replace [10.2 Tokyo]

    JsonObjectOwnership [JsonObjectOwnership<param>]

    [10.2 Tokyo] Specify handling of the original instance when class type member is generated when deserializing with TJsonSerializer Specify one of the following values ​​from the enumeration type TJsonObjectOwnership

    • Auto [10.2 Tokyo]
    • Owned [10.2 Tokyo]
    • NotOwned [10.2 Tokyo]

    JsonSerializeAttribute [JsonSerialize<param>]

    [10.2 Tokyo] Specify one of the following values ​​from the enumeration type TJsonMemberSerialization as the specified parameter of the member to be serialized / deserialized by TJsonSerializer

    • Fields [10.2 Tokyo]
    • Public [10.2 Tokyo]
    • In [10.2 Tokyo]

• • Data.DBXJSONReflect unit (replaced by REST.JsonReflect unit in XE 5)

    JsonReflect [JsonReflect(<params>)]

    [XE..10.2 Tokyo] Parameters customizing the behavior when marshalling / unmarshalling objects in JSON format with TJSONMarshal / TJSONUnMarshal include the converter type, reverter type, interceptor type, population customizer type, marshaling Specify whether to automatically release generated intermediate objects

    JSONBooleanAttribute

    [XE..10.2 Tokyo] JSONMarshalled / JSONOwned to inherit from

    JSONMarshalled [JSONMarshalled(<param>)]

    [XE..10.2 Tokyo] The parameter (False | True) specifies whether the field and type are subject to marshalling / unmarshalling

    JSONOwned [JSONOwned(<param>)]

    The parameter (False | True) specifies whether [XE..10.2 Tokyo] field is released when unmarshalling

• • Datasnap.DSAuth unit

    TRoleAuth [TRoleAuth(<params>)]

    [XE..10.2 Tokyo] When authenticating with DataSnap, specify a list of authorized roles and a list of denied roles for parameters specifying roles that allow / deny access to server method classes and server methods Note: Roles (authentication and authorization)

• • REST.Json.Types Unit

    JSONBooleanAttribute [JSONBoolean]

    [XE 6 .. 10.2 Tokyo] See Data.DBXJSONReflect.JSONBooleanAttribute

    JSONMarshalledAttribute [JSONMarshalled]

    [XE 6 .. 10.2 Tokyo] See Data.DBXJSONReflect.JSONMarshalled

    JSONOwnedAttribute [JSONOwned]

    [XE 6 .. 10.2 Tokyo] See Data.DBXJSONReflect.JSONOwned

    JSONNameAttribute [JSONName]

    [XE 6 .. 10.2 Tokyo]

• • REST.JsonReflect unit

    JsonReflect(XE5)/JsonReflectAttribute(XE6以降) [JsonReflect]

    [XE5..10.2 Tokyo] Refer to Data.DBXJSONReflect.JsonReflect (the class name is changed in XE 6)

    JSONBooleanAttribute [JSONBoolean]

    [XE5] Refer to Data.DBXJSONReflect.JSONBooleanAttribute (Moved to REST.Json.Types unit after XE6)

    JSONMarshalled [JSONMarshalled]

    [XE5] Refer to Data.DBXJSONReflect.JSONMarshalled (Moved to REST.Json.Types unit after XE 6)

    JSONOwned [JSONOwned]

    [XE5] Refer to Data.DBXJSONReflect.JSONOwned (move to REST.Json.Types unit after XE 6)

• • EMS.ResourceType unit

    ResourceSuffixAttribute [ResourceSuffix]

    [XE 7 … 10.2 Tokyo] Specify the URL suffix with EMS Reference: EMS resource overview – RAD Studio

    ResourceNameAttribute [ResourceName]

    [XE 7 … 10.2 Tokyo] Specifying Resource Names with EMS Reference: Overview of EMS Resources – RAD Studio

    EndpointNameAttribute [EndpointName]

    [XE 7 … 10.2 Tokyo] Specify endpoint method name in EMS Reference: EMS resource overview – RAD Studio

    TResourceCustomAttribute [TResourceCustom]

    [10.1 Berlin..10.2 Tokyo] EndPointRequestSummaryAttribute / EndPointRequestParameterAttribute / EndPointResponseDetailsAttribute / EndPointObjectsYAMLDefinitionsAttribute / EndPointObjectsJSONDefinitionsAttribute / AllowAnonymousTenantAttribute

    EndPointRequestSummaryAttribute [EndPointRequestSummary]

    [10.1 Berlin..10.2 Tokyo] Generate method description on API document with EMS Note: Custom API document – RAD Studio

    EndPointRequestParameterAttribute [EndPointRequestParameter]

    [10.1 Berlin..10.2 Tokyo] Generate a description of the parameters used in the request on the API document on the EMS Reference: Custom API document – RAD Studio

    EndPointResponseDetailsAttribute [EndPointResponseDetails]

    [10.1 Berlin..10.2 Tokyo] Generate explanation of request response on API document with EMS Reference: Custom API document – RAD Studio

    EndPointObjectsYAMLDefinitionsAttribute [EndPointObjectsYAMLDefinitions]

    [10.1 Berlin..10.2 Tokyo] Generate YAML version object definition on API document with EMS Note: Custom API document – RAD Studio

    EndPointObjectsJSONDefinitionsAttribute [EndPointObjectsJSONDefinitions]

    [10.1 Berlin..10.2 Tokyo] Generate JSON version object definition on API document with EMS Reference: Custom API document – RAD Studio

    AllowAnonymousTenantAttribute [AllowAnonymousTenant]

    [10.2 Tokyo] Skip Tenant Validation Procedure with EMS Reference: Sample RAD Server Multi-Tenant Application – RAD Studio

• • Macapi.ObjectiveC unit

    MethodNameAttribute [MethodName]

    [XE4..10.2 Tokyo] For the Objective-C method defined in Delphi, specify the original method name on Objective-C

• • Androidapi.JNIBridge unit

    JavaSignatureAttribute [JavaSignature]

    [XE5..10.2 Tokyo] Specify the original class name on Android for Android (JNI) class (interface) defined in Delphi

• System.Win.WinRT Unit

  WinRTClassNameAttribute [WinRTClassName]

  [10 Seattle … 10.2 Tokyo] Specify the original class name on WinRT for the interface of WinRT API defined in Delphi

Differences between versions of Delphi:

• In Delphi 2010 there are no predefined attributes used in the system.
• Delphi XE defines TRoleAuth in relation to DataSnap and JSON ... for JSON reflection in DBX relation.
• In Delphi XE 2, ComponentPlatformsAttribute was defined for multi platform support.
• WeakAttribute / UnsafeAttribute / RefAttribute for ARC support in Delphi XE 3, TDefaultAttributeBase / DefaultAttribute / NoDefaultAttribute / StoredAttribute for migration from a future old RTTI to a new RTTI, and ObservableMemberAttribute for LiveBinding correspondence were respectively defined.
• In Delphi XE 4, MethodNameAttribute was defined as iOS support.
• In Delphi XE 5, since reflection of JSON was separated from DBX, JSON … of Data.DBXJSONReflect was redefined for REST.JsonReflect, and JavaSignatureAttribute was defined as Android correspondence.
• In Delphi XE 6, REST.JsonReflect.JsonReflect was renamed to REST.JsonReflect.JsonReflectAttribute and the definition of Json ... other than JsonReflectAttribute moved from the REST.JsonReflect unit to the REST.Json.Types unit.
• In Delphi XE 7, the definition of StoredAttribute moved from the System.Classes unit to the System unit, and ResourceSuffixAttribute / ResourceNameAttribute / EndpointNameAttribute was defined for EMS.
• In Delphi XE 8 HPPGENAttribute and HFAAttribute were defined.
• In Delphi 10 Seattle AlignAttribute and WinRTClassNameAttribute were defined.
• In Delphi 10.1 Berlin, the [weak][unsafe][volatile] attribute is now supported by all compilers (NEXTGEN compiler only before 10 Seattle). We also defined TResourceCustomAttribute / EndPointRequestSummaryAttribute / EndPointRequestParameterAttribute / EndPointResponseDetailsAttribute / EndPointObjectsYAMLDefinitionsAttribute / EndPointObjectsJSONDefinitionsAttribute for custom API documents used in retrieving EMS API resources .
• In Delphi 10.2 Tokyo, System.JSON.Serializers unit was added to define Json ... related to JSON serialization, and AllowAnonymousTenantAttribute was defined for multi-tenant support of EMS. As for the System.JSON.Serializers unit, since it is not officially documented at the present time (April 10, 2007), it is a change that seems not to be written in docwiki of Lyna ‘s Delphi 10.2 Tokyo. – Powerfully , how to use TJsonSerializer. – Powerfully , see the practical example of TJsonSerializer – full power .

If you want to specify an attribute as a return value of a method like Unsafe attribute, add [Result: <attr>] before the method declaration,

[Result: Unsafe]function Foo: TObject;

I will do as follows.

• 2015/06/19 Addendum: Added information on Delphi XE 6 / XE 7 / XE 8.
• 2015/10/05 Addendum: Added information on Delphi 10 Seattle.
• 2016/05/02 Addendum: Added information on Delphi 10.1 Berlin.
• 2017/04/10 Addendum: Added information on Delphi 10.2 Tokyo. I quoted a lot from Lyna’s point . Thank you very much.

Category: Delphi 10 Seattle , Delphi 10.1 Berlin , Delphi 10.2 Tokyo , Delphi 2010 , Delphi Programming Tips , Delphi XE , Delphi XE 2 , Delphi XE 3 , Delphi XE 4 , Delphi XE 5 , Delphi XE 6 , Delphi XE 7 , Delphi XE 8 at 15:25:00

–jeroen