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<string> Extensions;
    public List<string> TargetDirectories;
    public bool Recursive { get; set; }

    private string _currentPath;
    private List<string> _files = new List<string>();

    public Finder()
    {
        Extensions = new List<string>();
        TargetDirectories = new List<string>();

        _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 => 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>