Einführung in die Programmierung der Schnittgrößen von Einfeldträgern

Dr. Johannes Lange

2

Vorwort

Wissen Sie wie spannend es ist, sich auf eine Professur zu bewerben? Vielen Dank für die Einladung und die Chance eine Vorlesung bei Ihnen zu halten. Ich wünsche Ihnen genauso viel Spaß beim Lesen und Zuhören rund um das Thema Programmierung und Softwareentwicklung, wie ich bei der Erstellung der Unterlagen und der Vorlesung ge-habt habe. Die Entwicklung einer größeren Software ist vom Aufwand vergleichbar mit dem Bau eines Hauses und das Projektmanagement dazu enthält sogar ähnliche Aufgaben. Bei dem Haus wird selbstverständlich vorher genau geplant. Konstruktiv werden Details durchgesprochen oder Materialien diskutiert und es werden dazu CAD- Zeichnungen, Bilder, Schnitte und sogar Prototypen für die Vorstellung und Entscheidungen ver-wendet. Trotzdem kommt es immer wieder zu Zeitverzögerungen und Kostenerhö-hungen. Einerseits sind nicht alle Faktoren bekannt (Im Tunnelbau heißt es „Vor der Hacke ist es dunkel!“) und andererseits führen dazu Planungs- und Projektfehler. Wie sieht das in der Softwareentwicklung aus? Viele Projekte werden nur mäßig ge-plant, die Anforderungen sind leider oft nur grob bekannt und führen später zu Dis-kussionen und Zeitverzug. Gerade für die Softwareentwicklung von Projekten zu neu-en oder unbekannten Themen sind in der Literatur Statistiken mit Abbruch- bzw. Ver-zögerungsraten bis zu 70% zu finden [Zahrnt]. Das Hauptproblem ist wie in anderen Fachbereichen auch die fehlende Kommunikation, Kooperation und Koordination. Was macht ein (Bau-)Ingenieur im Softwarebereich? Bei der mittelständigen Firma, bei der ich angestellt bin, sind von den 45 Entwicklern 40% als Ingenieure, 40% als Informatiker (einschließlich Ausbildungsberufe) und 20% als Naturwissenschaftler ausgebildet; insgesamt arbeiten dort 3 Bauingenieure und 2 Architekten. Wir entwi-ckeln Software im Bereich Energieberatung von Gebäuden und TGA (technische Ge-bäudeausrüstung) einschließlich CAD sowie Abrechnungs- (AVA) und Kehrbezirks-verwaltungsoftware. Da die Kunden Ingenieure und Handwerker sind, werden oft Fra-gen aus der Praxis der Bauplanung und -betriebs gestellt und das Verständnis der Zu-sammenhänge, aktueller Normen usw. ist selbstverständlich. Wohin geht die Reise? In den letzten Jahren sind Simulationen und Visualisierungen durch leistungsfähigere Rechner in der Ingenieur-Software immer stärker vertreten. Aktuell ist der mobile Bereich mit vernetztem Arbeiten „Clouds“ u. ä. Trendsetter. Schließlich unverändert ist das Thema Daten- und Projektsicherheit immer wieder zu nennen. Wenn Sie möchten, können Sie die Beispiele der Vorlesung wiederholen und ergänzen, in Kapitel 5 finden Sie weitere Aufgaben. Gerne bin ich bereit, auch im Nachhinein Fragen zu beantworten oder Punkte zu diskutieren. Am Ende dieses Skript finden sie hierfür alle erforderlichen Links meine Emailadresse. Aachen-Köln im Dezember 2012 Johannes Lange

3

Inhalt

Vorwort ....................................................................................................................................... 2 1 Allgemeine Softwareentwicklung .................................................................................... 4

1.1 Anforderungen und Eigenschaften .............................................................................. 4 1.2 Vorgehensmodelle ......................................................................................................... 5 1.3 UML .............................................................................................................................. 6 1.4 Lastenheft, Pflichtenheft .............................................................................................. 6 1.5 Qualität ......................................................................................................................... 8

2 Grundlagen Programmierung .......................................................................................... 9 2.1 Anweisung von Programmiersprachen ....................................................................... 9 2.2 Entwicklungsumgebung MS Visual Studio C# - erstes Programm ........................... 10

3 Beispiele ........................................................................................................................... 13 3.1 Excel (Prototyping) ...................................................................................................... 13 3.2 Kleines Programm (Grundlagen) ................................................................................ 15 3.3 Erweitertes Programm (Listen, Objektorientierung)................................................. 17

4 Ausblick und Motivation zum Weitermachen ............................................................... 19 5 Aufgaben: Erweiterungen im Programm ....................................................................... 19 6 Verweise und Literatur ....................................................................................................20

Literaturverzeichnis..............................................................................................................20 Über den Autor .....................................................................................................................20

4

1 Allgemeine Softwareentwicklung

