De leesbuffer en de eigenschap bytesAvailable van een FileStream-object

Adobe AIR 1.0 of hoger

Wanneer een FileStream-object met leesmogelijkheden (een object waarbij de parameter fileMode van de methode open() of openAsync() is ingesteld op READ of UPDATE ) wordt geopend, slaat de runtime de gegevens op in een interne buffer. Het FileStream-object begint gegevens in de buffer in te lezen zodra u het bestand opent (door de methode open() of openAsync() van het FileStream-object op te roepen).

Voor een bestand dat is geopend voor synchrone bewerkingen (met behulp van de methode open() ), kunt u de aanwijzer position altijd instellen op een willekeurige geldige positie (binnen de grenzen van het bestand) en beginnen met het inlezen van een willekeurige hoeveelheid gegevens (binnen de grenzen van het bestand), zoals aangegeven in de volgende code (waarbij ervan wordt uitgegaan dat het bestand minimaal 100 bytes omvat):

var myFile:File = File.documentsDirectory.resolvePath("AIR Test/test.txt"); 
var myFileStream:FileStream = new FileStream(); 
myFileStream.open(myFile, FileMode.READ); 
myFileStream.position = 10; 
myFileStream.readBytes(myByteArray, 0, 20); 
myFileStream.position = 89; 
myFileStream.readBytes(myByteArray, 0, 10);

Of een bestand nu wordt geopend voor synchrone dan wel asynchrone bewerkingen, de leesmethode leest altijd uit de "beschikbare" bytes (vertegenwoordigd door de eigenschap bytesAvalable ). Als synchroon wordt gelezen, zijn alle bytes van het bestand op elk willekeurig moment beschikbaar. Als asynchroon wordt gelezen, worden de bytes beschikbaar gesteld vanaf de positie die wordt aangegeven door de eigenschap position terwijl de buffer op asynchrone wijze steeds verder wordt gevuld (gesignaleerd door progress -gebeurtenissen).

Voor bestanden die zijn geopend voor synchrone bewerkingen wordt de eigenschap bytesAvailable altijd zo ingesteld dat deze het aantal bytes vanaf de eigenschap position tot het einde van het bestand vertegenwoordigt (alle bytes in het bestand zijn altijd beschikbaar voor lezen).

Voor bestanden die zijn geopend voor asynchrone bewerkingen moet u ervoor zorgen dat de leesbuffer voldoende gegevens heeft verbruikt voordat een leesmethode wordt opgeroepen. Voor een bestand dat asynchroon is geopend, geldt dat naarmate de leesbewerking vordert, de gegevens uit het bestand aan de buffer worden toegevoegd, beginnende bij de waarde van position die werd opgegeven toen de leesbewerking werd gestart. De waarde van de eigenschap bytesAvailable wordt verhoogd met iedere byte die wordt gelezen. De eigenschap bytesAvailable geeft het aantal bytes aan dat beschikbaar is, vanaf de byte die zich bevindt op de positie die wordt aangegeven door de eigenschap position tot het einde van de buffer. Het FileStream-object verzendt regelmatig de gebeurtenis progress .

Voor een bestand dat asynchroon is geopend, verzendt het FileStream-object periodiek de gebeurtenis progress naarmate gegevens beschikbaar worden in de leesbuffer. De volgende code leest bijvoorbeeld gegevens in een ByteArray-object ( bytes ) terwijl dit in de buffer wordt ingelezen:

var bytes:ByteArray = new ByteArray(); 
var myFile:File = File.documentsDirectory.resolvePath("AIR Test/test.txt"); 
var myFileStream:FileStream = new FileStream(); 
myFileStream.addEventListener(ProgressEvent.PROGRESS, progressHandler); 
myFileStream.openAsync(myFile, FileMode.READ); 
 
function progressHandler(event:ProgressEvent):void  
{ 
    myFileStream.readBytes(bytes, myFileStream.position, myFileStream.bytesAvailable); 
}

Voor een bestand dat asynchroon is geopend, kunnen alleen de gegevens in de leesbuffer worden gelezen. Terwijl u de gegevens leest, worden ze verwijderd uit de leesbuffer. Voor leesbewerkingen moet u ervoor zorgen dat de gegevens aanwezig zijn in de leesbuffer voordat u de leesbewerking oproept. De volgende code leest bijvoorbeeld 8000 bytes aan gegevens vanaf positie 4000 in het bestand:

var myFile:File = File.documentsDirectory.resolvePath("AIR Test/test.txt"); 
var myFileStream:FileStream = new FileStream(); 
myFileStream.addEventListener(ProgressEvent.PROGRESS, progressHandler); 
myFileStream.addEventListener(Event.COMPLETE, completed); 
myFileStream.openAsync(myFile, FileMode.READ); 
myFileStream.position = 4000; 
 
var str:String = ""; 
 
function progressHandler(event:Event):void  
{ 
    if (myFileStream.bytesAvailable > 8000 ) 
    { 
        str += myFileStream.readMultiByte(8000, "iso-8859-1"); 
    } 
}

Tijdens een schrijfbewerking leest het FileStream-object geen gegevens in de leesbuffer. Wanneer een schrijfbewerking wordt voltooid (alle gegevens in de schrijfbuffer zijn naar het bestand geschreven), start het FileStream-object een nieuwe leesbuffer (ervan uitgaande dat het gekoppelde FileStream-object is geopend met leescapaciteiten) en begint het gegevens in de leesbuffer in te lezen, beginnende bij de positie die wordt aangegeven door de eigenschap position . De eigenschap position kan de positie aangeven van de byte die het laatst is geschreven, of een andere positie als de gebruiker een andere waarde voor het position -object na de schrijfbewerking heeft opgegeven.