Reference - ContentRetriever API

// Assuming 'ArticlePage' is a generated model class
// For instance, assume the request is handled by 'ArticlesController'
// so 'TResult' always matches the retrieved schema and is mapped correctly.
ArticlePage currentPage =
  await contentRetriever.RetrieveCurrentPage<ArticlePage>();

// If current page can be of multiple types, you can use 'IWebPageFieldsSource'
// or different suitable base class together with pattern matching.
// Suitable model classes are paired with content types using
// 'RegisterContentTypeMappingAttribute' (automatically added to generated classes)
//
// Retrieves the current page using a shared interface
var currentPageData =
  await contentRetriever.RetrieveCurrentPage<IWebPageFieldsSource>();

// Use pattern matching to handle the specific type
switch (currentPageData)
{
  case ArticlePage article:
    // Specific logic for ArticlePage
    Console.WriteLine($"Displaying Article: {article.Title}");
    // Render article view...
    break;

  case LandingPage landing:
    // Specific logic for LandingPage
    Console.WriteLine($"Displaying Landing Page: {landing.Headline}");
    // Render landing page view...
    break;

  case null:
    // Handle case where the page is not found or not retrievable
    Console.WriteLine("Current page not found.");
    // Render 404 view...
    break;

  default:
    // Handle any other unexpected page types
    // Render a default view...
    break;
}

// Overrides method defaults with custom parameters
var parameters = new RetrieveCurrentPageParameters
{
    // Force a language variant
    LanguageName = "spanish",
    // Include directly linked items
    LinkedItemsMaxLevel = 1,
    // Force preview mode data
    IsForPreview = true
};

ArticlePage page = await contentRetriever.RetrieveCurrentPage<ArticlePage>(parameters);

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

ArticlePage page = await contentRetriever.RetrieveCurrentPage<ArticlePage>(
    // Use the default retrieval params
    new RetrieveCurrentPageParameters(),
    // Only get the Title property
    query => query.Columns(nameof(ArticlePage.ArticleTitle)),
    cacheSettings,
    // Explicitly use default mapping
    configureModel: null 
);

// Assuming 'IPageMetadata' is an interface implemented by types using these schemas
var schemaNames = new[] { IMetadataFields.REUSABLE_FIELD_SCHEMA_NAME, ISeoFields.REUSABLE_FIELD_SCHEMA_NAME };

// Gets all pages using the specified schemas with default settings
IEnumerable<IPageMetadata> pagesWithSchemas =
  await contentRetriever.RetrievePagesOfReusableSchemas<IPageMetadata>(schemaNames);

var schemaNames = new[] { IMetadataFields.REUSABLE_FIELD_SCHEMA_NAME };

// Retrieve pages using the 'Metadata' schema under the /products path
var parameters = new RetrievePagesOfReusableSchemasParameters
{
    PathMatch = PathMatch.Children("/products")
};

IEnumerable<IPageMetadata> productPages =
  await contentRetriever.RetrievePagesOfReusableSchemas<IPageMetadata>(schemaNames, parameters);

var schemaNames = new[] { IMetadataFields.REUSABLE_FIELD_SCHEMA_NAME, ISeoFields.REUSABLE_FIELD_SCHEMA_NAME };

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Retrieve the top 20 pages using the schemas
IEnumerable<IPageMetadata> pageInfo =
  await contentRetriever.RetrievePagesOfReusableSchemas<IPageMetadata>(
    schemaNames,
    new RetrievePagesOfReusableSchemasParameters(),
    query => query
                // Get the top 20 results
                .TopN(20),
    cacheSettings,
    configureModel: null // Use default mapping (columnName <=> propertyName)
);

// Assuming 'NewsArticle' is a generated model class for your news pages
// Gets all news articles using default settings (language, preview context, etc.)
IEnumerable<NewsArticle> newsArticles =
  await contentRetriever.RetrievePages<NewsArticle>();

// Retrieve news articles under the /news path, including one level of linked items
var parameters = new RetrievePagesParameters
{
    // Retrieve only children under the specified path
    PathMatch = PathMatch.Children("/news"),
    // Include directly linked items
    LinkedItemsMaxLevel = 1
};

IEnumerable<NewsArticle> newsArticles =
  await contentRetriever.RetrievePages<NewsArticle>(parameters);

// Assuming NewsArticleSummary is a simpler model
public class NewsArticleSummary
{
    public string Title { get; set; }
    public string Summary { get; set; }
}

// Retrieve the top 5 latest news articles under /news, only getting specific columns
var parameters = new RetrievePagesParameters
{
    PathMatch = PathMatch.Children("/news")
};

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// NewsArticle is `TSource`, avalilable in configureModel
// NewsArticleSummary is `TResult`, the final type returned by the call
IEnumerable<NewsArticle> latestNews =
  await contentRetriever.RetrievePages<NewsArticle, NewsArticleSummary>(
    parameters,
    query => query
                .Columns("Headline", "PublicationDate", "Summary") // Select specific columns
                .OrderByDescending("PublicationDate") // Order by date
                .TopN(5), // Get the top 5
    cacheSettings,
    configureModel: async (container, source) => new NewsArticleSummary
    {
        // Source is 'NewsArticle'
        Title = $"{source.Headline} - #{source.PublicationDate.ToString("en-US")}",
        Summary = source.Summary
    }
);

