Mein Ansatz. Der Kern ist der Motor. - Seite 7

Neuer Kommentar
 
Die beste Möglichkeit, Eigenschaften, Objekte und Elemente zu ordnen, ist die Erstellung einer Tabelle.

Das Herzstück der Elemente ist die Tabelle.

Wir haben ein Proto-Kernel-Modell erstellt, das dazu dient, die anfänglichen Objektparameter eines bestimmten Elements zu speichern.

Als Nächstes müssen wir einen Haupt-Kernel erstellen und so viele Elemente wie nötig hineinschreiben.

Dann werden wir jedem Element innerhalb des Hauptkerns neue Werte zuweisen.

Danach werden wir Elemente erstellen.

Dann werden wir mit ihnen bei verschiedenen Veranstaltungen zusammenarbeiten.


 

Deklarieren Sie den Hauptkern:

int G_CORE[All_objects][All_properties];

Jede Zeile des Kerns nimmt ein Objekt ein.

Wir müssen bestimmen, wie viele Objekte sich insgesamt im Kern befinden werden. Dazu müssen wir die Anzahl der Elemente, die wir erstellen wollen, und die Anzahl der Objekte in jedem Element berechnen.

Nehmen wir an, wir haben 10 Schaltflächen. Also: 10 Elemente * 3 Objekte = 30 Objekte. Es gibt also 30 Zeilen.

#define  All_objects     30
#define  All_properties  10

Wir haben die Anzahl der Eigenschaften im Hauptkern erhöht, da wir zusätzlich zu den grundlegenden Parametern die Namen der Elemente und Objekte, die Verbindungen zwischen ihnen und einige andere Eigenschaften benötigen.


Wir deklarieren die Eigenschaften der Objekte neu:

#define  NAME        0
#define  TYPE        1
#define  ELEMENT     2

#define  X           3
#define  X_SIZE      4
#define  Y           5
#define  Y_SIZE      6
#define  BG_COLOR    7
#define  TEXT_COLOR  7
#define  TEXT        8
#define  CORNER      9
#define  STATE       10
//-------------------

Die Eigenschaft TEXT enthält einen Verweis auf ein anderes Array, das die Texte der Schaltflächen enthält.

Die Eigenschaft ELEMENT wird benötigt, um Objekte desselben Elements innerhalb des Kerns zu verknüpfen (um Verwechslungen zu vermeiden, welches Objekt zu welchem Element gehört). In dieser Eigenschaft wird die Sequenznummer des Elements festgelegt.

 
Реter Konow: //So würden die Aufrufe der Elementeigenschaften aussehen:

Es ist sehr leicht, Basis, Text und Symbol zu verwechseln. In der Beschreibung ist klar, was in diesem oder jenem Index enthalten ist. Beim echten Programmieren muss man alles im Kopf behalten. Ich weiß, dass Peter ein Titan des Gedächtnisses mit einer stark eingeschränkten Fähigkeit zu vergessen ist. Aber ich fürchte, es gibt nicht viele solcher Titanen. Ich vergesse jetzt schon, wo und was ich am nächsten Tag einpacken muss.

Wäre es nicht besser, in etwa folgendes zu haben (ich würde es so machen):

Deklarieren Sie die benötigten Elementarstrukturen.

struct SPosition
{
uint m_uiX;
uint m_uiY;
};

struct SElementSize
{
uint m_uiXSize;
uint m_uiYSize;
};

Jetzt können wir die Basis-, Text- und Symbolschnittstellen aus dem gemeinsamen Objekt abrufen:

CBaseI* pbBase = core.GetBase();
CTextI* ptText = core.GetText();
CIconI* pbIcon = core.GetIcon();

Und jede dieser drei Schnittstellen - setzt die entsprechende Eigenschaft. Nun, zum Beispiel Text:

ptText.SetPosition(SPosition& rpPos);

Wir füllen die Positionsstruktur (X und Y), rufen die Textschnittstelle aus dem Kern auf, und von dieser Schnittstelle aus rufen wir die Funktion zur Positionsbestimmung mit unserer Struktur auf. Jede dieser Schnittstellen verfügt auch über eine Funktion zur Einstellung von Größe und Farbe. Es ist sinnvoll, sie von einer gemeinsamen rein virtuellen Schnittstelle zu erben, bei der alle Funktionen auf Null gesetzt werden.

Hier ist es viel schwieriger, die Dinge durcheinander zu bringen. Denn zu jedem Zeitpunkt haben Sie nur Zugriff auf das, was Sie für Ihre Arbeit benötigen. Und für etwas anderes muss man es aufrufen, und wenn man das nicht darf, dann kann man bei richtigem Systemdesign nicht einmal diese "verbotene" Schnittstelle aufrufen und sich so vor Fehlern schützen.

 

Ändern wir also zunächst die Anzahl der Eigenschaften des Prototyp-Kernels, die die gleichen waren wie im Hauptkernel. Als Nächstes wollen wir einen Zyklus zum Aufbau von G_CORE durchführen.

