Na mégegyszer:

Alaphelyzetben a VB2005 a következő helyre menti a cuccait:
C:\Documents and Settings\...\Dokumentumok\Visual Studio 2005\
(A kipontozott részen a felhasználó neve van.)
Ahhoz hogy ezen a helyen megtaláld az általad írt progik forrását, az egész projectet el kell mentened a Save All paranccsal.
Hogy legyen EXE fájlod, le kell fordítani a forrást futtatható kódra a Build paranccsal.
Ezután már megtalálod azt a C:\Documents and Settings\...\Dokumentumok\Visual Studio 2005\Projects\Progi\Progi\bin\Release\ helyen. (A Progival jelölt helyeken a te programod neve van.)
Ha mégsem találod, akkor keress rá! (Progi.exe)

Ahhoz hogy egy VB-ben írt progit használjunk egy tetszőleges gépen, fent kell lennie a .NET Framework 2.0-nak. (Vagy legalább a megfelelő dll-eknek.)

Remélem érthető minden!

írjatok!!!!!!!

a fönt lévő kérdések még mindig álnak, csak azóta lett új i:
tudom hogy ezt egyszer már kitárgyaltuk, de hogy a fenébe kel egy projektet más gépen futtatnia leg egyszerűbben(azon a gépen ne legyen vb!)
Zsora hjavaslata a projekt mappán belül kimásolni az exet.
Baj: az általa megadott mappa üres!
A publis-nál ha a windows installert bepipálom, ako r nemengedi publikálni
ha nem jelölöm be akor azokon a gépeken, ahol nincs ot enm lehet futatni...

help!

szóval megoldottam egykét kérdést az msdn-el, de van, amit nemtudtam
:

ugye ha egy listbox-hoz akarunk adni valamit akkro az az item.add-al lehet.
de ha én akarok valuemembert is hozáadni?
pl:
hozáadom, hogy Kovács Lajos, és azt akarom, hogy amikor rákatintok, akor jelenjen meg egy szám, pl 13.
Ezt hogyan lehet, hogy nem cak itemet adok, ahnem anak értéket is?

ok, ok
használom.
és az a tömbös próbléma már nem létezik, kitaáltam, hogyan lehetne egyszerűbben:
egy listbox-ba adjuk az értékeket, és egy változóval számoltatjuk, hány tagja van, így utána már könyű lejkérdezni az egyes elemeket(elméletileg)
a dologal kapcsolatban még nekem is van egy rakás kérdésem, de megnézem, mit tud az MSDN és csak utána kérdezek

A megoldás a konkrét feledattól függ. pl.:
- a tömböt akkor hozod létre mielőtt felhasználod azt, és már nem változik az elemek száma
- tömbméretnek egy akkora értéket választasz, amekkorát biztosan nem lépsz túl

Az előző kérdéseddel kapcsolatban:
A file előző tartalmát úgy tarthatod meg ha felülírás helyett hozzáfűzéssel írod ki azt.
Továbbá: csak a RichTextBox alkalmas stílusok kezelésére, de ezt én még nem igazán használtam.
Tudod mit javasoltam már korábban is; MSDN!!!

egyire nem kell tolongani a válaszal, főleg, mert vane gy fontosabb és komplexebb kérdésem:
van egy szövegdobozom. Ha oda beírunk valamit, pl egy nevet, aztán hozzáagyuk egy legördülö menühöz, vagy sima menühöz vagy akáérmihez az item.add-al, aztán ha lett 5-6 név, akor hogyan lehet ebből egy tömböt létrehozni? a buktató az hogy nem lehet előre definiálni a tömböt pl5 emberel mert lehet hogy 2 vagy 10 vgay 200 tagja lesz...
és mint azt már kérdeztem, és kiderült nem lehet megváltoztatni a tömb tagjainak számára vonatkozó beálítűsokat.


...

