Scelta tra proprietà e metodi
In generale, i metodi rappresentano azioni e le proprietà rappresentano dati. Le proprietà sono destinate all'utilizzo come campi. In altri termini, le proprietà non devono essere complesse dal punto di vista dell'elaborazione né devono produrre effetti collaterali. Pur rispettando le seguenti linee guida, valutare l'opportunità di utilizzare una proprietà in alternativa a un metodo poiché le proprietà risultano più facili da utilizzare agli sviluppatori con minore esperienza.
Valutare l'opportunità di utilizzare una proprietà se il membro rappresenta un attributo logico del tipo.
BorderStyle, ad esempio, è una proprietà perché lo stile del bordo è un attributo di un oggetto ListView.
Utilizzare una proprietà, anziché un metodo, se il valore della proprietà viene archiviato nella memoria del processo e la proprietà fornirebbe semplicemente l'accesso a tale valore.
Questa linea guida è illustrata nell'esempio di codice riportato di seguito. La classe EmployeeRecord definisce due proprietà che forniscono l'accesso a campi privati. L'esempio completo è riportato alla fine di questo argomento.
Public Class EmployeeRecord
Private employeeIdValue as Integer
Private departmentValue as Integer
Public Sub New()
End Sub
Public Sub New (id as Integer, departmentId as Integer)
EmployeeId = id
Department = departmentId
End Sub
Public Property Department as Integer
Get
Return departmentValue
End Get
Set
departmentValue = value
End Set
End Property
Public Property EmployeeId as Integer
Get
Return employeeIdValue
End Get
Set
employeeIdValue = value
End Set
End Property
Public Function Clone() as EmployeeRecord
Return new EmployeeRecord(employeeIdValue, departmentValue)
End Function
End Class
public class EmployeeRecord
{
private int employeeId;
private int department;
public EmployeeRecord()
{
}
public EmployeeRecord (int id, int departmentId)
{
EmployeeId = id;
Department = departmentId;
}
public int Department
{
get {return department;}
set {department = value;}
}
public int EmployeeId
{
get {return employeeId;}
set {employeeId = value;}
}
public EmployeeRecord Clone()
{
return new EmployeeRecord(employeeId, department);
}
}
public ref class EmployeeRecord
{
private:
int employeeId;
int department;
public:
EmployeeRecord()
{
}
EmployeeRecord(int id, int departmentId)
{
EmployeeId = id;
Department = departmentId;
}
property int Department
{
int get() {return department;}
void set(int value) {department = value;}
}
property int EmployeeId
{
int get() {return employeeId;}
void set(int value) {employeeId = value;}
}
EmployeeRecord^ Clone()
{
return gcnew EmployeeRecord(employeeId, department);
}
};
Utilizzare un metodo, anziché una proprietà, nelle seguenti situazioni.
L'operazione risulta notevolmente più lenta rispetto all'utilizzo di un insieme di campi. Anche se si considera la possibilità di fornire una versione asincrona di un'operazione per evitare che venga bloccato il thread, è molto probabile che l'operazione risulti troppo dispendiosa come proprietà. In particolare, le operazioni che comportano l'accesso alla rete o al file system, tranne nel caso del singolo accesso per l'inizializzazione, sono gestibili più come metodi che non come proprietà.
L'operazione è una conversione, ad esempio il Object.ToString method.
L'operazione restituisce un risultato diverso ogni volta che viene chiamata, anche se i parametri rimangono invariati. Il metodo NewGuid, ad esempio, restituisce un valore diverso ogni volta che viene chiamato.
L'operazione ha un effetto collaterale significativo e osservabile. Si noti che la memorizzazione di dati in una cache interna non è in genere considerata un effetto collaterale osservabile.
L'operazione restituisce una copia di uno stato interno. Sono escluse le copie di oggetti di tipo valore restituiti sullo stack.
L'operazione restituisce una matrice.
Se l'operazione restituisce una matrice, è opportuno utilizzare un metodo poiché, per preservare la matrice interna, sarebbe necessario restituire una copia completa della matrice, non un riferimento alla matrice utilizzato dalla proprietà. Questo motivo, unito al fatto che gli sviluppatori utilizzano le proprietà come campi, può causare un problema di inefficienza nel codice. Questo concetto è illustrato nell'esempio di codice riportato di seguito, in cui viene restituita una matrice mediante una proprietà. L'esempio completo è riportato alla fine di questo argomento.
Public Class EmployeeData
Dim data as EmployeeRecord()
Public Sub New(data as EmployeeRecord())
Me.data = data
End Sub
Public ReadOnly Property Employees as EmployeeRecord()
Get
Dim newData as EmployeeRecord() = CopyEmployeeRecords()
Return newData
End Get
End Property
Private Function CopyEmployeeRecords() as EmployeeRecord()
Dim newData(UBound(data)) as EmployeeRecord
For i as Integer = 0 To UBound(data)
newData(i) = data(i).Clone()
Next i
Console.WriteLine ("EmployeeData: cloned employee data.")
Return newData
End Function
End Class
public class EmployeeData
{
EmployeeRecord[] data;
public EmployeeData(EmployeeRecord[] data)
{
this.data = data;
}
public EmployeeRecord[] Employees
{
get
{
EmployeeRecord[] newData = CopyEmployeeRecords();
return newData;
}
}
EmployeeRecord[] CopyEmployeeRecords()
{
EmployeeRecord[] newData = new EmployeeRecord[data.Length];
for(int i = 0; i< data.Length; i++)
{
newData[i] = data[i].Clone();
}
Console.WriteLine ("EmployeeData: cloned employee data.");
return newData;
}
}
public ref class EmployeeData
{
private:
array<EmployeeRecord^>^ data;
public:
EmployeeData(array<EmployeeRecord^>^ data)
{
this->data = data;
}
property array<EmployeeRecord^>^ Employees
{
array<EmployeeRecord^>^ get()
{
array<EmployeeRecord^>^ newData = CopyEmployeeRecords();
return newData;
}
}
private:
array<EmployeeRecord^>^ CopyEmployeeRecords()
{
array<EmployeeRecord^>^ newData = gcnew array<EmployeeRecord^>(data->Length);
for(int i = 0; i< data->Length; i++)
{
newData[i] = data[i]->Clone();
}
Console::WriteLine ("EmployeeData: cloned employee data.");
return newData;
}
};
Uno sviluppatore che utilizza questa classe presuppone che la proprietà non sia più dispendiosa dell'accesso a un campo e scrive il codice dell'applicazione in base a tale presupposto, come illustrato nell'esempio di codice riportato di seguito.
Public Class RecordChecker
Public Shared Function FindEmployees( _
dataSource as EmployeeData, _
department as Integer) as Collection(Of Integer)
Dim storage as Collection(Of Integer) = new Collection(Of Integer)()
Console.WriteLine("Record checker: beginning search.")
For i as Integer = 0 To UBound(dataSource.Employees)
If dataSource.Employees(i).Department = department
Console.WriteLine("Record checker: found match at {0}.", i)
storage.Add(dataSource.Employees(i).EmployeeId)
Console.WriteLine("Record checker: stored match at {0}.", i)
Else
Console.WriteLine("Record checker: no match at {0}.", i)
End If
Next i
Return storage
End Function
End Class
public class RecordChecker
{
public static Collection<int> FindEmployees(EmployeeData dataSource,
int department)
{
Collection<int> storage = new Collection<int>();
Console.WriteLine("Record checker: beginning search.");
for (int i = 0; i < dataSource.Employees.Length; i++)
{
if (dataSource.Employees[i].Department == department)
{
Console.WriteLine("Record checker: found match at {0}.", i);
storage.Add(dataSource.Employees[i].EmployeeId);
Console.WriteLine("Record checker: stored match at {0}.", i);
}
else
{
Console.WriteLine("Record checker: no match at {0}.", i);
}
}
return storage;
}
}
public class RecordChecker
{
public:
static Collection<int>^ FindEmployees(EmployeeData^ dataSource,
int department)
{
Collection<int>^ storage = gcnew Collection<int>();
Console::WriteLine("Record checker: beginning search.");
for (int i = 0; i < dataSource->Employees->Length; i++)
{
if (dataSource->Employees[i]->Department == department)
{
Console::WriteLine("Record checker: found match at {0}.", i);
storage->Add(dataSource->Employees[i]->EmployeeId);
Console::WriteLine("Record checker: stored match at {0}.", i);
}
else
{
Console::WriteLine("Record checker: no match at {0}.", i);
}
}
return storage;
}
};
Si noti che l'accesso alla proprietà Employees avviene in ogni iterazione del ciclo e anche quando i reparti corrispondono. Ogni volta che viene eseguito l'accesso alla proprietà, una copia della matrice relativa ai dipendenti viene creata, viene brevemente utilizzata e infine deve essere sottoposta a Garbage Collection. Implementando Employees come metodo, si indica agli sviluppatori che questa azione è più dispendiosa a livello di elaborazione che non l'accesso a un campo. È molto più probabile che venga eseguita una singola chiamata a un metodo e che i risultati di tale chiamata vengano memorizzati nella cache per l'elaborazione.
Esempio
Nell'esempio di codice riportato di seguito viene illustrata un'applicazione completa in cui si presuppone che l'accesso a una proprietà non sia impegnativo a livello di elaborazione. La classe EmployeeData definisce in modo non corretto una proprietà che restituisce una copia di una matrice.
Imports System
Imports System.Collections.ObjectModel
Namespace Examples.DesignGuidelines.Properties
Public Class EmployeeRecord
Private employeeIdValue as Integer
Private departmentValue as Integer
Public Sub New()
End Sub
Public Sub New (id as Integer, departmentId as Integer)
EmployeeId = id
Department = departmentId
End Sub
Public Property Department as Integer
Get
Return departmentValue
End Get
Set
departmentValue = value
End Set
End Property
Public Property EmployeeId as Integer
Get
Return employeeIdValue
End Get
Set
employeeIdValue = value
End Set
End Property
Public Function Clone() as EmployeeRecord
Return new EmployeeRecord(employeeIdValue, departmentValue)
End Function
End Class
Public Class EmployeeData
Dim data as EmployeeRecord()
Public Sub New(data as EmployeeRecord())
Me.data = data
End Sub
Public ReadOnly Property Employees as EmployeeRecord()
Get
Dim newData as EmployeeRecord() = CopyEmployeeRecords()
Return newData
End Get
End Property
Private Function CopyEmployeeRecords() as EmployeeRecord()
Dim newData(UBound(data)) as EmployeeRecord
For i as Integer = 0 To UBound(data)
newData(i) = data(i).Clone()
Next i
Console.WriteLine ("EmployeeData: cloned employee data.")
Return newData
End Function
End Class
Public Class RecordChecker
Public Shared Function FindEmployees( _
dataSource as EmployeeData, _
department as Integer) as Collection(Of Integer)
Dim storage as Collection(Of Integer) = new Collection(Of Integer)()
Console.WriteLine("Record checker: beginning search.")
For i as Integer = 0 To UBound(dataSource.Employees)
If dataSource.Employees(i).Department = department
Console.WriteLine("Record checker: found match at {0}.", i)
storage.Add(dataSource.Employees(i).EmployeeId)
Console.WriteLine("Record checker: stored match at {0}.", i)
Else
Console.WriteLine("Record checker: no match at {0}.", i)
End If
Next i
Return storage
End Function
End Class
Public Class Tester
Public Shared Sub Main()
Dim records(2) as EmployeeRecord
Dim r0 as EmployeeRecord = new EmployeeRecord()
r0.EmployeeId = 1
r0.Department = 100
records(0) = r0
Dim r1 as EmployeeRecord = new EmployeeRecord()
r1.EmployeeId = 2
r1.Department = 100
records(1) = r1
Dim r2 as EmployeeRecord = new EmployeeRecord()
r2.EmployeeId = 3
r2.Department = 101
records(2) = r2
Dim empData as EmployeeData = new EmployeeData(records)
Dim hits as Collection(Of Integer)= _
RecordChecker.FindEmployees(empData, 100)
For Each i as Integer In hits
Console.WriteLine("found employee {0}", i)
Next i
End Sub
End Class
End Namespace
using System;
using System.Collections.ObjectModel;
namespace Examples.DesignGuidelines.Properties
{
public class EmployeeRecord
{
private int employeeId;
private int department;
public EmployeeRecord()
{
}
public EmployeeRecord (int id, int departmentId)
{
EmployeeId = id;
Department = departmentId;
}
public int Department
{
get {return department;}
set {department = value;}
}
public int EmployeeId
{
get {return employeeId;}
set {employeeId = value;}
}
public EmployeeRecord Clone()
{
return new EmployeeRecord(employeeId, department);
}
}
public class EmployeeData
{
EmployeeRecord[] data;
public EmployeeData(EmployeeRecord[] data)
{
this.data = data;
}
public EmployeeRecord[] Employees
{
get
{
EmployeeRecord[] newData = CopyEmployeeRecords();
return newData;
}
}
EmployeeRecord[] CopyEmployeeRecords()
{
EmployeeRecord[] newData = new EmployeeRecord[data.Length];
for(int i = 0; i< data.Length; i++)
{
newData[i] = data[i].Clone();
}
Console.WriteLine ("EmployeeData: cloned employee data.");
return newData;
}
}
public class RecordChecker
{
public static Collection<int> FindEmployees(EmployeeData dataSource,
int department)
{
Collection<int> storage = new Collection<int>();
Console.WriteLine("Record checker: beginning search.");
for (int i = 0; i < dataSource.Employees.Length; i++)
{
if (dataSource.Employees[i].Department == department)
{
Console.WriteLine("Record checker: found match at {0}.", i);
storage.Add(dataSource.Employees[i].EmployeeId);
Console.WriteLine("Record checker: stored match at {0}.", i);
}
else
{
Console.WriteLine("Record checker: no match at {0}.", i);
}
}
return storage;
}
}
public class Tester
{
public static void Main()
{
EmployeeRecord[] records = new EmployeeRecord[3];
EmployeeRecord r0 = new EmployeeRecord();
r0.EmployeeId = 1;
r0.Department = 100;
records[0] = r0;
EmployeeRecord r1 = new EmployeeRecord();
r1.EmployeeId = 2;
r1.Department = 100;
records[1] = r1;
EmployeeRecord r2 = new EmployeeRecord();
r2.EmployeeId = 3;
r2.Department = 101;
records[2] = r2;
EmployeeData empData = new EmployeeData(records);
Collection<int> hits = RecordChecker.FindEmployees(empData, 100);
foreach (int i in hits)
{
Console.WriteLine("found employee {0}", i);
}
}
}
}
using namespace System;
using namespace System::Collections::ObjectModel;
namespace Examples { namespace DesignGuidelines { namespace Properties
{
public ref class EmployeeRecord
{
private:
int employeeId;
int department;
public:
EmployeeRecord()
{
}
EmployeeRecord(int id, int departmentId)
{
EmployeeId = id;
Department = departmentId;
}
property int Department
{
int get() {return department;}
void set(int value) {department = value;}
}
property int EmployeeId
{
int get() {return employeeId;}
void set(int value) {employeeId = value;}
}
EmployeeRecord^ Clone()
{
return gcnew EmployeeRecord(employeeId, department);
}
};
public ref class EmployeeData
{
private:
array<EmployeeRecord^>^ data;
public:
EmployeeData(array<EmployeeRecord^>^ data)
{
this->data = data;
}
property array<EmployeeRecord^>^ Employees
{
array<EmployeeRecord^>^ get()
{
array<EmployeeRecord^>^ newData = CopyEmployeeRecords();
return newData;
}
}
private:
array<EmployeeRecord^>^ CopyEmployeeRecords()
{
array<EmployeeRecord^>^ newData = gcnew array<EmployeeRecord^>(data->Length);
for(int i = 0; i< data->Length; i++)
{
newData[i] = data[i]->Clone();
}
Console::WriteLine ("EmployeeData: cloned employee data.");
return newData;
}
};
public class RecordChecker
{
public:
static Collection<int>^ FindEmployees(EmployeeData^ dataSource,
int department)
{
Collection<int>^ storage = gcnew Collection<int>();
Console::WriteLine("Record checker: beginning search.");
for (int i = 0; i < dataSource->Employees->Length; i++)
{
if (dataSource->Employees[i]->Department == department)
{
Console::WriteLine("Record checker: found match at {0}.", i);
storage->Add(dataSource->Employees[i]->EmployeeId);
Console::WriteLine("Record checker: stored match at {0}.", i);
}
else
{
Console::WriteLine("Record checker: no match at {0}.", i);
}
}
return storage;
}
};
public ref class Tester
{
public:
static void Main()
{
array<EmployeeRecord^>^ records = gcnew array<EmployeeRecord^>(3);
EmployeeRecord^ r0 = gcnew EmployeeRecord();
r0->EmployeeId = 1;
r0->Department = 100;
records[0] = r0;
EmployeeRecord^ r1 = gcnew EmployeeRecord();
r1->EmployeeId = 2;
r1->Department = 100;
records[1] = r1;
EmployeeRecord^ r2 = gcnew EmployeeRecord();
r2->EmployeeId = 3;
r2->Department = 101;
records[2] = r2;
EmployeeData^ empData = gcnew EmployeeData(records);
Collection<int>^ hits = RecordChecker::FindEmployees(empData, 100);
for each (int i in hits)
{
Console::WriteLine("found employee {0}", i);
}
}
};
}}}
Portions Copyright 2005 Microsoft Corporation. Tutti i diritti riservati.
Portions Copyright Addison-Wesley Corporation. Tutti i diritti riservati.
Per ulteriori informazioni sulle linee guida di progettazione, vedere “le linee guida di progettazione di Framework: Idiomi convenzioni, e modelli per libro raccolte riutilizzabili .NET„ di Krzysztof Cwalina e brad Abrams, emessi da Addison-Wesley, 2005.
Vedere anche
Concetti
Altre risorse
Linee guida di progettazione dei membri
Linee guida di progettazione per lo sviluppo di librerie di classi