C# ConcurrentQueue.IncompleteMoviesWaiting方法代码示例

        private static void RelationshipMaker(IMovieService movieService, IPersonService personService, ConcurrentQueue queue)
        {
            while (queue.IncompleteMoviesWaiting() || queue.IncompletePersonsWaiting() || queue.RelationshipsPending())
            {
                if (!queue.RelationshipsPending()) continue;

                var relationship = queue.PopRelationship();

                var movie = movieService.GetMovieByIdAsync(relationship.MovieId).Result;
                var person = personService.GetPersonByNameAsync(relationship.PersonName).Result;

                if (movie == null ||
                    person == null)
                {
                    queue.PushRelationship(relationship);
                    continue;
                }

                movieService.AddOrUpdateMovieWithRelationAsync(movie, person, relationship.RelationType).Wait();
            }
        }

        private static void MovieCollector(IMovieService movieService, IPersonService personService, 
            MyApiFilmsClient client, ConcurrentQueue queue)
        {
            while (queue.IncompleteMoviesWaiting() || queue.IncompletePersonsWaiting())
            {
                if (!queue.IncompleteMoviesWaiting()) continue;
                // ApiMovie is an alias for FilmIndustryNetwork.MyApiFilms.Entities.Movie
                // This is to distinguish between FilmIndustryNetwork.MyApiFilms.Entities.Movie
                // and FilmIndustryNetwork.Entities.Movie
                ApiMovie apiMovie;
                var title = queue.PopIncompleteMovie();

                if (title == "---") continue;

                try
                {
                    apiMovie =
                        client.GetDataAsObject<MovieResponse>(title, DataSetType.Movie)?.Data?.Movies?.FirstOrDefault();

                    if (apiMovie == null) throw new Exception();

                    if (apiMovie.Type.Contains("TV")) continue;
                }
                catch (MyApiFilmsTimeoutException e)
                {
                    // TODO: setup logging
                    FillQueueFromList(movieService, null, new [] {title}, queue, 0);
                    continue;
                }
                catch (NoMyApiFilmsResponseException e)
                {
                    // TODO: setup logging
                    continue;
                }
                catch (Exception)
                {
                    // TODO: setup logging
                    FillQueueFromList(movieService, null, new[] { title }, queue, 0);
                    continue;
                }

                var newMovie = new Movie
                {
                    Countries = apiMovie.Countries,
                    FilmingLocations = apiMovie.FilmingLocations,
                    Genres = apiMovie.Genres,
                    Id = apiMovie.IdIMDB,
                    Languages = apiMovie.Languages,
                    Plot = apiMovie.Plot,
                    NeedsApiLookup = false,
                    Rated = apiMovie.Rated,
                    Rating = apiMovie.Rating,
                    Title = apiMovie.Title,
                    Year = apiMovie.Year
                };

                FillQueueFromList(null, personService, apiMovie.Actors.Select(x => x.ActorName).ToList(), queue, 1);
                FillQueueFromList(null, personService, apiMovie.Directors.Select(x => x.Name).ToList(), queue, 1);
                FillQueueFromList(null, personService, apiMovie.Writers.Select(x => x.Name).ToList(), queue, 1);

                AddRelationshipsToQueue(new[] {apiMovie.IdIMDB}, apiMovie.Actors.Select(x => x.ActorName).ToList(), queue,
                    RelationTypes.ActedIn);
                AddRelationshipsToQueue(new[] {apiMovie.IdIMDB}, apiMovie.Directors.Select(x => x.Name).ToList(), queue,
                    RelationTypes.DirectorFor);
                AddRelationshipsToQueue(new[] {apiMovie.IdIMDB}, apiMovie.Writers.Select(x => x.Name).ToList(), queue,
                    RelationTypes.WriterOf);

                var existingMovie = movieService.GetMovieByIdAsync(newMovie.Id).Result;

                if (existingMovie != null) continue;

                movieService.AddMovieAsync(newMovie).Wait();
            }
        }

        private static void PersonCollector(IPersonService personService, IMovieService movieService, 
            MyApiFilmsClient client, ConcurrentQueue queue)
        {
            while (queue.IncompleteMoviesWaiting() || queue.IncompletePersonsWaiting())
            {
                if (!queue.IncompletePersonsWaiting()) continue;
                // ApiPerson is an alias for FilmIndustryNetwork.MyApiFilms.Entities.Person
                // This is to distinguish between FilmIndustryNetwork.MyApiFilms.Entities.Person
                // and FilmIndustryNetwork.Entities.Person
                ApiPerson apiPerson;
                var name = queue.PopIncompletePerson();

                if (name == "---") continue;

                try
                {
                    apiPerson =
                        client.GetDataAsObject<PersonResponse>(name, DataSetType.Person)?.Data?.Names?.FirstOrDefault();

                    if (apiPerson == null) throw new Exception();
                }
                catch (MyApiFilmsTimeoutException e)
                {
                    // TODO: setup logging
                    FillQueueFromList(null, personService, new [] {name}, queue, 1);
                    continue;
                }
                catch (NoMyApiFilmsResponseException e)
                {
                    // TODO: setup logging
                    continue;
                }
                catch (Exception)
                {
                    // TODO: setup logging
                    FillQueueFromList(null, personService, new[] { name }, queue, 1);
                    continue;
                }

                var person = new Person
                {
                    Bio = apiPerson.Bio,
                    BirthName = apiPerson.BirthName,
                    DateOfBirth = apiPerson.DateOfBirth,
                    Id = apiPerson.IdIMDB,
                    Name = apiPerson.Name,
                    NeedsApiLookup = false,
                    PlaceOfBirth = apiPerson.PlaceOfBirth,
                    UrlPhoto = apiPerson.UrlPhoto
                };

                FillQueueFromList(movieService, null, apiPerson.Filmographies
                    .Where(x => x.Section == "Actor" || x.Section == "Director" || x.Section == "Writer")
                    .SelectMany(f => f.Filmography.Select(m => m.Title)).ToList(), queue, 0);

                AddRelationshipsToQueue(
                    apiPerson.Filmographies
                        .Where(x => x.Section == "Actor")
                        .SelectMany(f => f.Filmography
                                          .Where(mm => mm.Remarks != null && !mm.Remarks.Contains("(TV Series)"))
                                          .Select(m => m.IMDBId)), new[] {person.Name}, queue,
                    RelationTypes.ActedIn);
                AddRelationshipsToQueue(
                    apiPerson.Filmographies
                        .Where(x => x.Section == "Director")
                        .SelectMany(f => f.Filmography
                                          .Where(mm => mm.Remarks != null && !mm.Remarks.Contains("(TV Series)"))
                                          .Select(m => m.IMDBId)), new[] { person.Name }, queue,
                    RelationTypes.DirectorFor);
                AddRelationshipsToQueue(
                    apiPerson.Filmographies
                        .Where(x => x.Section == "Writer")
                        .SelectMany(f => f.Filmography
                                          .Where(mm => mm.Remarks != null && !mm.Remarks.Contains("(TV Series)"))
                                          .Select(m => m.IMDBId)), new[] { person.Name }, queue,
                    RelationTypes.WriterOf);

                if (personService.GetPersonByNameAsync(person.Name).Result != null) continue;

                personService.AddPersonAsync(person).Wait();
            }
        }

 private static void FillQueueFromList(IMovieService movieService, IPersonService personService, 
     IEnumerable<string> values, ConcurrentQueue queue, int option)
 {
     switch (option)
     {
         case 0:
             foreach (var value in values)
             {
                 if (movieService.GetMovieByIdAsync(value).Result != null) continue;
                 if (!queue.IncompleteMoviesWaiting())
                 {
                     queue.PushIncompleteMovie(value);
                     queue.PushIncompleteMovie("---"); // "---" is for concurrency
                     continue;
                 }
                 var last = queue.PopLastIncompleteMovie();
                 queue.PushIncompleteMovie(value);
                 queue.PushIncompleteMovie(last);
             }
             break;
         case 1:
             foreach (var value in values)
             {
                 if (personService.GetPersonByNameAsync(value).Result != null) continue;
                 if (!queue.IncompletePersonsWaiting())
                 {
                     queue.PushIncompletePerson(value);
                     queue.PushIncompletePerson("---"); // "---" is for concurrency
                     continue;
                 }
                 var last = queue.PopLastIncompletePerson();
                 queue.PushIncompletePerson(value);
                 queue.PushIncompletePerson(last);
             }
             break;
     }
 }