LINQ-inspired recursive file search I've been working on a configurable tool that finds files by a certain specification and returns a list. I attempted to approach this in a more LINQ way and tried using appropriate design decisions, all while keeping it reasonably efficient.

Here is my Finder class:

public class Finder
{
    public List&lt;string&gt; Extensions;
    public List&lt;string&gt; TargetDirectories;
    public bool Recursive { get; set; }

    private string _currentPath;
    private List&lt;string&gt; _files = new List&lt;string&gt;();

    public Finder()
    {
        Extensions = new List&lt;string&gt;();
        TargetDirectories = new List&lt;string&gt;();

        _currentPath = Directory.GetCurrentDirectory();
    }

    public string[] GetFiles()
    {
        if (_files.Count != 0)
            return _files.ToArray();
        return new string[0];
    }

    public void Find()
    {
        try
        {
            foreach (var directory in TargetDirectories)
            {
                Search(directory);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    private void Search(string path)
    {
        var pathPoint = new DirectoryInfo($"{_currentPath}{path}");
        var files = Directory.EnumerateFiles(pathPoint.FullName, "*.*")
            .Where(s =&gt; Extensions.Contains(Path.GetExtension(s)))
            .ToList();
        files.ForEach(_files.Add);

        if (Recursive)
        {
            var subDirectories = Directory.GetDirectories(pathPoint.FullName);
            foreach (var subDir in subDirectories)
            {
                Search($"{path}/{new DirectoryInfo(subDir).Name}");
            }
        }
    }
}


And here's the usage:

var finder = new Finder();
finder.Extensions.Add(".cs");
finder.Extensions.Add(".dll");
finder.TargetDirectories.Add("/src");
finder.TargetDirectories.Add("/assembly");
finder.Recursive = true;
finder.Find();

foreach (var file in finder.GetFiles())
{
    Console.WriteLine(file);
}


The Output

It returns all of the files within every folder of /src and /assembly. If I change Recursive to false or omit it, the result will be only the files within the targeted directories. Extensions are also specified to retrieve files only of that type. 

Here's what the output looks like:

/long/path/name/src/helloworld.cs
/long/path/name/src/class.cs
/long/path/name/src/subdirectory/anotherclass.cs
/long/path/name/assembly/library.dll

This is the intended return.

Design

I store the directory information so I can scale that information and use fields like Name and FullName. The files for specifically that searched directory are inserted into a list and allocated to a returnable list. The return list, _files, is publicly immutable.

Efficiency

I'm unsure if there's any notable difference between using the LINQ in my Search method or using a for loop for iteration in terms of performance. I also believe there might be a way I can simply use the EnumerateFiles return array without converting to a list then back to an array when using GetFiles().

Any suggestions on how I can improve my class? I'm trying to better my C# knowledge and program; any feedback would be considerably helpful and will assist me in further implementing features.

EDIT: 
I am adopting suggestions actively. You can see the (amateur) repository here:
https://github.com/TGibsonn/FastCompile
As someone who's been writing cross-platform tools on .Net Core, this doesn't do what I expect it to do. 


finder.TargetDirectories.Add("/src");



I expect that to target a directory named src at the root of the file system. On Linux: /src; on windows C:\src. It would be more clear if the user passed in a relative file path or a complete file path. 

Also, please don't concatenate file paths this way. 


$"{path}/{new DirectoryInfo(subDir).Name}"



This is terribly error prone. It's hard to get right the first time and it's even harder to refactor later. Always use System.IO.Path.Combine().