VB.NET: Τι συνέβη με τον έλεγχο των συστοιχιών

Η παράλειψη των συστοιχιών ελέγχου από το VB.NET είναι μια πρόκληση για εκείνους τους διδάσκοντες σχετικά με τους πίνακες.

• Δεν είναι πλέον δυνατό απλά να αντιγράψετε ένα στοιχείο ελέγχου, όπως ένα πλαίσιο κειμένου, και στη συνέχεια να το επικολλήσετε (μία ή περισσότερες φορές) για να δημιουργήσετε έναν πίνακα ελέγχου.
• Ο κώδικας VB.NET για τη δημιουργία μιας δομής παρόμοιας με μια διάταξη ελέγχου υπήρξε, σε όλα τα βιβλία του VB.NET που αγόρασα και σε απευθείας σύνδεση, πολύ περισσότερο και πολύ πιο περίπλοκη. Χωρίς την απλότητα της κωδικοποίησης μιας διάταξης ελέγχου που βρίσκεται στο VB6.

Αν αναφερθείτε στη βιβλιοθήκη συμβατότητας VB6, υπάρχουν αντικείμενα που λειτουργούν σχεδόν σαν πίνακες ελέγχου. Για να δείτε τι εννοώ, απλά χρησιμοποιήστε τον οδηγό αναβάθμισης VB.NET με ένα πρόγραμμα που περιέχει πίνακα ελέγχου. Ο κώδικας είναι και πάλι άσχημος, αλλά λειτουργεί. Τα κακά νέα είναι ότι η Microsoft δεν θα εγγυηθεί ότι τα στοιχεία συμβατότητας θα εξακολουθήσουν να υποστηρίζονται και δεν πρέπει να τα χρησιμοποιήσετε.

Ο κώδικας VB.NET για τη δημιουργία και τη χρήση "συστοιχιών ελέγχου" είναι πολύ μεγαλύτερος και πολύ πιο περίπλοκος.

Σύμφωνα με τη Microsoft, για να κάνουμε κάτι ακόμα πιο κοντά σε αυτό που μπορείτε να κάνετε στο VB 6 απαιτεί τη δημιουργία ενός "απλού στοιχείου που αντιγράφει τη λειτουργικότητα του πίνακα ελέγχου".

Χρειάζεστε τόσο μια νέα τάξη όσο και μια φόρμα φιλοξενίας για να το δείξετε αυτό. Η κλάση δημιουργεί και καταστρέφει νέες ετικέτες. Ο πλήρης κωδικός κλάσης έχει ως εξής:

Δημόσια κλάση LabelArray
Κληρονομεί το σύστημα. Συλλογές. CollectionBase
Ιδιωτικό ReadOnly HostForm As _
Σύστημα. Windows. Έντυπα. Μορφή
Δημόσια Λειτουργία AddNewLabel () _
Ως Σύστημα. Windows. Έντυπα. Επιγραφή
'Δημιουργία νέας εμφάνισης της κλάσης Label.
DimaLabel ως νέο σύστημα. Windows. Έντυπα. Επιγραφή
'Προσθέστε την ετικέτα στη συλλογή
'εσωτερική λίστα.
Μου. Λίστα. Προσθήκη (aLabel)
'Προσθήκη της ετικέτας στη συλλογή Controls
'της φόρμας που αναφέρεται από το πεδίο HostForm.
HostForm. Έλεγχοι. Προσθήκη (aLabel)
'Ορισμός αρχικών ιδιοτήτων για το αντικείμενο Label.
μία ετικέτα. Κορυφή = Αρίθμηση * 25
μία ετικέτα. Πλάτος = 50
μία ετικέτα. Αριστερά = 140
μία ετικέτα. Ετικέτα = Me. μετρώ
μία ετικέτα. Κείμενο = "Ετικέτα" & Me. Μετρώ. ToString
Επιστροφή aLabel
Λειτουργία τερματισμού
Δημόσιο Υπο Νέο (_
ByVal υποδοχής ως σύστημα. Windows. Έντυπα. Μορφή)
HostForm = κεντρικός υπολογιστής
Μου. AddNewLabel ()
End Sub
Προεπιλεγμένη δημόσια ιδιότητα ReadOnly _
Στοιχείο (δείκτης ByVal ως ακέραιος αριθμός) Ως _
Σύστημα. Windows. Έντυπα. Επιγραφή
Παίρνω
Επιστροφή CType (Λίστα. Στοιχείο (Ευρετήριο), _
Σύστημα. Windows. Έντυπα. Επιγραφή)
Τέλος Πάρτε
End Property
Δημόσια κατάργηση ()
"Ελέγξτε για να βεβαιωθείτε ότι υπάρχει μια ετικέτα που θα καταργηθεί.
Αν Εγώ. Count> 0 Στη συνέχεια
'Αφαιρέστε την τελευταία Ετικέτα που προστέθηκε στον πίνακα
'από τη συλλογή ελέγχου φόρμας υποδοχής.
Msgstr "Σημειώστε τη χρήση της προεπιλεγμένης ιδιότητας στο
'πρόσβαση στη συστοιχία.
HostForm. Έλεγχοι. Κατάργηση (Me (Me Count - 1))
Μου. Λίστα. Αφαίρεση (Μέτρηση - 1)
Τέλος εαν
End Sub
Τέλος κλάσης

Για να απεικονίσετε τον τρόπο με τον οποίο θα χρησιμοποιηθεί αυτός ο κωδικός τάξης, μπορείτε να δημιουργήσετε μια φόρμα που το καλεί. Θα χρειαστεί να χρησιμοποιήσετε τον παρακάτω κώδικα στη φόρμα:

Δημόσια Κλάση1. Κληρονομεί το σύστημα. Windows. Έντυπα. Μορφή. #Region "Ο Windows Form Designer δημιούργησε τον κώδικα" 'Επίσης, πρέπει να προσθέσετε τη δήλωση:' MyControlArray = New LabelArray (Me) 'μετά την κλήση του InitializeComponent () στο. "κρυφό κωδικό περιοχής. 'Δηλώστε ένα νέο αντικείμενο ButtonArray. Dim MyControlArray ως LabelArray. Ιδιωτικό στοιχείο Sub btnLabelAdd_Click (_. ByVal αποστολέας ως σύστημα. Αντικείμενο, _. ByVal e ως σύστημα. EventArgs) _. Λαβές btnLabelAdd. Κάντε κλικ. 'Καλέστε τη μέθοδο AddNewLabel. 'του MyControlArray. MyControlArray. AddNewLabel () "Αλλάξτε την ιδιότητα BackColor. 'του κουμπιού 0. MyControlArray (0) .BackColor = _. Σύστημα. Σχέδιο. Χρώμα. Το κόκκινο. End Sub. Ιδιωτική υπο btnLabelRemove_Click (_. ByVal αποστολέας ως σύστημα. Αντικείμενο, _. ByVal e ως σύστημα. EventArgs) _. Λαβές btnLabelRemove. Κάντε κλικ. 'Καλέστε τη μέθοδο Κατάργηση του MyControlArray. MyControlArray. Αφαιρώ() End Sub. Τέλος κλάσης

Πρώτον, αυτό δεν κάνει καν την δουλειά στο Design Time όπως το κάναμε στο VB 6! Και δεύτερον, δεν είναι σε μια σειρά, είναι σε μια συλλογή VB.NET - κάτι πολύ διαφορετικό από ένα πίνακα.