Es liegt in der Natur der Sache, dass es zum Thema Softwareentwicklung im Internet viel Literatur gibt. Eine Ausgangsadresse ist sicherlich [wikipedia]. Das Nachschlage-werk ist zunächst unabhängig von Programmiersprachen und enthält viele Links, teil-weise auch zu gut laienverständlichen Seiten. Als umfassendes und deutschsprachiges Lehrbuch sei [Balzert] zu nennen. Im vorliegenden Skript finden Sie einen Überblick zum Thema, der hoffentlich Lust auf mehr macht.

Software wird üblicherweise als Gegenstück zur Hardware gesehen, also die nicht phy-sikalischen Funktionsbestandteile eines Computers. Üblicherweise werden diese in die ausführbaren Programme und in die zugehörigen Daten unterteilt. Ein Softwareprojekt unterscheidet sich von dem Ablauf eines Gebäude- oder Maschinenbauprojekts grund-legend, da Software

ein immaterielles Produkt ist,

physikalisch nicht begrenzt ist,

schnell änderbar ist,

schwer zu vermessen ist,

keinem Verschleiß unterliegt,

altert.

Nur einige Punkte herausgepickt - „Software ist schwer zu vermessen“: Gerade im Ma-nagement ist es nicht immer einfach den Fortschritt der Softwareentwicklung und die aktuelle Qualität abzuschätzen. Z.B. anhand der Anzahl der entwickelten Zeilen Code kann der Entwicklungsstand, aber auch die Qualität des Entwicklers erkannt werden (ein erfahrener Entwickler benötigt sehr viel weniger Zeilen Code). „Software unter-liegt keinem Verschleiß, aber sie altert“ – kaum jemand arbeitet heute noch mit einem Windowssystem vor XP – obwohl dessen Einführung gerade einmal 11 Jahre her ist (Okt 2001). Für viele Programme gibt es heute gar keine Computer mehr, oder kein Lesegerät (Lochkarten, Disketten). Zu jeder Zeit müssen Firmen, die am Markt beste-hen wollen, ihre Software an die neuste Hard- und Softwaregeneration anpassen und neuen Anforderungen wie Normenänderungen implementieren.

1.1 Anforderungen und Eigenschaften

Die Anforderungen an eine Software sind vielfältig und lassen sich in Anlehnung an die SRS (Software Requirement Specifications) der IEEE1 in folgende Punkte unterteilen:

Korrekt / Unzweideutig / Aktuell

Zuverlässig, Stabil

Vollständig, Konsistent

Verifizierbar

Verfolgbar (Traceable)

Benutzerfreundlich (für Anwender und Entwickler)

Modifizierbar

1 IEEE Institute of Electrical and Electronics Engineers – weltweiter Berufsverband von Ingenieuren

im Bereich Elektrotechnik und Informatik

5

Wieder herausgepickt - „Verfolgbar“ muss Software sein z.B. über Versionsnummern. Ohne diese würde der Update- (Aktualisierungs-) Mechanismus von Software nicht funktionieren. Software muss immer häufiger „modifizierbar“ sein. Sie baut auf alten Quellen auf oder wird kombiniert aus verschiedenen Produkten. Anpassungen auf vie-len Ebenen sind notwendig und erfordern eine möglichst gute Architektur und Doku-mentation.

Um die genannten Anforderungen zu erfüllen sollte die Software folgende Eigenschaf-ten (specifications) haben:

Präzise Spezifikation der Anforderungen

Separation der Anforderungen

Modularität

Abstrahiert und Generalisiert

Vorausschauend entwickelt

