¿Se puede llamar a Directory.GetFiles () con múltiples filtros?

354

Estoy tratando de usar el Directory.GetFiles()método para recuperar una lista de archivos de varios tipos, como mp3'sy jpg' s. He intentado lo siguiente sin suerte:

Directory.GetFiles("C:\\path", "*.mp3|*.jpg", SearchOption.AllDirectories);
Directory.GetFiles("C:\\path", "*.mp3;*.jpg", SearchOption.AllDirectories);

¿Hay alguna manera de hacer esto en una llamada?

Jason Z
fuente
3
Como nota al margen, el uso del patrón de búsqueda GetFiles para filtrar la extensión no es seguro. Por ejemplo, tiene dos archivos Test1.xls y Test2.xlsx y desea filtrar el archivo xls usando el patrón de búsqueda * .xls, pero GetFiles devuelve ambos Test1 .xls y Test2.xlsx. Lea la sección de notas para obtener más información
kiran el
Entonces, ¿cómo prevenir esto?
Brackets el
2
@kiran ¿Cómo es que eso no es seguro? Parece una característica más que un error.
Kyle Delaney

Respuestas:

521

Para .NET 4.0 y posterior,

var files = Directory.EnumerateFiles("C:\\path", "*.*", SearchOption.AllDirectories)
            .Where(s => s.EndsWith(".mp3") || s.EndsWith(".jpg"));

Para versiones anteriores de .NET,

var files = Directory.GetFiles("C:\\path", "*.*", SearchOption.AllDirectories)
            .Where(s => s.EndsWith(".mp3") || s.EndsWith(".jpg"));

editar: por favor lea los comentarios. La mejora que sugiere Paul Farry , y el problema de memoria / rendimiento que Christian.K señala son muy importantes.

Christoffer Lette
fuente
10
Hombre, tengo que pensar en términos de LINQ más a menudo. Buena solución!
Ken Pespisa el
61
Sin embargo, asegúrese de comprender las implicaciones: esto devolverá todos los archivos en una matriz de cadenas y luego los filtrará por las extensiones que especifique. Eso podría no ser un gran problema si "C: \ Path" no tiene muchos archivos debajo, pero puede ser un problema de memoria / rendimiento en "C: \" o algo así.
Christian.K
24
... 2 años después: buen código, pero cuidado con esto, si tienes un archivo que termina con .JPG no lo hará. Mejor agregars.ToLower().Endswith...
Stormenet 05 de
107
podrías usars.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase)
Paul Farry
119
Tenga en cuenta que con .NET 4.0, se puede reemplazar Directory.GetFilescon Directory.EnumerateFiles, msdn.microsoft.com/en-us/library/dd383571.aspx , lo que evitará los problemas de memoria que @ Christian.K menciona.
Jim Mischel
60

Qué tal esto:

private static string[] GetFiles(string sourceFolder, string filters, System.IO.SearchOption searchOption)
{
   return filters.Split('|').SelectMany(filter => System.IO.Directory.GetFiles(sourceFolder, filter, searchOption)).ToArray();
}

Lo encontré aquí (en los comentarios): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Albert
fuente
Supongo que esto evita los posibles problemas de memoria de la respuesta mejor calificada. En cuyo caso, debe ser calificado más alto!
Dan W
11
@DanW La respuesta mejor calificada seguramente supone una carga para la memoria, pero creo que no debería ser un problema. También me gustó esta respuesta, pero en realidad es (mucho) más lenta que la respuesta aceptada. Comprueba este SpeedTest
OttO
Gracias. Me alegra ver que solo es el doble de lento, creo que lo seguiré mientras tanto.
Dan W
77
Es solo el doble de lento si solo hay dos extensiones. Si tiene una lista de extensiones X, será X veces más lenta. Porque aquí está llamando a la función Directory.GetFiles varias veces, mientras que en la otra solución se llama solo una vez.
Oscar Hermosilla
1
@OscarHermosilla Uno puede usar Parallel.ForEachpara ponerlos en paralelo
FindOutIslamNow
33

Si tiene una gran lista de extensiones para verificar, puede usar lo siguiente. No quería crear muchas declaraciones OR, así que modifiqué lo que lette escribió.

