Newsgroup: it.comp.lang.visual-basic
Titolo: BinaryReader (.net)

scusate la domanda idiota, ma esplorare il visualizzatore classi 
non mi ha ancora ispirato ...
come fare ad associare gli oggetti BinaryReader e BinaryWriter 
(
system.io
, se non ricordo male) ad una particolare istanza di 
file ?
Ho provato a vedere oggetti di classe Stream o FileStream, ma 
nessuno di questi ha dentro un collegamento a BinaryReader (e il 
secondo non ha puntatori a stream o filestream).
Non ci sto capendo più niente, da che file leggono questi 
strumenti ?
grazie in anticipo
ciao
Soviet_Mario

 file ?
Credo che devi usare un FileStream. Una cosa tipo:
Dim fs As New System.IO.FileStream("C:\temp\prova.bin", IO.FileMode.Create)
Dim bw As New System.IO.BinaryWriter(fs)
bw.Write("ciao a tutti")
fs.Close()
bw.Close()
Aspetta altri consigli però ;-)
-- 
news://it-alt.comp.software.openoffice : Il newsgroup dedicato a
OpenOffice.org, la suite open source di applicazioni per ufficio.
Saluti, VITRIOL

 in ordine inverso alla creazione
Effettivamente sembrerebbe logico fare come dici tu, e pare così anche 
negli esempi che ho trovato. Comunque non so se sia importante o meno.
Nella guida in linea ho anche trovato un costrutto di questo tipo:
Imports System.IO
Dim bw As New BinaryWriter(File.Open("C:\temp\prova.bin", FileMode.Create))
bw.Write("Ciao ciao")
bw.Close()
E basta. Forse così non ci sono ambiguità.


 E basta. Forse così non ci sono ambiguità.
Beh, così la Dispose dello stream creato da File.Open viene demandata al GC, 
che ancora non ho capito se richiama o no la Dispose degli oggetti non 
disposti.
Ciao 

 disposti.
Perň il metodo File.Open č un metodo statico, infatti analizzando 
l'assembly con ildasm non vedo una istanziazione esplicita di un oggetto 
FileStream, ma la vedo solo per BinaryWriter.
Questo non cambia le cose?


 esplicita di un oggetto FileStream, ma la vedo solo per BinaryWriter.
Io analizzandolo con Reflector vedo un bel new FileStream.
Probabilmente con IlDasm non lo vedi perchè fa un'altra chiamata nidificata 
a un'overload di File.Open().
Ciao 

 Io analizzandolo con Reflector vedo un bel new FileStream.
Io con Reflector vedo questo (in IL):
.method private instance void Button1_Click(object sender, 
[mscorlib]System.EventArgs e) cil managed
{
       .maxstack 2
       .locals init (
             [0] [mscorlib]System.IO.BinaryWriter writer1)
       L_0000: nop
       L_0001: ldstr "C:\\temp\\prova.bin"
       L_0006: ldc.i4.2
       L_0007: call [mscorlib]System.IO.FileStream 
[mscorlib]System.IO.File::Open(string, [mscorlib]System.IO.FileMode)
       L_000c: call [mscorlib]System.Text.Encoding 
[mscorlib]System.Text.Encoding::get_ASCII()
       L_0011: newobj instance void 
[mscorlib]System.IO.BinaryWriter::.ctor([mscorlib]System.IO.Stream, 
[mscorlib]System.Text.Encoding)
       L_0016: stloc.0
       L_0017: ldloc.0
       L_0018: ldstr "Ciao ciao"
       L_001d: callvirt instance void 
[mscorlib]System.IO.BinaryWriter::Write(string)
       L_0022: nop
       L_0023: ldloc.0
       L_0024: callvirt instance void 
[mscorlib]System.IO.BinaryWriter::Close()
       L_0029: nop
       L_002a: nop
       L_002b: ret
}
Quindi un solo "newobj" per BinaryWriter; per FileStream c'è un "call". 
Invece usando il primo metodo che avevo proposto vedo:
.method private instance void Button1_Click(object sender, 
[mscorlib]System.EventArgs e) cil managed
{
       .maxstack 2
       .locals init (
             [0] [mscorlib]System.IO.BinaryWriter writer1,
             [1] [mscorlib]System.IO.FileStream stream1)
       L_0000: nop
       L_0001: ldstr "C:\\temp\\prova.bin"
       L_0006: ldc.i4.2
       L_0007: newobj instance void 
[mscorlib]System.IO.FileStream::.ctor(string, [mscorlib]System.IO.FileMode)
       L_000c: stloc.1
       L_000d: ldloc.1
       L_000e: newobj instance void 
[mscorlib]System.IO.BinaryWriter::.ctor([mscorlib]System.IO.Stream)
       L_0013: stloc.0
       L_0014: ldloc.0
       L_0015: ldstr "Ciao ciao"
       L_001a: callvirt instance void 
[mscorlib]System.IO.BinaryWriter::Write(string)
       L_001f: nop
       L_0020: ldloc.0
       L_0021: callvirt instance void 
[mscorlib]System.IO.BinaryWriter::Close()
       L_0026: nop
       L_0027: ldloc.1
       L_0028: callvirt instance void [mscorlib]System.IO.Stream::Close()
       L_002d: nop
       L_002e: nop
       L_002f: ret
}
Quindi due "newobj"; uno per BinaryWriter e uno per FileStream.
Poi quello che vuole dire non lo so :-)
Ma io posso chiamare un Close su un oggetto che non ho esplicitamente 
istanziato?


 Io con Reflector vedo questo (in IL):
Ma perchč non te lo guardi in VB.net o in c#?
E' decisamente piů chiaro che in IL.
Ciao 

 E' decisamente piů chiaro che in IL.
Perché se lo guardo in VB vedo praticamente alla lettera il codice che 
ho scritto io, e entro i 10 minuti quello che ho scritto me lo ricordo :-)
Se invece lo guardo in IL vedo il codice cosě come l'ha prodotto il 
compilatore, senza interpretazioni da parte di funzioni di 
decompilazione di Reflector. Sbaglio?


 di Reflector. Sbaglio?
No, intendo dire: perchè non ti guardi l'implementazione di File.Open n 
VB.net, così noti subito che fa una new FileStream, invece di impazzire con 
l'IL?
Ovvio che non guardi il tuo codice, ma quello del framework che non conosci 
;)
Ciao 

 l'IL?
OK, questo lo immagino, ma poi ci penserà il Framework a chiudere 
l'istanza che ha creato, no? Almeno spero, anche se non ho le idee molto 
chiare ;-)
Se devo stare a guardare come il Framework implementa tutti i metodi che 
uso, è un disastro.
Ma poi è possibile invocare il Dispose di un oggetto che non si è 
istanziato esplicitamente da codice? Se sì, come?


 istanziato esplicitamente da codice? Se sì, come?
in c# sì con
using (TextWriter w = File.CreateText("log.txt"))
{
    w.WriteLine("This is line one");
}Quando si esce dal blocco viene chiamata la Dispose automaticamente.In 
vb2005 dovrebbe esserci qualcosa di simile.Ciao 

 vb2005 dovrebbe esserci qualcosa di simile.Ciao 
OK, grazie. Vedrň di informarmi in proposito.
Per ora confido nelle decisioni del GC ;-)
