Question

This looks like a bug to me. But, maybe you folks can help me decide.

Is this a bug?

The commented test case is as follows:

using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.IO;
using Microsoft.CSharp;

namespace CompilerBugTestCase
{
    internal static class Program
    {
        private const string DirectoryName = "TestSourceCode";
        private const string DirectoryNameTrailingSlash = DirectoryName + "/"; // This is intentionally defined with the wrong kind of slash
        private const string FileName = "Test.cs";
        private const string FilePath = DirectoryNameTrailingSlash + FileName; // By composition, this includes the wrong kind of slash

        private static void Main()
        {
            ShowItDoesWorkA();
            Console.WriteLine("ShowItDoesWorkA executed.");

            ShowItDoesWorkB();
            Console.WriteLine("ShowItDoesWorkB executed.");

            ShowItDoesNotWork();
            Console.WriteLine("ShowItDoesNotWork executed.");

            ShowItDoesNotWorkSimple();
            Console.WriteLine("ShowItDoesWorkSimple executed.");

            Console.WriteLine("Press [ ENTER ] to exit");
            Console.ReadLine();
        }

        private static void Setup()
        {
            if (!Directory.Exists(DirectoryName))
            {
                Directory.CreateDirectory(DirectoryName);
            }

            // Notice that this call has no problems
            // It uses the wrong slash, too!
            if (File.Exists(FilePath))
            {
                File.Delete(FilePath);
            }

            // We're creating a file with the wrong slash here as well.
            File.WriteAllText(FilePath, "using System; namespace TestCode { internal static class TestClass { public static void Main() { Console.WriteLine(\"I work!\"); } } }");
        }

        private static void CompileFiles(string[] files)
        {
            CSharpCodeProvider compiler = new CSharpCodeProvider();
            CompilerParameters parameters = new CompilerParameters()
            {
                GenerateExecutable = false,
                GenerateInMemory = true,
                IncludeDebugInformation = false,
                TreatWarningsAsErrors = true
            };

            CompilerResults results = compiler.CompileAssemblyFromFile(parameters, files);
            if (results.Errors.Count > 0)
            {
                // When looking at this exception, note the path it says it cannot find!
                // You will see it did not translate the path correctly and actually chopped the directory out.
                // Is that really the intended behavior?
                Debug.Fail(results.Errors[0].ErrorText);
            }
        }

        private static void ShowItDoesWorkA()
        {
            Setup();

            string[] files = Directory.GetFiles(DirectoryName);
            CompileFiles(files);
        }

        private static void ShowItDoesWorkB()
        {
            Setup();

            DirectoryInfo directory = new DirectoryInfo(DirectoryName);
            FileInfo[] files = directory.GetFiles();

            string[] paths = new string[files.Length];
            for (int i = 0; i < paths.Length; i++)
            {
                paths[i] = files[i].FullName;
            }

            CompileFiles(paths);
        }

        private static void ShowItDoesNotWork()
        {
            Setup();

            // Here we'll use the path with the wrong kind of slash.
            // It picks up the file just fine.
            string[] files = Directory.GetFiles(DirectoryNameTrailingSlash);
            CompileFiles(files);
        }

        private static void ShowItDoesNotWorkSimple()
        {
            // This is the simplest test case.
            // We hard code the path with the wrong kind of slash and it still crashes.

            Setup();

            string[] files = new string[1] { FilePath };
            CompileFiles(files);
        }
    }
}

Answer 1

 private const string DirectoryNameTrailingSlash = DirectoryName + "/";

The path separation character in Windows is a backslash, "\\". Or more accurately, it is Path.DirectorySeparatorChar. Now Windows itself makes some effort to try to interpret a forward slash as a separator as well. That however isn’t always widely matched by other code. Like this snippet I found in the source code for the CodeDOMProvider class:

    internal static bool TryGetProbableCoreAssemblyFilePath(CompilerParameters parameters, out string coreAssemblyFilePath) {
        string multiTargetingPackRoot = null;
        char[] pathSeperators = new char[] { Path.DirectorySeparatorChar };
        // etc..
    }

This kind of code just malfunctions when you use a forward slash. Last but certainly not least, compile options are passed to the compiler with a forward slash. Like /reference.

Trivially solve your problem by doing this the Right Way: use Path.Combine().