az a kérdésem lenne, megina a fájlbaírással kapcsolatban(már én is unom, de ez van )
hogy hogyan lehet egy szöveges fájlt elmenteni, meg betölteni, de:Ű
ha elmentem ne törölje ki azt, ami előte bene volt, hameg viszaolvasom, akor ne trölje ki az entereket.

és végezetül egy szövegdobozban hogyan leheta szöveg különböző részeinek különböző tulajdonságokat rendelni, pl más méret, más szín.

köszönöm a segítséget

jól emlékeztél, köszönöm

Szerintem IsNumeric(TextBox.Text), de ezt csak emlékezetből írom.

pedig nekem pont az kéne...

következő kérdés(megtudom xcsinálni, de csak bonyolultul):
hogyan lehet egyszerűen eldönteni, hogy egy textbox.text-e szöveg, vagy csak szám? (a nullorempty nem jó!)

Egy tömb dimenzióját (dimenzióit) szeretnéd megváltoztatni?
Arra a ReDim parancs alkalmazható.


Egyre kell ügyelni: a dimenziók száma nem változtatható meg.
Tehát a következő kifejezés helytelen:

hogyan lehet egy változót pl:
dim ember() as string-et
a ()-ben lévő értékét megváltoztatni programilag?

Én még nem találkoztam vele.

van valahol valami magyar dokumentációja a .NET Framework fejlesztőkörnyezetnek?
(ezen a fórumon kívül )

nekem nem úgy kéne portvezérlés, hogy egy stringet küldünk ki rajta, hanem úgy, hogy pl. 5 másidpercig adunk ki feszültslget a nyomtatóport egyik lábán.

de ezekszerint ezt nemlehet.

Csak a Serial Portról találtam infót.

http://msdn2.microsoft.com/en-us/library/e4560dx9(VS.80).aspx

Megj.: Mivel a VB2005 teljesen a .NET Framework fejlesztőkörnyezetre támaszkodik, a programozáshoz annak ismerete szükséges.
Ez vonatkozik a Visual Studio többi nyelvére is.

akor ezentúl énis csak ezt másolom ki.
Hogyan lehet vb-alatt portot vezérelni?

Pedig semmi különlegesség nincs a dologban.
A futtatható fájlt én a következő helyről másoltam ki:
...\Visual Studio 2005\Projects\Hullám2\Hullám2\bin\Release\
Így nem kell azt más gépen telepítgetni, hanem kapásból futtatható.

Zsora:
Hogyan tudod úgy lefordítani exe-be, hogy fut más gépeken is, mert ha én csak simán kimásolom a projekt mappából, akkor nemmegy más gépeken?

Azt hiszem sikerült!


Sajnos az integrálási pontatlanságok miatt nem tökéletes a lezárás, van egy kevés reflexió.

Hát akkor jöjjön a következő megoldandó probléma:
Ennek a modellnek van 2 dimenziós változata is. (A Progi és az egyszerűsített változat Forrása itt.)
Vajon annál is megoldható az illesztett lezárás?
Na ez már keményebb diónak tűnik!

ok utánna már én is rájöttem

energoman:
A programom nem tartalmaz függvényeket, nincs benne sem omega, sem t. Na jó, t az van benne, de igazából nem szükséges, egységnyinek lehet venni. A hullám terjedési sebességét csak a D és m értékek fogják meghatározni és persze az időalap.
A felhasznált mechanikai képletek:

F=D*x (rugóerő = rugóállandó * megnyúlás)
dv=a*t=F/m*t (sebességváltozás = erő / tömeg * időváltozás)
s=v*t (út = sebesség * idő)

Erre a három alapösszefüggésre épül az egyész hullámmozgás.
Az ezzel analóg villamos mennyiségek és összefüggések:

U=1/C*Q (feszültség = 1 / kapacitás * töltés)
dI=U/L*t (áramváltozás = feszültség / induktivitás * időváltozás)
Q=I*t (töltés = áramerősség * idő)