Ο λόγος για τον οποίο το VB.NET δεν υποστηρίζει τον VB 6 "πίνακα ελέγχου" είναι ότι δεν υπάρχει τέτοιος πίνακας "ελέγχου" (σημειώστε την αλλαγή εισαγωγικών). Το VB 6 δημιουργεί μια συλλογή πίσω από τα σκηνικά και το κάνει να εμφανίζεται σαν πίνακας στον προγραμματιστή. Αλλά δεν είναι ένας πίνακας και έχετε λίγο έλεγχο πάνω από αυτό πέρα ​​από τις λειτουργίες που παρέχονται μέσω του IDE.

Το VB.NET, από την άλλη πλευρά, το αποκαλεί αυτό που είναι: μια συλλογή αντικειμένων. Και παραδίδουν τα κλειδιά στο βασίλειο στον κύριο του έργου, δημιουργώντας το όλο θέμα απευθείας στο ύπαιθρο.

Ως παράδειγμα του είδους των πλεονεκτημάτων αυτό δίνει στον κύριο του έργου, στο VB 6 οι έλεγχοι έπρεπε να είναι του ίδιου τύπου και έπρεπε να έχουν το ίδιο όνομα. Επειδή αυτά είναι απλά αντικείμενα στο VB.NET, μπορείτε να τα κάνετε διαφορετικούς τύπους και να τους δώσετε διαφορετικά ονόματα και να τα διαχειριστείτε ακόμα στην ίδια συλλογή αντικειμένων.

Σε αυτό το παράδειγμα, το ίδιο συμβάν κλοπής χειρίζεται δύο κουμπιά και ένα τετραγωνίδιο επιλογής και εμφανίζει σε ποιο κλικ έγινε κλικ. Κάνετε αυτό σε μια γραμμή κώδικα με VB 6!

Ιδιωτική Sub MixedControls_Click (_
ByVal αποστολέας ως σύστημα. Αντικείμενο, _
ByVal e ως σύστημα. EventArgs) _
Κουμπιά χειρολαβής1.Κάντε κλικ, _
Κουμπί2.Κάντε κλικ, _
CheckBox1.Click
«Η παρακάτω δήλωση πρέπει να είναι μια μακρά δήλωση!
«Είναι εδώ τέσσερις γραμμές για να το κρατήσουμε στενό
'αρκετά για να χωρέσει σε μια ιστοσελίδα
Label2.Text =
Microsoft. VisualBasic. Δεξιά (αποστολέας. GetType. ToString,
Len (αποστολέας. GetType. ToString) -
(InStr (αποστολέας. GetType. ToString, "Έντυπα") + 5))
End Sub

Ο υπολογισμός του υποστυλώματος είναι αρκετά περίπλοκος, αλλά δεν είναι πραγματικά αυτό που μιλάμε εδώ. Θα μπορούσατε να κάνετε οτιδήποτε στο συμβάν Click. Θα μπορούσατε, για παράδειγμα, να χρησιμοποιήσετε τον τύπο του στοιχείου ελέγχου σε μια εντολή If για να κάνετε διαφορετικά πράγματα για διαφορετικά στοιχεία ελέγχου.

Η ομάδα μελέτης του Frank παρουσίασε ένα παράδειγμα με μια φόρμα που έχει 4 ετικέτες και 2 κουμπιά. Το πλήκτρο 1 διαγράφει τις ετικέτες και το κουμπί 2 τους γεμίζει. Είναι καλή ιδέα να ξαναδιαβάσετε την αρχική ερώτηση του Frank και να παρατηρήσετε ότι το παράδειγμα που χρησιμοποίησε ήταν ένας βρόχος που χρησιμοποιείται για να καθαρίσει την ιδιότητα του λεζάντα μιας σειράς στοιχείων των ετικετών. Εδώ είναι το ισοδύναμο VB.NET αυτού του κώδικα VB 6. Αυτός ο κώδικας κάνει αυτό που αρχικά ζήτησε ο Frank!

