Develop REST API-based CRUD Operation using Azure Function and EF Core 7

Step 7. Now, add the below code in the Employee.cs file.

public class Employee {
  [JsonPropertyName("id")]
  public int Id {
    get;
    set;
  }

  [JsonPropertyName("code")]
  public string Code {
    get;
    set;
  }

  [JsonPropertyName("fullName")]
  public string FullName {
    get;
    set;
  }

  [JsonPropertyName("dateOfBirth")]
  public DateTime DateOfBirth {
    get;
    set;
  }

  public string ? Address {
    get;
    set;
  }
  public string ? City {
    get;
    set;
  }
  public string ? State {
    get;
    set;
  }
  public string ? PostalCode {
    get;
    set;
  }
  public string ? Country {
    get;
    set;
  }
  public string ? PhoneNo {
    get;
    set;
  }
  public string EmailId {
    get;
    set;
  }
  public DateTime JoiningDate {
    get;
    set;
  }
}

Step 8: Now, open the already created function file and add the below code to that file. This part of the code is used to retrieve all records from the Employee Table.

public class FnGetEmployees {
  private readonly ILogger _logger;

  public FnGetEmployees(ILoggerFactory loggerFactory) {
    _logger = loggerFactory.CreateLogger < FnGetEmployees > ();
  }

  [Function("GetEmployees")]
  public async Task < List < Employee >> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetEmployees")] HttpRequestData req) {
    var _employee = new List < Employee > ();
    try {
      using(SqlConnection connection = new SqlConnection(Environment.GetEnvironmentVariable("DBConnections"))) {
        connection.Open();
        var query = @ "Select * from Employees";
        SqlCommand command = new SqlCommand(query, connection);
        var reader = await command.ExecuteReaderAsync();
        while (reader.Read()) {
          Employee employee = new Employee() {
            Id = Convert.ToInt32(reader["Id"]),
              Code = Convert.ToString(reader["Code"]),
              FullName = Convert.ToString(reader["FullName"]),
              DateOfBirth = Convert.ToDateTime(reader["DOB"]),
              Address = Convert.ToString(reader["Address"]),
              City = Convert.ToString(reader["City"]),
              State = Convert.ToString(reader["State"]),
              Country = Convert.ToString(reader["Country"]),
              PostalCode = Convert.ToString(reader["PostalCode"]),
              EmailId = Convert.ToString(reader["EmailId"]),
              PhoneNo = Convert.ToString(reader["PhoneNo"]),
              JoiningDate = Convert.ToDateTime(reader["JoiningDate"])
          };
          _employee.Add(employee);
        }
      }
    } catch (Exception e) {
      _logger.LogError(e.ToString());
    }

    return _employee;
  }
}

Step 9. Now, run the applications and check the API Endpoints.

Step 10. Now, simply copy that API End Points and either run it by using any browser (as it is a GET API, we can using paste the URL in the browser and can check the output) or in the Postman.

Step 11. Now, Add another new function called FnCreateEmployee and add the below code.

public class FnCreateEmployee {
  private readonly ILogger _logger;

  public FnCreateEmployee(ILoggerFactory loggerFactory) {
    _logger = loggerFactory.CreateLogger < FnCreateEmployee > ();
  }

  [Function("CreateEmployee")]
  public async Task < IActionResult > Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req) {
    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var _input_data = JsonConvert.DeserializeObject < Employee > (requestBody);

    try {
      using(SqlConnection connection = new SqlConnection(Environment.GetEnvironmentVariable("DBConnections"))) {
        connection.Open();
        if (!string.IsNullOrEmpty(_input_data.Code)) {
          var query = $ "INSERT INTO [dbo].[Employees] ([Code],[FullName],[DOB],[Address],[City],[State],[Country],[PostalCode],[EmailId],[PhoneNo],[JoiningDate]) VALUES (" +
            $ "'{_input_data.Code}'," +
            $ "'{_input_data.FullName}'," +
            $ "'{_input_data.DateOfBirth}'," +
            $ "'{_input_data.Address}'," +
            $ "'{_input_data.City}'," +
            $ "'{_input_data.State}'," +
            $ "'{_input_data.Country}'," +
            $ "'{_input_data.PostalCode}'," +
            $ "'{_input_data.EmailId}'," +
            $ "'{_input_data.PhoneNo}'," +
            $ "'{_input_data.JoiningDate}')";
          SqlCommand command = new SqlCommand(query, connection);
          command.ExecuteNonQuery();
        }
      }
    } catch (Exception e) {
      _logger.LogError(e.ToString());
      return new ObjectResult(e.ToString());
    }
    return new OkObjectResult(HttpStatusCode.OK);
  }
}

