Blogging Software

Part 2:Another popular option is Google's Blogger platform, which offers a robust set of features and is easily customizable.  To integrate Blogger with an ASP.NET Core C# web application, you can use the Blogger API. Code snippet in C# that demonstrates how to retrieve a list of blog posts from a Blogger account:
 

using Google.Apis.Auth.OAuth2;
using Google.Apis.Blogger.v3;
using Google.Apis.Services;
using Google.Apis.Util.Store;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;

public class BloggerService
{
    private static string[] Scopes = { BloggerService.Scope.BloggerReadonly };
    private static string ApplicationName = "My Blogger App";

    public static List GetBlogPosts(string blogId)
    {
        UserCredential credential;

        using (var stream =
            new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
        {
            string credPath = "token.json";
            credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                GoogleClientSecrets.Load(stream).Secrets,
                Scopes,
                "user",
                CancellationToken.None,
                new FileDataStore(credPath, true)).Result;
            Console.WriteLine($"Credential file saved to: {credPath}");
        }

        var service = new BloggerService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
            ApplicationName = ApplicationName,
        });

        // Define parameters of request.
        var listRequest = service.Posts.List(blogId);
        listRequest.FetchBodies = false;
        listRequest.FetchImages = false;
        listRequest.MaxResults = 10;
        listRequest.OrderBy = PostsResource.ListRequest.OrderByEnum.Published;

        // List posts.
        var posts = new List();
        var response = listRequest.Execute();
        foreach (var post in response.Items)
        {
            posts.Add(post.Title);
        }

        return posts;
    }
}

This code demonstrates how to authenticate with the Blogger API using OAuth2, create a new instance of the BloggerService class, and retrieve a list of blog post titles from a specified blog using the Posts.List() method. 
To use this code in your ASP.NET Core C# web application, you would simply call the GetBlogPosts() method and pass in your blog ID as a parameter, This will retrieve the 10 most recent blog posts from the specified blog and print their titles to the console. You can customize this code to fit your specific needs and integrate it with your web application as desired.
 

 
var posts = BloggerService.GetBlogPosts("123456789");
foreach (var post in posts)
{
    Console.WriteLine(post);
}

Part 1
There are several free blogging platforms that can be integrated with an ASP.NET Core C# web application. One of the most popular options is WordPress, which is open-source and can be easily integrated using the WordPress REST API. To get started with integrating WordPress into your ASP.NET Core C# web application, you can use the following code as a starting point: 

using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class WordPressPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

public class WordPressApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;

    public WordPressApiClient(string baseUrl)
    {
        _httpClient = new HttpClient();
        _baseUrl = baseUrl;
    }

    public async Task GetRecentPostsAsync(int count)
    {
        var url = $"{_baseUrl}/wp-json/wp/v2/posts?per_page={count}";
        var response = await _httpClient.GetAsync(url);
        var json = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject(json);
    }
}

This code defines two classes, `WordPressPost` and `WordPressApiClient`, which represent a WordPress post and a client for the WordPress REST API, respectively. The `WordPressApiClient` class provides a method `GetRecentPostsAsync` which retrieves the specified number of recent posts from a WordPress site and returns them as an array of `WordPressPost` objects. To use this code in your ASP.NET Core C# web application, you can create an instance of the `WordPressApiClient` class and call its `GetRecentPostsAsync` method to retrieve the recent posts.  

public async Task Index()
{
    var apiClient = new WordPressApiClient("https://example.wordpress.com");
    var posts = await apiClient.GetRecentPostsAsync(10);
    return View(posts);
}

This code retrieves the 10 most recent posts from a WordPress site hosted at `https://example.wordpress.com` and passes them to a view for display. You can customize the `WordPressApiClient` class to add additional functionality as needed, such as creating or editing posts.

Yes, there are several free blogging software options that can be easily integrated with an ASP.NET C# web application. Check this

1. WordPress: WordPress is a popular blogging platform that is widely used and supported. It is written in PHP, but can be easily integrated with ASP.NET using the WordPress REST API.

2. Blogger: Blogger is a free blogging platform owned by Google. It is written in Java and can be integrated with ASP.NET using the Blogger API.

3. DotNetBlogEngine: DotNetBlogEngine is an open-source blogging platform that is built with ASP.NET. It is designed to be easy to use and customize, and can be easily integrated with an existing ASP.NET web application.