Δημόσια Κλάση1. Κληρονομεί το σύστημα. Windows. Έντυπα. Μορφή. #Region "Ο Windows Form Designer δημιούργησε τον κώδικα" Dim LabelArray (4) Ως ετικέτα. 'δηλώνει μια σειρά ετικετών. Ιδιωτική υπο φόρμα1_Load (_. ByVal αποστολέας ως σύστημα. Αντικείμενο, _. ByVal e ως σύστημα. EventArgs) _. Χειρίζεται MyBase. Φορτώνω. SetControlArray () End Sub. Sub SetControlArray () LabelArray (1) = Ετικέτα1. LabelArray (2) = Label2. LabelArray (3) = Ετικέτα3. LabelArray (4) = Label4. End Sub. Private Sub Button1_Click (_. ByVal αποστολέας ως σύστημα. Αντικείμενο, _. ByVal e ως σύστημα. EventArgs) _. Χειριστήρια Κουμπί1.Κάντε κλικ. 'Κουμπί 1 Clear Array. Dim a ως ακέραιο. Για α = 1 έως 4. LabelArray (α) .Text = "" Επόμενο. End Sub. Private Sub Button2_Click (_. ByVal αποστολέας ως σύστημα. Αντικείμενο, _. ByVal e ως σύστημα. EventArgs) _. Χειριστήρια Κουμπί2.Κάντε κλικ. 'Κουμπί 2 Συμπληρώστε τον πίνακα. Dim a ως ακέραιο. Για α = 1 έως 4. LabelArray (a) .Text = _. "Πίνακας Ελέγχου" & CStr (a) Επόμενο. End Sub. Τέλος κλάσης

Εάν δοκιμάσετε αυτόν τον κώδικα, θα ανακαλύψετε ότι εκτός από τον ορισμό ιδιοτήτων των ετικετών, μπορείτε επίσης να καλέσετε μεθόδους. Γιατί λοιπόν (και η Microsoft) πήγαν σε όλο το πρόβλημα για να χτίσουν τον "άσχημο" κώδικα στο Μέρος Ι του άρθρου;

Πρέπει να διαφωνήσω ότι είναι πραγματικά ένα "Control Array" στην κλασική VB έννοια. Η διάταξη ελέγχου VB 6 είναι ένα υποστηριζόμενο τμήμα της σύνταξης VB 6, όχι μόνο μια τεχνική. Στην πραγματικότητα, ίσως ο τρόπος για να περιγράψουμε αυτό το παράδειγμα είναι ότι πρόκειται για μια σειρά ελέγχων, όχι για πίνακα ελέγχου.

Στο Μέρος Ι, παραπονέμησα ότι το παράδειγμα της Microsoft εργάστηκε ΜΟΝΟ σε χρόνο εκτέλεσης και όχι σε χρόνο σχεδιασμού. Μπορείτε να προσθέσετε και να διαγράψετε τα στοιχεία ελέγχου από μια φόρμα δυναμικά, αλλά το όλο θέμα πρέπει να εφαρμοστεί στον κώδικα. Δεν μπορείτε να σύρετε και να αποθέσετε τα χειριστήρια για να τα δημιουργήσετε όπως μπορείτε στο VB 6. Αυτό το παράδειγμα λειτουργεί κυρίως κατά το σχεδιασμό και όχι κατά το χρόνο εκτέλεσης. Δεν μπορείτε να προσθέσετε και να διαγράψετε στοιχεία ελέγχου δυναμικά κατά το χρόνο εκτέλεσης. Κατά κάποιο τρόπο, είναι το αντίθετο από το παράδειγμα του μέρους Ι.

Το κλασικό παράδειγμα πίνακα ελέγχου VB 6 είναι το ίδιο που εφαρμόζεται στον κώδικα VB .NET. Εδώ στο κώδικα VB 6 (αυτό έχει ληφθεί από την Mezick & Hillier, Visual Basic 6 Οδηγός για τις εξετάσεις πιστοποίησης, p 206 - ελαφρώς τροποποιημένη, αφού το παράδειγμα στο βιβλίο έχει ως αποτέλεσμα ελέγχους που δεν μπορούν να φανούν):