Step 12: Now, run the Application and execute the Create Employee endpoints from the Postman.

Implement EF Core 7 within the Azure Functions

Now, in the above example, we used SqlDataClient to communicate with the SQL Server database to retrieve or save operations. Now, in this part, we will use the Entity Framework Core 7.0 for the same purpose. So, for that purpose, first, we need to install the Entity Framework Core-related NuGet Packages from NuGet Package Manager –

• Microsoft.EntityFrameworkCore
• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools

Now, after installing the above nuget packages, Create a folder called DataAccessLayer, and then within that folder, add a new file called SQLDBContext and add the below code there.

public partial class SQLDBContext: DbContext {
  public SQLDBContext() {}

  public SQLDBContext(DbContextOptions < SQLDBContext > options): base(options) {}

  public virtual DbSet < Employee > Employees {
    get;
    set;
  }

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {

  }

  protected override void OnModelCreating(ModelBuilder modelBuilder) {

  }
}

Now, open the already existing FnGetEmployees function and replace the existing code with the below one.

public class FnGetEmployees {
  private readonly ILogger _logger;
  private readonly HttpClient _httpClient;

  public FnGetEmployees(ILoggerFactory loggerFactory) {
    _logger = loggerFactory.CreateLogger < FnGetEmployees > ();
  }

  [Function("GetEmployees")]
  public async Task < List < Employee >> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetEmployees")] HttpRequestData req) {
    var _employee = new List < Employee > ();
    try {
      string defaultConnection = Environment.GetEnvironmentVariable("DBConnections");

      _logger.LogInformation(defaultConnection);
      var options = new DbContextOptionsBuilder < SQLDBContext > ();
      options.UseSqlServer(defaultConnection);

      var _dbContext = new SQLDBContext(options.Options);

      _employee = await _dbContext.Employees.ToListAsync();
    } catch (Exception e) {
      _logger.LogError(e.ToString());
    }

    return _employee;
  }
}

Now, in the same way, will change the implementation of Employee Create functions as below.

public class FnCreateEmployee {
  private readonly ILogger _logger;

  public FnCreateEmployee(ILoggerFactory loggerFactory) {
    _logger = loggerFactory.CreateLogger < FnCreateEmployee > ();
  }

  [Function("CreateEmployee")]
  public async Task < IActionResult > Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req) {
    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var _input_data = JsonConvert.DeserializeObject < Employee > (requestBody);

    try {

      string defaultConnection = Environment.GetEnvironmentVariable("DBConnections");
      var options = new DbContextOptionsBuilder < SQLDBContext > ();
      options.UseSqlServer(defaultConnection);

      var _dbContext = new SQLDBContext(options.Options);

      _dbContext.Employees.Add(_input_data);
      await _dbContext.SaveChangesAsync();

    } catch (Exception e) {
      _logger.LogError(e.ToString());
      return new ObjectResult(e.ToString());
    }
    return new OkObjectResult(HttpStatusCode.OK);
  }
}

Now, we can use the Application and test the API endpoints by using Postman.

Conclusion

This article discusses how to develop REST APIs for CRUD operations using Azure Function. Also, we discussed the steps related to the implementation of Entity Framework Core 7 in Azure Function. Any suggestions, feedback, or queries related to this article are welcome.