Heutzutage wird die Entwicklung im Anwendungsbereich mit Standardwerkzeugen durchgeführt. Mit den aktuellen, am häufigsten genutzten Programmiersprachen „Hochsprachen“ (C++, C#, Java) wird durchgehend objektorientiert entwickelt.

1.2 Vorgehensmodelle

Ein Haus wird üblicherweise geplant, bevor gebaut wird. Also auch:

Vorgehensmodelle geben bei der Entwicklung von Software einen Überblick über den prinzipiellen Ab-lauf.

Beim Wasserfallmodell (Abbildung 1) werden einzelne Fasen definiert und sukzessiv abgearbeitet. Der Vorteil ist, dass nach jedem Schritt der Stand der Dinge reflektiert werden kann. Nach-teilig ist, dass Erkenntnisse in einer späten Fase nur mit viel Aufwand über-arbeitet werden können, da der Zustand der Software sehr weit ist. Dieser Nachteil wird gerne durch die Entwicklung von Pro-totypen während der Analyse- und Entwurfsfase reduziert.

Eine deutliche Verbesserung lässt durch ein iteratives Vorgehen erreichen. Hierbei wird das Wasserfallmodell wiederholt durchlaufen und Fehler und fehlende Anforde-rungen aus der früheren Iteration überarbeitet. Dies entspricht eher der Realität, da nicht immer alle Anforderungen zu Beginn des Projekts bekannt sind.

Das V-Modell (Abbildung 2) erweitert die Schritte Analyse, Entwurf und Realisierung mit Testmethoden, die weiter in Kapitel 1.5 beschrieben werden. Nach der Verifizie-

Software bitte nicht einfach oder „Quick and Dirty“. „losprogrammieren“!

Abbildung 1: Ablauf beim Wasserfallmodell [Balzert]

6

rung (Korrekter Programmdurch) und Validierung (Übereinstimmung mit den Anfor-derungen) wird die Software an den Kunden ausgeliefert.

Abbildung 2: V-Modell mit Testfällen

Je nach Fachgebiet und Entwicklungsteam sind dynamischere Verfahren wie Scrum oder Extreme Programming als Vorgehensmodell empfehlenswert. /link/: Vorgehensmodelle Scrum, Extreme Programming [wikipedia]

1.3 UML

Die UML (Unified Modeling Language) ist eine Sammlung von Diagrammen für den Entwurf von Computerprogrammen. Sie ist prinzipiell unabhängig von Programmier-sprachen, obwohl viele Diagramme objektorientiert arbeiten. Mit UML-Diagrammen kann eine vollständige Entwicklung durchgeführt werden. In Abbildung 4 werden ei-nige Diagramme und Anwendung vorgestellt [Fowler].

Anwendungsfalldiagramm [Analyse]

Use case diagram Aufstellung der Akteure (z.B. Kunde, Ab-rechnungsabteilung) und Anwendungs-fälle (z.B. Rechnung stellen)

Aktivitätsdiagramm [Entwurf]

Activity diagram Reihenfolge von Aktivitäten, bedingtes Verhalten, Verzweigungen Ablauf von Programmen u. Algorithmen

Klassendiagramm [Entwurf]

Class diagram Beziehungen von Klassen als Grundlage der objektorientierten Programmierung, Automatische Erstellungstools bei Klas-sendiagrammen üblich

Sequenzdiagramm [Entwurf]

Sequence diagram Visualisierung der Existenz und der In-teraktion von Objekten

Abbildung 3: ausgewählte UML Diagramme

In den Beispielen (Kapitel 3) werden die Anwendungen anhand einiger Diagramme vorgestellt. Z.B. zeigt ein Aktivitätsdiagramm den Ablauf des „kleinen Programms“ (Abbildung 14) und ein Klassendiagramm die Vererbung der Kräfte (Abbildung 16).

1.4 Lastenheft, Pflichtenheft

Nach einer Initialisierung werden die Ziele eines Projekts (üblicherweise) vom Auf-traggeber mit einem Lastenheft definiert. „Was“ soll gemacht werden? Dies können nur einige Basisanforderungen oder eine detaillierte Aufgabenstellung mit Vorgaben über den Vorgang sein. Das Lastenheft kann für eine Ausschreibung mit definierten Anforderungen an Projekt, Auftragnehmer und Ablauf, je nach Einsatz des Pro-gramms, Ziel oder Kenntnisstand des Auftraggebers verwendet werden. Abbildung 4

7

zeigt einige Hauptaspekte eines Lastenhefts. Im Fallbeispiel (Prototyp und Kleines Programm Kapitel 3) wurde nur eine allgemeingehaltene Aufgabe und der Produktein-satz vorgegeben:

Zielbestimmung Programm zur Berechnung der Schnittgrößen eines Ein-feldträgers

Produkteinsatz Präsentations-Beispiel für Studierende und Mitglieder der Berufungskommission

Produktfunktion (Detailliertere Aspekte des Programms und seines Ablaufs)

Produktdaten (Informationen über die Datenhaltung z.B. Speichern, La-den)

Produktleistung (Leistungsdaten wie Geschwindigkeit, Stabilität)

Qualitätsanforderungen (z.B.: Zuverlässigkeit des Produkts, Stresstests)

Ergänzungen (z.B.: Erweiterungsmöglichkeiten, zu beachtende Normen, Anforderungen an Auftragnehmer u. Projektmanagement)

Abbildung 4: Aspekte eines Lastenhefts, in Klammern mögliche Ergänzungen

Das Pflichtenheft wird vom Auftragnehmer erstellt und definiert das „Wie?”. Dieser beschreibt wie und womit er die Anforderungen erfüllen wird. Das Pflichtenheft sollte Grundlage des Vertrags zwischen Auftraggeber und -nehmer sein und daher nachprüf-bare Fälle ein- oder auch ausschließen. Durch die Definition von Testszenarien sollte die Qualität des Produkts prüfbar sein („Akzeptanztest“). Abbildung 5 zeigt die Aspek-te eines Pflichtenhefts mit dem Fallbeispiel.

Zielbestimmung Muss: Programm zur Berechnung der Schnittgrößen eines Einfeldträgers

Produkteinsatz Präsentations-Beispiel für Studierende und Mitglieder der Berufungskommission

Produktfunktionen Berechnung eines Einfeldträger mit einer Streckenlast Eingabeparameter: Streckenlast, Länge, Darstellungspara-meter Anzeige der Auflagergrößen Darstellung der Schnittgrößen M, Q, (N) Leicht erklärbar (gute Dokumentation)

Produktdaten Keine Datenhaltung (Speichern, Laden)

Produktleistungen Exakte Berechnung, hohe Stabilität

Qualitätsanforderungen Gute Zuverlässigkeit, keine Anforderungen an Effizienz

Benutzeroberfläche Windows-GUI

Technische Produktum-gebung

Prototyp in Excel, Entwicklung in VisualStudio-C#

Ergänzungen Erweiterbarkeit des Programms beachten Veröffentlichungsrechte (Schulungsbetrieb)

Abbildung 5: Aspekte des Pflichtenhefts angewendet auf das Fallbeispiel aus Kapitel 3

/link/: Lastenheft und Pflichtenheft: Normierung und weitere Aspekte [wikipedia]

8

1.5 Qualität

Was ist die Qualität einer Software? Grundsätzlich ist die Qualität die Erfüllung der Anforderungen von Kunden und weiteren interessierten Parteien (wie z.B. auch Um-welt). Die Norm ISO 9126 spezifiziert für Software folgende Punkte (vgl. Softwarean-forderungen aus Kapitel 1.1):

Funktionalität (functionality)

Zuverlässigkeit (reliability)

Benutzbarkeit (usability)

Effizienz (efficiency)

Änderbarkeit (maintainability)

Übertragbarkeit (portability)

Werden die Anforderungen nicht erfüllt, wird von einem Fehler gesprochen. Da die Behebung von Fehlern je nach Zeitpunkt des Auftretens immer teurer wird, ist ein Ziel Fehler möglichst frühzeitig aufzudecken. Üblich sind Entwurfs- und Entwicklungsbe-gleitende Testverfahren (siehe auch V-Modell in Abbildung 2) auf allen Ebenen. Z.B. werden Unit-Test-Programme geschrieben oder manuelle Reviews durchgeführt um einzelne Funktion zu überprüfen (Modultest). Mit Integrations- und Systemtests wer-den Programme und das Zusammenspiel verschiedener Programmteile getestet. Ab-nahmetests prüfen schließlich ob die Anforderungen an das Programm erfüllt sind.

Hinweise zum allgemeinen betrieblichen Ablauf in der Entwicklung gibt schließlich die ISO EN DIN 9000 und weitere mit folgenden Punkten

Lenkung von Dokumenten und Fehlern

Kontinuierliche Verbesserung (Produkt und Prozess)

Dokumentation (Qualitätsaufzeichnungen)

Validierung von Produkten und Lieferanten (z.B. Softwarebibliotheken)

Grundsätzlich sollten Programmierer und Tester nicht eine Person sein.

9

2 Grundlagen Programmierung

Eine Programmiersprache ist eine Schnittstelle zwischen Mensch und Computer. Bei der Programmierung werden Computerprogramme in einem Quellcode (z.B. C#, Java, C++ uvm.) erstellt – „implementiert“. Hierzu werden

Editoren (spezielle Textverarbeitung für Code mit strukturierter Darstellung – Highlighting bestimmter Ausdrücke wie Befehle),

Frameworks („Ordnungsrahmen“, vorgegebene Strukturen, wie Oberflächen-elemente, Funktionselemente, Schnittstellen etc.),

SDKs (Software Development Kit)(Sammlung von Werkzeugen und Anwen-dungen)

sowie viele weitere Softwareprogramme wie z.B. Bild-, Audio-, Videoverarbeitungs-software verwendet. Die heute hauptsächlich genutzten Programmiersprachen sind sog. „Hochsprachen“, problemorientierte, für den Menschen lesbare Sprachen, die erst in eine Maschinen-sprache übersetzt - „compiliert“ werden müssen. Je nach Programmiersprache wird vor oder während der Ausführung (just-in-time) compiliert. Erst die Maschinensprache ist für den Prozessor des Computers ausführbar. Abbildung 6 zeigt den Ablauf vom im Editor erstellten Code bis zum ausführbaren Programm in Maschinensprache. Da ein Teil der Fehler im Code erst bei der Ausführung der Maschinensprache festgestellt werden können, wird das Programm in der Entwicklung mit einem Debugger gestartet der es ermöglicht während der Ausführung auf den Code zuzugreifen.

Abbildung 6: Ablauf der Programmerstellung

2.1 Anweisung von Programmiersprachen Eine Programmiersprache enthält Anweisungen, die in der Syntax der jeweiligen Pro-grammiersprache formuliert sind und im Programmverlauf abgearbeitet werden. Unter Semantik wird die Bedeutung der Anweisungen verstanden. Syntax und Semantik werden in Abbildung 7 für die wichtigsten Anweisungen kurz beschrieben:

10

Deklaration / Variable / Type int A; In Variablen werden Daten abgelegt. Durch ihren Typ wird die Art der Daten eingeschränkt. Folgen-de Typen werden verwendet:

Text: char (ein Zeichen), string (Zeichenket-te)

Numerische: int (Integer - Ganze Zahlen) double (Fließkomma-Zahlen), float, decimal, long, short…

Boolean: bool (Logische Variable true/false)

byte: Speichereinheit

Zuweisung A = 5; Einer Variablen wird ein Wert zugewiesen.

Block { } Anweisungen werden bzw. müssen in Blöcke zu-sammengefasst werden.

Bedingte Anweisung if (A > 5) {A = 3} Eine bedingte Anweisung entscheidet durch eine Bedingung, ob in einen Programmabschnitt ver-zweigt wird oder nicht.

Switch-Case Anweisung Switch (A){case 5: A=1; break; case 3: A=10;break} Mehrere bedingte Anweisungen werden kombi-niert.

Schleifen for(int i=0; i<10; i++) while(i<10) Schleifen wiederholen Codebereiche bis eine Ab-bruchbedingung erfüllt / nicht erfüllt ist.

Funktionsaufruf TestFunktion(); Funktionsaufruf verzweigt in ein Unterprogramm.

Return Return A; Rücksprungmarke für Unterprogramme

Kommentar // Das ist ein Kommentar-Text /* das ist auch einer */ Kommentare sind vom Programm nicht beachtete Dokumentationshilfen.

Felder, Listen Int[] TestFeld; List<int> TestListe; Felder und Listen strukturieren Gruppen von Vari-ablen.

Abbildung 7: Programmiersprachenelemente (Beispiele in C#) (eine Auswahl)

2.2 Entwicklungsumgebung MS Visual Studio C# - erstes Programm

Das Beispielkapitel 3 enthält zwei Programme, die mit der Entwicklungsumgebung Visual Studio2 C# von Microsoft entwickelt wurden. Sowohl die Programmiersprache C# als auch die Entwicklungsumgebung sollen an dieser Stelle exemplarisch sein. Ent-sprechend lässt es sich mit anderen Programmiersprachen, Editoren und Betriebssys-

2 Für die Beschaffung und Installation auf Ihrem Rechner siehe Kapitel 6 -Anhang

11

temen arbeiten. Da Microsoft mit dem sogenannten .Net Framework mehrere Pro-grammiersprachen (C#, C++, VBA, J#) in Visual Studio bearbeitbar und sogar kombi-nierbar macht, ist diese Programmierumgebung neben verschiedenen Java-Entwicklungsumgebungen Marktführer.

Abbildung 8 zeigt die Oberfläche von Visual Studio und die wichtigsten Elemente. Star-ten Sie mit „Datei/Neues Projekt“ und wählen Sie „Windows Forms-Anwendung Visual C#“. Sie beginnen mit einer leeren Dialogbox, aber einem vollständigen Programm. Starten Sie mit dem Button „Debugging starten“ das Programm und Sie erhalten die leere Dialogbox als reguläres Windowsprogramm. Beenden Sie dieses und ziehen Sie aus der Toolbox (links) verschiedene Form-Elemente in die Dialogbox-Ansicht (Mitte). Abbildung 8 zeigt eine Dialogbox, die für das Einfeldträger-Testprogramm zusammen-gestellt worden ist.

Abbildung 8: Oberfläche von Microsoft Visual Studio C# Express

Klicken Sie auf ein beliebiges Element in der Dialogbox-Ansicht und Sie erhalten dazu rechts unten das Fenster „Eigenschaften“ mit denen Sie einerseits die Eigenschaften (Button mit Liste) und andererseits die Ereignisse (Button mit Blitz) einstellen können. Eigenschaften können Farben, Schriftarten oder Initialisierungstexte sein, Ereignisse zeigen die Verweise auf eine Codestelle, die z.B. bei Maus-Klick auf einen Button, aus-geführt wird.

Erzeugen Sie einen Button aus der Toolbox in Ihrer Dialogbox, markieren Sie Ihn, wechseln Sie in den Eigenschaften in Ereignisse (Blitz) und machen Sie einen Doppel-klick auf „Click“. Der Editor erzeugt Ihnen eine Codestelle, die ausgeführt wird, wenn

12

Sie auf den Button clicken. Schreiben Sie „Mess“ und warten einen Augenblick. Der Vervollständigungsassistent „Intellisense“ hilft Ihnen mit möglichen Erweiterungen (Abbildung 9).

Abbildung 9: Vervollständigungsassistent „Intellisense“

Vervollständigen Sie damit folgenden Befehl:

und starten Sie das Programm mit dem „Debugging starten“-Button (oder ShortCut F5) erneut. Klicken Sie einmal auf den Button3…

Sie wollen zurückwechseln in die Dialogbox-Ansicht? Mit dem Reiter für Dateien (sie-he Abbildung 8) können Sie zwischen der Dialogbox und dem zugehörigen Code und weiteren Dateien wechseln.

Nicht immer läuft alles korrekt in einem Programm. In der Fehlerbox (Abbildung 8) werden Fehler und Warnung, die beim Compilieren erkannt werden, aufgelistet.

Zum Schluss der Einführung sollten Sie noch den „Debugger“ kennenlernen. Mit dem Button „Debugger starten“ haben Sie ja bereits schon mit gearbeitet. Mit einem De-bugger können Sie ein Programm Schritt für Schritt durchlaufen, an einer beliebigen Stelle anhalten und z.B. den Wert von Variablen prüfen. Mit der Taste F11 (Debug-gen/Einzelschritt) können Sie das Programm in Einzelschritten durchlaufen, mit F10 (Debuggen/Prozedurschritt) werden größere Schritte ausgeführt.

Alternativ können Sie mit der rechten Maustaste / Haltepunkt / Haltepunkt einfügen einen Haltepunkte (Breakpoint) einsetzen, an dem das Programm stehen bleibt (Abbildung 10).

Abbildung 10: Haltepunkt

3 Mit “Hello World“ als Ausgabe in einer Programmiereinführung zu beginnen ist Tradition seit den

ersten Entwicklungen von C im Jahre 1974.

13

3 Beispiele

Zunächst wird die Grundlage der Mechanik „Berechnung von Auflagern und Schnitt-größen an einem Einfeldträger“ anhand der Abbildung 11 gezeigt. Dies muss aber an dieser Stelle genügen – für weitere Erklärungen verweise ich auf die Grundlagenvorle-sungen und -skripte in Mechanik und Statik.

Abbildung 11: Berechnung der Auflagergrößen AV,BV,AH und der Schnittgrößen Mx,Qx,Nx an der Position x

Im Folgenden werden diese Formeln auf die Programmierung übertragen, zunächst als Prototyp in Excel – um sie dann unter C# zu programmieren.

3.1 Excel (Prototyping)

Microsoft Excel (oder auch OpenOffice – siehe Kapitel 6) lässt sich für Ingenieuraufga-ben mit geringerer Programmier-Komplexität hervorragend verwenden. Als Prototyp wird zunächst die Aufgabenstellung in einer Excel-Tabelle gelöst. Hierzu sind nur die Berechnungsformeln und ihre Anwendung in Excel notwendig. Excel bietet bei dieser „einfachen“ Berechnung klare Vorteile:

Schnelle Programmierung

Oberfläche “wysiwyg” (what you see is what you get)- man sieht jederzeit das Ergebnis

Eingabefelder, Diagramme sind einfach erstellt

Erweiterbarkeit über VBA (Visual Basic for Applications) möglich Arbeitsschritte in Excel:

1) Eingabe-Felder 2) Berechnung Auflager 3) Rasterschritte für Zeichnung, x-Position bestimmen

14

4) Berechnungsformeln für Auflagerkräfte, Momenten-, Querkraftberechnung 5) Diagramm erzeugen (Punkte mit interpolierten Linien und Datenpunkten) 6) Oberfläche und Diagramm anwenderfreundlich formatieren