string supportedExtensions = "*.jpg,*.gif,*.png,*.bmp,*.jpe,*.jpeg,*.wmf,*.emf,*.xbm,*.ico,*.eps,*.tif,*.tiff,*.g01,*.g02,*.g03,*.g04,*.g05,*.g06,*.g07,*.g08";
foreach (string imageFile in Directory.GetFiles(_tempDirectory, "*.*", SearchOption.AllDirectories).Where(s => supportedExtensions.Contains(Path.GetExtension(s).ToLower())))
{
    //do work here
}
jnoreiga
fuente
Ayúdame con esto, por favor ... Cuando imprimo imageFile, me da una ruta total. ¿Cómo puedo reducirlo solo al nombre del archivo?
Naresh
1
System.IO.Path.GetFileName (imageFile)
jnoreiga
Path.GetExtensiondevuelve '.ext', no '* .ext' (al menos en 3.5+).
Anulable el
2
FYI: necesita System.Linq para .where (
jnoreiga
1
Hay una falla potencial. Ya pasamos los días en que las extensiones deben tener exactamente tres caracteres. Suponga que puede encontrar un archivo con .abc, y que admite Extensions contiene .abcd. Coincidirá, aunque no debería. Para arreglar: supportedExtensions = ".jpg|.abcd|";con .Contains(Path.GetExtension(s).ToLower() + "|"). Es decir, incluya su carácter separador en la prueba. IMPORTANTE: su carácter separador también debe estar después de la ÚLTIMA entrada en las excepciones admitidas.
ToolmakerSteve
31

para

var exts = new[] { "mp3", "jpg" };

Tú podrías:

public IEnumerable<string> FilterFiles(string path, params string[] exts) {
    return
        Directory
        .EnumerateFiles(path, "*.*")
        .Where(file => exts.Any(x => file.EndsWith(x, StringComparison.OrdinalIgnoreCase)));
}

Pero el beneficio real de EnumerateFilesaparece cuando divide los filtros y combina los resultados:

public IEnumerable<string> FilterFiles(string path, params string[] exts) {
    return 
        exts.Select(x => "*." + x) // turn into globs
        .SelectMany(x => 
            Directory.EnumerateFiles(path, x)
            );
}

Se vuelve un poco más rápido si no tiene que convertirlos en globos (es decir, exts = new[] {"*.mp3", "*.jpg"}ya).

Evaluación de rendimiento basada en la siguiente prueba de LinqPad (nota: Perf solo repite el delegado 10000 veces) https://gist.github.com/zaus/7454021

(reenviado y extendido desde 'duplicado' ya que esa pregunta no solicitó específicamente LINQ: múltiples extensiones de archivo searchPattern para System.IO.Directory.GetFiles )

drzaus
fuente
¿Qué quieres decir con "me vuelvo un poco más rápido si no tienes que convertirlos en globos"? ¿Es O (1) o es O (n) (en lo que respecta al número de archivos, no al número de extensiones)? Habría adivinado que es O (1) (u O (n) en lo que respecta al número de extensiones) y probablemente en algún lugar dentro del rango de unos pocos ciclos de CPU ... Si ese es el caso, es probable que
términos de
@BatteryBackupUnit sí, con 10k repeticiones contra 2 extensiones, la diferencia entre glob y str es de 3 ms, por lo que sí es técnicamente insignificante (ver enlace de resultados de rendimiento), pero sin saber cuántas extensiones necesita filtrar, pensé que vale la pena señalar que hay una diferencia; Dejo que usted decida si el "uso simplificado" (es decir .FilterFiles(path, "jpg", "gif")) es mejor que los "globos explícitos" (es decir .FilterFiles(path, "*.jpg", "*.gif")).
drzaus
perfecto gracias. Lo siento, de alguna manera me salté ese enlace de Github. Tal vez debería adaptar la configuración de color de mi pantalla :)
BatteryBackupUnit
¿Esto admite la extensión en mayúscula como .JPG o .MKV?
Wahyu
1
La falla con la solución SelectMany es que iterará sobre todos los archivos una vez por cada extensión de archivo aprobada.
17 de 26
16

Sé que es una pregunta antigua pero LINQ: (.NET40 +)

var files = Directory.GetFiles("path_to_files").Where(file => Regex.IsMatch(file, @"^.+\.(wav|mp3|txt)$"));
Cazador de hielo
fuente
3
Buena idea. Considere usar file.ToLower()para hacer coincidir fácilmente las extensiones de mayúsculas. Y por qué no extraer la extensión primero, para que Regex no tenga que examinar la ruta completa: Regex.IsMatch(Path.GetExtension(file).ToLower(), @"\.(wav|mp3|txt)");
ToolmakerSteve
13

