Assuming we have a `UserProfileController` with a created endpoint for updating user profiles, which accepts a DTO containing `UserId`, `Username`, and an `IFormFile` named `UserProfilePicture`. If we receive an `IFormFile` and want to convert it to a `byte[]`, how can we achieve that?

To convert an IFormFile to byte[] in C#, there are a couple of approaches we can take, let's assume we have a UserProfileController with a created endpoint for updating user profiles, accepting a DTO with UserId, Username, and an IFormFile type UserProfilePicture. 

1.Using CopyToAsync() method:

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


public async Task<IActionResult> UpdateUserProfile(UserProfileDto userProfileDto)
{
    byte[] userProfilePictureBytes = null;

    if (userProfileDto.UserProfilePicture != null)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            await userProfileDto.UserProfilePicture.CopyToAsync(ms);
            userProfilePictureBytes = ms.ToArray();
        }
    }

   

    return Ok();
}
2.Using BinaryReader: 
using System.IO;
using Microsoft.AspNetCore.Http;


public IActionResult UpdateUserProfile(UserProfileDto userProfileDto)
{
    byte[] userProfilePictureBytes = null;

    if (userProfileDto.UserProfilePicture != null)
    {
        using (BinaryReader reader = new BinaryReader(userProfileDto.UserProfilePicture.OpenReadStream()))
        {
            userProfilePictureBytes = reader.ReadBytes((int)userProfileDto.UserProfilePicture.Length);
        }
    }

  

    return Ok(); 
}
In both approaches, we check if the UserProfilePicture is not null, then we read the data from the IFormFile into a byte[] array and this byte[] array can then be used for further storing in the database as needed.

We can create an extension method to convert an IFormFile to a byte[], so that you can use it anywhere in your application. 
public static class FormFileExtensions
{
    public static byte[] ToByteArray(this IFormFile formFile)
    {
        if (formFile == null)
            return null;

        using (var memoryStream = new MemoryStream())
        {
            formFile.CopyTo(memoryStream);
            return memoryStream.ToArray();
        }
    }
}
With this extension method, you can now easily convert an IFormFile to a byte[] like this: 
IFormFile userProfilePicture = // Get the UserProfilePicture from the request
byte[] userProfilePictureBytes = userProfilePicture.ToByteArray();
This extension method checks if the IFormFile is not null, copies its content to a MemoryStream, and then converts the MemoryStream to a byte[] array.
2

I want to convert a file into a byte array and then save the byte array into my SQL database. Instead of saving the file itself, I prefer to upload the file directly into my database. To achieve this, I only want to convert the file into a byte array without saving it separately.

Let's create a ProductController with an endpoint for creating a product , this endpoint will accept a ProductModel with properties Id, Name, Category, and a List of ProductPicture of type IFormFile.

Product Model Class:


    public class ProductModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Category { get; set; }
        public List<IFormFile> ProductPictures { get; set; }
    }

ProductController:


    using Microsoft.AspNetCore.Mvc;
    using Microsoft.AspNetCore.Http;
    using System.Collections.Generic;
    using System.Threading.Tasks;

    [ApiController]
    [Route("api/[controller]")]
    public class ProductController : ControllerBase
    {
        private readonly ProductDbContext _dbContext;

        public ProductController(ProductDbContext dbContext)
        {
            _dbContext = dbContext;
        }

        [HttpPost("create")]
        public async Task CreateProduct([FromForm] ProductModel productModel)
        {
            if (productModel == null)
            {
                return BadRequest("Product details are required.");
            }

            // save to database
            var productEntity = new Product
            {
                Id = productModel.Id,
                Name = productModel.Name,
                Category = productModel.Category
            };

            

            // ProductPictures
            if (productModel.ProductPictures != null && productModel.ProductPictures.Count > 0)
            {
                foreach (var picture in productModel.ProductPictures)
                {
                    // Convert IFormFile to byte[] and save it to the database
                    byte[] pictureBytes = picture.ToByteArray();

                    // Save pictureBytes to database
                }
            }

            // You may also want to return the created product details
            return Ok("Product created successfully.");
        }
    }

In above code, we have a ProductController with a POST endpoint at /api/product/create. We inject a ProductDbContext into the controller to interact with the database, the CreateProduct endpoint accepts a ProductModel from the form data, including Id, Name, Category, and a list of ProductPictures of type IFormFile.

Inside the endpoint, we map the ProductModel to our entity model, save it to the database, and then process the ProductPictures. For each ProductPicture, we convert the IFormFile to a byte[] using the extension method we created earlier, and save it to the database.

So we've created a ProductController with an endpoint for creating products, accepting ProductModel with IFormFile for product pictures, and handling the saving of product details and pictures to the database.

Database Code 
// Assuming you have a Product entity and a ProductPicture entity in your database model

// Product entity class
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Category { get; set; }
    public List<ProductPicture> Pictures { get; set; } = new List<ProductPicture>();
}

// ProductPicture entity class
public class ProductPicture
{
    public int Id { get; set; }
    public byte[] PictureData { get; set; }
    public int ProductId { get; set; }
    public Product Product { get; set; }
}

// Inside your ProductController, after mapping ProductModel to Product entity

// Save productEntity to database using _dbContext
_dbContext.Products.Add(productEntity);
await _dbContext.SaveChangesAsync();

// Process ProductPictures
if (productModel.ProductPictures != null && productModel.ProductPictures.Count > 0)
{
    foreach (var picture in productModel.ProductPictures)
    {
        // Convert IFormFile to byte[] and save it to the database
        byte[] pictureBytes = picture.ToByteArray();

        // Save pictureBytes to database
        var productPicture = new ProductPicture
        {
            PictureData = pictureBytes,
            ProductId = productEntity.Id // Assuming ProductId is the foreign key to relate the picture with the product
        };

        _dbContext.ProductPictures.Add(productPicture);
    }
}

await _dbContext.SaveChangesAsync();

In this code , we  have Product and ProductPicture entity classes in database model. After mapping the ProductModel to the Product entity, we add the product to the database using
_dbContext.Products.Add(productEntity) and save the changes to the database, then, for each ProductPicture in the ProductModel.
We convert the IFormFile to a byte array, create a new ProductPicture entity, set the PictureData property to the byte array, and set the ProductId to relate the picture with the product and then we add each ProductPicture to the database using _dbContext.ProductPictures.Add(productPicture) and save the changes to the database again.

Read Similar Articles