Verkrijgbare variabelen in Visual Studio 2010 en VB.NET

Hoe verklaar ik een wereldwijde variabele in Visual Basic?

Deze variabelen moeten toegankelijk zijn van alle visuele basisvormen. Ik weet hoe ik een publieke variabele kan verklaren voor een specifieke vorm, maar hoe doe ik dit voor alle vormen in mijn project?


Antwoord 1, Autoriteit 100%

Er is geen manier om globale variabelen te declareren terwijl u zich waarschijnlijk in vb.net voorstelt.

Wat u kunt do (zoals sommige van de andere antwoorden hebben gesuggereerd), verklaart alles wat u als een globale variabele als statische variabelen wilt behandelen in plaats daarvan binnen een bepaalde klasse:

Public Class GlobalVariables
    Public Shared UserName As String = "Tim Johnson"
    Public Shared UserAge As Integer = 39
End Class

Je moet echter echter volledig in aanmerking komen voor alle verwijzingen naar die variabelen waar je ze in je code wilt gebruiken. In die zin zijn ze niet het type globale variabelen waarmee u misschien bekend bent uit andere talen, omdat ze nog steeds geassocieerd zijn met een bepaalde klasse.

Als u bijvoorbeeld een berichtvak in de code van uw formulier wilt weergeven met de naam van de gebruiker, moet u zoiets doen:

Public Class Form1: Inherits Form
    Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load
        MessageBox.Show("Hello, " & GlobalVariables.UserName)
    End Sub
End Class

U kunt niet alleen toegang krijgen tot de variabele door UserNamebuiten de klasse te typen waarin deze is gedefinieerd – u moet ook de naam van de klasse opgeven waarin deze is gedefinieerd.

Als de praktijk van het volledig kwalificeren van uw variabelen u om wat voor reden dan ook afschrikt of van streek maakt, kunt u altijd de klasse importeren die uw globale variabeledeclaraties bevat (hier GlobalVariables) bovenaan elk codebestand (of zelfs op projectniveau, in het venster Eigenschappen van het project). Vervolgens kunt u eenvoudig naar de variabelen verwijzen met hun naam.

Imports GlobalVariables

Merk op dat dit exacthetzelfde is wat de compiler voor u doet achter de schermen wanneer u uw globale variabelen declareert in een Module, in plaats van een Class. In VB.NET, dat modules biedt voor achterwaartse compatibiliteit met eerdere versies van VB, is een Modulegewoon een verzegelde statische klasse (of, in VB.NET-termen, Shared NotInheritable Class). Met de IDE kunt u leden van modules oproepen zonder volledig te kwalificeren of een verwijzing naar hen te importeren. Zelfs als je besluit deze weg te gaan, is het de moeite waard om te begrijpen wat er achter de schermen gebeurt in een objectgeoriënteerde taal als VB.NET. Ik denk dat het als programmeur belangrijk is om te begrijpen wat er aan de hand is en wat je tools precies voor je doen, zelfs als je besluit ze te gebruiken. En voor wat het waard is, raad ik dit niet aan als een “best practice” omdat ik vind dat het neigt naar onduidelijkheid en schone objectgeoriënteerde code/ontwerp. Het is veel waarschijnlijker dat een C#-programmeur uw code zal begrijpen als deze is geschreven zoals hierboven weergegeven, dan wanneer u deze in een module propt en de compiler alles laat afhandelen.

Merk op dat, zoals ten minste één ander antwoord heeft gezinspeeld, VB.NET een volledig objectgeoriënteerde taal is. Dat betekent onder andere dat alleseen object is. Zelfs “algemene” variabelen moeten binnen een instantie van een klasse worden gedefinieerd, omdat het ook objecten zijn. Elke keer dat u de behoefte voelt om globale variabelen in een objectgeoriënteerde taal te gebruiken, is dat een teken dat u uw ontwerp moet heroverwegen. Als je net de overstap naar objectgeoriënteerd programmeren maakt, is het meer dan de moeite waard om te stoppen en enkele basispatronen te leren voordat je je verder verdiept in het schrijven van code.


Antwoord 2, autoriteit 26%

Vrijwel op dezelfde manier als altijd, met “Modules” in plaats van klassen en gebruik gewoon “Openbaar” in plaats van het oude “Globale” trefwoord:

Public Module Module1
    Public Foo As Integer
End Module

Antwoord 3, autoriteit 8%

Ok. Ik heb eindelijkgevonden wat echt werkt om de vraag te beantwoorden die lijkt te worden gesteld;

“Als ik veel modules en formulieren nodig heb, hoe kan ik dan een variabele voor iedereen openbaar maken, zodat ze allemaal naar dezelfde variabele verwijzen?”

