Changing DisplayNames of my properties using PropertyGrid
component, how ??

I'm using Delphi 2006 and I have a class defination like this:

TPerson = class
 fPersonName  : String;
 fPersonSurName : String;
 fPersonAge : Integer;
published
  property PersonName : String read fPersonName write fPersonName;
  property PersonSurname : String read fPersonSurname write fPersonSurname;
  property PersonAge  : Integer read fPersonAge write fPersonAge;
end;

 and i want to display my class instance using PropertyGrid,so...

 var
  mPerson : TPerson;
 begin
  mPerson := TPerson.Create;
  mPerson.PersonName := 'Tugrul';
  mPerson.PersonSurname := 'HELVACI';
  mPerson.PersonAge := 31;
  PropertyGrid1.SelectedObject := mPerson;
 end;

 at the above code i can see my class instance in the property grid.
But i want to change property display names in the propertygrid component.
Because of these, i was searching on the net and i found PropertyDescriptor 
abstract class
and ICustomTypeConverter interface.

 i implemented theese classes following:

  TArrayOfAttribute = array of Attribute;
  TMyDescriptor = class(PropertyDescriptor)
  private
    base : PropertyDescriptor;
    fName: String;

    function GetName : String;
    function GetDisplayName : String;
    function GetIsReadOnly : Boolean;
    function GetComponentType : &Type;
    function GetPropertyType : &Type;

    function GetCustomNames(baseName : String) : String; // my custom names 
getter function
  public
    constructor Create(baseP : PropertyDescriptor; filter : 
TArrayOfAttribute); overload; virtual;
    constructor Create(baseP : PropertyDescriptor); overload; virtual;

    function CanResetValue(comp : TObject) : Boolean;
    function GetValue(comp : TObject) : TObject;

    procedure ResetValue(comp : TObject);
    procedure SetValue(comp : TObject; Value : TObject);
    function ShouldSerializeValue(comp : TObject) : Boolean;


    property Name : String read GetName;
    property DisplayName : String read GetDisplayName;
    property IsReadOnly  : Boolean read GetIsReadOnly;
    property ComponentType : &Type read GetComponentType;
    property PropertyType : &Type read GetPropertyType;
  end;

  TMyClass = class(TInterfacedObject, ICustomTypeDescriptor)
  public
    function GetProperties(filter : TArrayOfAttribute) : 
PropertyDescriptorCollection; overload;
    function GetAttributes : AttributeCollection;
    function GetClassName : String;
    function GetComponentName : String;
    function GetConverter : TypeConverter;
    function GetDefaultEvent : EventDescriptor;

    function GetEvents(attributes : TArrayOfAttribute) : 
EventDescriptorCollection; overload;
    function GetEvents : EventDescriptorCollection; overload;
    function GetDefaultProperty : PropertyDescriptor;

    function GetProperties : PropertyDescriptorCollection; overload;
    function GetEditor(editorBaseType : System.Type) : TObject;
    function GetPropertyOwner(pd : PropertyDescriptor) : TObject;
  end;


and my new TPerson class is:
  TPerson = class(TMyClass)
   fPersonName  : String;
   fPersonSurName : String;
   fPersonAge : Integer;
  published
   property PersonName : String read fPersonName write fPersonName;
   property PersonSurname : String read fPersonSurname write fPersonSurname;
   property PersonAge  : Integer read fPersonAge write fPersonAge;
  end;

**************** IMPLEMENTATIONS BELOW *********************************


function TMyDescriptor.CanResetValue(comp: TObject): Boolean;
begin
   Result := base.CanResetValue(comp);
end;


constructor TMyDescriptor.Create(baseP: PropertyDescriptor;
  filter: TArrayOfAttribute);
begin
  inherited Create(baseP, filter);
  Self.base := baseP;
end;

constructor TMyDescriptor.Create(baseP: PropertyDescriptor);
begin
  inherited Create(baseP);
  Self.base := baseP;
end;

function TMyDescriptor.GetComponentType: &Type;
begin
  Result := base.ComponentType;
end;

