Guten Tag! In diesem Tutorial erstellen wir Ihre erste GUI-Anwendung in MS. visuelles Studio. Es wird eine Art "Hello World" für grafische Anwendungen sein. Das sage ich gleich Windows-Nutzung Forms ist nicht die einzige Möglichkeit für C#-Programmierer, grafische Anwendungen (Anwendungen mit einer grafischen Benutzeroberfläche) zu erstellen, aber es ist ein guter Ort, um mit dem Lernen zu beginnen. Und so starten wir Visual Studio.

Gestartet? Dann zum Geschäft! Wir gehen zum Hauptmenü und wählen den Punkt "Datei - Neu - Projekt", wie in der folgenden Abbildung gezeigt.

Im erscheinenden Fenster:

• Wählen Sie auf der linken Seite „Vorlagen – Visual C# – Windows“;
• Wählen Sie im Hauptbereich das Element „Windows Forms-Anwendung“;
• Geben Sie im unteren Teil des Fensters den Namen des Projekts ein und geben Sie seinen Speicherort auf der Festplatte an.

Im Allgemeinen, wie in der Abbildung unten gezeigt.

Haben Sie angegeben, was Sie brauchen? Klicken Sie dann auf die Schaltfläche „OK“. Jetzt sollten Sie so etwas sehen (die Hauptbereiche sind mit Rechtecken hervorgehoben):

In der obigen Abbildung habe ich die Hauptbereiche beschriftet: den Designerbereich (oben links), den Lösungs-Explorer-Bereich (oben rechts) und den Eigenschaftenbereich (unten rechts). Dies sind die Bereiche, mit denen wir am häufigsten arbeiten werden.

Im Designerbereich befindet sich nun ein leeres „Formular“, das sogenannte Fenster, in diesem Fall das Hauptfenster unseres Programms. Der Eigenschaftenbereich zeigt die Eigenschaften des im Designer ausgewählten Elements an, in diesem Fall unser Formular, aber der Lösungs-Explorer-Bereich enthält Projektdateien, einschließlich derjenigen, die sich auf die Formulare (Fenster) des Programms beziehen. Und jetzt ändern wir unser Formular ein wenig und führen diese erste Anwendung aus.

Wählen Sie dazu das Formular im Designer aus (dazu können Sie einfach mit der linken Maustaste auf das Formular klicken) und gehen Sie zum Eigenschaftenblock, in dem wir die Zeile "Text" finden (das Wort ist Text, das wir suchen es in der linken Spalte), wie in der Abbildung unten gezeigt.

Eigenschaft "Text" des Hauptformulars der Anwendung

Bitte beachten Sie, dass die linke Spalte den Namen (Name der Eigenschaft) und die rechte Spalte seinen Wert anzeigt.

In diesem Fall haben wir es mit einer Texteigenschaft zu tun, und ihr Wert wird im Fenstertitel angezeigt, also fügen wir jetzt etwas Eigenes hinzu, zum Beispiel so etwas wie: "Hauptfenster", wie in der folgenden Abbildung gezeigt:

Jetzt können Sie das Projekt erstellen und ausführen. Gehen Sie dazu in das Hauptmenü und wählen Sie "Build - Build Solution". Und dann starten wir die Anwendung, dazu wählen wir im Hauptmenü den Punkt "Debug - Ohne Debugging ausführen". Als Ergebnis sollten Sie das folgende Fenster sehen.

In der nächsten Lektion schauen wir uns an einfache Arbeit mit dem Formulardesigner und dem Einrichten von GUI-Elementen, und diese Lektion ging zu Ende, wir haben die erste grafische Anwendung erstellt, gebaut und gestartet.

Hallo an alle. In meinen vorherigen Lektionen habe ich über das Erstellen von Konsolenanwendungen in der Borland C++ Builder-Umgebung gesprochen. Ausgehend von dieser Lektion lernen wir C++ am Beispiel grafischer Anwendungen. Wer lernen möchte, wie man Konsolen erstellt. Kann das Buch "The Art of Building Console Applications in C++" lesen. Unsere erste Anwendung wird ein Programm sein, das eine Zufallszahl anzeigt. Wir öffnen borlandyayu, erstellen einfach keine Konsolenanwendung. Nach dem Start erscheint das folgende Formular auf dem Bildschirm:

