This article explains C# naming conventions, such as how to name classes, methods, interfaces, and constants as well as some general naming guidelines. Like any other programming language, C# also follows certain naming conventions to enhance the readability, maintainability, and consistency of the code. In this article, we will discuss the common C# naming conventions and best practices. If you want to skyrocket your C# career, check out our powerful ASP.NET full-stack web development course that also covers test-driven development.
PascalCase
The PascalCase convention is used for naming public classes, structs, and methods. The first letter of each word in the name is capitalized, except for the first word. For example, MyClass, MyStruct, and MyMethod.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public class MyClass { public string MyProperty { get; set; } public MyClass(string propertyValue) { MyProperty = propertyValue; } public static int AddNumbers(int a, int b) { return a + b; } } public struct MyStruct { public int FirstNumber { get; } public int SecondNumber { get; } public MyStruct(int first, int second) { FirstNumber = first; SecondNumber = second; } } |
camelCase
The camelCase convention is used for naming variables, parameters, and private fields. The first letter of the first word is in lowercase, and the first letter of each subsequent word is capitalized. For example, myVariable, myParameter, and myPrivateField. You can find the examples in the code above.
UPPERCASE
The UPPERCASE convention is used for naming constants. The name is in all uppercase letters, and words are separated by underscores. For example, MY_CONSTANT.
|
1 |
const string SERVICE_NAME = "Accounting"; |
Prefixes
Prefixes are used to denote the type or nature of the element being named. In C#, “I” is the prefix developers use for interfaces. For example, IMyInterface.
|
1 2 3 4 |
interface IPaymentStrategy { } |
Abbreviations
Abbreviations should be avoided as much as possible. If an abbreviation is used, it should be in all uppercase or all lowercase, depending on the convention being followed. For example, HTTP, URL, and XML. By the way, did you know that we offer a unique online course that boosts your C# career? Check it out here!
Plurals
Plurals should be used for collections or arrays. For example, fruits, numbers, and words.
|
1 2 3 4 5 6 7 |
List<string> fruits = new List<string>(); int[] numbers = new int[3] { 1, 2, 3 }; Dictionary<string, int> words = new Dictionary<string, int>(); |
Verb-Noun Pairs
For events or methods that perform an action, verb-noun pairs should be used. For example, OnClick, GetResults, and ProcessData.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public void OnClick() { Debug.Log("Button was clicked"); } public string GetResults(int input) { int result = input * 2; return "The result is: " + result; } public void ProcessData(List<int> data) { int sum = 0; foreach(int value in data) { sum += value; } Debug.Log("The sum of the data is: " + sum); } |
In these examples, OnClick is a function that gets called when a button is clicked, GetResults is a function that takes an input, performs a calculation, and returns a string with the result, and ProcessData is a method that takes a list of integers as input, processes the data, and logs the result to the console.
Meaningful Names
Naming is a critical aspect of the development process, as it helps to establish a common language between the business stakeholders and the development team.
Some guidelines for naming include:
- Use business terms: Names of classes, methods, and variables should be based on the business domain, rather than technical implementation details. For example, if the business domain involves tracking customer orders, you might have classes like
Order,Customer, andProduct. - Be precise and clear: Names should accurately reflect what the entity or method does, and should not be ambiguous or confusing. For example, a method that retrieves a list of products might be called
GetProducts, while a method that saves changes to an order might be calledSaveOrder. - Use a consistent language: The same term should be used consistently throughout the system, by both the business stakeholders and the development team. This helps to avoid misunderstandings and confusion.
- Avoid technical jargon: Technical terms and acronyms should be avoided wherever possible, in order to make the system more accessible to non-technical stakeholders.
Names should be meaningful and reflect the purpose of the element being named. Avoid using single-letter or meaningless names. For example, use firstName instead of fn or f.
By following these guidelines, developers can create a system that accurately models the business domain, and that is easily understood and maintained by both technical and non-technical stakeholders.
Conclusion
In conclusion, following naming conventions in C# can improve the readability and maintainability of your code. By adhering to these conventions, you will create code that is easier to read, understand, and maintain. It is important to note that naming conventions are not only about consistency but also about clarity. Using clear and descriptive names helps others who read your code to understand what your code is doing without having to spend a lot of time figuring it out.
It is also essential to consider the audience that will be reading and using your code. If you are developing a library that will be used by other developers, it is critical to use descriptive and intuitive names. If you are developing a UI application, you should use names that are easily understandable to users. Also, avoid using reserved keywords as names. C# has a set of reserved keywords that cannot be used as names for elements in your code. Using these reserved keywords as names will result in compilation errors. It is always a good practice to check the C# documentation for the list of reserved keywords before naming your elements.
Lastly, it is essential to be consistent with the naming conventions you use throughout your code. Consistency is key to making your code readable and maintainable, and it makes it easier for other developers to understand and work with your code.
Following C# naming conventions is a good practice that can help improve the readability and maintainability of your code. By using descriptive and consistent names, avoiding reserved keywords, and considering your audience, you can create code that is not only functional but also easy to understand and update.
