multi-download files 多线程下载

using  System;
using  System.Net;
using  System.ComponentModel;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Diagnostics;

namespace  Downloader
{
     class  Program
    {
         static   void  Main( string [] args)
        {
            List < string >  uriList  =   new  List < string > ();

             #region  init data
            uriList.Add( " http://t1.gstatic.com/images?q=tbn:lJZx9zTCrSd9hM: " );
             //add more here
             #endregion

             // multi-download
            Stopwatch sw  =   new  Stopwatch();
            sw.Start();
            DownloaderOlder oldMDownloader  =   new  DownloaderOlder();
            oldMDownloader.DownloadFilesCompleted  +=   delegate
            {
                sw.Stop();
                Console.WriteLine( " ok: "   +  sw.ElapsedMilliseconds);
                Console.ReadLine();
            };
            oldMDownloader.Download(uriList);

             // single-download
            Stopwatch sw1  =   new  Stopwatch();
            sw1.Start();
            oldMDownloader.DownloadSingle(uriList);
            sw1.Stop();
            Console.WriteLine( " ok2:{0},{1} " , sw1.ElapsedMilliseconds, sw1.ElapsedMilliseconds  /  sw.ElapsedMilliseconds);

             // multi-download client can set the max-thread count
            Stopwatch sw2  =   new  Stopwatch();
            sw2.Start();
            MultiDownloader mdownloader  =   new  MultiDownloader(uriList);
            mdownloader.MaxThreadCount  =   100 ;
            mdownloader.DownloadFilesCompleted  +=   delegate
            {
                sw2.Stop();
                Console.WriteLine( " ok3:{0} " , sw2.ElapsedMilliseconds);
                Console.ReadLine();
            };
            mdownloader.Start();

            Console.ReadLine();
        }
    }

     public   class  DownloaderOlder
    {
         public   event  AsyncCompletedEventHandler DownloadFilesCompleted;

         private   int  TotalCount  =   0 ;
         private   int  count  =   0 ;
         public   void  Download(List < string >  uriList)
        {
            TotalCount  =  uriList.Count;

             foreach  (var uri  in  uriList)
            {
                Download(uri);
            }
        }

         public   void  DownloadSingle(List < string >  uriList)
        {
             foreach  (var uri  in  uriList)
            {
                 string  file  =   string .Format( @" d:\asy{0}.jpg " ,uri.GetHashCode());

                WebClient client  =   new  WebClient();
                client.DownloadFile(uri, file);

            }
        }

         public   void  Download( string  uri)
        {
             string  file  =   string .Format( @" d:\{0}.jpg " ,uri.GetHashCode());
            
            WebClient client  =   new  WebClient();
            client.DownloadFileCompleted  +=   new  AsyncCompletedEventHandler(onCompleted);
            client.DownloadFileAsync( new  Uri(uri), file);
            
        }

         public   void  onCompleted( object  sender,AsyncCompletedEventArgs e)
        {           
            count ++ ;
             if  (count  ==  TotalCount)
            {
                AsyncCompletedEventArgs args  = new  AsyncCompletedEventArgs( null , false , null );
                DownloadFilesCompleted.Invoke( this , args);
            }
            
        }

        
    }

     public   class  MultiDownloader
    {
         public   event  AsyncCompletedEventHandler DownloadFilesCompleted;
         public   int  MaxThreadCount {  get ;  set ; }
         private   int  _CurrentThreadCount  =   0 ;

         private   int  _TotalCount  =   0 ;
         private   int  _DownloadedCount  =   0 ;
         private  Queue < Uri >  _DownloadQueue  =   new  Queue < Uri > ();

         public   bool  CanStartThread
        {
             get  
            {
                 if  (_DownloadQueue.Count  ==   0 )
                     return   false ;

                 if  (_CurrentThreadCount  ==  MaxThreadCount)
                     return   false ;

                 return   true ;
            }
        }

         public   bool  DownloadCompleted
        {
             get  {  return  _DownloadedCount  ==  _TotalCount; }
        }
        

         public  MultiDownloader(List < string >  uriList)
        {
            MaxThreadCount  =   5 ;
            _TotalCount  =  uriList.Count;

             foreach  (var strURI  in  uriList)
                _DownloadQueue.Enqueue( new  Uri(strURI));
        }

         public   void  Start()
        {
             while  (CanStartThread)
            {
                Uri uri  =   null ;
                 lock  (_DownloadQueue)
                {
                    uri  =  _DownloadQueue.Dequeue();
                }

                 if  (uri  ==   null )
                     continue ;

                 string  file  =   string .Format( @" d:\{0}.jpg " , uri.GetHashCode());

                WebClient client  =   new  WebClient();
                client.DownloadFileCompleted  +=   new  AsyncCompletedEventHandler(onCompleted);
                client.DownloadFileAsync(uri, file);
            }
        }

         public   void  onCompleted( object  sender, AsyncCompletedEventArgs e)
        {
            _DownloadedCount ++ ;

             if  (DownloadCompleted)
            {
                AsyncCompletedEventArgs args  =   new  AsyncCompletedEventArgs( null ,  false ,  null );
                DownloadFilesCompleted.Invoke( this , args);
                 return ;
            }

            Start();

        }
        
       
    }
}