Verbazingwekkend genoeg heb ik veel tijd op internet besteed aan het zoeken naar die schijnbaar eenvoudige vraag, maar ik vond niets dan vaagheid waardoor ik nog steeds fouten kreeg.

Maar dankzij Cody Gray’s link naar een voorbeeldkon ik een goed antwoord vinden;


Situatie;
U heeft meerdere Modules en/of Formulieren en wilt van elke of alle naar een bepaalde variabele verwijzen.

“Een” manier die werkt;
Plaats op één module de volgende code (waarin “DefineGlobals” een willekeurig gekozen naam is);

Public Module DefineGlobals
Public Parts As Integer                 'Assembled-particle count
Public FirstPrtAff As Long              'Addr into Link List 
End Module

en vervolgens in elke module / formulier behoefte aan het aanpakken van die variabele “onderdelen”, plaatst u de volgende code (als een voorbeeld van het formulier “Initform2”);

Public Class InitForm2
Private Sub InitForm_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    Parts = Parts + 3
End Sub
End Class

en misschien een andere vorm;
Public Class Formx

Sub CreateAff()
   Parts = 1000
End Sub 
 End Class

Dat type codering lijkt te hebben gewerkt aan mijn VB2008 Express en lijkt allen alles nodig te zijn (ongeldig van onbekende bestanden die op de achtergrond worden geladen), ook al heb ik geen einde gevonden aan de “OH BTW .. . “Verras details. En ik ben er zeker van dat een grotere mate van standaardisatie de voorkeur heeft, maar de eerste taak is eenvoudigweg om iets te laten werken, met of zonder normen.

Niets verslaat exact en goed geformuleerd, expliciet voorbeelden.

Nogmaals bedankt, Cody


Antwoord 4, Autoriteit 5%

Maak het statisch (gedeeld in VB).

Public Class Form1
   Public Shared SomeValue As Integer = 5
End Class

Antwoord 5, Autoriteit 2%

Openbare variabelen zijn een codeur – probeer uw aanvraag opnieuw uit te lossen, zodat deze niet zijn nodig. Het grootste deel van de redenering here en Hier zijn zo van toepassing op vb.net.

De eenvoudigste manier om globale variabelen in VB.NET te hebben, is door openbare statische variabelen voor een klasse te maken (declareer een variabele als public shared).


Antwoord 6

Een globale variabele kan toegankelijk zijn in al je formulieren in je project als je het trefwoord public sharedgebruikt als het in een klas zit. Het werkt ook als u het trefwoord “public” gebruikt als het onder een module staat, maar het is om vele redenen niet de beste methode.

(… Ja, ik herhaal enigszins wat “Cody Gray” en “RBarryYoung” zeiden.)

Een van de problemen is wanneer je twee threads hebt die tegelijkertijd dezelfde globale variabele aanroepen. U zult enkele verrassingen hebben. U kunt onverwachte reacties krijgen als u hun beperkingen niet kent. Bekijk de post Global Variables in Visual Basic .NETen download het voorbeeldproject!


Antwoord 7

kleine opmerking: ik gebruik modules in een webgebaseerde applicatie (asp.net).
Ik moet onthouden dat alles wat ik opsla in de variabelen op de module door iedereen in de applicatie wordt gezien, lees website. Niet alleen in mijn sessie.
Als ik een berekening in mijn sessie probeer op te tellen, moet ik een array maken om de getallen voor mijn sessie en voor anderen te filteren.
Modules is een geweldige manier om te werken, maar je moet je concentreren op het gebruik ervan.

Om fouten te voorkomen: lessen worden naar de

. gestuurd

CarbageCollector

wanneer de pagina klaar is. Mijn modules blijven in leven (zolang de applicatie niet wordt beëindigd of opnieuw gestart) en ik kan de gegevens erin hergebruiken.
Ik gebruik dit om gegevens op te slaan die soms verloren gaan door de sessieafhandeling door IIS.

IIS-formulierverificatie

en

IIS_session

zijn niet synchroon en met mijn module trek ik gegevens terug die de klif overgingen.


Antwoord 8

Al het bovenstaande kan worden vermeden door simpelweg een vriendelijke waarde voor runtime te verklaren op het startformulier.

Public Class Form1 
Friend sharevalue as string = "Boo"

Open vervolgens deze variabele vanuit alle formulieren eenvoudig met Form1.sharevalue


Antwoord 9

U kunt gewoon een nieuwe variabele toevoegen onder de eigenschappen van uw project
Elke keer dat u die variabele wilt krijgen, moet u gewoon

gebruiken

My.Settings.(Name of variable)

Dat werkt voor het hele project in alle formulieren


Antwoord 10

