Modificatori di accesso

Public,Private,Sealed,Static...

Sono modificatori di accesso ossia sono dei delle parole private del linguaggio che indicano al compilatore il tipo di accesso che si avrà nei confronti di quella Classe, metodo, proprietà...

Benchè ci siano dei casi specifici dove utilizzare uno specifico modificatore i principali (giusto perchè sono i più utilizzati) rimangono Public e Private.

il loro scopo è quello di rendere Pubblico o Privato un metodo o una proprietà una classe

Questa rimarrà visibile a livello di soluzione
public class Tank
{
}
All'esterno sarà possibile individuare questa classe e usarla


Questa rimarrà visibile a livello di progetto (dato che private è di default nella dichiarazione di una classe lo si omette)
class Tank
{
}
Se la nostra soluzione fosse costituita da più progetti, questa classe da altri progetti non verrebbe vista.

Concettualmente è di fondamentale importanza compredere quanto un modificatore agisce su quanto abbiamo scritto.

public class Tank
{
private int _capacita;
public void Riempi(){...}
}

public class UsaTank
{
Tank t = new Tank();

public UsaTank() {t.Riempi();}
}

In questo specifico caso Tank e UsaTank sono due class dello stesso progetto.

In UsaTank sicuramente non avremmo accesso a _capacita perchè il suo modificatore rimane privato e non ne
consente quindi l'accesso dall'esterno.

Condividere.

In fase di progettazione, una delle parti più complesse, è sicuramente la condivisione delle informazioni.

E' possibile che membri dello stesso gruppo possano trovarsi nella spiacevole circostanza di avere informazioni diverse, sullo svolgimento del progetto.

E' sufficiente un piccolo problema a creare problemi relativamente grossi.

La base di questo rischio è la scarsità o l'inapropriata condivisione delle informazioni.

La Ide del frame work mette a disposizione svariate possibilità per realizzare frammenti di documentazione, e meglio ancora dispone di un tool dedicato completamente al diagramma delle classi.

/// <>
///
/// < /summary >
/// < name="obj"> < /param >

Questo tag si può (si deve/si dovrebbe) utilizzare, per dare una completa panoramica di quello quanto svolge il metodo.
Può essere esteso anche alle proprietà o agli eventi.

Ma ancora una volta è necessario che sia utilizzato con buon senso e cognizione di causa.


/// <>
/// Metodo WriteToPort Scarica il buffer sulla porta indicata dal parametro port
///< /summary >
///
/// < name="Port">Indirizzo logico della porta su cui scrivere< /param >


Questo "commento" risulta Leggibile e quanto meno comprensibile chiunque riesce a comprendere qual'e' lo scopo del metodo che sta per leggere.

Non da meno nel caso di utilizzo della class che espone questo metodo si avrebbe un tooltip recante la medesima descirzione.


/// <>
/// WriteToPort
/// Scrive dei bit nella port ( quando funziona !! )
/// < /summary >
/// < name="Port">< /param >


Naturalmente questo commento non è assolutamente valido, ne comprensibile. Ma il più delle volte ringrazio anche chi scrive commenti simili, perchè quanto meno ci sono.

E' valutabile il fatto che un commento sia efficace o meno, si deve comunque sensibilizzare il proprio team a creare
commenti OGGETTIVAMENTE comprensibili.

Un ulteriore strumento è la direttiva #region che permette di raggrupare delle righe di codice secondo una determinata logica.

#region Private
private int _id_CampoChiave;
private string _Campo_Nome;
private string _Campo_Note;
#endregion

In questo specifico caso è possibile indicare la presenza di una serie di attributi privati.

E' possibile specificare definizioni più o meno complesse, o annidare vari region fra loro.

Ancora una volta è necessario istruire il proprio gruppo in modo che vi sia uno standard diffuso e conosciuto, al fine
che tutti possano CONDIVIDERE la stessa esperienza.

Static

Che cos'e' una classe statica ?
Tecnicamente parlando una classe statica è una oggetto che espone i propri membri senza aver bisogno di essere istanziato.
Una classe dichiarata come static non potrà essere ereditata.

Quando ne è consigliato l'utilizzo ?
L'impiego di una classe statica è consigliato quando la classe non contiene dati, comportamenti che dipendono dalla classe stessa.

Come si dichiara una classe statica ?
public static class TestStatic
Questa scrittura implica che tutti i membri della classe dovranno essere dichiartati static.

esempio
class Program
{
static void Main(string[] args)
{
string content = "testo dimostrativo";

TestStatic.WriteFile(@"C:\test.txt", content, true);

content = TestStatic.ReadFile(@"C:\test.txt");
}

}

public static class TestStatic
{
public static string ReadFile(string fileName)
{
string dataFromFile ="";

// processo di verifica ( esistenza )

// processo di lettura

return dataFromFile;
}

public static void WriteFile(string fileName, string fileContent, bool Append)
{
// processo di verifica ( percorso )

// processo di verifica ( modalità di scrittura)

// processo di scrittura
}
}

Posto che vi sia del codice e posto anche che questa situazione abbia una certa utilità, abbiamo creato una
sottospecie di utility statica che legge e scrive un file.

Posto che si voglia aggiungere un contatore dei soli file creati :
public static class TestStatic
{
private static int fileCount = 0;

public static string ReadFile(string fileName)
{
string dataFromFile ="";

// processo di verifica ( esistenza )

// processo di lettura

return dataFromFile;
}

public static void WriteFile(string fileName, string fileContent, bool Append)
{
// processo di verifica ( percorso )

// processo di verifica ( modalità di scrittura)

if (Append == false)
{
// implica che stiamo creando un nuovo file...
fileCount++;
}

// processo di scrittura
}

public int FileCounter()
{
return fileCount;
}
}

Aggiungendo un metodo la cui firma non è statica il compilatore non consente la "compilazione"
comunicando che per una classe statica tutti i membri devo essere tali.

public static class TestStatic
{
private static int fileCount = 0;

public static string ReadFile(string fileName)
{
string dataFromFile ="";

// processo di verifica ( esistenza )

// processo di lettura

return dataFromFile;
}

public static void WriteFile(string fileName, string fileContent, bool Append)
{
// processo di verifica ( percorso )

// processo di verifica ( modalità di scrittura)

if (Append == false)
{
// implica che stiamo creando un nuovo file...
fileCount++;
}

// processo di scrittura
}

public static int FileCounter()
{
return fileCount;
}
}

Si possono creare Classi non statiche con metodi statici ?

Si si può fare e a questo punto solo i metodi di quella classe potranno essere utilizzati come static,
senza quindi dover istanziare la classe.

class Program
{
static void Main(string[] args)
{

TestStaticMethod ts = new TestStaticMethod();

Console.WriteLine(ts.GetTestResult());

Console.WriteLine(TestStaticMethod.GetStaticTestResult());

}

}

public class TestStaticMethod
{

public TestStaticMethod()
{
// costruttore
}

public static string GetStaticTestResult()
{
return "Risultato statico del test";
}

public string GetTestResult()
{
return "Risultato " + DateTime.Now.ToShortTimeString() + " non statico del test";
}
}

Differenze fra le due classi TestStatic e TestStaticMethod

//
// Questo non può essere fatto
// la classe TestStatic non è visibile
public class Test : TestStatic
{

}

//
// Questo è consentito
public class Test : TestStaticMethod
{

}

Ed è consentito anche questo ...
class Program
{
static void Main(string[] args)
{

Test nTest = new Test();

Console.WriteLine(nTest.GetTestResult());

Console.WriteLine(Test.GetStaticTestResult());
}
}

public class Test : TestStaticMethod
{

}