function TMyDescriptor.GetDisplayName: String;
begin
  Result := GetCustomNames(base.Name);
end;

function TMyDescriptor.Getir(baseName : String): String;
begin
  if baseName = 'PersonName' then Result := 'Names of the Personel';
  if baseName = 'PersonSurname' then Result := 'Surname of the personel';
  if baseName = 'PersonAge' then Result := 'Age of the personel';
end;

function TMyDescriptor.GetIsReadOnly: Boolean;
begin
  Result := base.IsReadOnly;
end;

function TMyDescriptor.GetName: String;
begin
  Result := base.Name;
end;


function TMyDescriptor.GetPropertyType: &Type;
begin
  Result := base.PropertyType;
end;

function TMyDescriptor.GetValue(comp: TObject): TObject;
begin
  Result := base.GetValue(comp);
end;


procedure TMyDescriptor.ResetValue(comp: TObject);
begin
  base.ResetValue(comp);
end;

procedure TMyDescriptor.SetValue(comp, Value: TObject);
begin
  base.SetValue(comp, value);
end;

function TMyDescriptor.ShouldSerializeValue(comp: TObject): Boolean;
begin
  Result := base.ShouldSerializeValue(comp);
end;



function TMyClass.GetProperties(
  filter: TArrayOfAttribute): PropertyDescriptorCollection;
var
  baseProps : PropertyDescriptorCollection;
  newProps  : array of PropertyDescriptor;
  iCounter  : Integer;
  oldname,
  newname   : String;
begin
  baseProps := TypeDescriptor.GetProperties(GetType(), filter);

  SetLength(newProps, baseProps.Count);

  for iCounter := 0 to baseProps.Count do
  begin
    newProps[iCounter] := TMyDescriptor.Create(baseProps[iCounter], filter); 
// An error occured : E2402 constructing instance of abstract class..
    oldname := PropertyDescriptor(baseProps[iCounter]).DisplayName;
    newName := TMyDescriptor(newProps[iCounter]).DisplayName;
  end;

  Result := PropertyDescriptorCollection.Create(newProps);
end;

function TMyClass.GetAttributes: AttributeCollection;
begin
  Result := TypeDescriptor.GetAttributes(Self, true);
end;

function TMyClass.GetClassName: String;
begin
  Result := TypeDescriptor.GetClassName(Self, true);
end;

function TMyClass.GetComponentName: String;
begin
  Result := TypeDescriptor.GetComponentName(Self, true);
end;

function TMyClass.GetConverter: TypeConverter;
begin
  Result := TypeDescriptor.GetConverter(Self, true);
end;

function TMyClass.GetDefaultEvent: EventDescriptor;
begin
  Result := TypeDescriptor.GetDefaultEvent(Self, true);
end;

function TMyClass.GetDefaultProperty: PropertyDescriptor;
begin
  Result := TypeDescriptor.GetDefaultProperty(Self, true);
end;

function TMyClass.GetEditor(editorBaseType: System.Type): TObject;
begin
  Result := TypeDescriptor.GetEditor(Self, editorBaseType, true);
end;

function TMyClass.GetEvents: EventDescriptorCollection;
begin
  Result := TypeDescriptor.GetEvents(Self, true);
end;

function TMyClass.GetEvents(
  attributes: TArrayOfAttribute): EventDescriptorCollection;
begin
  Result := TypeDescriptor.GetEvents(Self, attributes, true);
end;

function TMyClass.GetProperties: PropertyDescriptorCollection;
begin
  Result := TypeDescriptor.GetProperties(Self, true);
end;

function TMyClass.GetPropertyOwner(pd: PropertyDescriptor): TObject;
begin
  Result := Self;
end;


 I dont understand what is this. Can anybody helps me , how can i 
subclassing PropertyDescriptor class correctly ??


Even we take an error when using  delphi.net , we dont take any error 
message using c#,

i want change the display name of the property which is the added to my 
special class by using the propertyGrid Component ...
It's seems like DisplayNameAttirubute of the .net Framework 2.0

With My Best Regards,

Thanks For Helping