A távíróegyenletből számolt bemenő impedancia (veszteségmentes esetben):
Zo=sqr(Z/Y)=sqr(L/C)
Z - az egységnyi vezetékszakasz impedanciája
Y - az egységnyi vezetékszakasz admittanciája
L - az egységnyi vezetékszakasz soros induktivitása
C - az egységnyi vezetékszakasz párhuzamos kapacitása
Ha a Zo hullámimpedanciájú tápvonalat ugyanekkora értékű óhmikus ellenállással zárjuk le, nem következik be reflexió a vonal végén.
Na ezzel analóg módon kell megoldani a problémát a mechanikai modell esetén is. Nekem erre ez jött ki:
Zo=sqr(m*D) [Ns/m] és Zo=F/v
A mechanikai ellenállás tehát egy erő hatására létrejövő sebességet jelent, ami tulajdonképpen felfogható súrlódásnak ill. közegellenállásnak.
Már csak a megvalósítás hiányzik...

akkor lehet az a megoldás ha:
m (tömeg) tart a végtelenhez, szóval minél nagyobb annál keveésbé érvényesül a reflexió
vagy az
F (erő) tart a nullához, amit tényleg be tusz épiteni ugy hogy minden ciklus után beteszel egy mü-t mondjuk ugy hogy annak az értéke az előző ciklus számitásakor keletkező x=db-helyen lévő (y(x)-y(x-1))*cD/F=mü értéket használja és ezt a müt teszed be az uj ciklusba F =mü( Dc * (y(x - 1) - y(x)) + Dc * (y(x + 1) - y(x)))
itt megint kapcs egy uj mü-t és igy tovább.....

üdv

Megj.:lehet teljesen hüleség amit irtam.

Bocs eszebe se jutott hogy idelinkelted a forráskódot!

Zsora:
csak egy kósza tipp és lehet hogy roszabb, mint hatásosabb, de mivan akkor ha az utolsó golyó senem rögzített, senem szabadon mozgó?
pl: fele annyira hat csak rá a mellete lévő golyó, vagy csak fele olyan magasra tud elmozdulni?

Én nem szereték áttérni, csak egyik ismerősömnek kellett, és ugy kézenfekvőek a parancsok csak ugye ahány nyelv annyi szintaktika.

Zsora:
Szóval van egy egyenleted, ami előállitja az idelinkelt mozgást.
Ezt az egyenletet deriváld le omegaT szerint (mert gondolom van benne) és ami maradt konstans vagy vizikai változó, azokat kell olyan előállirásokkal ellátni hogy nullák legyenek, tehát a mozgás során a derivált értékét is kell folyamatosan számolni és az ebböl kiszámolt konstansokat majd ogye ezeket nullázni és visszahelyettesiteni az eredeti f(omegaT) egyenletbe és talán eltünik a reflexió, de nem 100%
ez egy kóbor ötlet volt!
üdv
energo

energoman:
én is rátérek az MSDN-re
http://msdn2.microsoft.com/en-us/library/zc1dyw8b.aspx

Zsora:
Nem semmi ez a program, nem is tudtam, hogy a vb ilyenre is képes.
Ha megtudod oldani, eltudod küldeni, mert engem is érdekel nek a modellezőprogramok.

Egy rövid példa:


Egyébként nem egészen értem az általad leírtakat.

véleményem szerint reflexió akkor nem fod kezdődni ha az adott (ugy látom az 4) priódus alatt a df(x)/d(omegaT) zérussá válik. Rosszul fogalmaztam ha nem válik zérussá akkor a maradék tagokban szereplő változóknak kell olyan feltételt adni hogy mégis zérussá regyék a diffi hányadost. Ilyen a teáltalad elmitett surlódás kényszermozgás....

Most lehet hülyeséget mondtam!


MÁS!