Abbildung 12: Excel- Berechnung und Diagramm für einen Einfeldträger mit konstanter Streckenlast

Formeln werden in Excel mit einem beginnenden „=“ eingegeben, Werte (Variablen) verweisen auf die Position in der Tabelle (Buchstabe Zahl). Durch „$“ lassen sich Werte arretieren (z.B. für das Kopieren). Im Beispiel (Abbildung 12) wird die Länge des Einfeldträgers in 10 Rasterschritte geteilt und die Positionen in x-Richtung (3) berechnet. Schließlich wird diese Position für die Berechnung von Querkraft (4a) und Moment (4b) verwendet. Die Formeln (3, 4a, 4b) werden zunächst in der Tabellenzeile (B11, C11, D11) eingegeben und danach bis (B21, C21, D21) kopiert. Arretierung mit „$“ nicht vergessen. Die Darstellung dieser Tabelle als Diagramm wird von Excel über die Diagrammfunk-tionen übernommen. Die Einstellung „Punkte mit interpolierten Linien und Daten-punkten“ lässt die Positionierung von Einzelpunkten mit x und y-Parametern zu und interpoliert eine Funktion.

15

3.2 Kleines Programm (Grundlagen) Ein erstes Programm in C# können Sie nach Kapitel 2.2 bereits schreiben. Wiederholen Sie diese ersten Schritte, nur erweitern Sie jetzt die Dialogbox durch zwei Eingabefel-der (TextBox) und ein Bildfeld (PictureBox). Suchen Sie diese aus der Toolbox heraus und platzieren Sie diese ähnlich wie in Abbildung 13. Durch zusätzliche Labels können Sie erklärende Wörter und Texte hinzufügen.