Oben befindet sich eine Symbolleiste:

Rechts der Objektinspektor und die Formularliste:

Komponenten (im Gegensatz zu BASIC) sind bereits in Registerkarten unterteilt. Nach Namen ist es nicht schwer zu erraten, welche Art von Komponenten auf der Registerkarte platziert sind. Öffnen Sie die Standard-Registerkarte und platzieren Sie die Komponenten wie bei mir auf dem Formular:

Die Schaltfläche wird mit Button1 bezeichnet. Sie muss geändert werden. Im unteren linken Fenster von Borland werden die Eigenschaften der Komponenten angezeigt, die auf unsere geändert werden müssen:

Wechseln Sie beim Button Caption (Inscription) auf Generate

Ändern Sie für die Beschriftung Label1 die Caption-Eigenschaft in Number

In Edit1 wird die Text-Eigenschaft (der Text in der Bearbeitung selbst) einfach gelöscht.

Nach diesen Manipulationen sieht das Formular wie meins aus:

Wir sind übrigens mit dem visuellen Stil fertig, die meisten Eigenschaften in Borlyad sehen aus wie BASIC oder Delphi. Experimentieren Sie mit ihnen.

Lassen Sie uns jetzt über Ereignisse sprechen. Jede Komponente hat Ereignisse, sie enthalten Code, der ausgeführt wird, wenn bestimmte Bedingungen erreicht werden. Bei einer Schaltfläche wird beispielsweise der Code im Click-Ereignis ausgeführt, wenn wir darauf klicken usw.

Heute verwenden wir nur das Click-Ereignis. Klicken Sie zweimal auf die Schaltfläche und gelangen Sie in das Codefenster:

Das Click-Ereignis für die Schaltfläche wurde automatisch generiert. Der Code wird wie bei einer Konsolenanwendung zwischen geschweiften Klammern platziert. Wir schreiben den Code:

Void __fastcall TForm1::Button1Click(TObject *Sender) ( double aaa; //Lege hier die vom Prozessor generierte Zahl String count; //Schreibe die gleiche Zahl, aber reduziert auf einen String randomize; //Dies ist notwendig, damit die Zahlen wiederholen sich nicht aaa=random (34)*43646; //Erzeuge eine beliebige Zahl count=FloatToStr (aaa); //Übersetze die Zahl in einen String mit der FloatToString-Funktion Edit1->Text=count; //Gib eine String-Variable aus in das Textfenster)

Der Algorithmus ist einfach, wir deklarieren eine Variable, um eine Bruchzahl darin zu speichern, und eine Variable für die Zahl in Zeichenfolgenform. Tatsache ist, dass die sofort generierte Zahl nicht in einem Textfeld angezeigt werden kann (es wird ein Fehler auftreten. Es wurde ein Text erwartet und eine Zahl wurde empfangen), also übersetzen wir die Zahl mit der FloatToStr-Funktion in einen String und zeigen sie in a an Textfeld. Zur Ausgabe wenden wir uns (mit dem ->-Zeichen (ähnlich einem Punkt in vb)) der Edit1-Texteigenschaft zu und zeigen dort den Text an. Das ist alles für jetzt.

Übrigens eine Backfilling-Frage: Wer züchtet schneller Computer Virus, Chinesen oder Hasen?

Kommentare()

Leben

Artjomka

"randomize; //Dies ist notwendig, damit sich die Zahlen nicht wiederholen." Ich wiederhole immer noch. was zu tun ist?

Andrej

Es gibt 2 Optionen 1-use "randomize();" oder in Zeile 6 erschweren die Funktion z.B. weitere Sekunden hinzufügen

Andrej

"Sekunden" oder das Ergebnis der Addition zweier Pseudozufallszahlen dividiert durch Sekunden - je mehr Faktoren, desto unvorhersehbarer die Zahl

Artjomka Alexei (alex13sh)

randomisieren
damit sich die Zahlen nicht wiederholen, wenn das Programm eingeschaltet wird
Nun, das ist. das Programm eingeschaltet haben, drücken Sie die Taste mehrmals
1)5
2)47
3)86
das bin ich in ganzen Zahlen
Nun, wenn Sie das Programm ausschalten und wieder einschalten, werden beim wiederholten Drücken der Taste dieselben Zahlen mit denselben Sequenzen angezeigt
Dies ist ohne Randomize, aber dies wird nicht entfernt

