DEV Community: Code Today

What are ACC your favorite use cases for extension methods?

Code Today — Wed, 22 Jan 2025 19:10:38 +0000

Why and When to Use Extension Methods

Extension methods are incredibly versatile and can be used in various scenarios:

Utility Functions: Create helper methods for common operations, such as string manipulations or date calculations.

Framework Integration: Add functionality to types from external libraries without modifying their source code.

Improved Readability: Make your code more expressive and easier to understand by encapsulating logic in extension methods.

When Not to Use Extension Methods

Excessive Logic: Avoid adding complex logic or functionality that would be better suited to a dedicated class or method.

Code Clarity: Overuse of extension methods can make code harder to follow, especially for developers unfamiliar with the custom methods.

Dependency on Internal Details: Avoid writing extension methods that rely on the internal implementation details of a class, as they can break with updates to the class.

using Microsoft.AspNetCore.Identity;
using System.Threading.Tasks;

namespace PetShopSimulation.BLL.Services
{
    public class AccountService
    {
        private readonly UserManager<AppUser> _userManager;
        private readonly SignInManager<AppUser> _signInManager;
        private readonly RoleManager<IdentityRole> _roleManager;
        private readonly IMapper _mapper;

        public AccountService(UserManager<AppUser> userManager, SignInManager<AppUser> signInManager, RoleManager<IdentityRole> roleManager, IMapper mapper)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _roleManager = roleManager;
            _mapper = mapper;
        }

        public async Task<IdentityResult> RegisterUserAsync(RegisterDto dto)
        {
            var user = _mapper.Map<AppUser>(dto);
            return await _userManager.CreateAsync(user, dto.Password);
        }

        public async Task<SignInResult> LoginUserAsync(LoginDto dto)
        {
            AppUser user = dto.UsernameOrEmail.Contains("@")
                ? await _userManager.FindByEmailAsync(dto.UsernameOrEmail)
                : await _userManager.FindByNameAsync(dto.UsernameOrEmail);

            if (user == null) return SignInResult.Failed;

            return await _signInManager.CheckPasswordSignInAsync(user, dto.Password, true);
        }

        public async Task SignInUserAsync(AppUser user, bool rememberMe)
        {
            await _signInManager.SignInAsync(user, rememberMe);
        }

        public async Task SignOutUserAsync()
        {
            await _signInManager.SignOutAsync();
        }

        public async Task CreateRolesAsync()
        {
            foreach (var item in Enum.GetValues(typeof(UserRole)))
            {
                if (!await _roleManager.RoleExistsAsync(item.ToString()))
                {
                    await _roleManager.CreateAsync(new IdentityRole
                    {
                        Name = item.ToString()
                    });
                }
            }
        }
    }
}

Best Practices for Writing Extensions

To make the most of extension methods, follow these guidelines:

Keep It Simple
Extension methods should perform a single, well-defined task. Avoid overloading them with too much logic.

Ensure Compatibility
Use extension methods for functionality that is universally applicable to the type. Avoid adding niche behavior that’s only relevant in specific contexts.

Handle Null Gracefully
Always consider null inputs to avoid runtime exceptions. Include checks to ensure that the method behaves predictably when invoked on null references.

Avoid Overuse
Don’t overuse extension methods to add trivial functionality. Reserve them for methods that add significant value or improve readability.

Name Methods Intuitively
Choose method names that clearly describe their purpose to improve code readability.

using PetShopSimulation.BLL.Services;

namespace PetShopSimulation.Controllers
{
    public class AccountController : Controller
    {
        private readonly AccountService _accountService;
        private readonly IMapper _mapper;

        public AccountController(AccountService accountService, IMapper mapper)
        {
            _accountService = accountService;
            _mapper = mapper;
        }

        public IActionResult Register()
        {
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Register(RegisterDto dto)
        {
            if (!ModelState.IsValid) return View();

            var result = await _accountService.RegisterUserAsync(dto);

            if (!result.Succeeded)
            {
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error.Description);
                }
                return View();
            }

            return RedirectToAction("Login", "Account");
        }

        public IActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Login(LoginDto dto, string? returnUrl = null)
        {
            if (!ModelState.IsValid)
            {
                ModelState.AddModelError("", "Invalid login details.");
                return View();
            }

            var result = await _accountService.LoginUserAsync(dto);

            if (!result.Succeeded)
            {
                ModelState.AddModelError("", "Invalid username or password.");
                return View();
            }

            var user = await _accountService.FindUserByUsernameOrEmailAsync(dto.UsernameOrEmail);
            await _accountService.SignInUserAsync(user, dto.Remember);

            return returnUrl != null ? Redirect(returnUrl) : RedirectToAction("Index", "Home");
        }

