Implementing method in a functional style

Question

I have the following method:

private List<string> CreateSegments(string virtualPath)
{
    List<string> segments = new List<string>();
    int i = virtualPath.IndexOf('/', 1);
    while (i >= 0 && i < virtualPath.Length)
    {
        var segment = virtualPath.Substring(0, i);
        if (!string.IsNullOrWhiteSpace(segment))
        {
            segments.Add(segment);
            segments.Add(VirtualPathUtility.Combine(segment, "default"));
        }
        i = virtualPath.IndexOf('/', i + 1);
    }
    segments.Add(virtualPath);
    segments.Add(VirtualPathUtility.Combine(virtualPath, "default"));

    return segments;
}

Basically, it creates path segments which I will use to check if a file exists in any of those segments. Like this:

string[] extensions = GetRegisteredExtensions();
HttpServerUtilityBase server = HttpContext.Current.Server;
List<string> segments = CreateSegments(virtualPath);

// check if a file exists with any of the registered extensions
var match = extensions.SelectMany(x => segments.Select(s => string.Format("{0}.{1}", s, x)))
.FirstOrDefault(p => System.IO.File.Exists(server.MapPath(p)));

All the above code looks like it could use some clean up and optimization, but I'm looking for a way to use LINQ if possible to generate the segments.

Something like: var segments = virtualPath.Split('/').SelectMany(...) and get a result similar to the following:

/path
/path/default
/path/to
/path/to/default
/path/to/file
/path/to/file/default

Where virtualPath would contain the value "/path/to/file"

EDIT: Changed string.Format("{0}/{1}", ...) to VirtualPathUtility.Combine(..., ...)

Any ideas?

Answer 1

This might do the trick. It is not the most succinct code but it seems very readable to me. It uses string concatenation because for short strings, like paths or URLs, it is faster than any of the alternatives.

Edit: fixed and tested.

var query = path.Split(new[] {'/'}, StringSplitOptions.RemoveEmptyEntries)
    .Aggregate(new List<string>(), (memo, segment) => {

        memo.Add(memo.DefaultIfEmpty("").Last() + "/" + segment);

        return memo;

    }).Aggregate(new List<string>(), (memo, p) => {

        memo.Add(p);
        memo.Add(p + "/default");

        return memo;

    });

Answer 2

The higher-order function you're looking for is called scan. There is no such function in normal LINQ, but you can find it in MoreLinq. Using that, your code could look like this:

private List<string> CreateSegments(string virtualPath)
{
    return virtualPath.Split('/')
                      .Scan((s1, s2) => s1 + '/' + s2)
                      .Skip(1)
                      .SelectMany(p => new[] { p, p + "/default" })
                      .ToList();
}

This assumes your path will be always an absolute path starting with a /. For relative paths, you will need to remove the .Skip(1) part.

If you don't want to get MoreLinq just for this one method, you can just copy its source into your project.

Answer 3

Something like this:

public static IEnumerable<string> EnumerateSegments( this IEnumerable<string> segments )
{
  StringBuilder sb = new StringBuilder() ;
  foreach ( string segment in segements )
  {
    sb.Append( Path.DirectorySeparatorChar ).Append( segment ) ;
    yield return sb.ToString() ;
    int n = sb.Length ;
    sb.Append( Path.DirectorySeparatorChar ).Append("default") ;
    yield return sb.ToString() ;
    sb.Length = n ;
  }
}

ought to do you.

Answer 4

If you first define an extension method like this:

public static IEnumerable<int> SplitIndexes(this string subject, char search)
{
    for(var i = 1; i < subject.Length; i++)
    {
        if(subject[i] == search)
        {
            yield return i;
        }
    }

    yield return subject.Length;
}

Then you could do this:

var endings = new string[] { string.Empty, "/default" };
var virtualPath = "/path/to/file";
var results = 
    from i in virtualPath.SplitIndexes('/')
    from e in endings
    select virtualPath.Substring(0, i) + e;

Or if you prefer query syntax:

var endings = new string[] { string.Empty, "/default" };
var virtualPath = "/path/to/file";
var results = virtualPath.SplitIndexes('/')
                         .SelectMany(i => endings.Select(e => virtualPath.Substring(0, i) + e));

The result will be:

/path
/path/default
/path/to
/path/to/default
/path/to/file
/path/to/file/default

As others have suggested, you can this in a more platform independent way by using Path.Combine, like this:

var endings = new string[] { string.Empty, "default" }; // Note: no / before default
var results = 
    from i in virtualPath.SplitIndexes(Path.DirectorySeparatorChar)
    from e in endings
    select Path.Combine(virtualPath.Substring(0, i), e);

Answer 5

The provided answers so far are more succinct, but this is what I came up with:

public static IEnumerable<string> PossiblePaths(string basePath)
{
    return PossiblePaths(basePath.Split(new[] { "/" }, 
                         StringSplitOptions.RemoveEmptyEntries));
}

private static IEnumerable<string> PossiblePaths(IEnumerable<string> segments, 
                                                 string current = "/")
{
    if (segments.Count() == 0)
    {
        return new string[0];
    }
    else
    {
        string next = current + segments.First();
        return new[] { next, next + "/default" }
                         .Concat(PossiblePaths(segments.Skip(1), next + "/"));
    }
}

Answer 6

One way would be to incrementally select the path segments, then "join" it with an empty string and "/default" to get the two variations:

string path = @"/path/to/file";

string temp = "";

var query = path.Split('/')
                .Where(s => !string.IsNullOrEmpty(s))
                .Select((p) => {temp += ("/" + p); return temp;} )
                .SelectMany(s => new[]{"","/default"}.Select (d => s + d) );