Und was wird auf diese Weise wiederholt
1)3
2)69
3)1
4)3
5)8
6)1
DIES GILT NICHT FÜR Randomisierung
um dies zu vermeiden, hat Andrey bereits geantwortet))

Begzod

Ich habe Visual c++.net auf meinem Computer. Ich kann keine Lehrbücher, Quellcodes dafür finden. Hilfe pzhs.

Ali05

Ich habe in der Buchhandlung ein Lehrbuch zu Visual C ++.Net "Nikita Kultin Programming Basics in Microsoft Visual C++ 2010", zeigt es nur, wie man erstellt grafische Anwendungen unter Windows (WinForms).

Coolhacker Nintendo

Ich frage mich, was ist sein "schlecht"?

Coolhacker

In Ermangelung der Fähigkeit, das Material richtig darzustellen und Sie, meine Herren, an einen schlechten Programmierstil zu gewöhnen, a la transliterierte Variablen- / Funktionsnamen.

Eduard Coolhacker

Ministerium für Bildung und Wissenschaft der Russischen Föderation

Staatliche Haushaltsbildungseinrichtung

höhere Berufsausbildung

„UFA STATE OIL

TECHNISCHE UNIVERSITÄT"

Institut für Informatik und Technische Kybernetik

Erstellen einer GUI-Anwendung in Microsoft Visual Studio 2010

Lehrhilfe

für Labor- und Praktikumsunterricht

mit Studenten der Richtung

230100 (09.03.01) "Informatik und Technische Informatik"

Das Lehrmittel vermittelt theoretische Informationen, Aufgabenstellungen für die Praxis und Laborarbeiten der Lehrveranstaltung „Programmieren“.

Das Handbuch richtet sich an Lehrende des Faches, sowie Studierende der Richtung: 230100 „Informatik und Technische Informatik“.

Zusammengestellt von: Gabdullina A.A., Art.-Nr. Dozent am Fachbereich VTIK

Druzhinskaya E.V., Art.-Nr. Dozent am Fachbereich VTIK

Gutachter: Filippov V.N., Ph.D., außerordentlicher Professor der Abteilung. VTIK.

1. Theoretische Informationen 4

1.1. Grundbegriffe 4

1.2. Bekanntschaft mit Windows-Anwendung Formular in Microsoft Visual Studio 2010 4

1.3. Formular 7-Steuerung

1.5. MessageBox 9-Funktion

1.6. TextBox-Steuerelement 10

2. Praktische Aufgabe. Einführung in die Windows Form-Anwendung in Microsoft Visual Studio 2010 12

2.1. Bewertungsstruktur für abgeschlossene Arbeiten 12

2.2. Verfahren zur Durchführung praktischer Arbeiten 12

3. Laborarbeit. Anwendungsentwicklung in Microsoft Visual Studio 2010 16

3.1. Laborauftrag 16

3.2. Aufgabe 1. Tabellierung einer Funktion und Berechnung ihrer Werte im angegebenen Intervall mit einem bestimmten Schritt 16

3.3. Einzelaufgaben 19

3.4. Aufgabe 2. Verarbeitung zweidimensionale Arrays 21

3.5. Einzelaufgaben 27

1. Theoretische Informationen

1. 1.1. Grundlegendes Konzept

Die Automatisierung von Informationsprozessen wird derzeit vor allem durch die Entwicklung einer Softwareanwendung mit einer grafischen Benutzeroberfläche (GUI) dargestellt, die Datenflüsse verwaltet.

Die grafische Benutzeroberfläche (GUI) ist ein System von Mitteln zur Benutzerinteraktion mit einem Gerät, das auf der Darstellung aller Systemobjekte und Funktionen basiert, die dem Benutzer in Form von grafischen Bildschirmkomponenten (Fenster, Schaltflächen, Bildlaufleisten usw.) zur Verfügung stehen.

