在Delphi中创建和销毁对象

Question

I am new to Delphi and am trying to better understand object creation / freeing as I am used to the luxury of .NET's GC. I have two questions specifically:

1. Let's assume I am setting a TDataSource as below. In .NET I wouldn't explicitly destroy the object as I am with adoQuery.Free. But I am assuming that with Delphi I need to free these objects. However, by destroying the adoQuery I am also setting the dataset to null. In this way adoQuery is meant to be a locally scoped variable to the function only with the datsource being retuned from the function. Therefore, how can I best handle this?

    dataSrc := TDataSource.Create(nil); dataSrc.DataSet := adoQuery; dataSrc.Enabled := true; { adoQuery.Free; } cnt := DataSrc.DataSet.RecordCount; 

2. I've been reading several suggestions when returning a variable from a function that the best thing to do is create the variable within the caller and pass it to the subroutine. Therefore, the signature to a function would look like:

    AdoConnectionManager.GetResult(query : String; dataSrc: TDataSource) : TDataSource; Result := dataSrc; 

This is unattractive to me. I'd prefer to have a new variable created within the subroutine and then returned back to the caller. However, this is something again I never really had to worry about with .NET GC and here I have to explicitly destroy the variable, right?

Thanks!

Answer 1

You've asked two questions. One concerns these database classes, and I'm going to ignore that question since I don't know anything about those classes. Instead I will answer the other questions. Do note that this sort of answer is why the site policy is for questions to be asked one at a time.

Regarding a function that returns a new object, that is certainly viable. However, it is sometimes more flexible to let the caller supply the object. That allows them to re-use instance, or supply objects that are derived from a base class. A classic example would be a function that populated a TStrings instance.

In this scenario you'd probably use a procedure rather than a function. It might look like this:

procedure PopulateList(List: TMyList);

---

If you want to have a function that returns a newly minted instance that would be done like so:

function CreateAndPopulateList: TMyList;
begin
  Result := TMyList.Create;
  try
    // code to populate Result goes here, and may raise exceptions
  except
    Result.Free; // in case of exceptions, we must destroy the instance to avoid leaks
    raise;
  end;
end;

Note the naming. I use create to imply to the caller that a new instance is created. The calling code would look like this:

List := CreateAndPopulateList;
try
  // do stuff with list
finally
  List.Free;
end;

And this pattern is the standard object creation pattern. So you use CreateAndPopulateList just as you could a constructor.

Answer 2

It should also be mentioned here, that Delphi also provides Reference-Counting (but different to .NET).

The very short explanation to Reference-Counting in Delphi:
In difference to other Languagues, Reference-Counting in Delphi is only available by using Interfaces. Further, there is no Garbage-Collector: a reference-counted Object gets instantly destroyed when its Referencecount reaches 0.

So as an Delphi Developer, there are the following "global" Rules for destroying Instances:
- you do destroy an Object manually, whenever it's declared as a ClassType (eg var m: TMyClass)
- you never destroy an Object manually, whenever it's declared as a InterfaceType (eg var m: IMyClass)

Answer 3

With Delphi when you create an object, you should decide how it would be freed. There are several ways:

1. You can free it manually
2. It can be freed together with it's owner
3. It can be freed as a part of TObjectList or similar container
4. It can be freed because it's interfaced and reference counter for it became zero
5. And so on...

About first question: you should understand that with Delphi object variable is a pointer to object. When leaving function, you can lost locally scoped (pointer) variable, but you don't harm object itself. For example, you can do something like this:

function GetDataSource: TDataSource;
var Query: TADOQuery;
begin
  Result := TDataSource.Create(nil);
  Query := TADOQuery.Create(Result);
  Query.SQL.Text := ' ... ';
  Result.DataSet := Query;
end;

It'll give you datasource you want with background query. When you free this datasource, query also would be freed.

About second question: intrafunction creation of return object is a normal practise, part of good design. Yes, you should decide who will free this object and how. You can use many strategies, there are no silver bullet here. Just for example, you can decide to add parameter 'datasource's owner' to function above and controls it's lifetime this way.