Ci sono alcuni casi (abbastanza rari) in cui esiste il rischio di:
-
riutilizzare una variabile che non è destinata a essere riutilizzata (vedi esempio 1),
-
o utilizzando una variabile anziché un'altra, semanticamente chiusa (vedi esempio 2).
Esempio 1:
var data = this.InitializeData();
if (this.IsConsistent(data, this.state))
{
this.ETL.Process(data); // Alters original data in a way it couldn't be used any longer.
}
// ...
foreach (var flow in data.Flows)
{
// This shouldn't happen: given that ETL possibly altered the contents of 'data', it is
// not longer reliable to use 'data.Flows'.
}
Esempio 2:
var userSettingsFile = SettingsFiles.LoadForUser();
var appSettingsFile = SettingsFiles.LoadForApp();
if (someCondition)
{
userSettingsFile.Destroy();
}
userSettingsFile.ParseAndApply(); // There is a mistake here: 'userSettingsFile' was maybe
// destroyed. It's 'appSettingsFile' which should have
// been used instead.
Questo rischio può essere mitigato introducendo un ambito:
Esempio 1:
// There is no 'foreach', 'if' or anything like this before '{'.
{
var data = this.InitializeData();
if (this.IsConsistent(data, this.state))
{
this.ETL.Process(data);
}
}
// ...
// A few lines later, we can't use 'data.Flows', because it doesn't exist in this scope.
Esempio 2:
{
var userSettingsFile = SettingsFiles.LoadForUser();
if (someCondition)
{
userSettingsFile.Destroy();
}
}
{
var appSettingsFile = SettingsFiles.LoadForApp();
// 'userSettingsFile' is out of scope. There is no risk to use it instead of
// 'appSettingsFile'.
}
Sembra sbagliato? Eviteresti tale sintassi? È difficile da capire per i principianti?