var contentTypes = new[] { Article.CONTENT_TYPE_NAME, Blog.CONTENT_TYPE_NAME };

// Gets all articles and blogs using default settings
// Assuming 'BaseViewModel' is a suitable base class or interface
// You can also use 'IWebPageFieldsSource' as the shared type
// Suitable model classes are paired with content types using
// 'RegisterContentTypeMappingAttribute' (automatically added to generated classes)
IEnumerable<BaseViewModel> pages =
  await contentRetriever.RetrievePagesOfContentTypes<BaseViewModel>(contentTypes);

// Use pattern matching to handle the specific type
switch (allPages.FirstOrDefault())
{
  case Article article:
    // Specific logic for ArticlePage
    Console.WriteLine($"Displaying Article: {article.Title}");
    // Render article view...
    break;

  case Blog blog:
    // Specific logic for LandingPage
    Console.WriteLine($"Displaying Landing Page: {blog.Headline}");
    // Render landing page view...
    break;

  default:
    // Handle any other unexpected page types
    // Render a default view...
    break;
}

var contentTypes = new[] { Article.CONTENT_TYPE_NAME, Blog.CONTENT_TYPE_NAME };

// Retrieve articles and blogs under the /archive path
var parameters = new RetrievePagesOfContentTypesParameters
{
    PathMatch = PathMatch.Children("/archive")
};

IEnumerable<BaseViewModel> archivePages =
  await contentRetriever.RetrievePagesOfContentTypes<BaseViewModel>(contentTypes, parameters);

var contentTypes = new[] { Article.CONTENT_TYPE_NAME, Blog.CONTENT_TYPE_NAME };

// Retrieve the first 10 articles or blogs under /archive, ordered by name
var parameters = new RetrievePagesOfContentTypesParameters
{
    PathMatch = PathMatch.Children("/archive")
};

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Assuming BaseViewModel is a suitable base class
IEnumerable<BaseViewModel> links = await contentRetriever.RetrievePagesOfContentTypes<BaseViewModel>(
    contentTypes,
    parameters,
    query => query
                .OrderBy("DocumentName") // Order by name
                .TopN(10), // Get the top 10
    cacheSettings,
    configureModel: null // Use default mapping
);

// Assuming 'BasePageViewModel' is a suitable base class for all pages
// Gets all pages using default settings
IEnumerable<BasePageViewModel> allPages =
  await contentRetriever.RetrieveAllPages<BasePageViewModel>();

// Use pattern matching to handle the specific type
switch (allPages.FirstOrDefault())
{
  case ArticlePage article:
    // Specific logic for ArticlePage
    Console.WriteLine($"Displaying Article: {article.Title}");
    // Render article view...
    break;

  case LandingPage landing:
    // Specific logic for LandingPage
    Console.WriteLine($"Displaying Landing Page: {landing.Headline}");
    // Render landing page view...
    break;

  case null:
    // Handle case where the page is not found or not retrievable
    Console.WriteLine("Current page not found.");
    // Render 404 view...
    break;

  default:
    // Handle any other unexpected page types
    // Render a default view...
    break;
}

var parameters = new RetrieveAllPagesParameters() {
  ChannelName = "FrenchCuisine"
};

IEnumerable<BasePageViewModel> allLivePages =
  await contentRetriever.RetrieveAllPages<BasePageViewModel>(parameters);

// Retrieve all pages under '/Articles', getting only specific columns
var parameters = new RetrieveAllPagesParameters
{
  PathMatch = PathMatch.Section("/Articles")
};

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Assuming Article is a generated model class
IEnumerable<PageTitleModel> pageLinks =
  await contentRetriever.RetrieveAllPages<BasePageViewModel>(
    parameters,
    query => query
                .Columns("PageTitle")
    cacheSettings,
    configureModel: async (container, baseModel) => {
      // Retrieve only the title and map to specific model
      return new PageTitleModel() {
        PageTitle = baseModel.PageTitle ?? "Untitled page"
      }
    } 
);

// Assuming 'IContactDetails' is an interface implemented by types using the 'ContactSchema'
var schemaNames = new[] { IContactSchema.REUSABLE_FIELD_SCHEMA_NAME };

// Gets all content items using the 'IContactSchema' generated schema interface
IEnumerable<IContactSchema> contacts =
  await contentRetriever.RetrieveContentOfReusableSchemas<IContactSchema>(schemaNames);

var schemaNames = new[] { IAddressSchema.REUSABLE_FIELD_SCHEMA_NAME,
                          ILocationSchema.REUSABLE_FIELD_SCHEMA_NAME };

