Question

In other words, how can I kick off some custom processing of newly uploaded files to FTP server on my machine with IIS-backed FTP server and .NET?

Clarification
This is to run on the machine that hosts FTP server. Permissions are not an issue in my case.

It seems I’d need to ask the uploading entities to add a listing file that is sent after the actual data file is completely uploaded. Imagine that there is an actual xxx.data file uploaded, followed by xxx.listing file that signifies completion of xxx.data file upload.

Originally this question was talking about Reactive Extensions. I was hoping that someone has a bridge from IIS 7.5’s FTP server to Reactive Extensions, so I can focus on the higher-level implementation details.

Answer 1

I’ve slimmed down the MSDN sample to focus in on file creation, as it’s the only event of interest when files are uploaded to FTP server.

One would have to install the Reactive Extensions for this code sample to work in Visual Studio 2012.

 class Program
 {
     static void Main()
     {
         // Create a FileSystemWatcher to watch the FTP incoming directory for creation of listing file

         using (var watcher = new FileSystemWatcher(@"C:\FTP-Data\Incoming", "*.lst"))
         {
             // Use the FromEvent operator to setup a subscription to the Created event.           
             //                                                                                    
             // The first lambda expression performs the conversion of Action<FileSystemEventArgs> 
             // to FileSystemEventHandler. The FileSystemEventHandler just calls the handler       
             // passing the FileSystemEventArgs.                                                   
             //                                                                                    
             // The other lambda expressions add and remove the FileSystemEventHandler to and from 
             // the event.                                                                         

             var fileCreationObservable = Observable.FromEvent<FileSystemEventHandler, FileSystemEventArgs>(
                                         UseOnlyTheSecondArgument,
                                         fsHandler => watcher.Created += fsHandler,
                                         fsHandler => watcher.Created -= fsHandler);

             fileCreationObservable.Subscribe(ActionWhenFileIsUploaded);

             watcher.EnableRaisingEvents = true;

             Console.WriteLine("Press ENTER to quit the program...\n");
             Console.ReadLine();
         }
     }

     private static void ActionWhenFileIsUploaded(FileSystemEventArgs args)
     {
         Console.WriteLine("{0} was created.", args.FullPath);

         // TODO
         // 1. Deduce original file name from the listing file info
         // 2. Consume the data file
         // 3. Remove listing file
     }

     private static FileSystemEventHandler UseOnlyTheSecondArgument(Action<FileSystemEventArgs> handler)
     {
         return (object sender, FileSystemEventArgs e) => handler(e);
     }
 }

I am still working out the details of transforming observable of listing files to observable of actual data files. Stay tuned.