Wann sollten Klassen in C# verwendet werden?

Question

Ich bin relativ neu in der C# -Sprache, aber mit viel Hilfe von Google-Suchen und Stack Overflow habe ich bereits eine Reihe von Apps gemacht, die mit Office, System Services, Prozesse, WMI, SQL, Linq und Active arbeiten Verzeichnis ...

Obwohl trotz Erfolg hat mit diesen Anwendungen funktional immer bin ich immer noch unsicher über viele Dinge in der Sprache C# wie gute Code der Praxis und mit vielen Suchbegriffen etc ..

C# Klassen; Ich weiß, was ich mit ihnen tun kann, ich weiß über Konstruktoren und Destruktoren, Instantiierung und Eigenschaften, aber ich bin unsicher von , wenn ich sie verwenden sollte. Bisher habe ich alle meines Codes in meiner Form1.cs-Datei in verschiedenen Methoden geschrieben. Diese Methoden machen eine Reihe verschiedener Dinge mit völlig verschiedenen APIs. Dies bedeutet natürlich, dass der Versuch, diesen Code aufrechtzuerhalten, ziemlich schwierig werden kann und ich finde es zunehmend frustrierend, finden Sie alles in meinem Form1.cs.

Meine Frage an euch ist, sollte ich meinen Code in verschiedene Klassen aufteilen? Ich habe versucht, Sachen in Bezug auf SqlConnection und SqlCommands in eine separate Klasse aufzuteilen, aber ohne dieselbe Klasse mehrfach in Form1.cs zu instanziieren. Ich kann nicht sehen, dass dies einfacher oder besser ist.

Ich habe versucht, eine neue App zusammen zu stellen, aber diesmal Funktionalität in seiner eigenen Klasse zu halten, ich hatte gehofft, jemand könnte mir entweder sagen, ich bin dumm und mache es falsch oder zumindest gebe mir eine Anleitung.

Diese App lädt schließlich meine Verbindungszeichenfolge aus App.Config, stellt eine Verbindung zu einer SQL-Datenbank her und füllt ein DataSet mit mehreren Tabellen aus der Datenbank. Das ist auf keinen Fall funktional, da ich nicht in der Lage bin, die gesamte Klassenfrage zu verstehen.

Vielen Dank :)

partial class Form1 : Form 
{ 
    public Form1() 
    { 
     InitializeComponent(); 
    } 

    string myConnectionString; 

    private void Form1_Load(object sender, System.EventArgs e) 
    { 
     AppConfig cfg = new AppConfig(); 
     if (cfg.loadConfig()) 
     { 
      myConnectionString = cfg.myConnectionString(); 
     } 

     if (!String.IsNullOrEmpty(myConnectionString)) 
     { 
      SQLConn SQL = new SQLConn(); 
      if (SQL.createConnection(myConnectionString)) 
      { 
       MessageBox.Show("Connected!"); 
      } 
     } 
    } 
} 

class myDataSet 
{ 
    DataSet DataSet() 
    { 
     DataSet ds = new DataSet(); 

     SQLConn sql = new SQLConn(); 

     return ds; 
    } 

    public void fillData() 
    { 
     try 
     { 
      SqlCommand sqlCmd = new SqlCommand("SELECT * FROM hardware");     
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show(ex.Message); 
     } 
    } 
} 

class SQLConn : IDisposable 
{ 
    SqlConnection sqlConn; 
    public bool createConnection(string myConnectionString) 
    { 
     sqlConn = new SqlConnection(); 
     sqlConn.ConnectionString = myConnectionString; 
     try 
     { 
      sqlConn.Open(); 
      return true; 
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show(ex.Message); 
     } 
     return false; 
    } 

    public void Dispose() 
    { 
     if (sqlConn.State == ConnectionState.Open) 
     { 
      sqlConn.Close(); 
      sqlConn.Dispose(); 
     } 
    } 
} 

class AppConfig 
{ 
    Configuration cfg; 

    public bool loadConfig() 
    { 
     try 
     { 
      cfg = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); 
      if (!File.Exists(cfg.FilePath)) 
      { 
       MessageBox.Show("No configuration file"); 
      } 
      return true; 
     } 
     catch(Exception ex) 
     { 
      MessageBox.Show(ex.Message); 
     } 
     return false; 
    } 

    public string myConnectionString() 
    { 
     string connectionString = ConfigurationManager.ConnectionStrings["IT_ProjectConnectionString"].ConnectionString; 
     return connectionString; 
    } 
} 

Answer 1

Die Prinzipien hinter OOP sagen mehr oder weniger, dass Sie Dinge so weit wie möglich aufteilen sollten, so dass verwandte Dinge in ihrer eigenen Klasse gruppiert sind, wie die SQL-Sachen in Ihrem Beispiel. Ein anderes, oft verwendetes Beispiel ist das eines Autos - wenn Sie mit den Daten von Autos umgehen müssen, würden Sie eine Autoklasse machen, die relevante Variablen wie Höchstgeschwindigkeit, Name, Farbe und geeignete Methoden wie zum Beispiel drive(double distance) oder etwas ähnliches enthält.

