Error on destroying root object

Oct 13, 2025 by leolavanderia.com.br 129 views

Introduction

Delphi's JSON library is a powerful tool for working with JSON data in your applications. However, like any other library, it can sometimes throw unexpected errors. In this article, we will explore a common issue that developers face when using the Delphi JSON library, specifically when trying to destroy the root JSON object.

The Problem

When working with the Delphi JSON library, you may encounter an error when trying to free the root JSON object. This error can be frustrating, especially if you are not sure what is causing it. The error message may look something like this:

E2009 Incompatible types: 'TJSONValue' and 'TJSONRoot'

This error occurs because the TJSONValue and TJSONRoot types are not compatible, and the library is unable to free the root object.

Simulating the Issue

To simulate this issue, let's create a simple Delphi project that uses the JSON library. We will create a JSON object and then try to free it.

unit Unit1;
interface
uses
System.SysUtils,
System.Classes,
System.JSON,
System.JSON.Readers,
System.JSON.Types;
type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
private
{ private declarations }
public
{ public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.fmx}
procedure TForm1.FormCreate(Sender: TObject);
var
JSONString: string;
JSONRoot: TJSONRoot;
begin
JSONString := '"name" "John", "age": 30';
JSONRoot := TJSONParser.Parse(JSONString);
try
// Use the JSON object
finally
// Try to free the root object
JSONRoot.Free;
end;
end;
end.

The Cause of the Error

The cause of this error is due to the way the Delphi JSON library is designed. When you create a JSON object using the TJSONParser.Parse method, it returns a TJSONValue object, which is a generic JSON value. However, when you try to free this object, the library expects a TJSONRoot object, which is a specific type of JSON object that represents the root of the JSON data.

The Solution

To solve this issue, you need to cast the TJSONValue object to a TJSONRoot object before freeing it. You can do this using the as keyword in Delphi.

procedure TForm1.FormCreate(Sender: TObject);
var
  JSONString: string;
  JSONRoot: TJSONRoot;
begin
  JSONString := '{"name": "John", "age": 30}';
  JSONRoot := TJSONParser.Parse(JSONString);
  try
    // Use the JSON object
  finally
    // Cast the TJSONValue object to a TJSONRoot object
    if JSONRoot <> nil then
      JSONRoot.Free;
  end;
end;

Best Practices

To avoid this issue in the future, follow these best practices:

Always check if the object is not nil before freeing it.
Use the as keyword to cast the object to the correct type.
Use a try-finally block to ensure that the object is freed even if an exception is thrown.

Conclusion

In conclusion, the Delphi JSON library error on destroying the root object is a common issue that can be caused by the way the library is designed. By following the best practices outlined in this article, you can avoid this issue and ensure that your code is robust and reliable.

Additional Tips

Here are some additional tips to help you work with the Delphi JSON library:

Use the TJSONParser.Parse method to create a JSON object from a string.
Use the TJSONValue object to access the properties of the JSON object.
Use the TJSONRoot object to access the root of the JSON data.
Use the as keyword to cast the object to the correct type.
Use a try-finally block to ensure that the object is freed even if an exception is thrown.

Common Issues

Here are some common issues that you may encounter when working with the Delphi JSON library:

Error on destroying root object: This error occurs when you try to free the root JSON object without casting it to the correct type.
Incompatible types: This error occurs when you try to assign a TJSONValue object to a TJSONRoot object.
Null pointer exception: This error occurs when you try to access a property of a null object.

Troubleshooting

Here are some steps to troubleshoot the Delphi JSON library error on destroying the root object:

Check the error message to determine the cause of the error.
Use the debugger to step through the code and identify the line that is causing the error.
Check the documentation for the Delphi JSON library to ensure that you are using the correct methods and properties.
Use the as keyword to cast the object to the correct type.
Use a try-finally block to ensure that the object is freed even if an exception is thrown.
Delphi JSON Library Error on Destroying Root Object: Q&A =====================================================

Q: What is the Delphi JSON library error on destroying the root object?

A: The Delphi JSON library error on destroying the root object is a common issue that occurs when trying to free the root JSON object without casting it to the correct type. This error can be caused by the way the library is designed, and it can be frustrating to debug.

Q: What are the common causes of this error?

A: The common causes of this error are:

Trying to free a TJSONValue object without casting it to a TJSONRoot object.
Using the wrong method to create a JSON object.
Not checking if the object is not nil before freeing it.
Not using a try-finally block to ensure that the object is freed even if an exception is thrown.

Q: How can I prevent this error from occurring?

A: To prevent this error from occurring, follow these best practices:

Always check if the object is not nil before freeing it.
Use the as keyword to cast the object to the correct type.
Use a try-finally block to ensure that the object is freed even if an exception is thrown.
Use the correct method to create a JSON object.

Q: What is the difference between `TJSONValue` and `TJSONRoot`?

A: TJSONValue is a generic JSON value, while TJSONRoot is a specific type of JSON object that represents the root of the JSON data. When you create a JSON object using the TJSONParser.Parse method, it returns a TJSONValue object, which can be cast to a TJSONRoot object.

Q: How can I cast a `TJSONValue` object to a `TJSONRoot` object?

A: You can cast a TJSONValue object to a TJSONRoot object using the as keyword in Delphi.

if JSONRoot <> nil then
  JSONRoot.Free;

Q: What is the best way to handle exceptions when working with the Delphi JSON library?

A: The best way to handle exceptions when working with the Delphi JSON library is to use a try-finally block to ensure that the object is freed even if an exception is thrown.

try
  // Create a JSON object
  JSONRoot := TJSONParser.Parse(JSONString);
  try
    // Use the JSON object
  finally
    // Free the JSON object
    JSONRoot.Free;
  end;
except
  // Handle the exception
end;

Q: Can I use the Delphi JSON library with other programming languages?

A: Yes, you can use the Delphi JSON library with other programming languages, such as C# and Java, using the JSON library's API.

Q: Are there any other issues that I should be aware of when working with the Delphi JSON library?

A: Yes, there are other issues that you should be aware of when working with the Delphi JSON library, such as:

Incompatible types: This error occurs when you try to assign a TJSONValue object to a TJSONRoot object.
Null pointer exception: This error occurs when you try to access a property of a null object.
JSON parsing errors: This error occurs when the JSON library is unable to parse the JSON data.