IsolatedStorageFileStream.IsAsync Propriété

Définition

Espace de noms:

System.IO.IsolatedStorage

Assembly:

System.IO.IsolatedStorage.dll

Source:

IsolatedStorageFileStream.cs

Obtient une valeur booléenne indiquant si l’objet IsolatedStorageFileStream a été ouvert de façon asynchrone ou synchrone.

public:
 virtual property bool IsAsync { bool get(); };

public override bool IsAsync { get; }

member this.IsAsync : bool

Public Overrides ReadOnly Property IsAsync As Boolean

Valeur de propriété

Boolean

true si l'objet IsolatedStorageFileStream prend en charge l'accès asynchrone ; sinon, false.

Exemples

L’exemple de code suivant montre comment utiliser la IsAsync propriété pour vérifier qu’un IsolatedStorageFileStream est synchrone. Pour obtenir le contexte complet de cet exemple, consultez la vue d’ensemble IsolatedStorageFileStream .

double SetNewPrefsForUser()
{
   try
   {
      Byte inputChar;
      IsolatedStorageFile^ isoFile = IsolatedStorageFile::GetStore( static_cast<IsolatedStorageScope>(IsolatedStorageScope::User | IsolatedStorageScope::Assembly | IsolatedStorageScope::Domain), System::Security::Policy::Url::typeid, System::Security::Policy::Url::typeid );
      
      // If this is not a new user, archive the old preferences and 
      // overwrite them using the new preferences.
      if (  !this->NewPrefs )
      {
         if ( isoFile->GetDirectoryNames( "Archive" )->Length == 0 )
                     isoFile->CreateDirectory( "Archive" );
         else
         {
            
            // This is the stream to which data will be written.
            IsolatedStorageFileStream^ source = gcnew IsolatedStorageFileStream( this->userName,FileMode::OpenOrCreate,isoFile );
            
            // This is the stream from which data will be read.
            Console::WriteLine( "Is the source file readable?  {0}", (source->CanRead ? (String^)"true" : "false") );
            Console::WriteLine( "Creating new IsolatedStorageFileStream for Archive." );
            
            // Open or create a writable file.
            IsolatedStorageFileStream^ target = gcnew IsolatedStorageFileStream( String::Concat("Archive\\",this->userName),FileMode::OpenOrCreate,FileAccess::Write,FileShare::Write,isoFile );
            
            Console::WriteLine( "Is the target file writable? {0}", (target->CanWrite ? (String^)"true" : "false") );
            
            // Stream the old file to a new file in the Archive directory.
            if ( source->IsAsync && target->IsAsync )
            {
               
               // IsolatedStorageFileStreams cannot be asynchronous.  However, you
               // can use the asynchronous BeginRead and BeginWrite functions
               // with some possible performance penalty.
               Console::WriteLine( "IsolatedStorageFileStreams cannot be asynchronous." );
            }
            else
            {
               
               Console::WriteLine( "Writing data to the new file." );
               while ( source->Position < source->Length )
               {
                  inputChar = (Byte)source->ReadByte();
                  target->WriteByte( (Byte)source->ReadByte() );
               }
               
               // Determine the size of the IsolatedStorageFileStream
               // by checking its Length property.
               Console::WriteLine( "Total Bytes Read: {0}", source->Length.ToString() );
               
            }
            
            // After you have read and written to the streams, close them.
            target->Close();
            source->Close();
         }
      }
      
      // Open or create a writable file, no larger than 10k
      IsolatedStorageFileStream^ isoStream = gcnew IsolatedStorageFileStream( this->userName,FileMode::OpenOrCreate,FileAccess::Write,FileShare::Write,10240,isoFile );
      
      isoStream->Position = 0; // Position to overwrite the old data.

public double SetNewPrefsForUser()
{
    try
    {
        byte inputChar;
        IsolatedStorageFile isoFile = IsolatedStorageFile.GetStore(IsolatedStorageScope.User |
            IsolatedStorageScope.Assembly |
            IsolatedStorageScope.Domain,
            typeof(System.Security.Policy.Url),
            typeof(System.Security.Policy.Url));

        // If this is not a new user, archive the old preferences and
        // overwrite them using the new preferences.
        if (!this.myNewPrefs)
        {
            if (isoFile.GetDirectoryNames("Archive").Length == 0)
            {
                isoFile.CreateDirectory("Archive");
            }
            else
            {

                IsolatedStorageFileStream source =
                    new IsolatedStorageFileStream(this.userName, FileMode.OpenOrCreate,
                    isoFile);
                // This is the stream from which data will be read.
                Console.WriteLine("Is the source file readable? " + (source.CanRead ? "true" : "false"));
                Console.WriteLine("Creating new IsolatedStorageFileStream for Archive.");

                // Open or create a writable file.
                IsolatedStorageFileStream target =
                    new IsolatedStorageFileStream("Archive\\ " + this.userName,
                    FileMode.OpenOrCreate,
                    FileAccess.Write,
                    FileShare.Write,
                    isoFile);
                Console.WriteLine("Is the target file writable? " + (target.CanWrite ? "true" : "false"));
                // Stream the old file to a new file in the Archive directory.
                if (source.IsAsync && target.IsAsync)
                {
                    // IsolatedStorageFileStreams cannot be asynchronous.  However, you
                    // can use the asynchronous BeginRead and BeginWrite functions
                    // with some possible performance penalty.

                    Console.WriteLine("IsolatedStorageFileStreams cannot be asynchronous.");
                }

                else
                {
                    Console.WriteLine("Writing data to the new file.");
                    while (source.Position < source.Length)
                    {
                        inputChar = (byte)source.ReadByte();
                        target.WriteByte(inputChar);
                    }

                    // Determine the size of the IsolatedStorageFileStream
                    // by checking its Length property.
                    Console.WriteLine("Total Bytes Read: " + source.Length);
                }

                // After you have read and written to the streams, close them.
                target.Close();
                source.Close();
            }
        }

        // Open or create a writable file with a maximum size of 10K.
        IsolatedStorageFileStream isoStream =
            new IsolatedStorageFileStream(this.userName,
            FileMode.OpenOrCreate,
            FileAccess.Write,
            FileShare.Write,
            10240,
            isoFile);
        isoStream.Position = 0;  // Position to overwrite the old data.

Public Function SetNewPrefsForUser() As Double
    Try
        Dim inputChar As Byte
        Dim isoFile As IsolatedStorageFile = IsolatedStorageFile.GetStore(IsolatedStorageScope.User Or _
            IsolatedStorageScope.Assembly Or IsolatedStorageScope.Domain, _
            GetType(System.Security.Policy.Url), GetType(System.Security.Policy.Url))

        ' If this is not a new user, archive the old preferences and 
        ' overwrite them using the new preferences.
        If Not Me.myNewPrefs Then
            If isoFile.GetDirectoryNames("Archive").Length = 0 Then
                isoFile.CreateDirectory("Archive")
            Else

                Dim source As New IsolatedStorageFileStream(Me.userName, FileMode.OpenOrCreate, isoFile)
                Dim canWrite, canRead As Boolean
                ' This is the stream from which data will be read.
                If source.CanRead Then canRead = True Else canRead = False
                Console.WriteLine("Is the source file readable? " & canRead)
                Console.WriteLine("Creating new IsolatedStorageFileStream for Archive.")
                ' Open or create a writable file.
                Dim target As New IsolatedStorageFileStream("Archive\ " & Me.userName, _
                     FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write, isoFile)
                ' This is the stream to which data will be written.
                If target.CanWrite Then canWrite = True Else canWrite = False
                Console.WriteLine("Is the target file writable? " & canWrite)
                target.SetLength(0)  'rewind the target file

                ' Stream the old file to a new file in the Archive directory.
                If source.IsAsync And target.IsAsync Then
                    ' IsolatedStorageFileStreams cannot be asynchronous.  However, you
                    ' can use the asynchronous BeginRead and BeginWrite functions
                    ' with some possible performance penalty.
                    Console.WriteLine("IsolatedStorageFileStreams cannot be asynchronous.")
                Else
                    Console.WriteLine("Writing data to the new file.")
                    While source.Position < source.Length
                        inputChar = CByte(source.ReadByte())
                        target.WriteByte(inputChar)
                    End While

                    ' Determine the size of the IsolatedStorageFileStream
                    ' by checking its Length property.
                    Console.WriteLine(("Total Bytes Read: " & source.Length))
                End If

                ' After you have read and written to the streams, close them.	
                target.Close()
                source.Close()
            End If
        End If
        ' Open or create a writable file with a maximum size of 10K.
        Dim isoStream As New IsolatedStorageFileStream(Me.userName, FileMode.OpenOrCreate, _
            FileAccess.Write, FileShare.Write, 10240, isoFile)
        isoStream.SetLength(0) 'Position to overwrite the old data.

Remarques

Impossible de créer des objets asynchrones IsolatedStorageFileStream , contrairement à FileStream. Toutefois, les BeginWriteméthodes , BeginRead, EndWriteet EndRead sont prises en charge sur les instances synchrones, avec certaines pénalités de performances.

Voir aussi

• FileStream