Wenn Sie verschiedene Objekte dieser Klasse nicht benötigen und dasselbe Verhalten an mehreren Stellen benötigen, können Sie mehrere Instanzen auf verschiedene Arten verhindern: Wenn alle Punkte in Ihrer Form1 sind, müssen Sie Ihre Klasse nur einmal als Instanz instanziieren ein Klassenmitglied und Sie können es in der Klasse Form1 verwenden. Wenn Sie von verschiedenen Klassen aus darauf zugreifen müssen, können Sie entweder eine globale Variable haben (was von den meisten als schlecht angesehen wird) oder die Klasse, die Sie benötigen, auf static zugreifen - auf diese Weise müssen Sie sie überhaupt nicht instanziieren.

Wenn Ihre App wirklich klein ist, könnten Sie es schaffen, alles in Ihre Form1 Klasse zu legen, aber wie Sie selbst bemerkt haben, kann es sehr schnell unordentlich und verwirrend werden. Stellen Sie sich Klassen als eine Möglichkeit vor, Ihren Code zu sortieren. Denken Sie darüber nach, was mit was verbunden ist und was Sie erwarten würden, zusammen zu finden, und bringen Sie dieses Zeug in Klassen. Wenn Sie sich daran halten, erhalten Sie einen Code, der weniger frustrierend ist, um Code zu finden, und der eine klare und logische Struktur hat. Sie können Dinge wie die Vererbung nutzen, sobald die Dinge komplexer werden, und Sie können Klassen wiederverwenden, die Dinge tun (zum Beispiel Datenbankmaterial), die Sie möglicherweise in verschiedenen Anwendungen benötigen.

Dies ist eine sehr kurze und sehr grobe Beschreibung. Ich kenne keine guten Bücher über das Thema selbst (außer denen, die für Anfänger gedacht sind, was hier unpassend erscheint), aber ich schlage vor, eine auf OOP zu finden oder nach guten Einführungsartikeln zu diesem Thema zu suchen. Ich persönlich finde, dass das CodeProject eine gute Quelle für Artikel ist. Here is one on OOP.

Answer 2

Ich benutze das Einzel Prinzip Verantwortung als Leitfaden für die Klassen zu entwerfen. Hier ist eine gutes discussion dieser, mit der ausgeprägten Punkt ist:

Der Punkt ist, dass jede Klasse einen zusammenhängenden Satz von bezogenen Funktionen implementieren sollte. Eine einfache Möglichkeit, die Single Responsibility Prinzip zu befolgen ist, sich ständig zu fragen, ob jede Methode und Operation einer Klasse direkt mit dem Namen dieser Klasse verbunden ist. Wenn Sie einige Methoden finden, die nicht mit dem Namen der Klasse übereinstimmen, sollten Sie in Betracht ziehen, diese Methoden in eine andere Klasse zu verschieben.

In diesem Sinne denke ich, dass Sie richtig sind, die Funktionalität Ihrer Beispielanwendung in separate Klassen zu teilen. Andernfalls haben Sie eine Konglomeratform1-Klasse, die mehrere Verantwortlichkeiten besitzt: Lesen von Konfigurationswerten, Verbinden mit Datenbanken, Lesen von Daten. Wie Sie sehen, erleichtert das Aufteilen des Codes in separate Klassen auch das Verständnis und die Navigation des Programms.

Answer 3

Denken Sie an Ihre Klassen, die eine Art von Funktionalität kapseln. In Ihrem Fall behandelt SQLConn Verbindungen mit der Datenbank, dh diese Klasse besitzt die Datenbankverbindung und der gesamte Datenverkehr sollte nun diese Klasse durchlaufen.Das bedeutet auch, dass Ihre myDataSet-Klasse Ihre SQLConn-Klasse für alle Kommunikationen verwenden sollte. Daher ist es ein Fehler, dass Sie einen SqlCommand instanziieren.

Ich denke, Sie können Instanzen mit Klassen in Ihrer Implementierung verwechseln. Sie erstellen mehrere Instanzen der Klasse SQLConn, zuerst in Ihrer OnLoad-Methode, bei der Sie eine Verbindung mit der Datenbank herstellen, später in Ihrer myDataSet-Klasse. Dies ist nicht die gleiche Instace der Klasse. Daher verwendet Ihre Klasse myDataSet einen SQLConn, der nicht mit der Datenbank verbunden ist.

Sie können stattdessen die gleiche Instanz teilen, indem die MyDataSet Klasse mit der Instanz SQLConn Bereitstellung Sie es wollen arbeiten:

public myDataSet(SQLConn conn) 
{ 
    SQLConn sql = conn; 
} 

{ 
    SQLConn conn = new SQLConn(); 
    conn.createConnection(...); 
    myDataSet ds = new myDataSet(conn); 
} 

Dies ist immer noch nicht ein gutes Design, aber es zeigt, wie auf passieren eine Instanz gegenüber einer Klasse direkt referenzieren.