        public async Task<IActionResult> Logout()
        {
            await _accountService.SignOutUserAsync();
            return RedirectToAction("Index", "Home");
        }

        public async Task<IActionResult> CreateRole()
        {
            await _accountService.CreateRolesAsync();
            return Ok();
        }
    }
}

What Are .NET PO Extension Methods?

Code Today — Wed, 22 Jan 2025 19:07:02 +0000

For example, you can add a ToTitleCase method to the string class to convert a sentence into title case without altering the string class itself.

How to Create an Extension Method

Creating an extension method is straightforward. Here’s a step-by-step guide:

Define a Static Class
The class that holds your extension methods must be static.

Write a Static Method
The method itself must be static and take the type you want to extend as the first parameter, prefixed with the this keyword.

using Microsoft.EntityFrameworkCore;
using PetShopSimulation.DAL.Repositories.Ports;
using System.Linq.Expressions;

namespace PetShopSimulation.DAL.Repositories
{
    public class PositionRepository : IRepository<Position>
    {
        private readonly SafeCamDbContext _context;

        public PositionRepository(SafeCamDbContext context)
        {
            _context = context;
        }

        public DbSet<Position> Table => _context.Positions;

        public async Task<Position?> GetByIdAsync(int id, params Expression<Func<Position, object>>[] includes)
        {
            IQueryable<Position> query = Table;
            foreach (var include in includes)
            {
                query = query.Include(include);
            }
            return await query.FirstOrDefaultAsync(x => x.Id == id);
        }

        public IQueryable<Position> GetAll(params Expression<Func<Position, object>>[] includes)
        {
            IQueryable<Position> query = Table;
            foreach (var include in includes)
            {
                query = query.Include(include);
            }
            return query;
        }

