Beim Erstellen einer Anwendung stehen Entwickler häufig vor der Entscheidung, entweder selbst die Funktionalität zu schreiben, oder schauen Sie sich eine Komponente eines Drittanbieters an, um die Aufgabe rechtzeitig zu erledigen. Im letzteren Fall kann eine gut entworfene Komponente die Produktivität eines Entwicklers erheblich verbessern. Wenn Sie Komponenten schreiben, müssen Sie sicherstellen, dass Ihre Komponenten gut entworfen, einfach zu implementieren und vor allem einfach zu verwenden sind.
Tutorial-Details
Technologie: .NET (C #)
Schwierigkeit: Erweitert
Geschätzte Fertigstellungszeit: 1 Stunde
Der in diesem Artikel verwendete Begriff "Komponente" bezieht sich auf ein einzelnes wiederverwendbares Programm Baustein. Es ist durchaus möglich, mehrere Komponenten zu gruppieren Um eine komplexe Komponente zu bilden, wird in diesem Artikel das Design von einfachen, einzigen Zwecken beschrieben Komponenten. In diesem Artikel werden C # und .NET für Beispiele verwendet, und Sie werden für Sie verwendet kann die gleichen Prinzipien auf jede Sprache und Plattform anwenden.
Es gibt drei Aspekte, auf die sich Komponentenautoren beziehen müssen, um brauchbar zu schreiben Komponenten.
Identifizieren des Komponententyps
API entwerfen
Dokumentation und Verpackung
Identifizieren des Komponententyps
Das Bestimmen des Typs Ihrer Komponente ist der entscheidende Absprungpunkt eines Schreibens eine verwendbare Komponente. Es ist unmöglich, eine saubere und einfache API zu schreiben, und noch viel weniger verpacken Sie es zur Verteilung, ohne dessen Typ ausreichend zu identifizieren. Gott sei Dank, Dieser erste Schritt ist einfach.
Die zwei Hauptkomponententypen sind Hilfskomponenten, um bestimmte, nicht visuelle Funktionen auszuführen Task- und UI-Komponenten (visuell), um die Benutzererfahrung zu verbessern oder zu erstellen Entwicklung einfacher für den Entwickler. Betrachten Sie die folgende Komponente als Beispiel:
öffentliche Klasse HtmlRetriever öffentliche statische Zeichenfolge GetPageSource (Zeichenfolge-URL) // Code zum Abrufen von HTML von der angegebenen URL // Code zum Zurückgeben des HTML
Dies ist eine einfache Komponente, die nur diese HtmlRetriever-Klasse enthält. Diese Klasse hat eine statische Methode namens GetPageSource (), die einen String-Parameter akzeptiert, der enthält die URL einer Seite. Diese Komponente enthält keine visuellen Elemente - es handelt sich lediglich um eine Komponente das führt eine Art Funktion aus. Daher können Sie diese Komponente leicht identifizieren als Hilfskomponente.
Betrachten Sie nun die nächste Komponente namens LabelTextBox, die UserControl erbt und enthält Markup in einer ASCX-Datei:
Die Tatsache, dass diese Komponente UserControl erbt, bindet ASP.NET direkt ein Steuerelemente und Ausgaben HTML sind offensichtliche Hinweise darauf, dass diese Komponente eine visuelle Komponente ist. Daher sollte es als ein Steuerelement der UI-Komponente von ASP.NET verwendet werden WebForms.
Wie bereits erwähnt, ist die Identifizierung der einfachste Schritt beim Schreiben einer verwendbaren Komponente, Es muss jedoch getan werden, bevor Sie mit dem Schreiben von Code beginnen können. Folge diesen Faustregeln beim Identifizieren eines Komponententyps:
Wenn Ihre Komponente die Verwendung eines Benutzeroberflächenelements umfasst oder daran gebunden ist, wird Ihre Komponente verwendet sollte selbst als UI-Element für die Plattform konzipiert sein, für die Sie gerade entwickeln. Wenn es sich bei Ihrer Plattform um ASP.NET-WebForms handelt, sollte die Komponente ein Steuerelement sein. Wenn ASP.NET MVC sollte es ein HTML-Helfer sein. Wenn Ihre Plattform der Browser ist (JavaScript), Die Komponente sollte als HTMLElement fungieren.
Wenn Ihre Komponente einfach mit Daten arbeitet und unabhängig von der Benutzeroberfläche ist, ist es besser dient als Dienstklasse oder Referenztyp.
Durch die richtige Identifizierung des Komponententyps, den Sie schreiben müssen, wird festgelegt, wie Sie dies tun Ansatz seiner API und Verpackung.
Die API und warum es wichtig ist
Eine gut konzipierte API führt aufgrund ihrer Einfachheit - der Entwickler - natürlich zur Produktivität Sie brauchen weniger Zeit, um sich mit der API vertraut zu machen und benötigen mehr Zeit für das Schreiben von Code. Aus dieser Einfachheit ergibt sich auch eine Wartbarkeit, da die API einfach gestaltet werden kann Im Hinterkopf behalten Sie den Code des Entwicklers einfach.
In einer einfachen API spielen mehrere Schlüsselfaktoren eine Rolle, die Sie durch Einhaltung erreichen können nach den folgenden Richtlinien:
Befolgen Sie die Namenskonventionen und allgemeinen Verfahren für Ihre Sprache und Plattform.
Emulieren Sie eine API von einer ähnlichen Komponente.
Gestalten Sie für sich.
Design für Flexibilität und Sauberkeit.
Namenskonventionen und allgemeine Praktiken
Egal in welcher Sprache Sie schreiben oder welche Plattform Sie als Ziel verwenden, die wichtigste Die Regel, die beim Entwerfen der API zu beachten ist, ist die Benennungskonvention und die allgemeinen Regeln Praktiken speziell für Ihre Sprache und Plattform. Dies fördert die Einheitlichkeit und also einfachheit.
In .NET konzentrieren sich diese Konventionen auf zwei Arten von Gehäusen:
Pascal-Fall ñ Der erste Buchstabe eines Bezeichners wird groß geschrieben. Wenn der Bezeichner besteht aus mehreren Wörtern, dann sollte jedes Wort mit einem Großbuchstaben beginnen. Beispiel: MyClass ist ein richtiger Name für eine Klasse.
Kamel Fall ñ Der erste Buchstabe ist in Kleinbuchstaben und jedes nachfolgende Wort in der Bezeichner beginnt mit einem Großbuchstaben. Beispiel: myVariable.
Der Pascal-Fall sollte für alle Klassennamen, Aufzählungen und ihre Werte sowie Ereignisse verwendet werden, Schnittstellen, Methoden, Namespaces und Eigenschaften.
Der Kamelfall sollte für alle Parameter und lokalen Variablen verwendet werden.
Eine andere API emulieren
Wenn Sie von vorne anfangen, ist es möglicherweise eine gute Idee, mit a nach Komponenten zu suchen ein ähnliches Dienstprogramm und emulieren ihre API, wenn dies seitdem erfolgt. Betrachten Sie textbasiert ASP.NET-Steuerelemente als Beispiel. Die Hauptfunktion der Steuerelemente Label und TextBox soll dem Benutzer Text präsentieren. Daher ist ihre Standardeigenschaft die Texteigenschaft. Wenn Sie ein anderes textbasiertes Steuerelement erstellen, sollte auch eine Texteigenschaft implementiert werden um den textbasierten Inhalt des Steuerelements abzurufen und festzulegen.
Die API für UI-Komponenten ist normalerweise viel einfacher zu entwerfen und zu implementieren als die von nicht-visuellen Komponenten. Die UI-Komponenten Ihrer Zielplattform werden mehr als haben wahrscheinlich einen gemeinsamen Satz von Eigenschaften und Methoden. Für .NET-Komponenten gilt dies leicht durch einfaches Erben der System.Web.UI.Control, System.Web.UI.WebControls.WebControl, oder System.Web.UI.UserControl-Klassen.
Es ist absolut wichtig, dass die API Ihrer UI-Komponente mit der anderer UI-Komponenten übereinstimmt in Ihrer Zielplattform. Es fördert die Einheitlichkeit und Vertrautheit des Entwicklers ñ weniger Zeitaufwand für das Erlernen einer neuen API.
Erstellen Sie eine API für sich
Die Chancen stehen gut, dass Sie eine Komponente für Ihre eigenen Bedürfnisse erstellen, und Sie haben sich später entschieden um es der Welt freizugeben. Nach dem Emulieren der API eines anderen Dienstprogramms oder Steuerelements, Im nächsten Schritt fügen Sie die Eigenschaften und Methoden hinzu, die Sie hinzufügen möchten. Immerhin du baue es für einen bestimmten Zweck. Sie sind nicht nur der erste Konsument von Ihnen Komponente, Sie sind auch die beste Ressource, um es mit einer API bereitzustellen. Erinnere dich an halte es so einfach und logisch wie möglich. Denken Sie auch daran, Ihre Eigenschaften anzugeben und Methoden mit beschreibenden und eindeutigen Namen.
Machen Sie es flexibel
Achten Sie beim Entwerfen der API darauf, dass Sie flexibel mit mehreren Szenarien umgehen können. Verwenden Sie die von Ihnen erstellte API als Grundlage und planen Sie die Planung für andere Szenarien, die andere Entwickler möglicherweise für Ihre Komponente benötigen.
HtmlRetriever flexibel machen
Betrachten Sie die HtmlRetriever-Klasse aus dem vorherigen Abschnitt. Seine GetPageSource () Methode kann für den ursprünglich vorgesehenen Zweck funktionieren, aber auch die Verbraucher davon in Kenntnis setzen Ihre Klasse möchte möglicherweise den Quellcode einer Seite ohne Element-Tags. Machen Sie es flexibel durch Refactoring der Methode in zwei Überladungen, wie im folgenden Code:
öffentliche Klasse HtmlRetriever // Die erste "Standardüberladung" Öffentliche statische Zeichenfolge GetPageSource (Zeichenfolge url) return GetPageSource (url, false); // die zweite öffentliche statische Überladungszeichenfolge GetPageSource (Zeichenfolge url, bool stripTags) // Code zum Abrufen der HTML-Quelle hier if if (stripTags) // Code zum Entfernen von Tags // Rückgabedaten
Bei dieser Iteration der HtmlRetriever-Klasse werden Sie einige Änderungen feststellen von dem, was im vorherigen Abschnitt vorgestellt wurde. Beachten Sie beim Lesen dieses Codes, wie Die Methodennamen und die Namen ihrer Parameter sind beschreibend. Es gibt kein Vermutung hier; Verbraucher dieser Klasse wissen genau, was die Methode macht und wie Die Parameter ändern ihr Verhalten einfach dadurch, wie sie benannt werden.
Die erste Überladung dient als Standardverhalten von GetPageSource (), das zurückgegeben wird der HTML-Quellcode einer Seite mit intakten Tags. Die zweite Überladung von GetPageSource () ist das Arbeitspferd der Überladungen von GetPageSource (). Es akzeptiert eine URL und ein Boolean Wert als seine Parameter. Es ruft die HTML-Quelle ab und gibt sie mit oder ohne zurück Die Element-Tags hängen davon ab, welcher Wert an den Parameter stripTags übergeben wurde.
Überladen ist ein fantastisches Mittel, um Ihre API flexibler zu gestalten. Es hat auch Der zusätzliche Vorteil, dass Sie Ihre API sauber und störungsfrei halten.
Hinzufügen einer API zu LabelTextBox
Verweisen Sie nun zurück auf die LabelTextBox. Sie erbt die System.Web.UI.UserControl-Klasse, also die Basis der API des Steuerelements in der Basisklasse. LabelTextBox ist Im Wesentlichen ein Wrapper um ein Label und ein TextBox, daher sollten einige Eigenschaften geschrieben werden um die Eigenschaften der zugrunde liegenden Steuerelemente zu umschließen. Die erste ist die Texteigenschaft, welche umgibt die Text-Eigenschaft des TextBox:
public string Text get return txtTextBox.Text; set txtTextBox.Text = value;
Die Entscheidung, die Text-Eigenschaft von LabelTextBox so zu gestalten, dass die des TextBox-Objekts umbrochen wird, ist a Designwahl. Die TextBox erhält vom Benutzer die meiste Aufmerksamkeit. Daher ist es sinnvoll, die Text-Eigenschaft um den Text des TextBox-Objekts zu legen Eigentum. Erstellen Sie zum Festlegen der Texteigenschaft des Label-Steuerelements eine Eigenschaft namens LabelText:
öffentliche Zeichenfolge LabelText get return lblLabel.Text; set lblLabel.Text = value;
Diese beiden Eigenschaften entsprechen dem Hauptbedarf dieser Komponente - zum Abrufen und Einstellen von Werten. Ein Entwickler, der diese Komponente konsumiert, kann jedoch für ein TextChanged-Ereignis verwendet werden. Dies kann leicht mit dem folgenden Code ausgeführt werden, der den TextChanged der TextBox einschließt Veranstaltung:
Die erste Zeile dieses Codes gibt einen EventHandler-Delegaten mit dem Namen TextChanged an, Entwickler können Event-Handler hinzufügen, um das TextChanged-Ereignis zu behandeln. Nächster, In PageLoad () wird das TextChanged-Ereignis der TextBox von txtTextBox_TextChanged () behandelt. Methode. Auf diese Weise können Sie überprüfen, ob TextChanged Abonnenten hat, und wenn ja, Führen Sie diese Ereignishandler aus.
Sie können die TextBox-Eigenschaften und -Methoden für dieses Steuerelement weiterhin emulieren. Der Kürze halber gilt dies für die API-Emulation in diesem Artikel.
Nun besteht die API dieser Komponente aus bekannten Elementen, wie z. B. der Eigenschaft Text und das TextChanged-Ereignis sowie benutzerdefinierte Eigenschaften (LabelText) entsprechend Ihrem braucht. Sie könnten weitere Anpassungsmöglichkeiten hinzufügen, z. B. das dynamische Bereitstellen von Funktionen Fügen Sie ein Validierungssteuerelement hinzu, um den Text innerhalb des TextBox zu überprüfen. Die Möglichkeiten, und somit sind API nur durch Ihre Vorstellungskraft begrenzt. Stellen Sie sicher, dass Sie sich selbst als Wie jeder andere auch, verfügt er über die geeigneten Werkzeuge, um das Beste aus Ihrer Komponente herauszuholen.
Final Touches: Dokumentation und Verpackung
Wie Sie Ihre Komponente dokumentieren und verpacken, ist für die Benutzerfreundlichkeit ebenso entscheidend als seine API. Alle harte Arbeit, die Sie in Ihre Komponente stecken, ist umsonst, wenn ihre Dokumentation vorliegt ist schlecht und es ist schwierig, ein Projekt hinzuzufügen. Befolgen Sie die Richtlinien in diesem Abschnitt, und Ihre Komponente kann leicht zu einem Projekt hinzugefügt werden.
Verwenden Sie XML-Kommentare
Die Chancen stehen gut, dass Sie sich beim Experimentieren mit Stücken auf Intellisense verlassen das .NET Framework, mit dem Sie noch nie gearbeitet haben. Die Mehrheit der Entwickler mach das selbe. Intellisense ist ein fantastisches Werkzeug, das Ihre Komponente unterstützen kann Intellisense, wenn Sie XML-Kommentare verwenden und eine XML-Dokumentationsdatei generieren. Das Der folgende Code fügt der Eigenschaft Text von LabelTextBox einen XML-Kommentar hinzu:
/// /// Ruft den im Textfeld enthaltenen Text ab oder legt diesen fest. /// public string Text get return txtTextBox.Text; set txtTextBox.Text = value;
Der Schrägstrich ist kein Tippfehler. Einfach den Schrägstrich dreimal über einer Klasse eingeben, Diese Eigenschaft oder Methode fügt die XML-Kommentare für diesen Bezeichner automatisch ein. Die einzige Information, die Sie angeben müssen, ist die Funktion dieser Kennung.
Führen Sie die folgenden Schritte aus, um die Generierung von XML-Dokumentationsdateien zu aktivieren:
Öffnen Sie die Eigenschaftenseiten Ihres Projekts.
Klicken Sie auf die Registerkarte "Erstellen".
Scrollen Sie nach unten und aktivieren Sie das Kontrollkästchen neben der XML-Dokumentationsdatei.
Verteilung nicht visueller Komponenten
Dienstprogrammkomponenten werden am besten als Klassenbibliotheken verteilt. Dadurch erhält der Entwickler Eine schnelle und einfache Möglichkeit, Ihre Komponente in Ihr Projekt aufzunehmen. Alles, was sie müssen Fügen Sie dem Projekt einen Verweis auf die DLL hinzu, und sie können mit der Verwendung beginnen.
Es ist auch eine praktikable Lösung, Ihre Komponente solange als Codedatei freizugeben Der Code in den Dateien bezieht sich nur auf Ihre Komponente. Den Code darin einbetten Ein Code-Behind oder ein anderer Quelldateityp ist unprofessionell und führt zu Konsumenten Ihrer Komponente, um den Code zu kopieren und in separate Codedateien einzufügen.
Das Beste aus beiden Welten: Geben Sie die DLL und die Codedateien gemeinsam frei. Falls Sie es wollen Um Ihre Komponente zu verkaufen, müssen Sie bei einigen Marktplätzen die Quelle angeben Code. Das Bereitstellen einer vorkompilierten DLL ist ein Bonus für Entwickler, da sie dies nur können Lass es in ihr Projekt fallen.
UI-Komponentenverteilung
Das Verteilen von UI-Komponenten kann einem von zwei Szenarien folgen. Die LabelTextBox-Komponente In diesem Artikel wird ein UserControl (ASCX) beschrieben. Verteilen dieser Komponente als ein ASCX ist in Ordnung. Es gibt Entwicklern die Möglichkeit, die Steuerung einfach zu erweitern Dank des Markup-Teils von ASCX-Dateien passen sie ihren Bedürfnissen an.
Die Alternative ist, von Control oder WebControl abzuleiten. In diesem Fall haben Sie das Steuerelement manuell codieren, ohne Markup zu verwenden. Für einfache Steuerelemente wie LabelTextBox, Dies ist kein großes Problem. Komplexere Steuerelemente erfordern jedoch mehr Code Schreiben Sie das Ausgabe-HTML mit Render () und RenderControl (). Dieser Ansatz macht Verteilung viel einfacher, da die einzige Ergänzung zu einem Projekt eine DLL-Datei (oder eine Codedatei) ist im Gegensatz zu ASCX und seiner Code-Behind-Datei.
Geben Sie Ihren Code niemals frei, ohne ihn zu verpacken.
Nur wenige Dinge sind frustrierender für einen Entwickler, als mehrere kopieren und einfügen zu müssen Codezeilen aus einem ASPX-Code-Behind oder, noch schlimmer, einer ASPX-Markup-Datei. Als eine Komponente Es liegt in Ihrer Verantwortung, sicherzustellen, dass die Benutzer Ihres Codes Ihre Komponente verwenden können so schnell wie möglich. Alles andere als das Hinzufügen einer Datei oder eines Verweises zu einem Projekt lenkt den Entwickler schnell von Ihrer Komponente ab. Halte es einfach!
Schließen
Komponenten zu schreiben ist ein edles Unterfangen. Sie verbringen (unzählige) Stunden damit, Code zu schreiben um die Arbeit eines anderen Entwicklers zu erleichtern. Seien Sie stolz darauf, verwendbare Komponenten schriftlich zu schreiben. Je professioneller und benutzerfreundlicher Sie sind, desto mehr Entwickler möchten dies tun benutze sie.
Verkaufen Sie ASP.NET-Skripts auf CodeCanyon
Wussten Sie, dass Sie Ihre ASP.NET-Skripts und -Komponenten auf CodeCanyon verkaufen können? Melden Sie sich einfach für ein kostenloses Autorenkonto an und beginnen Sie mit dem Verkauf!
Folgen Sie uns auf Twitter oder abonnieren Sie den Nettuts + RSS-Feed für die besten Webentwicklungs-Tutorials im Web.
Share
Accentsconagua
