Skip to main content

Standards

Introduction​

Standardized development guidelines are a set of best practices, principles, and processes that developers follow to ensure consistent, efficient, and high-quality software development. These guidelines can vary depending on the programming language, development environment, and specific project needs, but there are several core areas to cover. These guidelines should be adapted to fit your team’s workflow and project needs. Having a well-documented and shared guideline repository helps to maintain consistency, reduce errors, and improve code quality across the development lifecycle.

Here’s a comprehensive outline for standardized development guidelines:

Code Style and Formatting​

  • Consistent Indentation: Use 4 spaces per indentation level.
  • Braces: Place opening braces on a new line for methods, properties, and constructors. For other blocks, place the opening brace on the same line.
  • Line Length: Limit lines to 120 characters.
  • Whitespace: Use a single space after commas, semicolons, and around binary operators.

Naming Conventions​

  • Classes: Use PascalCase (e.g., CustomerManager).
  • Methods: Use PascalCase (e.g., GetCustomerDetails).
  • Properties: Use PascalCase (e.g., CustomerName).
  • Fields: Use camelCase with a leading underscore for private fields (e.g., _customerId).
  • Interfaces: Prefix with I (e.g., ILogger).
  • Constants: Use PascalCase (e.g., MaxRetryCount).
  • Local Variables: Use camelCase (e.g., totalAmount).

Specific Rules​

  • Use var when the type is obvious: Prefer var for local variable declarations when the type is evident from the right side of the assignment.
  • Use explicit types when the type is not apparent: Avoid var when it makes the code less readable.
  • Use expression-bodied members: For simple properties, methods, and constructors, use expression-bodied members.
  • Use string interpolation: Prefer string interpolation over String.Format or concatenation.
  • String.Empty: use when comparing a value to an empty string. Using string.Empty improves code readability and clearly indicates that the comparison is intended to be with an empty string.
  • Limit methods to a single functionality: It's advisable to keep your methods to a single functionality. Do not attempt to integrate numerous functionalities of a class into a single method. This improves code readability and prevents you from producing "spaghetti code".
  • Always Do Null Checks for Objects: Null reference exceptions can bring even the most powerful applications to their knees. To avoid these issues, conduct null checks before accessing object attributes or methods.
  • Always Use Any() Extension Method Instead of Count: The Any() method checks for the presence of any items in the collection and returns a boolean value. It reduces code complexity and improves performance by removing needless enumeration of the full collection to calculate the count.
  • Automatically fix your code using a Roslyn analyzer: You can use a Roslyn analyzer to see how these methods are used in your apps.You can install the Visual Studio extension to analyze your code.
  • Use StringBuilder: Every operation that appears to modify a string object generates a new string. To enhance efficiency while concatenating a random number of strings with a loop, utilize a StringBuilder. StringBuilder denotes a modifiable string of characters. As a result, you can make changes without having to create a new string.

Read more - Code Style and Formatting

Coding Principle​

  • DRY Principle The Don't Repeat Yourself (DRY) principle is a fundamental programming concept aimed at reducing redundancy in code. It emphasizes that every piece of knowledge must have a single, unambiguous representation within a system.

Key Points

  • Single Source of Truth: Ensure that each piece of information or logic is defined only once. This reduces the risk of inconsistencies and makes the code easier to maintain.
  • Modular Code: Break down your code into reusable modules or functions. This not only adheres to the DRY principle but also enhances readability and testability.
  • Refactoring: Regularly refactor your code to eliminate duplication. Look for patterns and commonalities that can be abstracted into a single method or class.

Read more - DRY Architectural Principle

  • SOLID Principles The SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable. Here’s a brief overview of each principle:

  • Single Responsibility Principle (SRP) : A class should have only one reason to change, meaning it should have only one job or responsibility. This helps in making the class more robust and easier to maintain.

  • Open/Closed Principle (OCP): Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means you should be able to add new functionality without changing existing code, often achieved through inheritance or interfaces.

  • Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. This ensures that a subclass can stand in for its superclass without causing errors.

  • Interface Segregation Principle (ISP): Many client-specific interfaces are better than one general-purpose interface. This principle encourages creating smaller, more specific interfaces so that implementing classes only need to be concerned with the methods that are of interest to them.

  • Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions. Additionally, abstractions should not depend on details. Details should depend on abstractions. This principle helps in reducing the coupling between different parts of the code.

  • Error Handling: Implement robust error handling and logging mechanisms.

Read more - SOLID Principles

Security​

When designing and writing your code, you need to protect and limit the access that code has to resources, especially when using or invoking code of unknown origin.

So, keep in mind the following techniques to ensure your code is secure:

  • Do not use Code Access Security (CAS).
  • Do not use partial trusted code.
  • Do not use the AllowPartiallyTrustedCaller attribute (APTCA).
  • Do not use .NET Remoting.
  • Do not use Distributed Component Object Model (DCOM).

Secure Coding Practices:

  • Use parameterized queries and prepared statements to avoid direct execution of user inputs
  • Follow secure coding guidelines to prevent vulnerabilities like SQL injection and XSS.
  • Implement robust authentication and authorization mechanisms.
  • Encrypt sensitive data both in transit and at rest.
  • Implement strong authentication mechanisms, such as multi-factor authentication (MFA).
  • Handle errors gracefully without exposing sensitive information to users
  • Conduct regular code reviews with a focus on security to identify and fix vulnerabilities early.
  • Use automated security testing tools to perform static and dynamic analysis of your code.

Read more - Security

Testable code​

In the realm of software development, the term "testable code" refers to code that is designed and written in a way that makes it easy to test. Testable code is crucial for ensuring the reliability, maintainability, and quality of software applications. By adhering to principles that promote testability, developers can create code that is easier to debug, extend, and refactor.

Key Characteristics of Testable Code:

  • Modularity: Testable code is often broken down into small, independent modules or functions. This modularity allows individual components to be tested in isolation, making it easier to identify and fix issues.

  • Separation of Concerns: By separating different aspects of the code (such as business logic, data access, and user interface), developers can create more focused and manageable tests. This separation also enhances code readability and maintainability.

  • Dependency Injection: Instead of hard-coding dependencies within a class or function, testable code uses dependency injection to pass dependencies from the outside. This approach makes it easier to substitute real dependencies with mock objects during testing.

  • Clear and Simple Interfaces: Testable code often features well-defined interfaces that are easy to understand and use. Clear interfaces facilitate the creation of test cases and improve the overall readability of the code.

  • Minimal Side Effects: Code with minimal side effects is easier to test because it reduces the complexity of the interactions between different parts of the system. Functions and methods should aim to be pure, meaning they produce the same output given the same input and do not alter the state of the system.

Read more - Testable code