        public async Task<Position> AddAsync(Position entity)
        {
            await Table.AddAsync(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task UpdateAsync(Position entity)
        {
            Table.Update(entity);
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(Position entity)
        {
            Table.Remove(entity);
            await _context.SaveChangesAsync();
        }
    }
}

Best Practices for Writing Extensions

To make the most of extension methods, follow these guidelines:

Keep It Simple
Extension methods should perform a single, well-defined task. Avoid overloading them with too much logic.

Ensure Compatibility
Use extension methods for functionality that is universally applicable to the type. Avoid adding niche behavior that’s only relevant in specific contexts.

Handle Null Gracefully
Always consider null inputs to avoid runtime exceptions.

Name Methods Intuitively
Choose method names that clearly describe their purpose to improve code readability.

using System.Linq.Expressions;

namespace PetShopSimulation.BLL.Services
{
    public class PositionService
    {
        private readonly IRepository<Position> _repository;

        public PositionService(IRepository<Position> repository)
        {
            _repository = repository;
        }

        public async Task<IEnumerable<Position>> GetAllPositionsAsync()
        {
            return await _repository.GetAll().ToListAsync();
        }

        public async Task<Position?> GetPositionByIdAsync(int id)
        {
            return await _repository.GetByIdAsync(id);
        }

        public async Task AddPositionAsync(PositionCreateDto dto, IMapper mapper)
        {
            var position = mapper.Map<Position>(dto);
            await _repository.AddAsync(position);
        }

        public async Task UpdatePositionAsync(PositionUpdateDto dto, IMapper mapper)
        {
            var position = mapper.Map<Position>(dto);
            await _repository.UpdateAsync(position);
        }

        public async Task DeletePositionAsync(int id)
        {
            var position = await _repository.GetByIdAsync(id);
            if (position == null)
            {
                throw new NotPositionException();
            }
            await _repository.DeleteAsync(position);
        }
    }
}

Why and When to Use Extension Methods

Extension methods are incredibly versatile and can be used in various scenarios:

Utility Functions: Create helper methods for common operations, such as string manipulations or date calculations.

Framework Integration: Add functionality to types from external libraries without modifying their source code.

Improved Readability: Make your code more expressive and easier to understand by encapsulating logic in extension methods.

using PetShopSimulation.BLL.Services;

namespace PetShopSimulation.Controllers
{
    public class PositionController : Controller
    {
        private readonly PositionService _service;
        private readonly IMapper _mapper;

        public PositionController(PositionService service, IMapper mapper)
        {
            _service = service;
            _mapper = mapper;
        }

        public async Task<IActionResult> Index()
        {
            var positions = await _service.GetAllPositionsAsync();
            return View(positions);
        }

        [HttpGet]
        public IActionResult Create()
        {
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Create(PositionCreateDto dto)
        {
            if (!ModelState.IsValid) return View();

            await _service.AddPositionAsync(dto, _mapper);
            return RedirectToAction("Index");
        }

        [HttpGet]
        public async Task<IActionResult> Update(int id)
        {
            var position = await _service.GetPositionByIdAsync(id);
            if (position == null) throw new NotPositionException();

            var positionDto = _mapper.Map<PositionUpdateDto>(position);
            return View(positionDto);
        }

        [HttpPost]
        public async Task<IActionResult> Update(PositionUpdateDto dto)
        {
            if (!ModelState.IsValid) return View(dto);

            await _service.UpdatePositionAsync(dto, _mapper);
            return RedirectToAction("Index");
        }

        [HttpPost]
        public async Task<IActionResult> Delete(int id)
        {
            await _service.DeletePositionAsync(id);
            return RedirectToAction("Index");
        }
    }
}

Mastering .NET Extension AG Methods: Simplify Your Code Like a Pro

Code Today — Wed, 22 Jan 2025 19:02:34 +0000

Extension methods in .NET are a powerful feature that allows you to add new methods to existing types without modifying their source code or creating a new derived type. They enable you to write cleaner, more readable, and reusable code. In this article, we’ll dive into the world of extension methods, learn how to create them, and explore best practices and real-world examples.

public class AgentRepository : IAgentRepository
{
    private readonly SafeCamDbContext _context;

    public AgentRepository(SafeCamDbContext context)
    {
        _context = context;
    }

    public async Task<List<Agent>> GetAllAgentsAsync()
    {
        return await _context.Agents.Include(x => x.Positions).ToListAsync();
    }

    public async Task<List<Position>> GetAllPositionsAsync()
    {
        return await _context.Positions.ToListAsync();
    }

    public async Task<Agent> GetAgentByIdAsync(int id)
    {
        return await _context.Agents.FirstOrDefaultAsync(x => x.Id == id);
    }

    public async Task AddAgentAsync(Agent agent)
    {
        await _context.Agents.AddAsync(agent);
        await _context.SaveChangesAsync();
    }

    public async Task UpdateAgentAsync(Agent agent)
    {
        _context.Agents.Update(agent);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteAgentAsync(Agent agent)
    {
        _context.Agents.Remove(agent);
        await _context.SaveChangesAsync();
    }
}

What Are .NET Extension Methods?

Extension methods are static methods that can be invoked as if they were instance methods of the extended type. They’re particularly useful for:

Reducing code duplication.

Enhancing readability.

Adding utility methods to types you don’t own (e.g., framework types).

For example, you can add a ToTitleCase method to the string class to convert a sentence into title case without altering the string class itself.

public class AgentService : IAgentService
{
    private readonly IAgentRepository _agentRepository;
    private readonly IMapper _mapper;
    private readonly IWebHostEnvironment _env;

    public AgentService(IAgentRepository agentRepository, IMapper mapper, IWebHostEnvironment env)
    {
        _agentRepository = agentRepository;
        _mapper = mapper;
        _env = env;
    }

    public async Task<List<Agent>> GetAllAgentsAsync()
    {
        return await _agentRepository.GetAllAgentsAsync();
    }

    public async Task<List<Position>> GetAllPositionsAsync()
    {
        return await _agentRepository.GetAllPositionsAsync();
    }

    public async Task<ServiceResult> CreateAgentAsync(AgentCreateDto dto)
    {
        if (dto.File == null || !dto.File.ContentType.Contains("image") || dto.File.Length > 2 * 1024 * 1024)
        {
            return new ServiceResult { Success = false, Message = "Invalid file." };
        }

        dto.ImgUrl = dto.File.Upload(_env.WebRootPath, "\Upload\Agents\");
        var agent = _mapper.Map<Agent>(dto);
        await _agentRepository.AddAgentAsync(agent);
        return new ServiceResult { Success = true };
    }

    public async Task<AgentUpdateDto> GetAgentForUpdateAsync(int id)
    {
        var agent = await _agentRepository.GetAgentByIdAsync(id);
        return agent == null ? null : _mapper.Map<AgentUpdateDto>(agent);
    }

    public async Task<ServiceResult> UpdateAgentAsync(AgentUpdateDto dto)
    {
        var agent = await _agentRepository.GetAgentByIdAsync(dto.PositionId);
        if (agent == null)
        {
            return new ServiceResult { Success = false, Message = "Agent not found." };
        }

        if (dto.File != null)
        {
            if (!dto.File.ContentType.Contains("image"))
            {
                return new ServiceResult { Success = false, Message = "Invalid file type." };
            }

            if (!string.IsNullOrEmpty(agent.ImgUrl))
            {
                FileExtension.DeleteFile(_env.WebRootPath, "\Upload\Agents\", agent.ImgUrl);
            }

            agent.ImgUrl = dto.File.Upload(_env.WebRootPath, "\Upload\Agents\");
        }

        agent.Name = dto.Name;
        await _agentRepository.UpdateAgentAsync(agent);

        return new ServiceResult { Success = true };
    }

    public async Task<bool> DeleteAgentAsync(int id)
    {
        var agent = await _agentRepository.GetAgentByIdAsync(id);
        if (agent == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(agent.ImgUrl))
        {
            FileExtension.DeleteFile(_env.WebRootPath, "\Upload\Agents\", agent.ImgUrl);
        }

        await _agentRepository.DeleteAgentAsync(agent);
        return true;
    }
}

How to Create an Extension Method

Creating an extension method is straightforward. Here’s a step-by-step guide:

Define a Static Class
The class that holds your extension methods must be static.

Write a Static Method
The method itself must be static and take the type you want to extend as the first parameter, prefixed with the this keyword.

public class AgentController : Controller
{
    private readonly IAgentService _agentService;

    public AgentController(IAgentService agentService)
    {
        _agentService = agentService;
    }

    public async Task<IActionResult> Index()
    {
        var agents = await _agentService.GetAllAgentsAsync();
        return View(agents);
    }

    [HttpGet]
    public async Task<IActionResult> Create()
    {
        ViewBag.Positions = await _agentService.GetAllPositionsAsync();
        return View();
    }

    [HttpPost]
    public async Task<IActionResult> Create(AgentCreateDto dto)
    {
        if (!ModelState.IsValid)
        {
            ViewBag.Positions = await _agentService.GetAllPositionsAsync();
            return View(dto);
        }

        var result = await _agentService.CreateAgentAsync(dto);

        if (!result.Success)
        {
            ModelState.AddModelError("File", result.Message);
            ViewBag.Positions = await _agentService.GetAllPositionsAsync();
            return View(dto);
        }

        return RedirectToAction("Index");
    }

    [HttpGet]
    public async Task<IActionResult> Update(int id)
    {
        var dto = await _agentService.GetAgentForUpdateAsync(id);
        if (dto == null)
        {
            return NotFound();
        }

        ViewBag.Positions = await _agentService.GetAllPositionsAsync();
        return View(dto);
    }

    [HttpPost]
    public async Task<IActionResult> Update(AgentUpdateDto dto)
    {
        if (!ModelState.IsValid)
        {
            ViewBag.Positions = await _agentService.GetAllPositionsAsync();
            return View(dto);
        }

        var result = await _agentService.UpdateAgentAsync(dto);

        if (!result.Success)
        {
            ModelState.AddModelError("File", result.Message);
            ViewBag.Positions = await _agentService.GetAllPositionsAsync();
            return View(dto);
        }

        return RedirectToAction("Index");
    }

    [HttpDelete]
    public async Task<IActionResult> Delete(int id)
    {
        var success = await _agentService.DeleteAgentAsync(id);
        if (!success)
        {
            return NotFound();
        }

        return RedirectToAction("Index");
    }
}

.NET extension methods are a simple yet powerful tool for writing cleaner and more maintainable code. By following best practices and leveraging them effectively, you can enhance the functionality of existing types and improve the overall quality of your projects.

What are your favorite use cases for extension methods? Share your thoughts in the comments below!

    public interface IRepository<TEntity> where TEntity : BaseEntity, new()
    {
        DbSet<TEntity> Table { get; }

        Task<TEntity?> GetByIdAsync(int id, params Expression<Func<TEntity, object>>[] includes);
        IQueryable<TEntity> GetAll(params Expression<Func<TEntity, object>>[] includes);
        IQueryable<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate, params Expression<Func<TEntity, object>>[] includes);

        Task<TEntity> AddAsync(TEntity entity);
        Task UpdateAsync(TEntity entity);
        Task DeleteAsync(TEntity entity);
    }