También hay una solución de descenso que parece no tener sobrecarga de memoria o rendimiento y es bastante elegante:

string[] filters = new[]{"*.jpg", "*.png", "*.gif"};
string[] filePaths = filters.SelectMany(f => Directory.GetFiles(basePath, f)).ToArray();
Bas1l
fuente
1
Supongo que podría editarlo para que acepte un número ilimitado desconocido de extensiones con una nueva variable de cadena y una función Split. Pero incluso entonces, ¿cómo es esto mejor que la solución de jnoreiga? ¿Es más rápido? ¿Menos consumo de memoria?
Brackets el
1
Hay una compensación. Este enfoque llama a GetFiles varias veces, uno por filtro. Esas llamadas múltiples pueden ser una "sobrecarga de rendimiento" significativa en algunas situaciones. Tiene la ventaja importante de que cada GetFiles solo devuelve una matriz con las rutas de archivo coincidentes . Esperaría que este sea generalmente un buen resultado de rendimiento, tal vez incluso un rendimiento superior , pero eso necesita ser probado. Si GetFiles es significativamente más rápido que EnumerateFiles, entonces este puede ser el mejor enfoque hasta ahora. También tenga en cuenta que el ".ToArray ()" final puede omitirse cuando IEnumerable se puede usar directamente.
ToolmakerSteve
11

Otra forma de usar Linq, pero sin tener que devolver todo y filtrar eso en la memoria.

var files = Directory.GetFiles("C:\\path", "*.mp3", SearchOption.AllDirectories).Union(Directory.GetFiles("C:\\path", "*.jpg", SearchOption.AllDirectories));

En realidad son 2 llamadas GetFiles(), pero creo que es consistente con el espíritu de la pregunta y las devuelve en una enumerable.

Dave Rael
fuente
¿Por qué usar Linq, entonces? ¿Sería más rápido que usar una Lista y un rango adicional?
ThunderGr
1
No sé qué sería más rápido y no creo que sea una pregunta importante. para casi cualquier lugar donde usaría el código para cualquier solución a este problema, la diferencia en el rendimiento sería insignificante. la pregunta debería ser qué es más legible para facilitar la mantenibilidad del código en el futuro. Creo que esta es una respuesta razonable porque pone en una línea de origen, que creo que es parte de lo que la pregunta desea, las llamadas necesarias y expresa claramente la intención de esa línea. list and addrange es una distracción con múltiples pasos para lograr lo mismo.
Dave Rael el
7

No Intenta lo siguiente:

List<string> _searchPatternList = new List<string>();
    ...
    List<string> fileList = new List<string>();
    foreach ( string ext in _searchPatternList )
    {
        foreach ( string subFile in Directory.GetFiles( folderName, ext  )
        {
            fileList.Add( subFile );
        }
    }

    // Sort alpabetically
    fileList.Sort();

    // Add files to the file browser control    
    foreach ( string fileName in fileList )
    {
        ...;
    }

Tomado de: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Yo no
fuente
7

Dejar

var set = new HashSet<string> { ".mp3", ".jpg" };

Entonces

Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
         .Where(f => set.Contains(
             new FileInfo(f).Extension,
             StringComparer.OrdinalIgnoreCase));

o

from file in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
from ext in set
where String.Equals(ext, new FileInfo(file).Extension, StringComparison.OrdinalIgnoreCase)
select file;
abatishchev
fuente
los getfiles no tienen la sobrecarga publicada.
nawfal
5

No puedo usar el .Wheremétodo porque estoy programando en .NET Framework 2.0 (Linq solo es compatible con .NET Framework 3.5+).

Código de abajo no es sensible a mayúsculas (por lo que .CaBo .cabse enumeran también).

string[] ext = new string[2] { "*.CAB", "*.MSU" };

foreach (string found in ext)
{
    string[] extracted = Directory.GetFiles("C:\\test", found, System.IO.SearchOption.AllDirectories);

    foreach (string file in extracted)
    {
        Console.WriteLine(file);
    }
}
Jay patrocinado
fuente
4

La siguiente función busca en múltiples patrones, separados por comas. También puede especificar una exclusión, por ejemplo: "! Web.config" buscará todos los archivos y excluirá "web.config". Los patrones se pueden mezclar.

private string[] FindFiles(string directory, string filters, SearchOption searchOption)
{
    if (!Directory.Exists(directory)) return new string[] { };

    var include = (from filter in filters.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) where !string.IsNullOrEmpty(filter.Trim()) select filter.Trim());
    var exclude = (from filter in include where filter.Contains(@"!") select filter);

    include = include.Except(exclude);

    if (include.Count() == 0) include = new string[] { "*" };

    var rxfilters = from filter in exclude select string.Format("^{0}$", filter.Replace("!", "").Replace(".", @"\.").Replace("*", ".*").Replace("?", "."));
    Regex regex = new Regex(string.Join("|", rxfilters.ToArray()));

    List<Thread> workers = new List<Thread>();
    List<string> files = new List<string>();

    foreach (string filter in include)
    {
        Thread worker = new Thread(
            new ThreadStart(
                delegate
                {
                    string[] allfiles = Directory.GetFiles(directory, filter, searchOption);
                    if (exclude.Count() > 0)
                    {
                        lock (files)
                            files.AddRange(allfiles.Where(p => !regex.Match(p).Success));
                    }
                    else
                    {
                        lock (files)
                            files.AddRange(allfiles);
                    }
                }
            ));

        workers.Add(worker);

        worker.Start();
    }

    foreach (Thread worker in workers)
    {
        worker.Join();
    }

    return files.ToArray();

}