De verschillende antwoorden in deze blog lijken te worden gedefinieerd door SE’s die strikte naleving bevorderen aan de gebruikelijke regels van objectgerichte programmering (gebruik een openbare klasse met openbare gedeelde (aka-statisch) en volledig gekwalificeerde klassenreferenties, of SE’s Wie promoot met behulp van de functie achteruit-compatibiliteit (module) waarvoor de compiler uiteraard hetzelfde hoeft te doen om het te laten werken.

Als SE met meer dan 30 jaar ervaring, zou ik de volgende richtlijnen voorstellen:

  1. Als u alle nieuwe code schrijft (niet probeert een Legacy-app te converteren) die u vermijdt met behulp van deze formulieren helemaal, behalve in het zeldzame exemplaar dat u echt een statische variabele moet hebben, omdat ze vreselijke gevolgen kunnen hebben (en echt moeilijk te vinden insecten). (Multithread- en multiprocessing-code vereist semaforen rond statische variabelen …)

  2. Als u een kleine toepassing aanpast die al een paar globale variabelen heeft, formuleer ze dan zodat ze niet worden verduisterd door Modules, dat wil zeggen, gebruik de standaardregels van objectgeoriënteerd programmeren om ze opnieuw te maken als openbare statische gegevens en toegang met volledige kwalificatie, zodat anderen kunnen achterhalen wat er aan de hand is.

  3. Als je een enorme legacy-applicatie hebt met tientallen of honderden globale variabelen, gebruik dan in ieder geval Modules om ze te definiëren. Er is geen reden om tijd te verspillen aan het werkend krijgen van de applicatie, omdat je waarschijnlijk al achter de 8-ball zit in tijd besteed aan Properties, etc.


Antwoord 11

De eerste man met een openbare les is veel logischer. De originele man heeft meerdere vormen en als globale variabelen nodig zijn, zal de globale klasse beter zijn. Denk aan iemand die achter hem codeert en een globale variabele moet gebruiken in een klas waarin je IntelliSense hebt, het zal ook het coderen van een wijziging 6 maanden later een stuk eenvoudiger maken.

Ook als ik een hersenscheet heb en zoals in een voorbeeldgedeelte op moduleniveau gebruik, dan wil ik mijn globale onderdelen, dan kan ik zoiets doen als

Dim Parts as Integer
parts = 3
GlobalVariables.parts += Parts  '< Not recommended but it works

Daarom zou ik tenminste voor de klas gaan.


Antwoord 12

Geen van deze antwoorden lijkt iets voor mij te veranderen.

Ik ben een oud Excel-programma aan het converteren naar VB 2008. Natuurlijk zijn er veel Excel-specifieke dingen die moeten veranderen, maar iets dat hoofdpijn veroorzaakt, lijkt dit hele “publieke” probleem te zijn.

Ik heb ongeveer 40 arrays waarnaar wordt verwezen door ongeveer 20 modules. De arrays vormen de basis van het hele project en worden door zowat elke procedure aangepakt.

In Excel moest ik gewoon ze allemaal als openbaar verklaren. Werkte geweldig. Geen probleem. Maar in VB2008 vind ik het een behoorlijk probleem. Het is absurd om te denken dat ik duizenden regels van de code moet doorlopen om elke referentie te vertellen waar het publiek is verklaard. Maar zelfs bereid om dat te doen, lijkt geen van de voorgestelde regelingen te helpen bij het geheel te helpen.

Het lijkt erop dat “publiek” alleen maar “openbaar binnen deze ene module” betekent. Het toevoegen van “gedeelde” lijkt niets te doen om dat te veranderen. De naam van de module toevoegen of iets anders lijkt dat niet te veranderen. Elke module dringt erop aan dat ik alle arrays (en ongeveer 100 andere fundamentele variabelen) binnen elke module (een schijnbaar achterbeeld) verklaar. En de “import” bit lijkt niet te weten waar ik het over heb, “kan niet worden gevonden”.

Ik moet sympathiseren met de vragensteller. Iets lijkt vreselijk amiss met dit.


Antwoord 13

U kunt de variabele pijpen in een bestand in de uitvoermap en vervolgens dat bestand in de variabele laden.

Imports System.IO

Deze code schrijft het bestand.

Dim somevariable = "an example"
Dim fs As FileStream = File.Create("globalvars/myvar1.var")
                Dim filedata As Byte() = New UTF8Encoding(True).GetBytes(somevariable)
                fs.Write(filedata, 0, filedata.Length)
                fs.Close()

Dit laadt het bestand in een ander formulier.

Dim form2variable
    Dim fileReader As String
fileReader = My.Computer.FileSystem.ReadAllText("globalvars/myvar1.var")
form2variable = filereader

Antwoord 14

Public Class Form1
   Public Shared SomeValue As Integer = 5
End Class

Het antwoord:

MessageBox.Show("this is the number"&GlobalVariables.SomeValue)

Other episodes