Aggregation is when an object is made up of one or more objects, but those objects can live outside the main object. It defines the has-a relationship.
Note: In the aggregation, if main object is destroyed, its aggregated objects may still live.
Example #1: A Library is an aggregation of Books. Books can live without the library.
Example #2: A Department is an aggregation of Employees. If department closes, the Employees can exist on their own.
Composition is when your class is composed of one or more objects from other classes. A simple example is a Car composed of Engine and Wheel objects. Inheritance defines an “is-a” relationship, while composition defines a “has-a” relationship.
For example, Dog is-a Animal, and Circle is-a Shape. It defines inheritance.
This makes sense because you want to reuse all the features of Animal (eat, sleep, walk, makeNoise) in the Dog class. Cow is-a Animal too, so Cow can also inherit the Animal class. Since cows and dogs make different noises and eat different things, we have to redefine or override the makeNoise() and eat() methods in the Dog and Cow classes. The point is when we want to reuse the functionality of a class and also want subtype polymorphism (Dog and Cow are subtypes of Animal), then we must use inheritance.
The Dependency Inversion Principle states that:
Source: Wikipedia
Other SOLID Principles
public class UserRepository
{
public string GetUserById(int id)
{
// Code to fetch user from the database
return "User";
}
}
public class UserService
{
private readonly UserRepository _userRepository;
public UserService()
{
_userRepository = new UserRepository();
}
public string GetUser(int id)
{
return _userRepository.GetUserById(id);
}
}
One problem with this code is , theUserService is tightly coupled with the UserRepository. Another problem is, if you want to use different implementation of UserReposoitory, you can not easily do it. For instance you want to swap your UserRepsoitory to UserRepositoryWithDifferentDatabase.
📢 Clients should not be forced to depend on interfaces they do not use.
In simpler terms, this principle suggests that an interface should not include methods that implementing classes don’t need. It Encourages us to create smaller interfaces over the big fat interface.
Other SOLID principles
Imagine you have an interface for workers in a company:
[Read More]
The Liskov Substitution Principle states that a derived type should be completely replaceable for its base type.
In simpler terms, a child class should do at least what the parent class can do. The child class can have additional behaviors, but it must have all the behaviors that the parent class has.
For instance, an Animal has behaviors (eat, sleep, makeSound). A Dog, which is a subtype of Animal, must have all the behaviors (eat, sleep, makeSound).
[Read More]
The Open-Closed Principle is one of the five SOLID principles. It states that a class should be open for extension but closed for modification. In other words, you should be able to add new functionality without changing existing code.
Once you have written your class, it should not be modified in the future. However, this doesn’t mean you cannot modify your class during early development stages. It means that once your application or software is in production and you want to introduce the new functionality, you should extend that class rather than modifying it.
[Read More]
The Single Responsibility Principle (SRP) is a cornerstone of object-oriented design, closely associated with the SOLID principles. It emphasizes that a class should have only one reason to change, meaning it should have a single responsibility or purpose.
The principle asserts that a class should do only one thing and do it very well. This doesn’t imply that a class should have only one method or behavior, but rather that it should contain a cohesive set of behaviors related to a single responsibility.
[Read More]
Upload images in .net core apis
In this article, we will learn how to upload/update/delete/read images in .net core APIs. I hate to give long and unnecessary intros, So let’s come to the point’s.
💻 You can get the code from this github repo.
When you upload the image (or any file), we will generate the unique image name with it’s extension (eg. uniquename.png). Save the image name in the database and save the file with the same name inside the project. In production apps, you can not simply upload files to the server, you have to give permission to that folder. Or you can use other file storage service, where you will save your files.
[Read More]
Let’s take a look at the program.cs file below.
using InventoryMgt.Api.Middlewares;
using InventoryMgt.Data.Repositories;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddTransient<ICategoryRepository, CategoryRepository>();
builder.Services.AddTransient<IProductRepository, ProductRepository>();
builder.Services.AddTransient<IPurchaseRepository, PurchaseRepository>();
builder.Services.AddTransient<IStockRepository, StockRepository>();
builder.Services.AddTransient<ISaleRepository, SaleRepository>();
builder.Services.AddTransient<ExceptionMiddleware>();
builder.Services.AddCors(options =>
{
options.AddDefaultPolicy(policy =>
{
policy.WithOrigins("*").AllowAnyHeader().AllowAnyMethod().WithExposedHeaders("X-Pagination");
});
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseCors();
app.UseAuthorization();
app.ConfigureExceptionMiddleware();
app.MapControllers();
app.Run();
It is a regular program.cs file. Since we use the dependency injection in our application, we have to register lots of service in our program.cs file. For example:
[Read More]
In C#, a private constructor is a constructor method declared with the private access modifier (or without mentioning any modifier). If a class have only a private constructor and does not have any public constructor, then you are not able to create the instance of a class. Example 👇
public class Student
{
Student() { } // private constructor
}
public class Program
{
static void Main()
{
Student stu = new(); //Error CS0122 'Student.Student()'
// is inaccessible due to its protection level
}
}
When you try to create the instance of stu, you will the following error.
[Read More]