Nem tudja valaki fejböl gyorsan megmondani hogy hogyan lehet a VB-ben tetszőleges szint deffiniálni a három alapszin megadásával???

üdv
energo

Na most én teszek fel kérdést.
A problémám nem igazán a VB 2005-höz kapcsolódok, de mégcsak nem is programozástechnikai, inkább fizikai jellegű.
Korábban már közzétettem egy kis progit ami 2 dimenziós térben terjedő transzverzális hullámokat szimulált. Ennek az 1 dimenziós változatát szeretném most finomítani egy kicsit.
(A Progi és a Forrás itt található. Bal egérgomb = start, jobb = pause be/ki, középső = hullám stop/start)

A modell:
Van néhány golyóm sorban egymás mellett (vízszintesen), melyek rugókkal kapcsolódnak egymáshoz. A golyók csak függőlegesen képesek elmozdulni. A rugók egységesen Dc rugóállandóval jellemezhetők, a megnyúlásukat a két szomszédos golyó függőleges távolsága adja. (A rugók megnyúlásának csak a függőleges komponensét vesszük, mert transzverzális hullámot szimulálunk!) A megnyúlás hatására bennük F rugóerő ébred. A golyókat m(x) tömeggel, v(x) sebességgel és y(x) kitéréssel jellemezzük. A kitérés alaphelyzetben 0, és pozitív ill. negatív értékeket vehet fel. Minden golyóra hat a két szomszédos rugóban ébredő erő.
A legelső golyónak kötött a mozgása, időben szinuszosan változik a függőleges kitérése pl. +100 és -100 között. A legutolsó golyó viszont rögzített a 0 pozícióban (kötött vég), vagy szabadon mozoghat és csak a tőle balra lévő rugó hat rá (szabad vég).

A golyósort akár szabad-, akár rögzített véggel zárjuk le, reflexió keletkezik. Szabad végről a hullám azonos fázisban, kötött végről viszont ellentett fázisban verődik vissza.

A kérdés: Mivel kell lezárnom a golyósort hogy ne legyen reflexió?
Eddig súrlódással próbálkoztam, de valamiért nem akart összejönni a dolog. Most éppen a távíróvezeték analógiáján próbálok elindulni, de még nem jutottam eredményre.

Minden segítséget előre is köszönök!

megoldottam . kivételesen nem kel segítség Ha valakinek kell a program, írjon.

windows xp sp2-mvan
és fenn van a windows installer szerintem, mert már mást is publikáltam ezzel, és ment, meg a telepítésnél mindent választottam(visual basic, sql, msdn)bár ezeknek egyike se utal a windows installere. Meg nekem nem is muszáj a w.i. 3.1 felőlem akármi lehet, csak exe-legyen

A hibát ezúttal a Windowsban kell keresni.
Az aktuális frissítések és patchek fent vannak?
Úgy látom a Windows Installer 3.1-et nem találja. Nem ártana telepíteni.
Mintha a területi beállítások sem stimmelnének...
Háááát...

Egyébként meg én sosem használom a publish funkciót. Egyszerűen felteszem a kész futtatható állományt vagy a forrást egy tárhelyre, ahonnan aztán bárki letöltheti.

Nagy M-betűvel MŰKÖDIK!!!!!!!!
Köszönök mindent!!!
Teljesen kész, tökéletesen működik minden helyzetben. Már csak publikálni kell. Már több projektel csináltam ezt, nemgond. De ez a projekt nem hagya magát ilyen könnyen megbeszélni egy fórumba, még egy gondot gördít elénk.
Amikor Publikálni akartam(És ZSorának küldeni egy díszpéldányt) akkor ezt lett:
http://esoma.atw.hu/baj2.png
Most mittegyek?