Uso:

foreach (string file in FindFiles(@"D:\628.2.11", @"!*.config, !*.js", SearchOption.AllDirectories))
            {
                Console.WriteLine(file);
            }
Alexander Popov
fuente
4
List<string> FileList = new List<string>();
DirectoryInfo di = new DirectoryInfo("C:\\DirName");

IEnumerable<FileInfo> fileList = di.GetFiles("*.*");

//Create the query
IEnumerable<FileInfo> fileQuery = from file in fileList
                                  where (file.Extension.ToLower() == ".jpg" || file.Extension.ToLower() == ".png")
                                  orderby file.LastWriteTime
                                  select file;

foreach (System.IO.FileInfo fi in fileQuery)
{
    fi.Attributes = FileAttributes.Normal;
    FileList.Add(fi.FullName);
}
Rajeesh Kuthuparakkal
fuente
file.Extension.ToLower()Es una mala práctica.
abatishchev
entonces que debemos usar? @abatishchev
Nitin Sawant
@Nitin:String.Equals(a, b, StringComparison.OrdinalIgnoreCase)
abatishchev 18/0613
1
En realidad, file.Extension.Equals (". Jpg", StringComparison.OrdinalIgnoreCase) es lo que prefiero. Parece ser más rápido que .ToLower o .ToUpper, o eso dicen en todas partes donde busqué. En realidad, .Equals también es más rápido que ==, ya que == llama .Equals y comprueba null (porque no puede hacer null.Equals (null)).
ThunderGr
4

en .NET 2.0 (sin Linq):

public static List<string> GetFilez(string path, System.IO.SearchOption opt,  params string[] patterns)
{
    List<string> filez = new List<string>();
    foreach (string pattern in patterns)
    {
        filez.AddRange(
            System.IO.Directory.GetFiles(path, pattern, opt)
        );
    }


    // filez.Sort(); // Optional
    return filez; // Optional: .ToArray()
}

Entonces úsalo:

foreach (string fn in GetFilez(path
                             , System.IO.SearchOption.AllDirectories
                             , "*.xml", "*.xml.rels", "*.rels"))
{}
Stefan Steiger
fuente
4
DirectoryInfo directory = new DirectoryInfo(Server.MapPath("~/Contents/"));

//Using Union

FileInfo[] files = directory.GetFiles("*.xlsx")
                            .Union(directory
                            .GetFiles("*.csv"))
                            .ToArray();
Nilesh Padhiyar
fuente
3

Acabo de encontrar otra forma de hacerlo. Todavía no es una operación, sino tirarla para ver qué piensan otras personas al respecto.

private void getFiles(string path)
{
    foreach (string s in Array.FindAll(Directory.GetFiles(path, "*", SearchOption.AllDirectories), predicate_FileMatch))
    {
        Debug.Print(s);
    }
}

private bool predicate_FileMatch(string fileName)
{
    if (fileName.EndsWith(".mp3"))
        return true;
    if (fileName.EndsWith(".jpg"))
        return true;
    return false;
}
Jason Z
fuente
3