Abbildung 13: Dialogbox der Anwendung

Für den nächsten Schritt wird zunächst das Verständnis für den Ablauf des Programms benötigt. Am Anfang des Kapitels 3 wurden die mechanischen Grundlagen erläutert, Kapitel 2.2 zeigte den Einstieg in die Programmierung mit C#.

Ähnlich wie im Prototypen mit Excel ist der Programmablauf „Eingabe der Werte“, „Berechnen der Auflager“, „Berechnen der Schnittgrößen“ und „Zeichen der Schnittgrößen“. Anstelle der Werteliste wird eine Schleife über die x-Positionen ver-wendet, deren Rasterschritte in dem kleinen Programm durch die Breite der PictureBox festgelegt werden. Abbildung 14 zeigt den Programmablauf und die Schleifenbedingung x < l.

Verwenden Sie das Programm Kapitel 2.2 und kommentieren Sie zunächst die „Hello World“- Ausgabe aus. Erweitern Sie die Funktion um eine Aktualisierungs-Funktion für die pictureBox, mit der bei Knopfdruck neu gerechnet und ge-zeichnet werden soll:

Abbildung 14: Ablauf kleines Programm

16

Die Hauptaufgabe wird in der Zeichenfunktion der pictureBox erledigt. Zunächst er-zeugen Sie die Zeichenfunktion, indem Sie in die Entwurfsansicht wechseln, die PictureBox auswählen und in den Eigenschaften/Ereignissen das Ereignis Darstellstel-lung – Paint auf pictureBox1_Paint setzen (Doppelklick automatisiert dies).