Dim MyTextBox ως VB.TextBox. Στατικό intNumber ως ακέραιο. intNumber = intNumber + 1. Ορίστε το MyTextBox = _. Μου. Έλεγχοι. Προσθέστε ("VB.TextBox", _. "Κείμενο" & intNumber) MyTextBox. Text = MyTextBox. Ονομα. MyTextBox. Ορατό = αληθινό. MyTextBox. Αριστερά = _. (intNumber - 1) * 1200

Όμως, καθώς η Microsoft (και εγώ) συμφωνούν, οι πίνακες ελέγχου VB 6 δεν είναι δυνατές στο VB.NET. Έτσι, το καλύτερο που μπορείτε να κάνετε είναι να αντιγράψετε τη λειτουργικότητα. Το άρθρο μου αντιγράφει τη λειτουργικότητα που υπάρχει στο παράδειγμα Mezick & Hillier. Ο κώδικας της ομάδας μελέτης αντιγράφει τη λειτουργικότητα του να είναι σε θέση να ορίσει ιδιότητες και μεθόδους κλήσης.

Έτσι, η κατώτατη γραμμή είναι ότι εξαρτάται πραγματικά από το τι θέλετε να κάνετε. Το VB.NET δεν έχει ολοκληρώσει το θέμα ως μέρος της γλώσσας - Ωστόσο - αλλά τελικά είναι πολύ πιο ευέλικτο.

Ο John έγραψε: Χρειαζόμουν συστοιχίες ελέγχου επειδή ήθελα να βάλω ένα απλό πίνακα αριθμών σε μια φόρμα στο χρόνο εκτέλεσης. Δεν ήθελα τη ναυτία να τις τοποθετήσω ξεχωριστά και θέλησα να χρησιμοποιήσω το VB.NET. Η Microsoft προσφέρει μια πολύ λεπτομερή λύση σε ένα απλό πρόβλημα, αλλά είναι ένα πολύ μεγάλο σφυρί για να σπάσει ένα πολύ μικρό παξιμάδι. Μετά από κάποιους πειραματισμούς, έφτασα τελικά σε μια λύση. Εδώ είναι το πώς το έκανα.

Το παράδειγμα για την Visual Basic παραπάνω δείχνει πώς μπορείτε να δημιουργήσετε ένα πλαίσιο κειμένου σε μια φόρμα δημιουργώντας μια παρουσία του αντικειμένου, ορίζοντας ιδιότητες και προσθέτοντάς το στη συλλογή Controls που είναι μέρος της φόρμας αντικείμενο.

Dim txtDataShow ως νέο κείμενο
txtDataShow. Ύψος = 19
txtDataShow. Πλάτος = 80
txtDataShow. Θέση = Νέο σημείο (X, Y)
Μου. Έλεγχοι. Προσθήκη (txtDataShow)
Παρόλο που η λύση της Microsoft δημιουργεί μια κλάση, σκέφτηκα ότι θα ήταν δυνατό να τυλιχτεί όλα αυτά σε μια υπορουτίνα. Κάθε φορά που καλείτε αυτή τη υπορουτίνα, δημιουργείτε μια νέα εμφάνιση του πλαισίου κειμένου στη φόρμα. Εδώ είναι ο πλήρης κώδικας:

Δημόσια Κλάση1
Κληρονομεί το σύστημα. Windows. Έντυπα. Μορφή

#Region "Ο Windows Form Designer δημιούργησε τον κώδικα"

Private Sub BtnStart_Click (_
ByVal αποστολέας ως σύστημα. Αντικείμενο, _
ByVal e ως σύστημα. EventArgs) _
Λαβές btnStart. Κάντε κλικ