Na szóval...
Van tehát 16 változónk; 8 integer és 8 sztring. Pont ilyen sorrendben.
Az integer változók egy-egy billentyűkódot tárolnak 32 biten. Pl.: 65
A sztringek pedig egy-egy fájl elérési útját és nevét tartalmazzák, a hosszuk bármekkora lehet. A nulla hossznak persze nincs értelme, mivel az nem jelöl fájlt. (Ezek ugye hangfájlok, amiket le kell játszani?)
Tehát valahogy így néz ez ki, ugye?:

1. 65 (Keys.A)
...
8. 127
9. "C:\Hang1.wav"
...
16. "C:\Hang8.wav"

Ezeket egy-egy változó tárolja: Gomb(1...8 ) ill. Hang(1...8 )
Ezeket a változókat kell tehát menteni, ill. ezekbe kell majd visszatölteni az elmentett tartalmakat.

egész ódát írtam ide, de mire megírtam, kiléptetett az a rohadt rendzser!
tehát röviden: amit írál értem, az 1-0-t tudtam .
Tehát:
18 változó:
gomb1-gomb8
hang1-hang8
a gombok pl"c:\mentes.sin"
a hangok pl: "keys.A"
ezeket kell lementeni, és viszatölteni. Ha veszem a fáradtságot, megismétlema keserves 30 percet és léeírok mindent.

SIS:
Mit is köszöntél meg, hiszen nem segítettem neked?
Nem azért mert nem akartam, hanem mert sajnos nem tudtam.
Én csak VB2005 alatt programozok, a régebbi verziókkal (VB6 és azalatt) nem foglalkoztam sosem. De azt tudom hogy azok teljesen más utasításokat használnak, és a logikájuk is sokban különbözik.
Pontosan miről is lenne szó? Nem egészen világos a probléma.

esoma:
Most már végképp nem értem hogy mit nem értesz.
Van egy ötletem: Pontosan írd le hogy mit szeretnél, mit kell a proginak megcsinálnia! Töviről hegyire! Úgy ahogy egy tök hülyének magyaráznád. Mit kell pontosan elmenteni? Változókat? Milyeneket? Milyen méretűeket? Mennyit? Milyen sorrendben?
Ahhoz hogy megoldást találjunk, pontosan kell ismerni a problémát.

Mint ahogy már korábban leírtam, a Keys.A egy változó, egy szám; 65. És nem kell azt alakítgatni, mert a VB is számként kezeli.
Sok más ilyen számváltozót használ még a VB, ezekre azért lehet névvel hivatkozni hogy egyszerűbb legyen őket megjegyezni. Éppen úgy mint a matekban a Pi szám; csak a görög pi betűvel hivatkozunk rá, holott tudjuk hogy az egy szám, aminek az értéke kb. 3.14159265.
Egy szövegfájl sem betűket tárol, hanem számokat; a karakterek kódját, ami egy 8, 16 v. 32 bites szám. Csak a képernyőn való megjelenítéskor kapják meg a betűk az ismert alakjukat. A számítógépek mindent számokként tárolnak, méghozzá bináris számrendszerben. Egy digitális számítógép csak az egyeseket meg a nullákat ismeri alapból. Már az Assembly nyelv is egy könnyítés a gépikódhoz képest, mi lenne ha úgy kellene ma is programozni? A mnemonikok helyett hexadecimális v. bináris számok ezreit kellene bepötyögni...

Visszatérve az A billentyűkódra:
Az If e.KeyCode = Keys.A Then Me.Close() kifejezés teljesen egyenértékű az If e.KeyCode = 65 Then Me.Close() kifejezéssel, ugyanis Keys.A = 65.
Az egyszerű billentyűkódok (vagy karakterkódok) persze átalakíthatók szöveges változókká, ha szükséges. Erre jó pl. a Chr() függvény. Chr(65) = "A". Ez viszont speciális karaktereknél nem használható, de ez teljesen érthető is.

bocs, de még mindiog nem értem, ebbe a 16 változót hogyan lehet beletenni. mindig aláhúzza. Csak a Sztring-et menti el.
ui: és a 65-öt hogyan lehet visza keys.a -nak konvertálni? nem lehet azt is sztringnek elmenteni?