// Retrieve items using Address or Location schemas from the 'Locations' workspace
var parameters = new RetrieveContentOfReusableSchemasParameters
{
    WorkspaceNames = new[] { "Locations" }
};

// Using 'IContentItemFieldsSource' as the shared type
IEnumerable<IContentItemFieldsSource> locationData =
  await contentRetriever
    .RetrieveContentOfReusableSchemas<IContentItemFieldsSource>(schemaNames, parameters);

var schemaNames = new[] { IMetadataSchema.REUSABLE_FIELD_SCHEMA_NAME };

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Assuming IMetadata is an inteface generated for 'MetadataSchema'
IEnumerable<IMetadata> oldestMetadataItems =
  await contentRetriever.RetrieveContentOfReusableSchemas<IMetadata>(
    schemaNames,
    parameters,
    query => query
                // Get the first 5
                .TopN(5),
    cacheSettings,
    configureModel: null // Use default mapping
);

// Assuming 'Author' is a generated model class for your author content items
// Gets all authors using default settings (language, preview context, etc.)
IEnumerable<Author> authors =
  await contentRetriever.RetrieveContent<Author>();

// Retrieve authors from a specific workspace
var parameters = new RetrieveContentParameters
{
    WorkspaceNames = new[] { "BlogContent" }, // Specify relevant workspace
};

IEnumerable<Author> blogAuthors =
  await contentRetriever.RetrieveContent<Author>(parameters);

// Retrieve the top 5 authors with the most articles from the 'BlogContent' workspace
var parameters = new RetrieveContentParameters
{
     WorkspaceNames = new[] { "BlogContent" }
};

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Assuming AuthorSummary is a simpler model with FullName and ArticleCount
public class AuthorSummary
{
    public string FullName { get; set; }
    public int ArticleCount { get; set; }
}

// 'TSource' set to generated model class 'Author'
// Final result `TResult` transformed and mapped to 'AuthorSummary'
IEnumerable<AuthorSummary> topAuthors = await contentRetriever.RetrieveContent<Author, AuthorSummary>(
    parameters,
    query => query
                // Select specific columns
                .Columns("FirstName", "LastName", "ArticleCount")
                // Order by count
                .OrderBy(new OrderByColumn("ArticleCount", OrderDirection.Descending))
                // Get the top 5
                .TopN(5),
    cacheSettings,
    // Example of custom mapping
    async (container, source) => new AuthorSummary
    {
        // Source is 'Author'
        FullName = $"{source.FirstName} {source.LastName}",
        ArticleCount = source.ArticleCount
    }
);

var contentTypes = new[] { Author.CONTENT_TYPE_NAME, Article.CONTENT_TYPE_NAME };

// Gets all authors and articles using default settings
// Uses 'IContentItemFieldsSource' as the shared type.
// Suitable model classes are paired with content types using
// 'RegisterContentTypeMappingAttribute' (automatically added to generated classes)
IEnumerable<IContentItemFieldsSource> blogItems =
  await contentRetriever
    .RetrieveContentOfContentTypes<IContentItemFieldsSource>(contentTypes);

foreach (var item in blogItems)
{
  switch (item)
  {
    case Author author:
      // Handle Author specific logic
      Console.WriteLine($"- Found Author: {author.DisplayName}");
      // e.g., DisplayAuthorBio(author);
      break;

    case Article article:
      // Handle Article specific logic
      Console.WriteLine($"- Found Article: {article.DisplayName}");
      // e.g., DisplayArticleSummary(article);
      break;

    default:
      break;
  }
}

var contentTypes = new[] { Author.CONTENT_TYPE_NAME, BookReview.CONTENT_TYPE_NAME };

// Retrieve authors and book reviews from the 'Reviews' workspace
var parameters = new RetrieveContentOfContentTypesParameters
{
    WorkspaceNames = new[] { "Reviews" }
};

IEnumerable<IContentItemFieldsSource> reviewContent =
  // Can use 'IContentItemFieldsSource' if no common base type
  await contentRetriever
    .RetrieveContentOfContentTypes<IContentItemFieldsSource>(contentTypes, parameters);

var contentTypes = new[] { Author.CONTENT_TYPE_NAME,
                           Article.CONTENT_TYPE_NAME,
                           Book.CONTENT_TYPE_NAME };

// Retrieve the 10 most recently modified authors, articles, or books
var parameters = new RetrieveContentOfContentTypesParameters
{
     WorkspaceNames = new[] { "MainContent", "BlogContent" } // Search multiple workspaces
};

// Disable caching
var cacheSettings = RetrievalCacheSettings.CacheDisabled;

// Assuming IContentInfo is an interface with Name and LastModified properties
IEnumerable<IContentInfo> recentContent =
  await contentRetriever.RetrieveContentOfContentTypes<IContentInfo>(
    contentTypes,
    parameters,
    query => query
                // Select specific columns
                .Columns("DisplayName", "ContentItemModifiedWhen")
                // Get the top 10
                .TopN(10),
    cacheSettings,
    configureModel: null // Use default mapping
);