Newsgroup: it.comp.lang.delphi
Titolo: Classi Interne

Ho quelche dubbio sulle classi interne... mi chiedevo se qualcuno puo 
darmi una mano
TMyClass = class
   private
   type
   TMyInternalClass = class
      procedure Pippo;
   end;
end;
1) una classe interna puo accedere ad i metodi (compresi quelli privati 
e quelli strict private / strict protected) della classe che li contiene ?
2) se 1) e vero e la stessa asserzione è valida anche epr altri 
linguaggi (in primis C# e Java),
Grazie in anticipo a chi mi risponde
Saluti
Geppo

 end;
Perché lo fai, "disperato ragazzo mio"?
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 
Devo raccoglere dei dati all'di diverse clssi ho avuto l'idea del 
"providere di informazioni"
TClasse = class
    private
    type
    TInfoProvider = class (TGenericInfoProvider)
      public
      constructor Create(AClass: TClasse);
      function GetData(ADataId: TANDataId): TInfoData; override;
    end;
    var
    FProvider: TGenericInfoProvider;
    public
    function GetProvider: TGenericInfoProvider;
end;
[...]
function TInfoProvider.GetProvider: TGenerciInfoProvider;
begin
   if FProvider = nil then
     FProvider := TInfoProvider.Create(Self);
   Result := FProvider
endif;
mi sono ispirato al pattern Memento. Ti prego non dirmi che e' 
un'emerita st...zata!! poteri buttarmi da un ponte e potresti avermi 
sulla coscienza :-)
Un saluto
Ing Giuseppe 'Geppo' Monteleone

 ponte e potresti avermi sulla coscienza :-)
Buttati da qualunque posto senza preoccuparti della coscienza di Andrea:
non ne ha!
;-)
Ciao
-- 
ACSH
[TurboDelphi]
Chi fa da se', fatica il doppio

 darmi una mano [...]
A mio avviso, il metodo più rapido per chiarirti i dubbi sulla 
visibilità è provarlo direttamente, d'altronde il codice l'hai già scritto.
Io uso solamente "inner types" nella creazione di enumeratori, al 
momento, ma è già un caso eccezionale: non vedo molti ambiti in cui 
l'uso di questo strumento, considerando che rende un po' più difficile 
leggere la dichiarazione della classe e la farcisce di ulteriori 
elementi, sia effettivamente indispensabile. :-|
Ciao,
   Marco.
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)

 endif;
In questo caso non occorre ricorrere necessariamente a classi interne: 
puoi sfruttare il meccanismo di "friendship implicita", secondo cui la 
tua classe TInfoProvider ha accesso a tutte le variabili protected e 
private della classe TClasse purche' sia nella stessa unit (se vuoi una
variabile che sia davvero privata devi usare "strict private")
quialcosa del genere (non testato) :
unit Prova;
interface
uses
   GenInfoProviders;
type
TClasse = class
private
   FProvider: TGenericInfoProvider;
public
   function GetProvider: TGenericInfoProvider;
private
   fX : integer;
strict private
   fY : integer;
end;
TInfoProvider = class (TGenericInfoProvider)
   ..
   fClass : TClasse;
   ..
   function GetData(ADataId: TANDataId): TInfoData; override;
end;
..
implementation
..
function TInfoProvider.GetData(ADataId: TANDataId): TInfoData;
begin
   Result.Add( fClass.X ); // Funziona: vede X anche se private
   Result.Add( fClass.Y ); // Errore di compilazione: Y e' strict private
end;
..
end.
ciao
   Giacomo

"providere di informazioni"
http://en.wikipedia.org/wiki/Visitor_pattern