static UploadedFilesStorage GetUploadedFilesStorageByKeyUnsafe(string key)
    {
        UploadedFilesStorage storage = UploadedFilesStorageList.Where(i => i.Key == key).SingleOrDefault();

        if (storage != null)
        {
            storage.LastUsageTime = DateTime.Now;
        }
        return(storage);
    }
 public static void RemoveUploadedFilesStorage(string key)
 {
     lock (storageListLocker)
     {
         UploadedFilesStorage storage = GetUploadedFilesStorageByKeyUnsafe(key);
         if (storage != null)
         {
             Directory.Delete(storage.Path, true);
             UploadedFilesStorageList.Remove(storage);
         }
     }
 }
    public static string GetUniqueFileName(UploadedFilesStorage currentStorage, string fileName)
    {
        string baseName = Path.GetFileNameWithoutExtension(fileName);
        string ext      = Path.GetExtension(fileName);
        int    index    = 1;

        while (currentStorage.Files.Any(i => i.UniqueFileName == fileName))
        {
            fileName = string.Format("{0} ({1}){2}", baseName, index++, ext);
        }

        return(fileName);
    }
    public static UploadedFileInfo AddUploadedFileInfo(string key, string originalFileName)
    {
        UploadedFilesStorage currentStorage = GetUploadedFilesStorageByKey(key);
        UploadedFileInfo     fileInfo       = new UploadedFileInfo
        {
            FilePath         = Path.Combine(currentStorage.Path, Path.GetRandomFileName()),
            OriginalFileName = originalFileName,
            UniqueFileName   = GetUniqueFileName(currentStorage, originalFileName)
        };

        currentStorage.Files.Add(fileInfo);

        return(fileInfo);
    }
 public static void AddUploadedFilesStorage(string key)
 {
     lock (storageListLocker)
     {
         UploadedFilesStorage storage = new UploadedFilesStorage
         {
             Key           = key,
             Path          = CreateTempDirectoryCore(),
             LastUsageTime = DateTime.Now,
             Files         = new List <UploadedFileInfo>()
         };
         UploadedFilesStorageList.Add(storage);
     }
 }
    public static void RemoveOldStorages()
    {
        if (!Directory.Exists(RootDirectory))
        {
            Directory.CreateDirectory(RootDirectory);
        }

        lock (storageListLocker)
        {
            string[] existingDirectories = Directory.GetDirectories(RootDirectory);
            foreach (string directoryPath in existingDirectories)
            {
                UploadedFilesStorage storage = UploadedFilesStorageList.Where(i => i.Path == directoryPath).SingleOrDefault();
                if (storage == null || (DateTime.Now - storage.LastUsageTime).TotalMinutes > DisposeTimeout)
                {
                    Directory.Delete(directoryPath, true);
                    if (storage != null)
                    {
                        UploadedFilesStorageList.Remove(storage);
                    }
                }
            }
        }
    }
    public static UploadedFileInfo GetDemoFileInfo(string key, string fileName)
    {
        UploadedFilesStorage currentStorage = GetUploadedFilesStorageByKey(key);

        return(currentStorage.Files.Where(i => i.UniqueFileName == fileName).SingleOrDefault());
    }