Qué pasa

string[] filesPNG = Directory.GetFiles(path, "*.png");
string[] filesJPG = Directory.GetFiles(path, "*.jpg");
string[] filesJPEG = Directory.GetFiles(path, "*.jpeg");

int totalArraySizeAll = filesPNG.Length + filesJPG.Length + filesJPEG.Length;
List<string> filesAll = new List<string>(totalArraySizeAll);
filesAll.AddRange(filesPNG);
filesAll.AddRange(filesJPG);
filesAll.AddRange(filesJPEG);
MattyMerrix
fuente
2

Haga las extensiones que desea una cadena, es decir, ".mp3.jpg.wma.wmf" y luego verifique si cada archivo contiene la extensión que desea. Esto funciona con .net 2.0 ya que no usa LINQ.

string myExtensions=".jpg.mp3";

string[] files=System.IO.Directory.GetFiles("C:\myfolder");

foreach(string file in files)
{
   if(myExtensions.ToLower().contains(System.IO.Path.GetExtension(s).ToLower()))
   {
      //this file has passed, do something with this file

   }
}

La ventaja de este enfoque es que puede agregar o quitar extensiones sin editar el código, es decir, para agregar imágenes png, simplemente escriba myExtensions = ". Jpg.mp3.png".

Evado
fuente
no sabe lo que ess
Brackets
2
/// <summary>
/// Returns the names of files in a specified directories that match the specified patterns using LINQ
/// </summary>
/// <param name="srcDirs">The directories to seach</param>
/// <param name="searchPatterns">the list of search patterns</param>
/// <param name="searchOption"></param>
/// <returns>The list of files that match the specified pattern</returns>
public static string[] GetFilesUsingLINQ(string[] srcDirs,
     string[] searchPatterns,
     SearchOption searchOption = SearchOption.AllDirectories)
{
    var r = from dir in srcDirs
            from searchPattern in searchPatterns
            from f in Directory.GetFiles(dir, searchPattern, searchOption)
            select f;

    return r.ToArray();
}
A.Ramazani
fuente
2

Nop ... creo que tienes que hacer tantas llamadas como los tipos de archivos que quieras.

Yo mismo crearía una función tomando una matriz en cadenas con las extensiones que necesito y luego iteraría en esa matriz haciendo todas las llamadas necesarias. Esa función devolvería una lista genérica de los archivos que coinciden con las extensiones que envié.

Espero eso ayude.

sebagomez
fuente
1

Tuve el mismo problema y no pude encontrar la solución correcta, así que escribí una función llamada GetFiles:

/// <summary>
/// Get all files with a specific extension
/// </summary>
/// <param name="extensionsToCompare">string list of all the extensions</param>
/// <param name="Location">string of the location</param>
/// <returns>array of all the files with the specific extensions</returns>
public string[] GetFiles(List<string> extensionsToCompare, string Location)
{
    List<string> files = new List<string>();
    foreach (string file in Directory.GetFiles(Location))
    {
        if (extensionsToCompare.Contains(file.Substring(file.IndexOf('.')+1).ToLower())) files.Add(file);
    }
    files.Sort();
    return files.ToArray();
}

Esta función llamará Directory.Getfiles()solo una vez.

Por ejemplo, llame a la función de esta manera:

string[] images = GetFiles(new List<string>{"jpg", "png", "gif"}, "imageFolder");

EDITAR: Para obtener un archivo con múltiples extensiones, use este:

/// <summary>
    /// Get the file with a specific name and extension
    /// </summary>
    /// <param name="filename">the name of the file to find</param>
    /// <param name="extensionsToCompare">string list of all the extensions</param>
    /// <param name="Location">string of the location</param>
    /// <returns>file with the requested filename</returns>
    public string GetFile( string filename, List<string> extensionsToCompare, string Location)
    {
        foreach (string file in Directory.GetFiles(Location))
        {
            if (extensionsToCompare.Contains(file.Substring(file.IndexOf('.') + 1).ToLower()) &&& file.Substring(Location.Length + 1, (file.IndexOf('.') - (Location.Length + 1))).ToLower() == filename) 
                return file;
        }
        return "";
    }

Por ejemplo, llame a la función de esta manera:

string image = GetFile("imagename", new List<string>{"jpg", "png", "gif"}, "imageFolder");
Quispie
fuente
1

