UWP Vérifier Si le Fichier Existe

Je suis actuellement en train de travailler sur un ordinateur Windows 10 UWP App.
L'Application doit Vérifier si un Fichier PDF est appelée "01-introduction", et si donc l'ouvrir.
J'ai déjà le code pour si le fichier n'existe pas.
Le Code ci-Dessous est ce que j'ai actuellement:

        try
        {
            var test = await DownloadsFolder.CreateFileAsync("01-Introduction.pdf", CreationCollisionOption.FailIfExists); 
        }
        catch
        {

        }

Ce code Ne fonctionne pas correctement parce que pour vérifier si le fichier existe ici, je tente de créer le fichier. Toutefois, si le fichier n'existe pas déjà un fichier vide est créé. Je ne veux pas faire n'importe quoi, si le fichier n'existe pas, il suffit d'ouvrir le fichier PDF s'il n'.

Si possible, je tiens à regarder à l'intérieur d'un dossier qui est dans le dossier téléchargements appelé "Mes Manuels".

Toute aide serait grandement appréciée.

Est la Swift "Manuels" dossier créé par votre application? Par défaut, votre application ne peut accéder aux fichiers et dossiers de l'utilisateur dans le dossier Téléchargements de votre application créée. Toutefois, vous pouvez accéder à des fichiers et des dossiers de l'utilisateur dans le dossier Téléchargements par l'appel d'un sélecteur de fichiers (FileOpenPicker ou FolderPicker), de sorte que les utilisateurs peuvent naviguer et de sélectionner les fichiers ou dossiers de votre application à accéder.
Merci pour la clarification Jay. C'est le problème que nous avons été à venir à travers. Ainsi, nous pouvons avoir accès à l'annuaire pour les Téléchargements. Nous avons besoin de regarder une autre approche et d'en faire un peu plus de lecture.
Si vous créez un fichier ou un dossier dans le dossier Téléchargements, nous vous recommandons d'ajouter cet élément à votre application FutureAccessList de sorte que votre application peut facilement accéder à cet élément dans l'avenir. Pour plus d'informations, veuillez consulter autorisations d'accès au Fichier.

OriginalL'auteur James Tordoff | 2016-05-09

c#pdf win-universal-app windows-10-mobile windows-10-universal

11
```
public async Task<bool> isFilePresent(string fileName)
{
    var item = await ApplicationData.Current.LocalFolder.TryGetItemAsync(fileName);
    return item != null;
}
```
Mais pas de support Win8/WP8.1

https://blogs.msdn.microsoft.com/shashankyerramilli/2014/02/17/check-if-a-file-exists-in-windows-phone-8-and-winrt-without-exception/

Ce n'est pas dans le dossier Téléchargements.
Écrivez-vous le Package.appxmanifest.
Il va lever une exception lorsque l'élément n'est pas trouvé.
Il ne jette pas une exception.
En effet, il ne jetez pas Exception, bien que les Docs disent qu'ils ne

OriginalL'auteur lindexi
6

Il existe deux méthodes

1) Vous pouvez utiliser StorageFolder.GetFileAsync() comme cela est également pris en charge par Windows 8.1 et WP 8.1 dispositifs.
```
try
{
   StorageFile file = await DownloadsFolder.GetFileAsync("01-Introduction.pdf");
}
catch
{
    Debug.WriteLine("File does not exits");
}
```
2) Ou vous pouvez utiliser FileInfo.Exists uniquement pris en charge pour windows 10 UWP.
```
FileInfo fInfo = new FileInfo("01-Introduction.pdf");
if (!fInfo.Exists)
{
    Debug.WriteLine("File does not exits");
}
```
Malheureusement (1) ne semble pas disponible dans Windows 10 UWP il n'y a pas de Définition de l'ofr GetFileAsync pour DownloadsFolder. (2) semble être juste que je suis à la recherche d', malheureusement, je retourne toujours False, comment puis-je spécifier le dossier à la recherche du FileInfo. Je suis seulement à l'appui de Win10 et pas compatible à tous.
Êtes-vous sûr DownloadFolder est un StorageFolder type, si il devrait donc avoir une définition. Essayez de copier l'intégralité de votre code, je vais vérifier
DownloadFolder ne GetFileAsync () la méthode
Si vous allez utiliser System.IO à tous, vous pouvez tout aussi bien utiliser des System.IO.File.Exists(String). Il est plus efficace - pas besoin de construire un objet - et le plus simple à lire.
N'a pas fonctionné pour mon UWP application en C# sur Windows 10.

OriginalL'auteur AbsoluteSith
2

Système.IO.Fichier.Existe est UWP trop. Je test maintenant dans Windows IDO. il fonctionne, tout simplement.

OriginalL'auteur Kursat Turkay

Cela m'a aidé dans mon cas:

ApplicationData.Current.LocalFolder.GetFileAsync(path).AsTask().ContinueWith(item => { 
    if (item.IsFaulted)
        return; //file not found
    else { /* process file here */ }
});

OriginalL'auteur Андрей Саяпин

public override bool Exists(string filePath)
    {
        try
        {
            string path = Path.GetDirectoryName(filePath);
            var fileName = Path.GetFileName(filePath);
            StorageFolder accessFolder = StorageFolder.GetFolderFromPathAsync(path).AsTask().GetAwaiter().GetResult();
            StorageFile file = accessFolder.GetFileAsync(fileName).AsTask().GetAwaiter().GetResult();
            return true;
        }
        catch
        {
            return false;
        }
    }