Dim I ως ακέραιο
Dim sData ως συμβολοσειρά
Για I = 1 έως 5
sData = CStr (Ι)
Καλέστε το AddDataShow (sData, I)
Επόμενο
End Sub
Sub AddDataShow (_
ByVal sText ως String, _
ByVal I ως ακέραιος)

Dim txtDataShow ως νέο κείμενο
Dim UserLft, UserTop ως ακέραιο
Dim X, Y ως ακέραιο
UserLft = 20
UserTop = 20
txtDataShow. Ύψος = 19
txtDataShow. Πλάτος = 25
txtDataShow. TextAlign = _
Οριζόντια ευθυγράμμιση. Κέντρο
txtDataShow. BorderStyle = _
BorderStyle. FixedSingle
txtDataShow. Κείμενο = sText
X = UserLft
Y = UserTop + (I - 1) * txtDataShow. Υψος
txtDataShow. Θέση = Νέο σημείο (X, Y)
Μου. Έλεγχοι. Προσθήκη (txtDataShow)
End Sub
Τέλος κλάσης
Πολύ καλό σημείο, John. Αυτό είναι σίγουρα πολύ πιο απλό από τον κώδικα της Microsoft... έτσι αναρωτιέμαι γιατί επέμεναν να το κάνουν με αυτόν τον τρόπο;

Για να ξεκινήσουμε την έρευνά μας, ας προσπαθήσουμε να αλλάξουμε μία από τις αναθέσεις ιδιοκτησίας στον κώδικα. Ας αλλάξουμε

txtDataShow. Ύψος = 19
προς το

txtDataShow. Ύψος = 100
απλά για να βεβαιωθείτε ότι υπάρχει μια αξιοσημείωτη διαφορά.

Όταν τρέχουμε τον κώδικα ξανά, παίρνουμε... Whaaaat??? ... το ίδιο πράγμα. Καμία αλλαγή καθόλου. Στην πραγματικότητα, μπορείτε να εμφανίσετε την τιμή με μια εντολή όπως το MsgBox (txtDataShow. Ύψος) και εξακολουθείτε να έχετε 20 ως την αξία του ακινήτου, ανεξάρτητα από το τι εκχωρείτε σε αυτό. Γιατί συμβαίνει αυτό;

Η απάντηση είναι ότι δεν εξάγουμε τη δική μας κλάση για να δημιουργήσουμε τα αντικείμενα, προσθέτουμε πράγματα σε μια άλλη κλάση, έτσι πρέπει να ακολουθήσουμε τους κανόνες της άλλης τάξης. Και αυτοί οι κανόνες δηλώνουν ότι δεν μπορείτε να αλλάξετε την ιδιότητα Ύψος. (Wellllll... μπορείς. Εάν αλλάξετε την ιδιότητα Multiline σε True, τότε μπορείτε να αλλάξετε το ύψος.)

Γιατί το VB.NET προχωράει και εκτελεί τον κώδικα χωρίς καν να φωνάζει ότι μπορεί να υπάρχει κάτι λάθος όταν, στην πραγματικότητα, αγνοεί εντελώς τη δήλωσή σας είναι μια ολόκληρη «κακοποίηση». Μπορεί όμως να προτείνω τουλάχιστον μια προειδοποίηση στο compile, ωστόσο. (Ιχνος! Ιχνος! Ιχνος! Η Microsoft ακούει;)

Το παράδειγμα από το Μέρος Ι κληρονομεί από μια άλλη κλάση και αυτό καθιστά τις ιδιότητες διαθέσιμες στον κώδικα στην κληρονομική κλάση. Η αλλαγή της ιδιότητας Ύψος σε 100 σε αυτό το παράδειγμα μας δίνει τα αναμενόμενα αποτελέσματα. (Πάλι... μία αποποίηση: Όταν δημιουργηθεί μια νέα παρουσία ενός μεγάλου στοιχείου ετικέτας, καλύπτει το παλιό. Για να δείτε τα νέα στοιχεία της ετικέτας, πρέπει να προσθέσετε την κλήση μεθόδου aLabel. BringToFront ().)