Zsora nagyon szépen köszönöm, itthon nem tudom kipróbálni, remélem ez alapján sikerül. És ugye még kérdezhetek, ha elakadok?

A fenti példában a SZTRING nevű sztringet 14db Integer-ként (azaz 32bites előjeles egész változó, ami 4byte hosszú) tárolja el, mivel 14 karakterből áll. (A szóköz is karakter, így összesen 14×4 byte hosszú lesz a fájlban a SZTRING változó.)
Előtte elmenti a SZTRING karakterben mért hosszát is, ez 14, és 4 byte-ot foglal.
A billentyűkódok pedig természetesen 32 bites egész számok (4 byte), és az A betű kódja 65. Nem egy A karakter tárolódik. Gondolj csak bele; hogyan tárolnánk a speciális billentyűk kódjait, amik lenyomásakor nem is kapunk írásjeleket, hanem csak módosítanak vagy egy alkalmazást indítanak el? (pl. Shift, Ctrl, F1, WWW, E-mail, Play, stb.)

A fenti példa tehát összesen 17db Integert ment el, ami 68 byte hosszú fájlt eredményez. Ez a példa tökéletesen elegendő, hogy megírd a programodat. Csak nyisd meg a fájlt pl. Notepaddel, és látni fogod a tartalmát!
Az elmentett 32bites számok rendre:
25 (a 25-ös szám )
65 (az A billentyűkód, ami megegyezik az ASCII kódjával is)
14 (a SZTRING változó byte-okban mért hossza)
69, 122, 32, 101, 103, 121, 32, 115, 122, 116, 114, 105, 110, 103 (az "Ez egy sztring" karaktersorozat)

Arra azonban vigyázz, hogy ha már egyszer létrehozta a progi a fájlt, akkor már nem hozhatjuk újra létre, tehát úgy kell megnyitni írásra, mint már létező fájl! A tartalmát töröljük, és új tartalmat adunk neki. Vagy töröljük magát a fájlt és újra leétrehozzuk.
Olvasásnál hasonló a helyzet; csak akkor tudjuk beolvasni ha már létezik.
Ehhez kell használni a fentebb már leírt File.Exists() parancsot.
(A parancs kiadása előtt importálni kell a System.IO classt a progi elején. Ennek hiányában az utasítás helyes szintaktikája: System.IO.File.Exists(). Ez vonatkozik minden fájlművelettel kapcsolatos utasításra.)

köszönöm az újboli kódot, ebbe már sikerült életet lehelnem, de nem tudom, hogyan lehet a SZTRING stringet 16 változóba beletenni. A két kód kombinálásával születhet meg a 16 változót binárisan lementő, majd visszaolvasó kód.
Nemtudom, hogy ez baj-e vagy direkt, de a keys.A-t 65 nek olvassa vissza.
Köszönöm türelmedet és segítségedet

A sztringek elmentését úgy lehet megoldani, ha karakterek helyett karakterkódokat mentesz el, és a sztringek hosszát.
Pl. 2 byte-on tárolod a változó hosszát (n), majd ezt követik az egyes karakterek 2 byte-os kódjai (n×2byte).
A billentyűkódok hasonlóan tárolhatók. Semmi nehézség nincs benne.
Az is adott, hogy sorjában milyen típusú változókat kell beolvasni, tehát a visszaállítás is egyszerű. De ha nincs előre meghatározva a mentett változók típusa, akkor egy típust jelölő 1 v. 2 byte-os változóval utalhatsz rá, hogy milyen típusú változó következik a beolvasásban.

Aztán ennek fordítottja is elképzelhető:
Az egyes változókat külön sorba mented le, de nem bináris hanem szöveges állományba. A sztringekkel nincs is gond, a numerikus változókat viszont sztringgé kell előtte alakítani, ez sem probléma. A billentyűkódokat úgyszintén...