int P_CORE[3][10] = {
//Основание кнопки.-----------------------------
//
//NAME     TYPE   ELEMENT     X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{ 100001,  base,  button,    100, 100,    200,    50,    C'245,245,245'},
//---------------------------------------------- 
//Текст кнопки.---------------------------------
//
//NAME    TYPE   ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{100002,  text,  button,  120, 120,     0,      0,       C'245,0,0'},
//---------------------------------------------- 
//Иконка кнопки.-------------------------------- 
//
//NAME    TYPE     ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
{100003,  icon,    button,  140, 140,     16,     16,           0},
//---------------------------------------------- 
};
//Далее, строим G_CORE:
//--------------------------------------
int q = 0;
//--------------
for(int a1 = 0; a1 < All_objects; a1++)
  {
   for(int a2 = 0; a2 < All_properties; a2++)
    {
     G_CORE[a1][a2] = P_CORE[q][a2];
    }
     q++;
     if(q == 3)q = 0;    
  }


Nach diesem Zyklus wird der G_CORE-Kern mit Prototypen von 10 Tasten gefüllt sein. Als Nächstes müssen wir den Elementen eindeutige Namen geben und die Objekte an ihre Elemente binden, wobei jedes Element einen eindeutigen Index erhält.

 
Реter Konow:

Ändern wir also zunächst die Anzahl der Eigenschaften des Prototyp-Kernels, die die gleichen waren wie im Hauptkernel. Dann machen wir eine Schleife, um G_CORE zu erstellen.

Anhand dieses Codes können Sie es perfekt erkennen.

Ich habe schon vergessen, wofür a1 steht und wofür a2 steht.

Aber das ist die halbe Miete - wenn ich es vergessen habe, muss ich oben nachsehen. Aber ich kann mir sicher sein, dass ich es nicht vergessen habe, und ich kann die Elemente immer noch verwechseln. Und dann ist es gut, wenn es auf Anhieb klappt. Andernfalls handelt es sich nicht um eine Tatsache, und der Fehler kann viel später auftreten, und er wird nach dem Gesetz des Pechs an der verwundbarsten Stelle und zum ungünstigsten Zeitpunkt auftreten.

Peters Ansatz ist der eines Titanen des Auswendiglernens, was auch ganz normal ist. Aber wie viele Teilnehmer sind solche Titanen?

 

In der Zwischenzeit haben sogar einige ein kleines Unternehmen öffnete den Code seiner lahmen grafischen Benutzeroberfläche :-)

Sie machen wirklich die Biege... sie haben Angst vor der Konkurrenz!

Scherz, Scherz, aber jeder Interessierte kann sehen, wie die Windows-GUI von innen aufgebaut ist:

WPF ist ein .NET Core UI-Framework zur Erstellung von Windows-Desktop-Anwendungen: https://github.com/dotnet/wpf

Windows Forms ist ein .NET Core UI-Framework zum Erstellen von Windows-Desktop-Anwendungen: https://github.com/dotnet/winforms

Abwärtskompatible Versionen von Windows UI-Funktionen, einschließlich UWP XAML-Steuerelemente und Fluent-Stile und -Materialien: https://github.com/Microsoft/microsoft-ui-xaml


 
Maxim Kuznetsov:

In der Zwischenzeit haben sogar einige ein kleines Unternehmen hat den Code seiner käsigen GUI geöffnet :-

Die grafische Benutzeroberfläche ist hier nicht das Problem. Mein Ansatz kann extrapoliert und auf jeden Zweck angewendet werden. Einschließlich AI.

Als Nächstes zeige ich Ihnen, wie Sie das machen können.

 
George, bitte lass mich fortfahren. Ich weiß, dass Sie OOP bevorzugen und dass Sie sich auf diese Weise wohler fühlen. Aber Ihre Entscheidungen werden auf der Grundlage der Referenzen eines Programmierers berechnet. Ich bin nun auf der Suche nach einem Ansatz, mit dem man eine maximale Entwicklung erreichen kann. Die Bequemlichkeit kommt an zweiter Stelle.
 
Реter Konow:

Wir müssen festlegen, wie viele Objekte sich im Kern befinden werden. Dazu müssen wir die Anzahl der Elemente, die wir erstellen wollen, und die Anzahl der Objekte in jedem Element berechnen.

#define  All_objects     30
#define  All_properties  10

Frage aus dem Publikum:

Nehmen wir an, dass wir eine Tabelle der Geschäfte des Trading Expert Advisors erstellen. Jede Zeile - eine Transaktion mit Einstiegskurs, Ausstiegskurs, Volumen, usw. Wie kann man im Voraus wissen, bevor wir kompilieren, die Anzahl der Geschäfte, die durch den Expert Advisor durchgeführt werden, um die Anzahl der Zeilen in der Tabelle korrekt zu bestimmen?

 
Vasiliy Sokolov:

Frage aus dem Publikum:

Angenommen, wir erstellen eine Tabelle mit den Geschäften eines Trading Expert Advisors. Jede Zeile ist ein Geschäft mit Einstiegskurs, Ausstiegskurs, Volumen usw. Wie kann ich im Voraus, vor der Kompilierung, die Anzahl der Geschäfte kennen, die der Expert Advisor durchführen wird, um die Anzahl der Zeilen in der Tabelle korrekt zu bestimmen?

Fügen Sie dem Array mit ArrayResize bei jeder Transaktion eine Nummer hinzu und zeichnen Sie die Eigenschaften des Geschäfts darin auf.

Gleichzeitig werden die Eigenschaften im Voraus auf die Zellen verteilt.

Anschließend werden alle Daten geordnet.

1234567891011121314...184
Neuer Kommentar