Die Eingabe von pictureBox1_Paint erweitert das Programm um eine weitere (noch lee-re) Funktion. Hier wird folgende Funktionalität hinzugefügt:

Zunächst beginnt die Funktion pictureBox1.Paint mit einer „bedingten Anweisung“ (if Abfrage), in der leere Texteingabefelder abgefragt werden und die Zeichenfunktion verlassen wird. Falsche Anwendereingaben (z.B. „123AB“) werden dabei nicht abgefan-gen. Als nächstes folgt ein Funktionsaufruf „Calculate_Bearing“ zur Berechnung der Auflager. Ähnlich folgen später die Aufrufe zur Berechnung von Moment (Calculate_M) und Querkraft (Calculate_Q). Eine Funktion verweist auf ein Unterpro-gramm und kann an dieses beliebig viele Werte übergeben. Zurück gegeben wird in dieser Funktion ein (oder kein) Wert mit der Anweisung „return“. Auf der gleichen Ebene wie die Funktion pictureBox1_Paint stehen diese Berechnungsfunktionen und enthalten jeweils die Berechnung von Auflager, Moment, Querkraft (Vergleiche die Formeln mit den Ansätzen in Abbildung 11).

17

Mit einer „For-Schleife“ werden sukzessiv die x-Werte für M und Q berechnet und in die PictureBox gezeichnet. Hierbei wird eine Laufvariable „i“ deklariert, die (manuell eingestellt) zwischen 0 und 100 hochzählt. Sie wird für die Berechnung der x-Position und für die Zeichenposition verwendet.

