Newsgroup: it.comp.lang.visual-basic
Titolo: Du cosette...File Binary e CreateProcess

...semplici semplici... per voi :-)))
1)-----------
Sto scrivendo un file binario aperto con Opzioni Write Access... un file che
non esisteva fino ad un secondo fa...da una variabile definita di tipo
String.
L'origine della Var è un'altra Var di tipo Variant.
quindi:
dim stringa as string
dim Buffer as variant
stringa = buffer
Write...
Il file scritto contiene una stringa in formato testo, quindi leggibile. nel
momento in cui apro il file con un normale editor ...o anche leggendolo
successivamente in VB.. non fosse che appaiono in testa al file dei
caratteri che non fanno parte della Stringa.
Ho pensato che fosse una sorta di lunghezza-stringa derivante dal Variant.
Ma perchè VB deve convertire una Stringa in Variant!?
Fatto sta che non riesco a toglierli... :-))
2)----------------
Createprocess... e simili.
Ho usato per lanciare un'applicazione il comando Openprocess.
Salvando il numero del Processo attivato e attendendo con
Waitforsingleobject la fine del processo, riesco a sapere "vita e morte"
dell'applicazione lanciata
Tutto questo su Win98 SE con VB6.
Se passo su WinXp il controllo WaitforsingleObject non funziona. Mi dice che
il processo è terminato nonostante sia attivo.
Ho provato quindi ad usare CreateProcess.
Su Win98 tutto bene. Su WinXp, non riesce a lanciare
l'applicazione...piccola clessidra, mi ritorna un Processo, ma
l'applicazione non parte. con WaitforsingleObject il processo risulta
ovviamente chiuso.
Ho utilizzato nelle varie prova la porzione di codice trovato su un Thread
passato con le necessarie correzioni per Xp (Variabili definite as Any
anzichè as Long), ma nulla è cambiato.
Se avete avuto esperienze in merito accetto consigli. Il Prossimo tentativo
sarà di ritornare ad OpenProcess e verivicare bene la gestione del
WaitforsingleObject visto che così almeno l'applicazione la lancia.
Mi scuso per non aver postato il codice, ma è a casa e sto scrivendo
dall'ufficio. Son disponibile a postare le porzioni se fosse necessario
nelle serate a seguire...
Vi ringrazio per l'interesse e mi scuso per il lungo post!
Saluti, Il Sora!!
P.S. Finitooooo.....chi si fosse assopito può riprendere coscienza!! :-)))

 il processo è terminato nonostante sia attivo.
[SNIP]
Puoi provare con un sistema alternativo basato sulla normale Shell di VB
accoppiata a OpenProcess e GetExitCodeProcess... piu' o meno cosi':
Private Declare Function OpenProcess Lib "kernel32" ( _
 ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, _
 ByVal dwProcessID As Long) As Long
Private Declare Function GetExitCodeProcess Lib "kernel32" ( _
 ByVal hProcess As Long, lpExitCode As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" ( _
 ByVal hObject As Long) As Long
Const STILL_ACTIVE As Long = &H103
Const PROCESS_QUERY_INFORMATION As Long = &H400
Public Function IsProcessRunning(ByVal TaskID As Variant) As Boolean
'Ritorna True se un processo figlio avviato con Shell e' ancora in
esecuzioine
'False se invece e' terminato. Il parametro è l'handle restituito dalla
'funzione Shell
Dim hProc As Long, iRet As Long
'Recuperiamo l'handle di processo
hProc = OpenProcess(PROCESS_QUERY_INFORMATION, False, TaskID)
'Controlliamo lo stato del processo
If hProc Then GetExitCodeProcess hProc, iRet
IsProcessRunning = CBool(iRet = STILL_ACTIVE)
CloseHandle hProc
End Function
da chiamare con con
ShellHandle = Shell("calc.exe", vbNormalFocus)
Do While IsProcessRunning(ShellHandle)
    Debug.Print "Processo in corso, attendere..."
    DoEvents
    Sleep 150
Loop
Debug.Print "processo terminato."
Ciao
-- 
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 Createprocess... e simili.
Passo.
Bye, G.


Rispondo a questa domanda e risolvo la questione :-)))
Dunque, lo spostamento fra le due var lo faccio perchè usando la Var Variant
mi mette questi Byte di lunghezza in testa.
Premetto che la routine ha funzionato per un periodo di tempo...oggi riapro
il progretto scrivo due righe di codice in altre parti e di colpo la Write
non funziona più... mi accorgo ora di aver usato la Put anzichè la Write e
mi scuso dell'errore (la write la uso per altri file...me sò confuso!!)...
cmq rileggendo l'help .."Verranno scritti due Byte che identificano la
lunghezza prima della Var se questa è di tipo variant ...se è di lunghezza
fissa verrà scritta solo la var..."  . Ma io uso una String...!!
Ho fatto questo ...la mia riga di definizione della Var era questa:
Dim stringa, interrotto As String
....eseguendo il codice prima della PUT nella Watch Windows la var Stringa
era di tipo Variant/String
ho fatto la modifica:
Dim stringa As String
Dim interrotto As String
la Var Stringa nella Watch Windows è di tipo String, la Put funziona!!!!!
Sono nell'informatica da 15 anni...da un mese su VB ...non mi stupisco più
di nulla :-)))
Saluti, Il Sora!!
P.S. Per il secondo punto provo ad utilizzare il codice di Luca e vi fò
sapere....grazie a entrambe!!

 la Var Stringa nella Watch Windows è di tipo String, la Put funziona!!!!!
Sicuro?
A me non succede (come mi aspettavo d'altronde).
A me risulta che (ma non ricordo mai se è così o il contrario) la Put (che è
l'unica che funziona, al contrario di Write e Print) mette due char di info
se la variabile è a lunghezza variabile (haha) e non li mette se è a
lunghezza fissa.
es:
Dim buffer() as byte
buffer = "ciao"
Put #1, buffer ' mette i 2 byte per sapere che "ciao" è di 4 char
Dim buffer(0 to 3) as byte
Put #1, buffer ' non mette i 2 byte.
Lo stesso se anzichè Byte() uso String e anzichè Byte(0 to 3) uso String * 4
Verifica.
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net


Saluti, Il Sora!!


Su 98 funziona, non avevo dubbi..proverň su Xp...:-)))
'zzie!!
Saluti, Il Sora!!


Non ti bacio perchè ho la barba :-))))
Funziona anche su XP!!!
Ancora grazie..
Saluti, Il Sora!!
P.S. ora mi studio la funzione ... non pretendo molto , ma almeno cercare di
capire :-)))

 di nulla :-)))
Probabilmente ti ha solo confuso la tua estrazione "non VB"...
poiche' variant e' il tipo predefinito, nella dichiarazioni di variabili
puo' essere omesso; questo vuol dire che se fai piu' dichiarazioni su una
stessa riga
Dim stringa, interrotto As String
il compilatore interpreta la prima come variant, e la seconda come string
la sintassi corretta, oltre a quella "monolinea" naturalmente, e':
Dim stringa As String, interrotto As String



'azz...a questo non ci avevo pensato....!!
pensavo che accomunasse la tipologia a tutte le variabili indicate...non
pensavo le interpretasse come istruzioni distinte!!
Questo spiega il mistero... e incrementa la mia esperienza!! :-)))
Quindi l'unico fattor comune è il DIM che viene applicato a tutta la
riga...vabbè .. ognuno ha la sua logica :-))
Griaze ancora!
Saluti, Il Sora!!