És jöjjön egy újabb példaprogram:

A progi egy numerikus változót, egy billentyűkódot és egy sztringet ment el binárisan, majd tölt vissza. (A sztring hosszát is elmentjük.)
Minden szám ill. betű 32 biten tárolódik.

köszönöm a példaprogramot, kipróbáltam, de nem működik, mert egy kicsit bonyibb a probléma, ugyanis a 16 változó közül 8 string, ami közül lehet üres(!) is , valamint 8 string, amik billentyűzetkódokat tartalmaznak, pl keys.a és ezért elég nehéz ezeket lementeni.
arra is gondoltam, hogy minden változót külön fájlba ment le, és a mentésnél csak a mappa nevét kell megadni, de ez enm túl jó megoldás, jobb lenne 1 fájlba lementeni.
Úgy nemlehet megoldani, hogy minden változót külön sorba ment le(mert az első 8 változó openfiledialog.filename-eket tartalmaz)
és a betöltésnél minden sort 1 változónak menti le.
Ez lehetséges?
Tudom nagyon sokat kérdezek, de ebből tanulok , és ha ez megvan, akor kész a program, aki kéri átküldöm, és ha Zsora kéri, beleírhatom a nevét, mint segítő és tanácasdó
Köszönöm a segítséget

SIS:
A VB3.0 és a VB2005 között óriási különbség van. Sajnos a régebbi VB verziókhoz nem értek, így nem tudok neked segíteni.

esoma:
A file-műveletekről korábban már volt szó, adtam hozzá linkeket is.
Na jó, itt egy rövid példa:


A Write rutin menti el a 16 egész változót, a Read rutin pedig beolvassa őket. Természetesen a hibakezelő rutinokat a példaprogi nem tartalmazza, amiket persze érdemes megírni. (Nem létező file olvasása, már létező file írása, stb.)
Egy file meglétét a következőképpen ellenőrizhetjük:

Sziasztok,

a kérdésem VB 3.0-ás fejlesztői környezetre vonatkozik, de gondolom 2005-ben is hasonlóképpen kell megoldani, mert nem túl összetett a problémám. Egy BMP állományt szeretnék megnyitni csak nyomtatásra egy vonalkódos programban úgy, hogy az ábra után egyazon sorba egyéb szöveget is szeretnék nyomtatni. Aki le tudná írni pár sorban, azt meghálálnám.

Előre is köszönet a segítségért.

ahhoz, hogy elkészüljön a program, még 1 dolog fontos lenne:
hogyan lehet 16 változót a program bezárásakor lementeni fájlba, vagy akármibe, és a következő indításkor visszatölteni?

tökéletesen érthető
köszönöm.
sokat segítettél

A VB2005-ben minden eseményekről (events), tulajdonságokról (properties) és eljárásokról (procedures) szól.

Tehát:
Ha egy billentyűt lenyomunk, az egy eseményt generál. Ez az esemény elindítja a hozzátartozó eseménykezelőt (Event Handler), ami feldolgozza azt.
A formnak 3 ilyen eseménye van:
KeyDown - egy billentyű lenyomása
KeyUp - egy billentyű felengedése
KeyPress - egy billentyű lenyomása, majd felengedése
Ahhoz hogy a form billentyűzetkezelését saját magunk tartsuk kézben, a KeyPreview tulajdonságot igazra (true) kell állítani.

És most jöjjön egy kis példaprogram:

Az első eseménykezelő (Form1_Load) a form betöltődésekor a KeyPreview tulajdonságot állítja igazra. Ezután már szabadon rendelkezhetünk a billentyűk ellenőrzése felett.
A következő eseménykezelő (Form1_KeyDown) egy billentyű lenyomása esetén ellenőrzi annak kódját, és ha az egyezik a Q billentyű kódjával, akkor bezárja a formot.
Remélem érthető!