OriginalL'auteur Ali Yousefie

0

Vous pouvez utiliser le Système.IO.Fichier.
Exemple:
```
//If file located in local folder. You can do the same for other locations.
string rootPath = ApplicationData.Current.LocalFolder.Path;
string filePath = Path.Combine(rootPath, "fileName.pdf");

if (System.IO.File.Exists(filePath))
{
    //File exists
}
else
{
    //File doesn't exist
}
```
Bien que pas "l'UWP" (en particulier, il effectue une opération d'e/S - même si elle est très rapide - synchrone), c'est une option viable sur UWP (Win10) des applications. Juste être conscient que l'application ne sera pas n'importe quel type de verrou sur le fichier; si un autre thread ou processus supprime ou que l'on crée le fichier entre les vérifier et de les utiliser, vous pourriez obtenir de l'inattendu (et potentiellement dangereux) le comportement.

OriginalL'auteur Sapan Ghafuri
0

Je suis en train de faire un Win10 l'Ido Core UWP app et j'ai vérifier le fichier de longueur au lieu de "il Existe" parce que CreateFileAsync() déjà crée un fichier vide talon immédiatement. Mais j'ai besoin d'appeler avant pour déterminer le chemin d'accès complet du fichier est situé à.

C'est donc:
```
    var destinationFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("MyFile.wow", ...);

    if (new FileInfo(destinationFile.Path).Length > 0)
        return destinationFile.Path;
```
OriginalL'auteur Waescher
0

De cette façon System.IO.File.Exists(filePath) je ne peux pas tester DocumentLibrary
parce que KnownFolders.DocumentsLibrary.Path renvoie la chaîne vide

Solution suivante est très lent await DownloadsFolder.GetFileAsync("01-Introduction.pdf")

À mon humble avis, la meilleure façon est de collecter tous les fichiers du dossier et de vérifier le nom de fichier existe.
```
List<StorageFile> storageFileList = new List<StorageFile>();

storageFileList.AddRange(await KnownFolders.DocumentsLibrary.GetFilesAsync(CommonFileQuery.OrderByName));

bool fileExist = storageFileList.Any(x => x.DisplayName == "01-Introduction.pdf");
```
OriginalL'auteur Jarek

Cela a fonctionné pour moi en cours d'exécution de mon UWP application en C# sur Windows 10...

    StorageFolder app_StorageFolder = await StorageFolder.GetFolderFromPathAsync( @App.STORAGE_FOLDER_PATH );
    var item = await app_StorageFolder.TryGetItemAsync(relative_file_pathname);
    return item != null;

OriginalL'auteur Doug Null

-1

Vous pouvez utiliser la classe FileInfo dans ce cas. Il a une méthode appelée FileInfo.Exists() qui renvoie un booléen résultat

https://msdn.microsoft.com/en-us/library/system.io.fileinfo.exists(v=vs. 110).aspx

EDIT:

Si vous souhaitez vérifier les fichiers existence, vous aurez besoin de créer un StorageFile objet et l'appel de l'un des GetFile.... des méthodes. Tels que:
```
StorageFile file = new StorageFile();
file.GetFileFromPathAsync("Insert path")

if(file == null)
{
   ///File doesn't exist
}
```
J'ai eu un coup d'oeil rapide à trouver le téléchargement chemin d'accès au dossier, mais pas de joie, mais la méthode GetFile devrait vous donner la réponse à votre recherche de

Merci Ben, vous et Absolu ont frappé dans la bonne direction, mais malheureusement, je suis actuellement seul le retour Faux, j'ai commenté ci-dessus Absolue, comment puis-je confirmer le Répertoire/Dossier est en cours de recherche pour le FileInfo ?
Je pense que vous pouvez avoir besoin d'utiliser la getfile fonctions, afin de voir si elles retournent un objet ou une valeur null. De réponses mis à jour

OriginalL'auteur Ben Steele
-1

Sur windows 10, pour moi, c'est la plus "élégante" façon:
```
private static bool IsFileExistent(StorageFile file)
{
    return File.Exists(Path.Combine(file.Path));
}
```
Ou, comme une extension si vous préférez et l'utiliser à grande échelle:
```
static class Extensions
{
    public static bool Exists(this StorageFile file)
    {
        return File.Exists(Path.Combine(file.Path));
    }
}
```
Cette échoue sur les fichiers lorsque les chemins d'accès sont trop longs: stackoverflow.com/questions/11210408/...
sur le Fil que vous voyez sur un commentaire de cette méthode est censée renvoyer false lorsque des erreurs se produit lorsque vous essayez d'atteindre fichier. Donc, si le système traite "chemin long" comme une erreur, cette méthode est encore à droite. La solution présentée sur l'autre fil est inefficace, comme l'auteur le confirme, j'ai essayé ici de présenter les plus "élégant" de la solution. Et il fonctionne sur à 99,9% du temps, donc je ne pense pas utile d'intégrer cette solution à cette proposition.

OriginalL'auteur Wagner Bertolini Junior

Vous devez vous connecter pour publier un commentaire.