3.3 Erweitertes Programm (Listen, Objektorientierung) Wie geht es weiter? Ein Programm, das genau eine Linienlast auf einem Einfeldträger zeichnen kann ist ein schönes Übungsbeispiel, aber sicherlich nicht wirklich hilfreich. Erweitert werden soll das Programm indem beliebige vertikale Linien- und Einzellas-ten eingetragen werden können (Abbildung 15 links). Schauen Sie sich das ganze Pro-gramm an – an dieser Stelle werden dazu die Themen Strukturierung des Codes, Felder und Listen und der erste Schritt objektorientierte Programmierung vorgestellt.

Abbildung 15: (links) Erweitertes Programm – mit mehreren Linien und Punktlasten; (rechts) Strukturierungsmöglichkeiten im Code

Strukturierung des Codes: Durch die Erweiterungen wächst der Code, so dass verschie-dene Methoden zur Strukturierung angewendet werden müssen um den Überblick zu bewahren. Neben der weiteren Modularisierung mit Funktionen, wird der Code im Editor strukturiert Abbildung 15 (rechts). Unterbereiche können mit den +/- Tasten ein bzw. ausgeklappt werden. Automatisch werden Unterbereiche bei Funktionen, Klassen

18

usw. erzeugt, eigene können mit dem Preprozessor-Befehl #region hinzugefügt wer-den. Schließlich sollte mit Kommentaren nicht gegeizt werden, da jemand, der das Programm liest, sehr dankbar sein wird.

Felder und Listen sind oft verwendete Datenstrukturen. Bei der Programmerweiterung können beliebig viele Lasten einer Liste hinzugefügt und in der Berechnung verwendet werden. Hierzu wird die Liste ähnlich wie eine Variable mit einem Typ initialisiert und es werden mit Add Elemente hinzugefügt oder mit Remove welche gelöscht.

Ähnlich können Felder verwendet werden. Die Größe eines Felds genauso wie sein Typ wird bei der Initialisierung festgelegt. Danach kann es über einen Index gefüllt und ausgelesen werden.

Die Objektorientierte Programmierung ist heute quasi Standard in der modernen An-wendungsentwicklung. Im Programm finden Sie eine Reihe von Elementen dieser Ar-chitektur wie die Befehle class, override oder public und private. Da dieses Thema eine eigene Vorlesungsreihe füllen würde, wird hier nur ein kleiner Eindruck vermittelt.

Die Aufgabenstellung wird in Objekte und ihre Eigenschaften zerlegt (OOD - objekt-orientiertes Design). Z.B. wird im Beispiel eine Last als Objekt modelliert. Dieses be-kommt als Eigenschaft die Angriffsposition (Punkt bei Einzellast und Strecke mit Beginn und Ende bei einer Streckenlast) und die Last. Bei der Berechnung wird der Hebelarm getLoadCenter und die summierte Last getLoadInCenter an dieser Stelle benötigt. Da die Lastobjekte gleiche Abfragen und Para-meter besitzen, werden diese Parameter in einer Basisklasse generalisiert. Die spezielle Lasten (Linien- und Einzel-) werden von die-ser Basisklasse abgeleitet und erben diese Eigenschaften. Sie müssen nur noch die Ein-zigartigkeit Last (q_load, F_load) hinzufügen. Der Vorteil ist, dass die Lasten in einer Liste vom Typ BasicForce verwaltet werden können und der spezielle Typ erst bei Laufzeit sich an die Eingabe vom Anwender anpasst.

