In ASP.NET Core, MIME types (also known as media types) define how the server interprets and serves different file formats to clients. While the framework includes default mappings for common extensions like .css, .js, and .jpg, custom or less common file types oftan require explicit configuration.

Configuring Static File MIME Types

To serve static assets with custom MIME types, customize the StaticFileMiddleware by providing a custom IContentTypeProvider. Start by ensuring the Microsoft.AspNetCore.StaticFiles package is referenced in your project.

In Program.cs (or Startup.cs in older versions), configure the middleware as follows:

app.UseStaticFiles(new StaticFileOptions
{
    ContentTypeProvider = new FileExtensionContentTypeProvider()
    {
        Mappings =
        {
            [".dat"] = "application/octet-stream",
            [".log"] = "text/plain",
            [".bin"] = "application/x-binary",
            [".tpl"] = "text/template"
        }
    }
});

This approach allows you to extend or override the built-in mappings without replacing the entire provider. The FileExtensionContentTypeProvider retains all default mappings and only adds or modifies the ones you specify.

Returning Custom MIME Types in API Responses

When building REST APIs, you may need to return non-standard content such as configuration files, serialized data, or custom binary formats. Use FileContentResult or ContentResult to explicitly set the response content type.

Example using FileContentResult to deliver a binary file:

[HttpGet("download/{filename}")]
public IActionResult DownloadFile(string filename)
{
    var filePath = Path.Combine("uploads", filename);
    
    if (!System.IO.File.Exists(filePath))
        return NotFound();

    var fileBytes = System.IO.File.ReadAllBytes(filePath);
    var mimeType = GetMimeTypeByExtension(Path.GetExtension(filename));

    return File(fileBytes, mimeType, filename);
}

For plain text or structured content, use ContentResult:

[HttpGet("config")]
public IActionResult GetConfiguration()
{
    var configContent = "{ \"version\": \"1.0\", \"mode\": \"dev\" }";
    return Content(configContent, "application/json; charset=utf-8");
}

Dynamic MIME Type Resolution

For applications handling arbitrary file uploads or unknown extensions, consider using a dedicated MIME type detection library. While ASP.NET Core provides basic extension-based mapping via FileExtensionContentTypeProvider, it lacks robust detection based on file content.

For enhanced accuracy, integrate a third-party library like MimeTypes (via NuGet) or use the System.Net.Mime namespace in combination with file signature analysis:

public static string GetMimeTypeByExtension(string extension)
{
    if (MimeTypes.MimeTypeMap.TryGetMimeType(extension, out var mimeType))
        return mimeType;

    // Fallback for unknown extensions
    return "application/octet-stream";
}

Alternatively, leverage file headers (magic numbers) for content-based detection using libraries such as FileSignatures, which analyze the first few bytes of a file to determine its true type—useful when extension information is unreliable or missing.