Αυτό το απλό παράδειγμα δείχνει ότι, αν και μπορούμε απλά να προσθέσουμε αντικείμενα σε μια άλλη κλάση (και μερικές φορές αυτό είναι το σωστό πράγμα), τον προγραμματισμό του ελέγχου πάνω στα αντικείμενα απαιτεί να τις αποκομίζουμε σε μια κλάση και με τον πιο οργανωμένο τρόπο (τολμώ να λέω, ο "τρόπος .NET" ??) είναι να δημιουργήσετε ιδιότητες και μεθόδους στη νέα παράγωγη κλάση για να αλλάξετε πράγματα. Ο Ιωάννης δεν ήταν πεισμένος στην αρχή. Είπε ότι η νέα προσέγγισή του ταιριάζει με το σκοπό του, παρόλο που υπάρχουν περιορισμοί από το να μην είναι "COO" (Correctly Oriented Object Oriented). Πιο πρόσφατα, ωστόσο, ο John έγραψε,

"... μετά τη σύνταξη ενός συνόλου 5 κειμένων σε χρόνο εκτέλεσης, ήθελα να ενημερώσω τα δεδομένα σε ένα επόμενο μέρος του προγράμματος - αλλά τίποτα δεν άλλαξε - τα αρχικά δεδομένα ήταν ακόμη εκεί.

Βρήκα ότι θα μπορούσα να ολοκληρώσω το πρόβλημα γράφοντας κώδικα για να βγάλω τα παλιά κιβώτια και να τα βάλω πίσω με νέα δεδομένα. Ένας καλύτερος τρόπος για να γίνει αυτό θα ήταν να Με χρησιμοποιήσει. Φρεσκάρω. Αλλά αυτό το πρόβλημα έχει τραβήξει την προσοχή μου για την ανάγκη να παρέχουμε μια μέθοδο για να αφαιρέσουμε τα κείμενα και να τα προσθέσουμε ».

Ο κώδικας του John χρησιμοποίησε μια παγκόσμια μεταβλητή για να παρακολουθήσει πόσα μάρτυρες είχαν προστεθεί στη φόρμα έτσι μια μέθοδος ...

Private Sub Form1_Load (_
ByVal αποστολέας ως σύστημα. Αντικείμενο, _
ByVal e ως σύστημα. EventArgs) _
Χειρίζεται MyBase. Φορτώνω
CntlCnt0 = Me. Έλεγχοι. μετρώ
End Sub

Στη συνέχεια, ο τελευταίος έλεγχος θα μπορούσε να καταργηθεί ...

Ν = Me. Έλεγχοι. Count - 1
Μου. Έλεγχοι. RemoveAt (N)
Ο Ιωάννης σημείωσε ότι "ίσως αυτό είναι λίγο αδέξια".

Είναι ο τρόπος με τον οποίο η Microsoft παρακολουθεί τα αντικείμενα στο COM και στον "άσχημο" κώδικα παραδείγματός τους παραπάνω.

Έχω επιστρέψει τώρα στο πρόβλημα της δυναμικής δημιουργίας ελέγχων σε μια φόρμα κατά το χρόνο εκτέλεσης και έχω ξαναβρεθεί στα άρθρα «Τι συνέβη για τον έλεγχο των συστοιχιών».

Δημιούργησα τις τάξεις και μπορώ τώρα να τοποθετήσω τους ελέγχους στη φόρμα με τον τρόπο που θέλω να είναι.

Ο John απέδειξε πώς να ελέγχει την τοποθέτηση των ελέγχων σε ένα πλαίσιο ομάδας χρησιμοποιώντας τις νέες τάξεις που έχει αρχίσει να χρησιμοποιεί. Ίσως η Microsoft είχε το δικαίωμα στην "άσχημη" λύση τους μετά από όλα!