C# YouTube.YouTubeQuery类代码示例

 public Video GetById(string id)
 {
     var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri + "/" + id);
     var res = GetVideos(query);
     var v = res.FirstOrDefault();
     return v;
 }

        public IEnumerable<VideoModel> Search(string searchText)
        {
            var modelList = new List<VideoModel>();
            var settings = new YouTubeRequestSettings("YouTunes", "AIzaSyCgNs6G_0w36g6dhAxxBL4nL7wD3C6jmOw");
            var request = new YouTubeRequest(settings);
            var query = new YouTubeQuery("https://gdata.youtube.com/feeds/api/videos") { Query = searchText };

            Feed<Video> feed = null;

            try
            {
                feed = request.Get<Video>(query);

                foreach (var video in feed.Entries)
                {
                    modelList.Add(new VideoModel() { VideoTitle = video.Title, VideoId = video.VideoId });
                }
            }
            catch (GDataRequestException gdre)
            {

            }

            return modelList;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Uri ur = new Uri("http://gdata.youtube.com/feeds/api/videos/fSgGV1llVHM&f=gdata_playlists&c=ytapi-DukaIstvan-MyYouTubeVideosF-d1ogtvf7-0&d=U1YkMvELc_arPNsH4kYosmD9LlbsOl3qUImVMV6ramM");
              YouTubeQuery query = new YouTubeQuery("http://gdata.youtube.com/feeds/api/channels?q=vevo");

              YouTubeFeed videoFeed = service.Query(query);
              YouTubeEntry en = (YouTubeEntry)videoFeed.Entries[0];

              Video video = request.Retrieve<Video>(new Uri("http://gdata.youtube.com/feeds/api/videos/" + en.VideoId));
              Feed<Comment> comments = request.GetComments(video);
            string cm = "";
            foreach (Comment c in comments.Entries)
            {
              cm +=  c.Content + "\n------------------------------------------\n";
            }

              VideoInfo info = new VideoInfo();
              info.Get("yUHNUjEs7rQ");
              //Video v = request.Retrieve<Video>(videoEntryUrl);

              //Feed<Comment> comments = request.GetComments(v);

              //string cm = "";
              //foreach (Comment c in comments.Entries)
              //{
              //  cm += c.Author + c.Content + "------------------------------------------";
              //}
        }

        private static IObservable<IReadOnlyList<ISong>> RealSearch(string searchTerm)
        {
            var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri)
            { 
                OrderBy = "relevance",
                Query = searchTerm,
                SafeSearch = YouTubeQuery.SafeSearchValues.None,
                NumberToRetrieve = RequestLimit
            };

            var settings = new YouTubeRequestSettings("Espera", ApiKey);
            var request = new YouTubeRequest(settings);

            return Observable.FromAsync(async () =>
            {
                Feed<Video> feed = await Task.Run(() => request.Get<Video>(query));
                List<Video> entries = await Task.Run(() => feed.Entries.ToList());

                return (from video in entries
                    let url = video.WatchPage.OriginalString.Replace("&feature=youtube_gdata_player", String.Empty).Replace("https://", "http://")
                    select new YoutubeSong()
                    {
                        Artist = video.Uploader, Title = video.Title, OriginalPath = url
                    }).ToList();
            })
            .Catch<IReadOnlyList<YoutubeSong>, Exception>(ex => Observable.Throw<IReadOnlyList<YoutubeSong>>(new Exception("YoutubeSongFinder search failed", ex)));
        }

        protected void BBuscador(String track)
        {
            string spotUrl = String.Format("http://ws.spotify.com/search/1/track?q={0}", track);
            WebClient spotService = new WebClient();
            spotService.Encoding = Encoding.UTF8;
            spotService.DownloadStringCompleted += new DownloadStringCompletedEventHandler(SpotService_DownloadTracksCompleted);
            spotService.DownloadStringAsync(new Uri(spotUrl));

            YouTubeRequest request = new YouTubeRequest(settings);
            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            query.OrderBy = "relevance";
            query.Query = track;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            Feed<Video> videoFeed = request.Get<Video>(query);
            if (videoFeed.Entries.Count() > 0)
            {
                video1 = videoFeed.Entries.ElementAt(0);
                literal1.Text = String.Format(embed, video1.VideoId);
                if (videoFeed.Entries.Count() > 1)
                {
                    video1 = videoFeed.Entries.ElementAt(1);
                    literal1.Text += String.Format(embed, video1.VideoId);
                }
            }
        }

        public void Skype_MessageStatus(IChatMessage message, TChatMessageStatus status) {
            Match output = Regex.Match(message.Body, @"(?:youtube\.\w{2,3}\S+v=|youtu\.be/)([\w-]+)", RegexOptions.IgnoreCase);
            // Use non-breaking space as a marker for when to not show info.
            if (output.Success && !message.Body.Contains(" ")) {
                String youtubeId = output.Groups[1].Value;
                log.Info("Sending request to YouTube...");

                YouTubeQuery ytq = new YouTubeQuery("http://gdata.youtube.com/feeds/api/videos/" + youtubeId);

                Feed<Video> feed = ytr.Get<Video>(ytq);
                Video vid = feed.Entries.ElementAt<Video>(0);
                String title = vid.Title;
                String user = vid.Author;
                String rating = vid.RatingAverage.ToString();

                int seconds = Int32.Parse(vid.Media.Duration.Seconds) % 60;
                int minutes = Int32.Parse(vid.Media.Duration.Seconds) / 60;
                String duration = String.Format(@"{0}:{1:00}", minutes, seconds);

                message.Chat.SendMessage(String.Format(@"YouTube: ""{0}"" (uploaded by: {1}) (avg rating: {2:F2}) (duration: {3})", title, user, rating, duration));
                return;
            }
            
            output = Regex.Match(message.Body, @"^!youtube (.+)", RegexOptions.IgnoreCase);
            if (output.Success) {
                String query = output.Groups[1].Value;

                YouTubeQuery ytq = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
                ytq.Query = query;
                ytq.SafeSearch = YouTubeQuery.SafeSearchValues.None;
                ytq.NumberToRetrieve = 10;

                Feed<Video> feed = ytr.Get<Video>(ytq);
                int count = feed.Entries.Count<Video>();

                string url;
                if (count > 0) {
                    Video vid = feed.Entries.ElementAt<Video>(random.Next(count));
                    url = vid.WatchPage.ToString();
                } else {
                    url = "No matches found.";
                }

                message.Chat.SendMessage(String.Format(@"YouTube search for ""{0}"": {1}", query, url));
                return;
            }

            output = Regex.Match(message.Body, @"^!youtube", RegexOptions.IgnoreCase);
            if (output.Success) {
                log.Debug("Got a request for a random video.");

                String url = randomCache.Count > 0 ? randomCache.Dequeue() : generateRandomVideos(true);

                message.Chat.SendMessage(String.Format(@"Random YouTube video: {0}", url));

                generateRandomVideos(false);
                return;
            }
        }

 public void TimeTest()
 {
     YouTubeQuery target = new YouTubeQuery(); // TODO: Initialize to an appropriate value
     YouTubeQuery.UploadTime expected = new YouTubeQuery.UploadTime(); // TODO: Initialize to an appropriate value
     YouTubeQuery.UploadTime actual;
     target.Time = expected;
     actual = target.Time;
     Assert.AreEqual(expected, actual);
 }

 public void VQTest()
 {
     YouTubeQuery target = new YouTubeQuery(); // TODO: Initialize to an appropriate value
     string expected = "secret text string"; // TODO: Initialize to an appropriate value
     string actual;
     target.VQ = expected;
     actual = target.VQ;
     Assert.AreEqual(expected, actual);
 }

 // Search for a video given a keyword
 // @return feed of retrieved videos
 public static Feed<Video> SearchForVideo(string keyword)
 {
     YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
     query.OrderBy = "relevance";
     query.Query = keyword;
     query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
     query.NumberToRetrieve = 10;
     return request.Get<Video>(query);
 }

        public void PerformSearch (string searchVal)
        {
            YouTubeQuery query = new YouTubeQuery (YouTubeQuery.DefaultVideoUri);

            //order results by the number of views (most viewed first)
            query.OrderBy = "relevance";

            // perform querying with restricted content included in the results
            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            query.Query = searchVal;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;

            this.video_results = yt_request.Get<Video> (query);
        }

 private static IEnumerable<Video> GetVideos(YouTubeQuery q)
 {
     YouTubeRequest request = GetRequest();
     Feed<Video> feed = null;
     try
     {
         feed = request.Get<Video>(q);
     }
     catch (GDataRequestException gdre)
     {
         var response = (HttpWebResponse)gdre.Response;
     }
     return feed != null ? feed.Entries : null;
 }

        private void AddVideo(YouTubeRequest request, string maxResultsKey, string query, VideoList videoList)
        {
            int maxResults = ConfigService.GetConfig(maxResultsKey, 0);
            if (maxResults > 0)
            {
                YouTubeQuery youtubeQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
                youtubeQuery.Query = "%22" + query +  "%22";
                youtubeQuery.SafeSearch = YouTubeQuery.SafeSearchValues.Strict;
                youtubeQuery.NumberToRetrieve = maxResults;
                Feed<Video> videos = request.Get<Video>(youtubeQuery);

                YouTubeVideoParser parser = new YouTubeVideoParser();
                parser.Parse(videos, videoList);
            }
        }

        // once you copied your access and refresh tokens
        // then you can run this method directly from now on...
        public void MainX(string args)
        {
            GOAuth2RequestFactory requestFactory = RefreshAuthenticate();
            YouTubeRequestSettings settings = new YouTubeRequestSettings(_app_name, _clientID, _devKey);
            YouTubeRequest request = new YouTubeRequest(settings);

            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            //order results by the number of views (most viewed first)
            query.OrderBy = "viewCount";
            // search for puppies and include restricted content in the search results
            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            query.Query = args;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            //Feed<Video> videoFeed = requestFactory.Get<Video>(query);
        }

        public IEnumerable<MediaItemViewModel> Search(string query)
        {
            YouTubeQuery youtubeQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            //order results by the number of views (most viewed first)
            youtubeQuery.OrderBy = "viewCount";

            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            youtubeQuery.Query = query;
            youtubeQuery.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            youtubeQuery.NumberToRetrieve = 20;

            return this.Request.Get<Video>(youtubeQuery)
                .Entries
                .AsQueryable()
                .Project()
                .To<MediaItemViewModel>();
        }

        private static IObservable<IReadOnlyList<YoutubeSong>> RealSearch(string searchTerm)
        {
            var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri)
            {
                OrderBy = "relevance",
                Query = searchTerm,
                SafeSearch = YouTubeQuery.SafeSearchValues.None,
                NumberToRetrieve = RequestLimit
            };

            // NB: I have no idea where this API blocks exactly
            var settings = new YouTubeRequestSettings("Espera", ApiKey);
            var request = new YouTubeRequest(settings);

            return Observable.FromAsync(async () =>
            {
                Feed<Video> feed = await Task.Run(() => request.Get<Video>(query));
                List<Video> entries = await Task.Run(() => feed.Entries.ToList());

                var songs = new List<YoutubeSong>();

                foreach (Video video in entries)
                {
                    var duration = TimeSpan.FromSeconds(Int32.Parse(video.YouTubeEntry.Duration.Seconds));
                    string url = video.WatchPage.OriginalString
                        .Replace("&feature=youtube_gdata_player", String.Empty) // Unnecessary long url
                        .Replace("https://", "http://"); // Secure connections are not always easy to handle when streaming

                    var song = new YoutubeSong(url, duration)
                    {
                        Artist = video.Uploader,
                        Title = video.Title,
                        Description = video.Description,
                        Rating = video.RatingAverage >= 1 ? video.RatingAverage : (double?)null,
                        ThumbnailSource = new Uri(video.Thumbnails[0].Url),
                        Views = video.ViewCount
                    };

                    songs.Add(song);
                }

                return songs;
            })
                // The API gives no clue what can throw, wrap it all up
            .Catch<IReadOnlyList<YoutubeSong>, Exception>(ex => Observable.Throw<IReadOnlyList<YoutubeSong>>(new NetworkSongFinderException("YoutubeSongFinder search failed", ex)));
        }