Is this you? As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.
Claim your profile
Articles by Assis Zang
How to Model Money in ASP.NET Core
Working with monetary values in C# seems simple until improper implementation introduces rounding errors, inconsistencies and financial losses that are difficult to detect. Learn best practices for coding financial systems in ASP.NET Core. Imagine you need to implement a new financial module where money is the system’s core entity: payments, reimbursements, recurring fees, discounts, interest and taxes all involve it daily. At first glance, the implementation seems simple.
Understanding Race Conditions in ASP.NET Core
Explore the concept of race conditions in ASP.NET Core, understand how to identify them in practice and learn strategies to protect applications against this type of issue. Two requests arrive at your application at the exact same moment. Both read the same data, both attempt to update it, and everything appears to work correctly. Yet one update silently overwrites the other. This is a classic race condition.
Creating a Production-Ready CRUD Application in ASP.NET Core
Are you a beginner looking to create a portfolio to impress recruiters? Or perhaps an experienced developer looking to build better basic apps ready to evolve? Learn how to create a CRUD application in ASP.NET Core that goes beyond the basics and has everything you need to stand out in the real world. In this post, you’ll learn how to structure an ASP.NET Core project following CRUD best practices, even when the premise is simple.
Best Practices for Exceptions in ASP.NET Core
Exceptions are a common approach to dealing with unexpected situations. But are they truly necessary? Let’s see some best practices for using them in ASP.NET Core. Exceptions have been part of the .NET ecosystem since the earliest versions of the .NET Framework. Today, with the platform’s continuous evolution, their use is simpler and more integrated than ever. The problem, however, arises when they are used inappropriately or imprecisely.
Practicing Vertical Slice Architecture in ASP.NET Core
Tired of organizing code through technical layers? How about going beyond the basics and “slicing” the system? Vertical Slice Architecture structures the application not by the type of code to be written, but by the problem to be solved. Let’s learn how to implement it in ASP.NET Core. If you’ve ever created an API in ASP.NET Core using the classic approach of dividing it into Controllers, Services and Repositories, you’ve probably faced some difficulties in creating the necessary structure.
Learn about error-prone domain validations in ASP.NET Core and how to correctly model them. In ASP.NET Core applications, developers often underestimate the importance of validating objects and classes. An if statement in the controller, a FluentValidation in the request or some DataAnnotations in the model, and that’s it. The problem is that, if care isn’t taken when implementing domain validations, responsibility ends up leaking, which can compromise the entire system’s evolution.
Creating a super-efficient Valid Palindrome algorithm in C#
First, do you know what a Palindrome is? No? So, according to the first Google result: A palindrome is a word, phrase, number, or sequence that reads the same backward as forward. The term originates from the Greek word "palindromos", meaning "running back again". Secondly, are you able to verify whether a string is a valid palindrome in an algorithm created with C#? This is the problem we're going to solve todayð«¡.
Creating More Realistic Tests with In-Memory Databases in ASP.NET Core
Testing ASP.NET Core APIs with in-memory SQLite and JustMock enables validation of real-world scenarios like pagination, keys and rules without a real database. Testing a web API involves much more than simply checking whether methods return or send data correctly. It requires validating real-world behaviors like pagination, unique keys, data persistence and other database rules.
How to Organize Minimal APIs
Minimal APIs arrived with .NET 6 and now, in Version 10, are already part of the daily routine for many developers. In this post, we'll explore best practices for organizing your Minimal APIs and see how Carter can help make them even cleaner, more modular and more elegant. In contrast to traditional Controller classes, minimal APIs offer a more compact way to create web APIs. The downside of this approach is that the Program class can quickly become bloated.
Building a RAG in ASP.NET Core
RAG is a technique that enhances language models by integrating them with internal knowledge sources. In this post, you’ll understand the concept of RAG and learn how to implement it in an ASP.NET Core application, exploring a practical, real-world scenario. The use of artificial intelligence has become increasingly common in web applications, so it’s important to consider how to optimize the use of AI via large language models (LLMs) for efficiency and cost reduction.
Building Resilient APIs with the Retry Pattern
Sending and receiving data is the essence of any web API. But what happens when something goes wrong and communication fails? To avoid unexpected issues and enable greater resilience, we can use the Retry Pattern. Learn how to implement this pattern in ASP.NET Core to make your APIs more reliable.
What’s New in .NET 10 for ASP.NET Core
.NET 10 brings significant changes to ASP.NET Core. In this post, we'll review some of the main changes, covering practical, everyday examples and the contexts in which they best fit. .NET 10 has arrived, bringing important improvements to ASP.NET Core with a focus on efficiency and productivity.
Architectural & Practical Approach
Microservices provide flexibility, scalability and independence when managing systems that require decentralized resources. But how do these qualities translate into practice? Let’s explore microservices from an architectural perspective and build a feedback microservice from scratch in ASP.NET Core. In a technology-driven and highly consumer-oriented world, using classic approaches like monoliths isn’t always the best choice.
How to Use DDD for More Sustainable Systems
Learn how to identify the problematic anemic model and transform it into a rich model that exposes your intentions and is aligned with the principles of domain-driven design. Domain-driven design (DDD) is an approach to creating complex software that is at the same time cohesive, efficient and easy to maintain. DDD explores several areas and relevant subjects to help developers achieve their goals when developing sustainable applications.
Automating Tasks with Quartz.NET
Quartz enables flexible task scheduling in .NET applications, making it ideal for systems that require automation, such as notifications, report generation and periodic synchronization. In this post, we'll build a job for periodic history-cleaning with Quartz. Running repetitive routines is just one of a backend developer’s many tasks, and, to be honest, writing a while(true) loop with Thread.Sleep isn’t exactly the most elegant solution and certainly not the most scalable.
Tips for Efficient Data Queries in ASP.NET Core
Efficient queries are essential to the performance and scalability of APIs that handle large volumes of data. In this post, we will explore best practices and strategies for optimizing backend queries using ASP.NET Core. In backend applications that consume relational databases, the way queries are structured can be crucial to application performance.
Handling Null Values in ASP.NET Core
Dealing with null values is a recurring challenge in any modern web application. The good news is that ASP.NET Core is prepared to face this type of situation. In this post, we will explore the tools and best practices that help identify and prevent problems caused by null values. Problems with null values are common in web applications that communicate with each other, constantly exchanging data.
Supercharging API Development with Fast Endpoints
Fast endpoints allow you to create web APIs with automatic validation, high performance and less code. In this post, we will understand how to use fast endpoints as an alternative to classic approaches and combine the best of both worlds when creating new web APIs in ASP.NET Core. Creating web APIs is part of most developers’ routines these days.
4 Essential Principles for Programmers
The KISS, YAGNI, DRY and Law of Demeter principles teach us from experienced people how to solve common problems. In this post, we will discuss each of them in detail and understand how they can help us create sustainable and professional code. The KISS, YAGNI, DRY and Law of Demeter principles, like other aspects of software engineering, are not rigid rules that must be followed at all costs. Instead, they help developers reflect and seek alternatives to create code with a more professional tone.
Query Analyst with Semantic.Kernel
In this post, I’ll demonstrate Semantic.Kernel, an open-source AI SDK provided by Microsoft, which makes it easy to interact with large language models (LLMs) and their services. This post demonstrates a powerful console chat, based on the entire SQL Server database schema, which maintains the session and chat history, displaying the results of executed queries and allowing users to ask questions about the data.
Creating and Publishing Your First NuGet Package
NuGet packages are a fundamental component of .NET and help speed up development without having to reinvent the wheel. Learn in this post how to create your own NuGet package, publish it and use it in your applications. NuGet packages provide a wide range of features to accelerate ASP.NET Core web development. With them, developers can access everything they need with just a few clicks or commands.
Understanding Parallel Programming in ASP.NET Core
Parallel programming is a fundamental concept for backend developers, as it helps create more efficient, scalable and responsive systems. In this post, we will explore five native ASP.NET Core features for dealing with parallelism. When working with applications that process large volumes of data, it is common to encounter scenarios in which multiple tasks must be executed simultaneously to facilitate performance and scalability.
Functional Programming in C#-Exploring Advanced Topics
Using functional programming can result in more reliable, less buggy software. Let’s see five more advanced functional programming concepts in practice in ASP.NET Core. Functional programming is a paradigm that opposes one of the principles of object orientation: state change.
Store Changes as Events
Learn how to implement the Event Sourcing architectural pattern in your ASP.NET Core app to record event-related system changes. Have you ever imagined having a complete history of data in a distributed application? With Event Sourcing, each change becomes an immutable event, for full traceability in ASP.NET Core.
Domain-Driven Design Principles: Value Objects in ASP.NET Core
Learn what value objects are, their main characteristics and how to use them to write code that is clearly expressed and easy to maintain in your ASP.NET Core app. When we write code, we are doing more than creating instructions for computers. We are making a business work in the way it was carefully imagined. In this sense, it is fair to consider that we have a great responsibility in our hands.
Vector Search with EF 9
Entity Framework Core 9 introduced a new feature for vector search, which allows searches based on vector similarity, allowing developers to incorporate these advantages directly into databases. Check out this post on how to implement vector search in ASP.NET Core using this new feature in EF 9. Vector search is an approach that allows finding a specific piece of data in a different way from traditional methods, as it is based on vector similarity.
10 New Features in EF 9
Entity Framework Core has been improving yearly, bringing tools to simplify data access and management in .NET applications. Check out this post with 10 of the main new features in EF 9 for ASP.NET Core. Entity Framework Core—EF Core—is the main object relational model (ORM) maintained by Microsoft. It has been continuously improved to meet the demands of developers and the needs of modern applications.
Here's what I do to perform well under pressure ๐คฆโโ๏ธโก๐โโ๏ธ
๐ก Hey, have you ever felt overwhelmed trying to juggle multiple tasks at once? If so, welcome to the club! ๐ The good news? You're not alone. ๐ The best news? There are techniques that can help you deal with those moments when all you want to do is close your computer, have a cup of tea... or catch a flight to the moon.
Deploying ASP.NET Core Applications with Docker-Part 2
Due to its flexibility and simplicity, Docker makes it easy to manage applications and their dependencies. In this second part about Docker with ASP.NET Core, we will see how to add a SQL Server database to the application and how to run it in a Docker container using Docker Compose. In the first part, we saw an introduction to Docker, understanding how it works and its advantages compared to virtual machines.
Deploying ASP.NET Core Applications with Docker-Part 1
In this post, we will understand what Docker is, how it works and how to create a complete environment to deploy ASP.NET Core applications in Docker containers. Keeping a web application running with all its dependencies involves several configurations and adjustments, which can be challenging. To help with this process, we can use Docker—a formidable tool that encapsulates the application, its dependencies and configurations in standardized containers.
Get Started Integrating AI in Your ASP.NET Core Applications
AI has the potential to transform data analysis and manipulation, making them significantly simpler. Learn how to integrate an ASP.NET Core application with the OpenAI API to perform data analysis directly on the backend. The use of artificial intelligence (AI) has been growing ever since it became popular among the world’s population. Since then, many models have emerged, each with its particularities. One of the best-known is GPT, created by OpenAI.
Getting Started with API Gateways in ASP.NET Core
An API gateway provides a central point for managing routing, security and data aggregation in web applications. Explore the key benefits of this approach, such as securing APIs by creating an external layer, rate-limiting access and optimizing performance using Ocelot. Web APIs are known for integrating and communicating between different applications through requests.
Tips for Improving API Performance in ASP.NET Core
Some techniques can make a big difference in the efficient use of resources, improving performance and scalability. Check out these nine tips on how to optimize APIs in ASP.NET Core. In scenarios that involve transferring or managing large amounts of data, the performance of APIs is crucial for fast, scalable and efficient applications. Good API performance can reduce latency, improve user experience and optimize the use of server resources.
ASP.NET Core Basics: Simplifying API Integration with Refit
Simplifying integration with APIs reduces boilerplate code and makes the application more modular, reducing coupling and resulting in cleaner, more concise code. Learn how to use Refit in this process and the best resources for handling requests between APIs. Modern applications use Application Programming Interfaces (APIs) to receive and send data or commands. However, creating HTTP clients to consume these APIs can be exhausting and error-prone.
ASP.NET Core Basics: Classes & Records—How and When to Use
Classes are fundamental to object-oriented programming, while records bring several advantages mainly for the data transport function. Learn the main functions of classes vs. records and which contexts each is best suited to. Despite being a basic subject, classes and records are important for both beginners and experienced developers to understand, as these structures are fundamental for organizing and manipulating data in object-oriented systems (OOP).
Manipulating Databases
Manipulating databases is a common activity in a web developer’s routine, so it is important to know the main approaches used to carry out this task and what features are available in ASP.NET Core. Learn about Code First and Database First with practical examples. Creating and maintaining databases is an essential part of web application development.
ASP.NET Core Basics: 12 Questions and Answers for Beginners
In this blog post, we will check out 12 questions and their answers on essential topics for understanding the basic concepts of ASP.NET Core and web development with C#. Understanding the basics of ASP.NET Core is essential for beginners, as it creates a solid foundation for developers who want to enter the world of web development with Microsoft’s .NET framework.
ASP.NET Core Basics: Introduction to Big O Notation
Understanding how the performance of algorithms and data structures can impact the overall performance of an application is crucial for web developers. Learn what Big O is and how we can use it to measure the performance of our algorithms, writing more optimized and scalable code.
Clean Code-A Practical Introduction in ASP.NET Core
Clean code is a fundamental concept in software engineering that focuses on writing readable, understandable and maintainable code. This blog post will cover tips on how to write clean code in ASP.NET Core applications. The term “clean code” is very well-known in application development. Both beginners and experts must understand this concept to create robust, scalable and easy-to-maintain systems.
My impressions about the book The Clean Coder 🧹📚
Recently, I finished reading the book The Clean Coder: A Code of Conduct for Professional Programmers by Robert C. Martin (Uncle Bob) (Brazilian Portuguese version), and here are my impressions about it. If you are inside the software development world, you've certainly heard about the legendary book The Clean Code, but there is another important book by the same author, called The Clean Coder.
ASP.NET Core Basics: Data Structures-Part 2
Data structures play a key role in computer science and software engineering, providing efficient solutions for various computational challenges. In this second part, we’ll cover advanced topics in data structures, but in an easy way to understand. In Part 1 of Data Structures, we saw some examples of basic structures in the ASP.NET Core context, what each one means and how it can be implemented. In this second part, we’ll cover the main advanced topics in data structures.
ASP.NET Core Basics: Understanding and Practicing SOLID
The application of SOLID principles is essential to promote code modularity, maintainability and scalability. Check out this blog post on understanding each of the SOLID principles and applying them in an ASP.NET Core application. Understanding SOLID principles and applying them is a decisive factor for any developer who wants to advance their career.
ASP.NET Core Basics: Understanding Dependency Injection
Check out what happens if you don’t use dependency injection, and then level up with best practices around DI, IoC and DIP. Dependency injection (DI) is a design pattern widely used in software development, and understanding it is a basic requirement for anyone wanting to work with web development in ASP.NET Core. The purpose of DI is to promote code modularity, reusability and testability. In ASP.NET Core specifically, DI plays a crucial role in building robust and scalable applications.
ASP.NET Core Basics: Creating Apps with More Accessibility
Through concepts, syntaxes and elements, you can make webpages accessible to users, especially those with disabilities. Find out how to make an ASP.NET Core application more accessible. The web is an incredible place where we can all search any question that comes to mind, or maybe buy something new, or even research places we want to visit. In short, the possibilities are endless. But have you ever stopped to think that not everyone can fully access this wonderful place?
ASP.NET Core Basics: Globalizing a Web Application
Globalization allows developers to handle the internationalization and localization of a web application, making it more accessible to a broader audience. Check out how to globalize an app in ASP.NET Core in this blog post. The globalization feature of an application has several advantages that make the application more useful for users, allowing them, for example, to choose which language to read the content in. Globalization is a complex subject and can be implemented in different ways.
ASP.NET Core Basics: Tag Helpers
Web, ASP.NET Core 0 Comments Tag Helpers are a great feature of ASP.NET Core and provide an easier and more intuitive way to add dynamic behavior to webpages. Check out in this post how Tag Helpers can make your development more accessible and more productive.
Create a Beautiful ASP.NET Core App
In addition to powerful backend features, ASP.NET Core allows the creation of beautiful applications. For example, let’s create a digital photo album. ASP.NET Core is well known for its extremely useful backend capabilities—web APIs, worker services and real-time communication, among others. Still, beyond that, it is possible to use its resources to create beautiful applications using HTML and CSS side by side with all its powerful backend features.
Show More
loading
Actions
Is this you?
As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.Get in touch with Assis
Contact Assis, search articles and posts on X, monitor coverage, and track replies from one place.
Learn more about Muck Rack