Meistens sind die Oberflächenelemente in der GUI auf der Grundlage von Metaphern implementiert und zeigen ihren Zweck und ihre Eigenschaften an, was es unvorbereiteten Benutzern erleichtert, Programme zu verstehen und zu beherrschen. So erfolgt die Arbeit des Benutzers über Masken mit Bedienobjekten und Symbolleisten mit Aktionsschaltflächen zur Bearbeitung.

Eine standardmäßige grafische Benutzeroberfläche muss eine Reihe von Anforderungen erfüllen:

Pflege der Informationstechnologie der Arbeit des Benutzers mit dem Softwareprodukt;

Konzentrieren Sie sich auf den Endbenutzer, der mit dem Programm auf der externen Interaktionsebene kommuniziert;

Erfüllen Sie das „Sechs“-Prinzip, wenn nicht mehr als 6 Konzepte in einer Menüleiste enthalten sind, von denen jedes nicht mehr als 6 Optionen enthält;

Behalten Sie einen standardisierten Zweck von grafischen Objekten und, wenn möglich, ihre Position auf dem Bildschirm bei.

In der objektorientierten Programmierung beschäftigen wir uns mit Klassen und Objekten. Objekte sind zusammengesetzte Datentypen: Sie kombinieren mehrere Werte zu einer einzigen Einheit und ermöglichen es uns, diese Werte namentlich zu schreiben und zu speichern. Mit anderen Worten, ein Objekt ist eine ungeordnete Sammlung von Eigenschaften, jede mit einem Namen und einem Wert. Die in einem Objekt enthaltenen benannten Werte können entweder primitive Typen wie Zahlen oder Zeichenfolgen oder andere Objekte sein.

Bei der Entwicklung von Nicht-Konsolenanwendungen ist das Hauptkonzept das Formular.

Ein Formular ist ein Container zum Hosten von Designumgebungssteuerelementen.

Eigenschaften - die Fähigkeit, auf Informationen zuzugreifen, die in diesem Element gespeichert sind.

Methoden sind eine Reihe von Aktionen, die ein Objekt ausführen kann.

Ein Ereignis ist eine von einem Objekt erkannte Aktion (z. B. ein Mausklick, ein Tastendruck), für die eine Reaktion programmiert werden kann, d. h. die Antwort des Objekts auf das Ereignis.

Letzte Aktualisierung: 26.05.2019

In Xamarin.Forms besteht die visuelle Schnittstelle aus Seiten. Die Seite ist ein Objekt der Klasse Page und nimmt den gesamten Bildschirmbereich ein. Das sehen wir auf dem Bildschirm Mobilgerät ist eine Seite. Eine Anwendung kann eine oder mehrere Seiten haben.

Die Seite akzeptiert einen der Layout-Container als Inhalt, der wiederum standardmäßige visuelle Elemente wie Schaltflächen und Textfelder sowie andere Layout-Elemente enthält.

Nehmen wir das im vorherigen Thema erstellte HelloApp-Projekt (oder erstellen Sie ein neues). Standardmäßig wird die gesamte Schnittstelle in der App-Klasse erstellt, die sich in der Datei App.xaml.cs befindet und die aktuelle Anwendung darstellt:

Sein Standardcode ist:

Verwenden des Systems; mit Xamarin.Forms; mit Xamarin.Forms.Xaml; namespace HelloApp ( öffentliche partielle Klasse App: Application ( public App() ( InitializeComponent(); MainPage = new MainPage(); ) protected override void OnStart() ( // Handle wenn deine App startet ) protected override void OnSleep() ( / / Behandeln, wenn Ihre App in den Ruhezustand versetzt wird ) protected override void OnResume() ( // Behandeln, wenn Ihre App fortgesetzt wird ) ) )

Die App-Klasse beginnt mit dem Konstruktor, wo zuerst die InitializeComponent()-Methode aufgerufen wird, die das Objekt initialisiert, und dann die MainPage-Eigenschaft festgelegt wird. Durch diese Eigenschaft legt die App-Klasse fest Startseite Anwendungen. In diesem Fall wird sie durch die HelloApp.MainPage-Klasse definiert, die die Klasse ist, die in den Dateien MainPage.xaml und MainPage.xaml.cs definiert ist.

Aber dieser Weg ist nicht der einzige. Xamarin.Forms ermöglicht Ihnen das Erstellen einer visuellen Schnittstelle entweder mithilfe von C#-Code oder deklarativ mithilfe der XAML-Sprache, ähnlich wie HTML, oder einer Kombination dieser Ansätze.

Erstellen einer Schnittstelle aus C#-Code

Fügen wir dem HelloApp-Projekt eine reguläre C#-Klasse hinzu, die wir StartPage nennen.

Und definieren Sie den folgenden Inhalt in dieser Klasse:

Verwenden von Xamarin.Forms; namespace HelloApp ( class StartPage: ContentPage ( public StartPage() ( Label header = new Label() ( Text = "Hello from Xamarin Forms" ); this.Content = header; ) ) )

Diese Klasse stellt eine Seite dar und erbt daher von der ContentPage-Klasse. Der Konstruktor erstellt ein Label mit Text, der als Inhalt der Seite gesetzt wird (this.Content = header).

Um MainPage als festzulegen Startseite, ändern Sie die App-Klasse:

Verwenden von Xamarin.Forms; namespace HelloApp ( öffentliche partielle Klasse App: Application ( public App() ( InitializeComponent(); MainPage = new StartPage(); ) protected override void OnStart() ( // Handle wenn deine App startet ) protected override void OnSleep() ( / / Behandeln, wenn Ihre App in den Ruhezustand versetzt wird ) protected override void OnResume() ( // Behandeln, wenn Ihre App fortgesetzt wird ) ) )

Die MainPage-Eigenschaft zeigt jetzt auf die neu erstellte StartPage.

Es ist auch erwähnenswert, dass Visual Studio eine vorgefertigte Vorlage zum Hinzufügen neuer Seitenklassen mit dem einfachsten Code hat. Um also eine neue Seite hinzuzufügen, müssen Sie beim Hinzufügen eines neuen Elements die Vorlage Inhaltsseite (C#) auswählen:

Diese Klasse wird dem Hauptprojekt der Lösung hinzugefügt (in diesem Fall ist es HelloApp).

Die hinzugefügte Seitenklasse hat den folgenden Code:

Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; mit System.Reflection.Emit; mit System.Text; mit Xamarin.Forms; namespace HelloApp ( public class Page1: ContentPage ( public Page1() ( Content = new StackLayout ( Children = ( new Label ( Text = "Hello Page" ) ) ) ) )

Diese Klasse erbt auch von der ContentPage-Basisklasse und hat fast die gleiche Organisation wie die oben erstellte MainPage-Klasse.

Und auch in der Anwendungsklasse können wir diese Seite als Startseite festlegen:

Verwenden von Xamarin.Forms; Namespace HelloApp ( öffentliche Teilklasse App: Application ( public App() ( InitializeComponent(); MainPage = new Page1(); ) //........... ) )

5

Ich habe viele verschiedene Bereiche des Nintendo DS-GUI-Systems wie Schaltflächen und Textfelder und Kontrollkästchen erstellt, aber ich brauche eine Möglichkeit, diese Klassen in einer GUI-Klasse zu verstecken, damit ich alles auf einmal auf den Bildschirm zeichnen und alle Schaltflächen gleichzeitig aktivieren kann um zu prüfen, ob irgendwelche Tasten gedrückt sind. Meine Frage ist, was ist der beste Weg, um alle Klassen (wie Schaltflächen und Textfelder) in einer einzigen GUI-Klasse zu organisieren?

Hier ist eine Möglichkeit, die ich dachte, aber es scheint nicht richtig zu sein:

Bearbeiten: Ich verwende C++.

Class Gui ( public: void update_all(); void draw_all() const; int add_button(Button *button); // Gibt Button-ID zurück void remove_button(int button_id); private: Button *buttons; int num_buttons; )

Dieser Code hat ein paar Probleme, aber ich wollte Ihnen nur eine Vorstellung davon geben, was ich will.

• 5 Antworten

Sortierung:

Aktivität

2

Diese Frage ist der Frage sehr ähnlich, die ich posten wollte, nur meine ist für die Sony PSP-Programmierung.

Ich habe eine Weile nach etwas gesucht, ich habe einige Bücher und VTMs konsultiert, und bisher ist dies eine grobe Vorstellung von einfachen UI-Systemen.

Klasse uiElement() ( ... virtual void Update() = 0; virtual void Draw() = 0; ... ) class uiButton() public: uiElement ( ... virtual void Update(); virtual void Draw() ; ... ) class uiTextbox() public: uiElement ( ... virtual void Update(); virtual void Draw(); ... ) ... // Andere ui-Elemente class uiWindow() ( ... void Update (); void Draw(); void AddElement(uiElement *Element); void RemoveElement(uiElement *Element); std::list Elemente; ... ) void uiWindow::Update() ( ... für (list ::iterator it = Elements.begin(); es != Elements.end(); it++) it->Update(); ... ) void uiWindow::Draw() ( ... für (list ::iterator it = Elements.begin(); es != Elements.end(); it++) it->Draw(); ... )

Prinzip ist die Gestaltung des Fensters und der Attact-Elemente Benutzeroberfläche dazu und rufen Sie die Draw- und Update-Methoden aus den entsprechenden Hauptfunktionen auf.

Bei mir funktioniert noch nichts, da ich Probleme mit dem Zeichencode habe. Mit verschiedenen APIs auf PC und PSP schaue ich mir Wrapper-Code für OpenGL und psp gu an.

Hoffe das hilft.

0

Eine nützliche Strategie, die man im Hinterkopf behalten sollte, könnte das zusammengesetzte Muster sein. Auf einer niedrigen Ebene können Sie damit alle GUI-Objekte (und Sammlungen von Objekten) einfacher handhaben, sobald sie erstellt wurden. Aber ich weiß nichts über GUI-Design, also ist ein Ort, an dem ich allgemeine Inspiration finden kann, der Quellcode eines bestehenden Projekts. WxWidgets ist eine plattformübergreifende GUI mit einem barrierefreien Quellcode. Viel Glück mit Ihrem Projekt!

0

3

Für Interessierte ist hier mein BSD-lizenziertes Open-Source-GUI-Toolkit für den DS:

Die Antwort von Subject2k ist ziemlich gut, aber ich würde ernsthaft empfehlen, Code zu haben, der untergeordnete Schnittstellenelemente in der uiElement-Basisklasse enthält. Dies ist das Muster, dem ich in Woopsie gefolgt bin.

Wenn Sie Nicht Wenn Sie dies in der Basisklasse unterstützen, werden Sie auf ernsthafte Probleme stoßen, wenn Sie versuchen, etwas Komplexeres als ein Textfeld und eine Schaltfläche zu implementieren. Zum Beispiel:

• Tabellenleisten können als mehrere Schaltflächen modelliert werden, die unter einem einzigen übergeordneten UI-Element gruppiert sind, das eine gegenseitige Ausschließlichkeit der Auswahl bietet;
• Gruppen von Radios (im Laufe der Zeit);
• Bildlaufleisten können als Schieberegler/Gutter-Element und als Auf-/Ab-Schaltfläche dargestellt werden;
• Bildlauflisten können als Container und mehrere Elemente der Benutzeroberfläche dargestellt werden.

Denken Sie auch daran, dass der DS über einen 66-MHz-Prozessor und 4 MB RAM verfügt, die sowohl zum Speichern Ihres Programms als auch zum Ausführen verwendet werden (DS-Festplatten werden in den RAM geladen, bevor sie ausgeführt werden). Sie sollten es wirklich als eingebettetes System betrachten, was bedeutet, dass es keine STL gibt. Ich habe die STL von Woopsi entfernt und es geschafft, 0,5 MB zu sparen. Nicht viel für Desktop-Standards, aber es ist 1/8 des gesamten verfügbaren DS-Speichers, der von STL-Müll verbraucht wird.

Ich beschreibe den gesamten Prozess des Schreibens einer Benutzeroberfläche in meinem Blog:

Es enthält eine Beschreibung von zwei Algorithmen, die ich mir für das Neuzeichnen von Bildschirmen ausgedacht habe, was der knifflige Teil beim Erstellen einer GUI ist (einer bricht nur Rechtecke auf und merkt sich sichtbare Bereiche, und der andere verwendet BSP-Bäume, was viel effizienter und einfacher ist). verstehen), Optimierungstipps etc. d.