Me pregunto por qué hay tantas "soluciones" publicadas?

Si mi comprensión de novato sobre cómo funciona GetFiles es correcta, solo hay dos opciones y cualquiera de las soluciones anteriores se puede resumir en estas:

  1. GetFiles, luego filtro: Rápido, pero un asesino de memoria debido al almacenamiento de sobrecarga hasta que se aplican los filtros

  2. Filtre mientras GetFiles: más lento cuanto más filtros estén configurados, pero menor uso de memoria ya que no se almacena ninguna sobrecarga.
    Esto se explica en una de las publicaciones anteriores con un punto de referencia impresionante: cada opción de filtro provoca una operación separada GetFile, por lo que la misma parte del disco duro se lee varias veces.

En mi opinión, la opción 1) es mejor, pero usar SearchOption.AllDirectories en carpetas como C: \ usaría grandes cantidades de memoria.
Por lo tanto, simplemente haría un submétodo recursivo que recorra todas las subcarpetas con la opción 1)

Esto debería causar solo 1 operación GetFiles en cada carpeta y, por lo tanto, ser rápido (Opción 1), pero use solo una pequeña cantidad de memoria ya que los filtros se aplican después de la lectura de cada subcarpeta -> la sobrecarga se elimina después de cada subcarpeta.

Por favor, corríjame si estoy equivocado. Soy, como dije, bastante nuevo en la programación, pero quiero obtener una comprensión más profunda de las cosas para eventualmente ser bueno en esto :)

Janis
fuente
1

Si está utilizando VB.NET (o importó la dependencia en su proyecto C #), en realidad existe un método conveniente que permite filtrar por múltiples extensiones:

Microsoft.VisualBasic.FileIO.FileSystem.GetFiles("C:\\path", Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, new string[] {"*.mp3", "*.jpg"});

En VB.NET se puede acceder a esto a través del espacio Mi nombre:

My.Computer.FileSystem.GetFiles("C:\path", FileIO.SearchOption.SearchAllSubDirectories, {"*.mp3", "*.jpg"})

Desafortunadamente, estos métodos de conveniencia no admiten una variante vagamente evaluada como lo Directory.EnumerateFiles()hace.

Crusha K. Rool
fuente
Esta es fácilmente la mejor respuesta y, sin embargo, algo mucho más hacky es el aceptado. Tengo que amar TAN.
Robbie Coyne
0

No sé qué solución es mejor, pero uso esto:

String[] ext = "*.ext1|*.ext2".Split('|');

            List<String> files = new List<String>();
            foreach (String tmp in ext)
            {
                files.AddRange(Directory.GetFiles(dir, tmp, SearchOption.AllDirectories));
            }
elle0087
fuente
0

Aquí hay una manera simple y elegante de obtener archivos filtrados

var allowedFileExtensions = ".csv,.txt";


var files = Directory.EnumerateFiles(@"C:\MyFolder", "*.*", SearchOption.TopDirectoryOnly)
                .Where(s => allowedFileExtensions.IndexOf(Path.GetExtension(s)) > -1).ToArray(); 
JohnnBlade
fuente
-1

O simplemente puede convertir la cadena de extensiones a Cadena ^

vector <string>  extensions = { "*.mp4", "*.avi", "*.flv" };
for (int i = 0; i < extensions.size(); ++i)
{
     String^ ext = gcnew String(extensions[i].c_str());;
     String^ path = "C:\\Users\\Eric\\Videos";
     array<String^>^files = Directory::GetFiles(path,ext);
     Console::WriteLine(ext);
     cout << " " << (files->Length) << endl;
}
usuario3512661
fuente
2
Esto es c ++ no c #
Paréntesis
-1

¡Usar el patrón de búsqueda GetFiles para filtrar la extensión no es seguro! Por ejemplo, tiene dos archivos Test1.xls y Test2.xlsx y desea filtrar el archivo xls utilizando el patrón de búsqueda * .xls, pero GetFiles devuelve Test1.xls y Test2.xlsx No estaba al tanto de esto y recibí un error en la producción entorno cuando algunos archivos temporales de repente se manejaron como archivos correctos. El patrón de búsqueda fue * .txt y los archivos temporales se llamaron * .txt20181028_100753898 Por lo tanto, no se puede confiar en el patrón de búsqueda, también debe agregar una verificación adicional en los nombres de archivo.

WillyS
fuente
No responde la pregunta.
Robbie Coyne