public LoadTorrentDialog(Torrent torrent, string defaultPath)
        {
            if (torrent == null)
                throw new System.ArgumentNullException ("torrent");
            if (defaultPath == null)
                throw new System.ArgumentNullException ("defaultPath");

            this.Build();
            PopulateStore (torrent);
            BuildColumns();

            this.lblName.Text = torrent.Name;
            this.lblSize.Text = ByteConverter.ConvertSize (torrent.Size);
            if (!string.IsNullOrEmpty(defaultPath))
                fileChooser.SetCurrentFolder(defaultPath);
        }

        public Television(TLFeed feed, Database database, Collector collector, Torrenter torrenter)
        {
            feed.New += item =>
            {
                if (item.Categories[0].Name != "Episodes")
                    return;
                var shows = database.Get<Show>();
                if (shows.Any(show => item.Title.Text.ToLower().Contains(show.Title.ToLower())))
                {
                    var model = new Torrent(item.Title.Text, item.Links.First().Uri.ToString(), item.Categories.First().Name);
                    collector.Event(model);
                    torrenter.Download(item.Links.First().Uri.ToString());
                }
            };

            collector.On<Search>(search =>
            {
                var wc = new WebClient();
                var result = wc.DownloadString("http://www.imdb.com/xml/find?json=1&tt=on&q=" + search.Query);
                try
                {

                    var json = JObject.Parse(result);
                    var exact = json["title_popular"];
                    if (exact == null) return;
                    if(!exact["description"].ToString().Contains("TV")) return;
                    var show = new Show(exact[0]["title"].ToString());
                    collector.Event(show);
                }
                catch { }
            });
        }

        public InfoHashTrackable(Torrent torrent)
        {
            Check.Torrent(torrent);

            name = torrent.Name;
            infoHash = torrent.InfoHash;
        }

 static void Main(string[] args)
 {
     Torrent torrent = new Torrent(BenDecoder.Decode(args[0]));
     Tracker trackerClient = new Tracker(torrent);
     Console.WriteLine("Connecting to tracker at {0}", torrent.AnnounceUri);
     object cv = new object();
     trackerClient.Connected += delegate
         {
             Console.WriteLine("Connected to {0}", torrent.AnnounceUri);
         };
     trackerClient.Updated += delegate
         {
             if(trackerClient.LastResponse.IsSuccessful)
             {
                 Console.WriteLine("{0} Seeders, {1} leechers", trackerClient.LastResponse.NumberOfSeeds, trackerClient.LastResponse.NumberOfLeechers);
                 ConnectToPeers(trackerClient.LastResponse.Peers, torrent);
             }
             else
             {
                 QuitWithError(cv, trackerClient.LastResponse.FailureReason);
             }
            
         };
     trackerClient.Error += delegate(object sender, Exception e)
         {
             QuitWithError(cv, e.Message);
         };
     trackerClient.Start();
     lock(cv)
     {
         Monitor.Wait(cv);
     }
 }

 public TorrentGetCommand(JsonObject response)
 {
     Program.DaemonDescriptor.ResetFailCount();
     if (!Program.Connected)
     {
         return;
     }
     JsonObject arguments = (JsonObject)response[ProtocolConstants.KEY_ARGUMENTS];
     JsonArray torrents = (JsonArray)arguments[ProtocolConstants.KEY_TORRENTS];
     Program.DaemonDescriptor.UpdateSerial++;
     oldCount = Program.TorrentIndex.Count;
     UpdateTorrents.Clear();
     for (int i = 0; i < torrents.Count; i++)
     {
         JsonObject torrent = (JsonObject)torrents[i];
         string hash = (string)torrent[ProtocolConstants.FIELD_HASHSTRING];
         Torrent t = null;
         lock (Program.TorrentIndex)
         {
             if (!Program.TorrentIndex.ContainsKey(hash))
             {
                 t = new Torrent(torrent);
             }
             else
             {
                 t = Program.TorrentIndex[hash];
                 if (t.Update(torrent, false))
                     stateChange = true;
             }
             UpdateTorrents.Add(t);
         }
         totalUpload += t.UploadRate;
         totalDownload += t.DownloadRate;
     }
 }

        public void SetUp()
        {
            socket = new FakeSocket();
            file = TorrentTestUtils.CreateMultiFileTorrent();
            socket.response = TrackerResponseTest.CreateTestResponseString();

        }

 public TorrentViewModel(Torrent torrent, IEventAggregator eventAggregator, ErrorTracker errorTracker, ServerUnits speedUnits, ServerUnits sizeUnits)
 {
     Id = torrent.ID;
     TorrentFileViewModel = new TorrentFileViewModel(Id, eventAggregator, errorTracker);
     Size = torrent.Size.ToSizeString(sizeUnits);
     Hash = torrent.Hash;
     Update(torrent, speedUnits, sizeUnits);
 }

 public HashFileLinkPieces(Torrent torrent, int pieceIndex,
     IList<FileLinkPiece> fileLinkPieces)
 {
     this._pieceIndex = pieceIndex;
     this._fileLinkPieces = fileLinkPieces;
     this._result = -1;
     this._torrent = torrent;
 }

        public InfoHashTrackable(Torrent torrent)
        {
            if (torrent == null)
                throw new ArgumentNullException("torrent");

            name = torrent.Name;
            infoHash = torrent.InfoHash;
        }

 public CustomITrackable(Torrent t)
 {
     // Note: I'm just storing the files, infohash and name. A typical Torrent instance
     // is ~100kB in memory. A typical CustomITrackable will be ~100 bytes.
     files = t.Files;
     infoHash = t.InfoHash;
     name = t.Name;
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="torrent"></param>
        /// <param name="tracker"></param>
        public TorrentTracker(Torrent torrent, Tracker tracker)
        {
            Torrent = torrent;
            Tracker = tracker;
            Peers = new List<Peer>();

            // par défaut, les peers ne sont pas compactés
            Compact = false;
        }

 public TorrentRandomAccessStream(TorrentStreamManager manager)
 {
     _manager = manager;
     _torrentFile = manager.TorrentVideoFile;
     _torrent = manager.Torrent;
     var stream = File.Open(Path.Combine(_torrentFile.TargetFolder.Path, _torrentFile.Path), FileMode.Open,
         FileAccess.Read, FileShare.ReadWrite);
     _internalStream = stream.AsRandomAccessStream();
 }

        public TorrentState CreateTorrentState(Torrent t)
        {
            var hash = ExtractHash(t.Magnet);

            var ts = new TorrentState(hash, t.Episode.Season, t.Episode.Number);

            _tracked.Add(new WeakReference(ts));
            return ts;
        }

        internal HdknTorrent(Torrent torrent)
        {
            _torrent = torrent;

            foreach (var file in torrent.Files)
            {
                _files.Add(new HdknTorrentFile(file));
            }
        }

 private void VerifyCommonParts(Torrent torrent)
 {
     Assert.Equal(Comment, torrent.Comment);
     Assert.Equal(CreatedBy, torrent.CreatedBy);
     Assert.True(DateTime.Now - torrent.CreationDate < TimeSpan.FromSeconds(5));
     Assert.Equal(PieceLength, torrent.PieceLength);
     Assert.Equal(Publisher, torrent.Publisher);
     Assert.Equal(PublisherUrl, torrent.PublisherUrl);
     Assert.Equal(2, torrent.AnnounceUrls.Count);
     Assert.Equal(2, torrent.AnnounceUrls[0].Count);
     Assert.Equal(2, torrent.AnnounceUrls[1].Count);
 }

    public WebMultiDownload(IEnumerable<string> links, string targetFilePath, string tempFolder, Torrent torrent)
    {
      this.torrent = torrent;
      Length = (int)torrent.Size;
      Name = torrent.Name;
      urls = new List<string>(links);
      this.targetFilePath = targetFilePath;

      pieceStates = new PieceState[torrent.Pieces.Count];
      for (var i = 0; i < pieceStates.Length; i++) pieceStates[i] = PieceState.Free;
      if (tempFolder != null) tempFilePath = Utils.MakePath(tempFolder, Path.GetFileName(targetFilePath));
      else tempFilePath = Path.GetTempFileName();
    }

        /// <summary>
        /// Adds the file to download. This method returns when the torrent is 
        /// added and doesn't wait for the download to complete.
        /// </summary>
        /// <param name="torrent">The torrent.</param>
        /// <param name="savePath">The save path.</param>
        public void StartDownloadingFile(Torrent torrent, string savePath, int lastPieceInProfile)
        {
            TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0);
            var tm = new TorrentManager(torrent, savePath, torrentDefaults, "", lastPieceInProfile);
            // There is no need to scrape since we manage the tracker.
            tm.TrackerManager.CurrentTracker.CanScrape = false;

            _clientEngine.Register(tm);

            tm.TrackerManager.CurrentTracker.AnnounceComplete +=
                new EventHandler<AnnounceResponseEventArgs>(
                    TorrentEventHandlers.HandleAnnounceComplete);

            tm.TrackerManager.CurrentTracker.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e) {
                logger.DebugFormat("Scrape completed. Successful={0}, Tracker={1}",
                    e.Successful, e.Tracker.Uri);
            };

            tm.TorrentStateChanged +=
                new EventHandler<TorrentStateChangedEventArgs>(
                    TorrentEventHandlers.HandleTorrentStateChanged);

            tm.PieceHashed +=
                new EventHandler<PieceHashedEventArgs>(
                    TorrentEventHandlers.HandlePieceHashed);

            tm.PeerConnected += delegate(object o, PeerConnectionEventArgs e) {
                // Only log three connections.
                if (e.TorrentManager.OpenConnections < 4) {
                    logger.DebugFormat(
                        "Peer ({0}) Connected. Currently {1} open connection.",
                        e.PeerID.Uri, e.TorrentManager.OpenConnections);
                }
            };

            tm.PieceManager.BlockReceived += delegate(object o, BlockEventArgs e) {
                logger.DebugFormat("Block {0} from piece {1} is received.", e.Block.StartOffset / Piece.BlockSize, e.Piece.Index);
            };

            // We really only deal with one file.
            foreach (var file in tm.Torrent.Files) {
                _torrentManagerTable[file.FullPath] = tm;
            }

            tm.Start();
            logger.DebugFormat(
                "Starting to download torrent: {0}. Torrent manager started.",
                tm.Torrent.Name);
        }

        public TorrentAdapter(Torrent torrent, ObjectPath path)
        {
            this.path = path;
            this.torrent = torrent;
            this.filesPath = path.ToString () + "/files/{0}";

            files = new ObjectPath[torrent.Files.Length];
            for (int i=0; i < files.Length; i++)
            {
                ObjectPath p = new ObjectPath (string.Format(filesPath, i));
                TorrentFileAdapter adapter = new TorrentFileAdapter (torrent.Files[i], p);
                files[i] = p;
                TorrentService.Bus.Register (p, adapter);
            }
        }

        public void StartUp()
        {
            DateTime current = new DateTime(2006, 7, 1, 5, 5, 5);
            DateTime epochStart = new DateTime(1970, 1, 1, 0, 0, 0);
            TimeSpan span = current - epochStart;
            creationTime = (long)span.TotalSeconds;
            Console.WriteLine(creationTime.ToString() + "Creation seconds");

            BEncodedDictionary torrentInfo = new BEncodedDictionary();
            torrentInfo.Add("announce", new BEncodedString("http://myannouceurl/announce"));
            torrentInfo.Add("creation date", new BEncodedNumber(creationTime));
            torrentInfo.Add("nodes", new BEncodedList());                    //FIXME: What is this?
            torrentInfo.Add("comment.utf-8", new BEncodedString("my big long comment"));
            torrentInfo.Add("comment", new BEncodedString("my big long comment"));
            torrentInfo.Add("azureus_properties", new BEncodedDictionary()); //FIXME: What is this?
            torrentInfo.Add("created by", new BEncodedString("MonoTorrent/" + VersionInfo.ClientVersion));
            torrentInfo.Add("encoding", new BEncodedString("UTF-8"));
            torrentInfo.Add("info", CreateInfoDict());
            torrentInfo.Add("private", new BEncodedString("1"));
            torrent = Torrent.Load(torrentInfo);
        }

 public void AddTorrent(Torrent torrent, string path, bool suppressMessages = false)
 {
     if (!Directory.Exists(path))
         Directory.CreateDirectory(path);
     var wrapper = new TorrentWrapper(torrent, path, new TorrentSettings());
     if (Client.Torrents.Any(t => t.Torrent.InfoHash == wrapper.InfoHash))
     {
         if (!suppressMessages)
             MessageBox.Show(torrent.Name + " has already been added.", "Error");
         return;
     }
     var periodic = Client.AddTorrent(wrapper);
     // Save torrent to cache
     var cache = Path.Combine(SettingsManager.TorrentCachePath, Path.GetFileName(torrent.TorrentPath));
     if (File.Exists(cache))
         File.Delete(cache);
     File.Copy(torrent.TorrentPath, cache);
     File.WriteAllText(Path.Combine(Path.GetDirectoryName(cache),
         Path.GetFileNameWithoutExtension(cache)) + ".info", path);
     periodic.CacheFilePath = cache;
 }