I am developing a REST API with C# and .NET Core 7. In this API, I have a function in my repository that accepts a parameter of type IFormFile and in another function returns a file as a byte array,when it comes to converting a byte array to an IFormFile in C# .NET Core, we need to create a custom implementation because the IFormFile interface represents an uploaded file received in an HTTP request, and there is no built-in method to directly convert a byte array to an IFormFile.

However, we can create a custom implementation by utilizing the MemoryStream class to copy an uploaded file's behavior. 

In below code , we create a static class called IFormFileExtensions with a method ToIFormFile that extends the byte array,this method takes the byte array representing the file content and the file name as parameters and returns an IFormFile.

    using System.IO;
    using Microsoft.AspNetCore.Http;

    public static class IFormFileExtensions
        public static IFormFile ToIFormFile(this byte[] fileBytes, string fileName)
            var memoryStream = new MemoryStream(fileBytes);
            var formFile = new FormFile(memoryStream, 0, fileBytes.Length, null, fileName);
            formFile.Headers = new HeaderDictionary();
            formFile.ContentType = "application/octet-stream"; //Set the appropriate content type based on the file type
            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileName}\"";

            return formFile;

Inside the method, we create a MemoryStream from the byte array and use it to instantiate a FormFile, which implements the IFormFile interface. We then set the appropriate headers and content type for the FormFile based on the file's characteristics.

With this extension method, you can easily convert a byte array to an IFormFile and use it wherever an IFormFile is expected, such as in file uploads or processing.


Creating ASP.NET Controller to Upload and Retrieve Files

If are using Blob Storage then can have a look on that, let's create an ASP.NET controller with two endpoints: one for uploading files to Azure Blob Storage and another for retrieving files from Azure Blob Storage and returning them as IFormFile.

1. Uploading File to Azure Blob Storage:

First, we need to create a method in our controller that accepts an IFormFile, uploads it to Azure Blob Storage, and returns a URL or identifier for the uploaded file. Here's how we can achieve this:

    using Microsoft.AspNetCore.Http;
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.Blob;
    using System.IO;
    using System.Threading.Tasks;

    public class FileController : ControllerBase
        private readonly CloudBlobContainer _container;

        public FileController()
            // Initialize Azure Blob Storage connection
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse("azure-storage-connection-string");
            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
            _container = blobClient.GetContainerReference("container-name");

        public async Task UploadFile(IFormFile file)
            if (file == null || file.Length == 0)
                return BadRequest("File is empty.");

            // Create a unique name for the blob
            string blobName = $"{Path.GetFileNameWithoutExtension(file.FileName)}-{Path.GetRandomFileName()}{Path.GetExtension(file.FileName)}";

            // Get a reference to the blob
            CloudBlockBlob blob = _container.GetBlockBlobReference(blobName);

            // Upload the file to Azure Blob Storage
            using (var stream = file.OpenReadStream())
                await blob.UploadFromStreamAsync(stream);

            // Return the URL or identifier for the uploaded file
            return Ok(blob.Uri);

2. Retrieving File from Azure Blob Storage and Returning as IFormFile:

Now, let's create another endpoint in our controller that accepts a URL or identifier for a file in Azure Blob Storage, retrieves the file as a byte array, and returns it as IFormFile. 

    public async Task RetrieveFile(string blobUrl)
        // Get a reference to the blob
        CloudBlockBlob blob = new CloudBlockBlob(new System.Uri(blobUrl));

        // Download the blob as a byte array
        byte[] fileBytes;
        using (var memoryStream = new MemoryStream())
            await blob.DownloadToStreamAsync(memoryStream);
            fileBytes = memoryStream.ToArray();

        // Create IFormFile from the byte array
        var fileStream = new MemoryStream(fileBytes);
        var file = new FormFile(fileStream, 0, fileStream.Length, "file", blob.Name);

        return Ok(file);

Using these two endpoints, we can now upload files to Azure Blob Storage and retrieve them as IFormFile whenever needed.