Angedeutet ist in Abbildung 16 auch die Erweiterung der Lastarten, denkbar sind hier weiter Lasten wie lineare Linienlasten oder Momente.

Abbildung 16: Klassendiagramm für Lasten; LineLoad und OneLoad erben von BasicForce

19

4 Ausblick und Motivation zum Weitermachen

Je weiter solch ein Programm wächst umso mehr Möglichkeiten werden sichtbar. Die Aufgaben in Kapitel 5 zeigen in diese Richtung. Das Programm lässt sich neben neuen Lastfällen auch in Richtung komplexere Geometrie oder andere Auflagertypen erwei-tern. Spätestens aber wenn der Träger statisch unbestimmt ist, werden die Rechnun-gen aufwendig. Dann wird üblicherweise die Finite Elemente Methode als Ansatz ver-wendet.

5 Aufgaben: Erweiterungen im Programm

Laden Sie sich die Programme herunter und versuchen Sie sie in der Entwicklungsum-gebung zum Laufen zu bringen. Funktioniert es? Dann geht es mit folgenden Aufgaben weiter:

A) Erweitern Sie die Excel-Tabelle um eine positionierbare Einzelkraft.

B) Bauen Sie das erweiterte Programm aus Kapitel 3.3 noch aus:

Gui (Graphical User Interface)– Oberfläche des Programms o Stellen Sie die Kräfte (Streckenlasten und Einzelkräfte) mit dar. o Beschriften Sie die Achsen automatisch mit Einheiten und Text

Umfang beim Berechnen o Erweitern Sie das Programm um weitere Lasttypen (Lineare Streckenlas-

ten, Momente, Normalkräfte). o Geben Sie optional die Durchbiegung und das maximale Moment mit

aus.

Entwerfen sie eine Routine zum Speichern und Laden (Stichwort „xml“).

C) Und zu guter Letzt ein Fehler: Geben Sie eine Kraftposition an, die außerhalb des Einfeldträgers liegt (Z.B. Pos = 15 m, Länge = 10 m). Dies ist nicht abgefan-gen und führt zu einer Fehlermeldung. Versuchen Sie diese abzufangen und bringen Sie eine Warnungsmeldung. Gibt es noch andere Möglichkeiten das Programm abstürzen zu lassen? –Testen Sie manuell – der Aufwand dieses Programm zur Kundenreife zu bringen ist mindestens noch einmal so groß wie es zu schreiben.

20

6 Verweise und Literatur Unter www.scraper.de finden Sie eine kurze Zusammenstellung – dieses Skript, die Programme und alle Verweise. Bei allen Microsoft-Programmen lohnt es sich die Aca-demic-Palette der Hochschulen durchzuschauen. Viele Produkte bekommen Sie hier kostenfrei. Auch nicht mehr kosten folgende Produkte, mit denen Sie die Beispiele im Skript reproduzieren können:

o (Apache) Openoffice (www.openoffice.org) enthält Calc3 als Alternative zu Excel

o C# Visual Studio Express (www.microsoft.com/visualstudio/deu/downloads)

Literaturverzeichnis

[wikipedia]: Die Online Enzyklopädie. Viele Aspekte aus dem Skript sind auf www.wikipedia.de sehr gut beschrieben und können gut für die weitere Vertiefung oder als Ausgangspunkt dienen. Eine Detaillierung erfolgt nicht, da alle Hauptbegriffe des Skripts als Suchbegriff verwendbar sind.

[Zahrnt] C. Zahrnt: IT-Projektverträge: Erfolgreiches Management. Dpunkt.verlag Hei-delberg, 2009.

[Fowler] M. Fowler, K. Scott: UML konzentriert, eine strukturierte Einführung in die Standard-Objektmodellierungssprache, 3. Auflage, Addison-Wesley, 2003.

[Balzert] H. Balzert: Lehrbuch der Software-Technik (Teile I und II), 3. Auflage, Speck-trum Akademischer, Verlag 2009.

Über den Autor

Der Weg eines Bauingenieurs oder ein CV zwischen Bauwesen und Informatik:

seit 2009 bei einer Mittelständischen Firma (140 Personen) in Köln, Projekt- und Teamleitung, Qualitätsmanagement, Organisationsleitung in der Softwareentwicklung: CAD Gebäudebetrachtung

Technische Ausrüstung (TGA) Energetische Betrachtung

Promotion zum Thema „Mess- und Auswertetechnik zur Riss- und Faserdetek-tion bei Betonbauteilen“ (RWTH Aachen)

Studium Bauingenieurwesen mit Vertiefung Massivbau, Grundbau, Wasserbau (RWTH Aachen)

Hobbies: Familie, Tanzen, Lebendiges Mittelalter …

Kontakt: Johannes Lange – lange.johannes@gmx.de