public EnumDirectory(DirectoryInfo directoryInfo, string pattern = null)
 {
     this.directoryInfo = directoryInfo;
     if (pattern == null)
         pattern = "*.*";
     this.directoryEnum = directoryInfo.EnumerateDirectories(pattern).GetEnumerator();
 }

        static void Main(string[] args)
        {
            //Works fine
            System.IO.DirectoryInfo sysDirectory = new System.IO.DirectoryInfo("C:\\TEST");
            sysDirectory.EnumerateFiles();

            //Does not compile:
            //'Pri.LongPath.DirectoryInfo' does not contain a definition for 'EnumerateFiles'
            //and no extension method 'EnumerateFiles' accepting a first argument of type
            //'Pri.LongPath.DirectoryInfo' could be found (are you missing a using directive or an assembly reference?)
            Pri.LongPath.DirectoryInfo longDirectory = new Pri.LongPath.DirectoryInfo("C:\\TEST");
            longDirectory.EnumerateFiles();
        }

        static long DirectorySize(DirectoryInfo dInfo, bool includeSubDir)
        {
            // Enumerate all the files
            long totalSize = dInfo.EnumerateFiles().Sum(file => file.Length);

            // If Subdirectories are to be included
            if (includeSubDir)
            {
                // Enumerate all sub-directories
                totalSize += dInfo.EnumerateDirectories().Sum(dir => DirectorySize(dir, true));
            }
            return totalSize;
        }

        public void TestSetLastWriteTimeUtc()
        {
            var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
            Directory.CreateDirectory(tempLongPathFilename);
            try
            {
                DateTime dateTime = DateTime.UtcNow.AddDays(1);
                Directory.SetLastWriteTimeUtc(tempLongPathFilename, dateTime);
                var fi = new DirectoryInfo(tempLongPathFilename);
                Assert.AreEqual(fi.LastWriteTimeUtc, dateTime);

            }
            finally
            {
                Directory.Delete(tempLongPathFilename);
            }
        }

        public void TestSetCreationTime()
        {
            var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
            Directory.CreateDirectory(tempLongPathFilename);
            Assert.IsTrue(Directory.Exists(tempLongPathFilename));
            try
            {
                DateTime dateTime = DateTime.Now.AddDays(1);
                Directory.SetCreationTime(tempLongPathFilename, dateTime);
                var di = new DirectoryInfo(tempLongPathFilename);
                Assert.AreEqual(di.CreationTime, dateTime);

            }
            finally
            {
                Directory.Delete(tempLongPathFilename);
            }
        }

 public void TestGetLastWriteTime()
 {
     var tempLongPathFilename = Path.Combine(longPathDirectory, Path.GetRandomFileName());
     Directory.CreateDirectory(tempLongPathFilename);
     try
     {
         var dateTime = Directory.GetLastWriteTime(tempLongPathFilename);
         var fi = new DirectoryInfo(tempLongPathFilename);
         Assert.AreEqual(fi.LastWriteTime, dateTime);
     }
     finally
     {
         Directory.Delete(tempLongPathFilename);
     }
 }

 public void TestGetFileSystemInfosWithSearch()
 {
     var di = new DirectoryInfo(uncDirectory);
     var randomFileName = Path.GetRandomFileName();
     var newDi = di.CreateSubdirectory(randomFileName);
     try
     {
         var fi = new FileInfo(Path.Combine(newDi.FullName, "filename"));
         using (fi.Create())
         {
         }
         try
         {
             Assert.AreEqual(2, di.GetFileSystemInfos("*").Count());
         }
         finally
         {
             fi.Delete();
         }
     }
     finally
     {
         newDi.Delete(true);
     }
 }

 public void TestGetFilesWithSearch()
 {
     var di = new DirectoryInfo(uncDirectory);
     var files = di.GetFiles("*").ToArray();
     Assert.AreEqual(1, files.Length);
 }

 public void TestGetDirectoriesWithSingleResultSubsetSearch()
 {
     var randomFileName = "TestGetDirectoriesWithSubsetSearch";
     var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName);
     Directory.CreateDirectory(tempLongPathFilename);
     try
     {
         var di = new DirectoryInfo(uncDirectory);
         var dirs = di.GetDirectories("A*").ToArray();
         Assert.AreEqual(0, dirs.Length);
         Assert.IsFalse(dirs.Any(f => f.Name == randomFileName));
     }
     finally
     {
         Directory.Delete(tempLongPathFilename);
     }
 }

 public void TestCreateSubdirectoryWithFileSecurity()
 {
     var di = new DirectoryInfo(uncDirectory);
     var randomFileName = Path.GetRandomFileName();
     Pri.LongPath.DirectoryInfo newDi = null;
     try
     {
         newDi = di.CreateSubdirectory(randomFileName, new DirectorySecurity());
         Assert.IsNotNull(newDi);
         Assert.IsTrue(di.Exists);
     }
     finally
     {
         if (newDi != null) newDi.Delete();
     }
 }

        public void TestToString()
        {
            var fi = new DirectoryInfo(uncDirectory);

            Assert.AreEqual(fi.DisplayPath, fi.ToString());
        }

 public void TestSetLastWriteTimeUtcMissingFile()
 {
     var filename = Path.Combine(uncDirectory, "gibberish.ext");
     DateTime dateTime = DateTime.UtcNow.AddDays(1);
     var di = new DirectoryInfo(filename);
     di.LastWriteTimeUtc = dateTime;
 }

 public void TestSetLastWriteTimeUtc()
 {
     var filename = Util.CreateNewFile(uncDirectory);
     try
     {
         DateTime dateTime = DateTime.UtcNow.AddDays(1);
         var di = new DirectoryInfo(filename);
         di.LastWriteTimeUtc = dateTime;
         Assert.AreEqual(dateTime, File.GetLastWriteTimeUtc(filename));
     }
     finally
     {
         File.Delete(filename);
     }
 }

 public void TestSetCreationTimeMissingFile()
 {
     var filename = Path.Combine(uncDirectory, "gibberish.ext");
     DateTime dateTime = DateTime.Now.AddDays(1);
     var di = new DirectoryInfo(filename);
     di.CreationTime = dateTime;
 }

 public void TestGetAccessControlSections()
 {
     var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
     Directory.CreateDirectory(tempLongPathFilename);
     try
     {
         var di = new DirectoryInfo(tempLongPathFilename);
         var security = di.GetAccessControl(AccessControlSections.Access);
         Assert.IsNotNull(security);
         Assert.AreEqual(typeof(FileSystemRights), security.AccessRightType);
         Assert.AreEqual(typeof(FileSystemAccessRule), security.AccessRuleType);
         Assert.AreEqual(typeof(FileSystemAuditRule), security.AuditRuleType);
         Assert.IsTrue(security.AreAccessRulesCanonical);
         Assert.IsTrue(security.AreAuditRulesCanonical);
         Assert.IsFalse(security.AreAccessRulesProtected);
         Assert.IsFalse(security.AreAuditRulesProtected);
         var securityGetAccessRules = security.GetAuditRules(true, true, typeof(System.Security.Principal.NTAccount)).Cast<FileSystemAccessRule>();
         Assert.AreEqual(0, securityGetAccessRules.Count());
         AuthorizationRuleCollection perm = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
         var ntAccount = new System.Security.Principal.NTAccount(System.Security.Principal.WindowsIdentity.GetCurrent().Name);
         FileSystemAccessRule rule = perm.Cast<FileSystemAccessRule>().SingleOrDefault(e => ntAccount == e.IdentityReference);
         Assert.IsNotNull(rule);
         Assert.IsTrue((rule.FileSystemRights & FileSystemRights.FullControl) != 0);
     }
     finally
     {
         Directory.Delete(tempLongPathFilename);
     }
 }

 public void TestGetDirectoriesWithAllSearch()
 {
     var randomFileName = Path.GetRandomFileName();
     var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName);
     Directory.CreateDirectory(tempLongPathFilename);
     try
     {
         var di = new DirectoryInfo(uncDirectory);
         var dirs = di.GetDirectories("*").ToArray();
         Assert.AreEqual(1, dirs.Length);
         Assert.IsTrue(dirs.Any(f => f.Name == randomFileName));
     }
     finally
     {
         Directory.Delete(tempLongPathFilename);
     }
 }

 public void TestCreateWithFileSecurity()
 {
     var tempLongPathFilename = Path.Combine(uncDirectory, Path.GetRandomFileName());
     var di = new DirectoryInfo(tempLongPathFilename);
     try
     {
         di.Create(new DirectorySecurity());
         Assert.IsTrue(Directory.Exists(tempLongPathFilename));
     }
     finally
     {
         di.Delete();
     }
 }

 public void TestGetFiles()
 {
     var di = new DirectoryInfo(uncDirectory);
     var files = di.GetFiles().ToArray();
     Assert.AreEqual(1, files.Length);
     Assert.IsTrue(files.Any(f => f.Name == Filename));
 }

 public void TestEnumerateDirectoriesWithSearchWithNoResults()
 {
     var randomFileName = Path.GetRandomFileName();
     var tempLongPathFilename = Path.Combine(uncDirectory, randomFileName);
     Directory.CreateDirectory(tempLongPathFilename);
     try
     {
         var di = new DirectoryInfo(uncDirectory);
         var dirs = di.EnumerateDirectories("gibberish").ToArray();
         Assert.AreEqual(0, dirs.Length);
     }
     finally
     {
         Directory.Delete(tempLongPathFilename);
     }
 }

 public void TestGetFilesWithSearchWithNoResults()
 {
     var di = new DirectoryInfo(uncDirectory);
     var files = di.GetFiles("giberish").ToArray();
     Assert.AreEqual(0, files.Length);
 }