In this article, we are going to learn about the readonly modifier in C#.<\/p>\n
However, before we go into detail on this topic, it is important to understand the concepts of mutability and immutability in programming.<\/p>\n
Let’s begin!<\/p>\n
In C#, immutability<\/a> refers to the inability to change the state of an object once we create it.<\/strong><\/p>\n When an object is mutable, we can change its state. Thus, it is flexible but potentially prone to unintended changes.<\/p>\n Immutable objects provide a level of thread safety since we can’t modify them after creation. However, we must create a new instance to have an updated version of an immutable object, which can be less efficient.<\/p>\n Hence, immutable objects are preferable for situations where data consistency is critical, whereas mutable objects offer more flexibility in cases where frequent modifications are necessary.<\/strong><\/p>\n We use the Once initialized, the value of a Let’s understand how the Here, we can set the value of the We get a compiler error:<\/p>\n In C#, we also have the The value of a To declare a <\/span> We can initialize the field either at the time of declaration:<\/span><\/p>\n Or within the constructor of the class:<\/span><\/p>\n Once set, we can’t modify the value of this field elsewhere in the class. However, we can use them in any method or property of the class:<\/span><\/p>\n Value types<\/a> are stored directly on the stack that holds the entire object. When we use the readonly modifier in C# on value type fields, it ensures that the value of the field can’t be modified after initialization.<\/p>\n Let’s create a read-only struct Here, we have read-only fields The Also, our properties encapsulate the Reference types, on the other hand, store a reference to an object on the heap. The However, we can still modify the state of the object itself as we saw in the previous It’s important to note that the We can’t use the With this approach, we use auto-implemented properties with the Here, we can only set the value of the property at the time of declaration or within the constructor of the class.<\/p>\n We can also have a similar implementation of\u00a0a Here, we can assign the value to the field inside the constructor and use the Here, we use public property with a private setter:<\/p>\n This restricts the property from any external modification:<\/p>\n So, directly trying to change the As the We can also create read-only properties with custom getters:<\/p>\n This allows us to calculate the value of the property based on some logic every time we access it.<\/p>\n We looked at various ways to create a read-only property with or without using the In C#, the concept of However, we have related concepts such as “read-only methods”<\/em> and “pure functions”<\/em> to explore immutability in methods.<\/p>\n A read-only method refers to a method that does not modify the state of the object it belongs to. In other words, a read-only method does not change the values of any fields or properties of the class. Instead, it operates only on its input parameters.<\/p>\n A pure function is a special type of read-only method that produces the same output for the same input and has no side effects<\/strong>. It solely depends on its input parameters and avoids modifying any external state or variables.<\/p>\n The We can’t directly apply the When we make the class read-only, we can only initialize it once during construction, and can’t modify its state afterward.<\/p>\n Read-only classes are useful in specific scenarios where we want to ensure that the state of an object remains constant and can’t be replaced.\u00a0 This can be particularly valuable in multithreaded environments when we need to guarantee that the object won’t change unexpectedly.<\/p>\n When we apply the We can still create multiple instances of the struct:<\/p>\n However, we can’t modify the value of the struct members.<\/p>\n Now that we have explored the usage of the We should use the To enforce immutability on collections, we should prefer the use of immutable collections<\/a> such as We should use While Not everything needs to be immutable. We should try to strike a balance between mutability and immutability by using mutable objects where we require flexibility.<\/p>\n In this article, we’ve looked at the readonly modifier in C# and its impact on fields, properties, methods, classes, and structs. Understanding when and how to use In this article, we are going to learn about the readonly modifier in C#. However, before we go into detail on this topic, it is important to understand the concepts of mutability and immutability in programming. Let’s begin! Mutable vs. Immutable in C# In C#, immutability refers to the inability to change the state of […]<\/p>\n","protected":false},"author":6,"featured_media":62189,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[12,506],"tags":[1811,1914,1931],"class_list":["post-94906","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-csharp","category-intermediate","tag-c","tag-readonly","tag-readonly-modifier","et-has-post-format-content","et_post_format-et-post-format-standard"],"yoast_head":"\n<\/a>Readonly Modifier in C#<\/h2>\n
readonly<\/code> modifier to make a variable immutable.\u00a0<\/p>\nreadonly<\/code> variable can’t be changed throughout the object’s lifetime. It ensures that the variable remains constant after initialization, enforcing immutability on the variable.<\/p>\nreadonly<\/code> modifier works:<\/p>\npublic class Circle\r\n{\r\n private readonly double _radius;\r\n\r\n public Circle(double radius)\r\n {\r\n _radius = radius;\r\n }\r\n}\r\n<\/pre>\n_radius<\/code> field at the time of declaration, or within the constructor. However, if we try to set the field value outside the constructor:<\/p>\npublic void ModifyRadius()\r\n{\r\n _radius = _radius + 2;\r\n}<\/pre>\nError CS0191 A readonly field cannot be assigned to (except in a constructor or init-only setter of the type in which the field is defined or a variable initializer)<\/code><\/p>\nconst<\/code>\u00a0 keyword that helps us enforce a form of immutability. However, it works differently<\/a> from the readonly<\/code> modifier. It’s typically useful for values that are universal constants, like mathematical constants.<\/p>\nconst<\/code> variable is directly embedded into the compiled code<\/strong>, and any attempt to modify it, even in the constructor, results in a compile-time error.<\/p>\n<\/a>Use Readonly Modifier in C# With Fields<\/h2>\n
readonly<\/code> field, we use the <\/span>readonly<\/code> keyword followed by the type and field name. <\/span><\/p>\nprivate readonly double _radius = 2.5;<\/code><\/p>\npublic Circle(double radius)\r\n{\r\n _radius = radius;\r\n}<\/pre>\npublic double GetCircumference()\r\n{\r\n return 2 * Math.PI * _radius;\r\n}<\/pre>\n<\/a>Impact on Value Types vs. Reference Types<\/h3>\n
Point<\/code> (later on in the article, we will explain how readonly<\/code> keyword affects the structure):<\/p>\npublic readonly struct Point\r\n{\r\n private readonly int _x;\r\n private readonly int _y;\r\n\r\n public int X => _x;\r\n public int Y => _y;\r\n\r\n public Point(int x, int y)\r\n {\r\n _x = x;\r\n _y = y;\r\n }\r\n}<\/pre>\n_x<\/code> and _y<\/code>. We encapsulate them within the properties X<\/code> and Y<\/code> respectively.<\/p>\nreadonly<\/code> modifier ensures that once we create the Point<\/code> object, we can’t modify the value of its fields.<\/p>\nprivate<\/code> read-only fields and those properties are also only-getters (readonly), so if we try to modify their values, we get a compilation error:<\/p>\nvar point = new Point(2, 3);\r\nConsole.WriteLine($\"Coordinates: X - {point.X}, Y - {point.Y}\");\r\n\r\npoint.X = 6; \/\/error\r\npoint.Y = 10; \/\/error<\/pre>\nreadonly<\/code> modifier ensures that the reference to the object can’t be changed after initialization.<\/p>\nCircle<\/code> class example. We couldn’t change the value of the _radius<\/code> field outside the constructor but could still use the field value to calculate the circumference without any issues.<\/p>\nreadonly<\/code> modifier only makes the reference to the object immutable, and not the actual object itself. <\/strong>If we want to create a fully immutable object, we need to design the object itself to be immutable, such as by using readonly<\/code> fields or properties within the object.<\/p>\n<\/a>Readonly Modifier in Properties<\/h2>\n
readonly<\/code> modifier with properties to create read-only properties.\u00a0However, we can make a property read-only in other ways.<\/p>\n<\/a>Readonly Auto-Implemented Properties<\/h3>\n
get<\/code> accessor only. We omit the set<\/code> accessor, making the property read-only:<\/p>\npublic int Age { get; }<\/code><\/p>\npublic<\/code> readonly property:<\/p>\npublic class Person\r\n{\r\n private readonly int _age;\r\n \r\n public int Age => _age;\r\n\r\n public Person(int age)\r\n {\r\n _age = age;\r\n }\r\n}<\/pre>\nAge<\/code> property to access the value of the _age<\/code> field. The Age<\/code> property is only-getter so it makes it readonly.<\/p>\n<\/a>Readonly Properties With Private Setters<\/h3>\n
public class Person\r\n{\r\n public string Name { get; private set; }\r\n public int Age { get; }\r\n\r\n public Person(string name, int age)\r\n {\r\n Name = name;\r\n Age = age;\r\n }\r\n\r\n public void ChangeName(string changedName)\r\n {\r\n Name = changedName;\r\n }\r\n}<\/pre>\nvar person = new Person(\"Jack\", 21);\r\nConsole.WriteLine($\"Name: {person.Name}\");\r\n\r\nperson.Name = \"Emily\";<\/pre>\nName<\/code> property gives us a compiler error.\u00a0However, we can still set the property within the class or constructor:<\/p>\nperson.ChangeName(\"Emily\");<\/code><\/p>\nChangeName()<\/code> method is present within the Person<\/code> class, we can change the property value using this method. Thus, it is important to note that this approach makes a property read-only only from the perspective of the consumer<\/strong>. Internally, we can still change the state of such property.<\/p>\n<\/a>Readonly Properties With Custom Getters<\/h3>\n
public double Area\r\n{\r\n get { return Math.PI * _radius * _radius; }\r\n}<\/pre>\nreadonly<\/code> modifier. Let’s also understand how it differs from a read-write property.<\/p>\n<\/a>Readonly Modifier in Methods<\/h2>\n
readonly<\/code> is primarily used for fields and properties to create read-only data, and it does not have a direct counterpart for methods.<\/p>\n<\/a>Readonly Methods and Pure Functions<\/h3>\n
GetCircumference()<\/code> method we discussed earlier is an example of a pure function as it calculates the circumference of a circle using the read-only _radius<\/code> field without modifying any value.<\/p>\n<\/a>Readonly Modifier in Classes<\/h2>\n
readonly<\/code> modifier to a class. However, we can make a class read-only by making all its members immutable<\/strong>. For example, using only read-only fields and properties within the class.<\/p>\n<\/a>Readonly Modifier in Structs<\/h2>\n
readonly<\/code> modifier to a struct, it indicates that instances of the struct are immutable, meaning that their values cannot be changed after initialization. All the fields and properties of the readonly struct must be readonly as well.<\/strong> If they are not, we will get an error: CS8340: Instance fields of readonly structs must be readonly<\/code>.<\/p>\nvar point = new Point(2, 3);\r\nvar otherPoint = new Point(1, 4);<\/pre>\n
readonly<\/code> modifier in fields, properties, methods, classes, and structs, let’s look into some essential best practices for using it.<\/p>\n<\/a>Best Practices<\/h2>\n
readonly<\/code> modifier for fields or properties that are designed not to change their values after initialization. This helps enforce immutability and prevents accidental modifications.<\/p>\nImmutableList<\/code>, or ImmutableDictionary<\/code>.<\/p>\nreadonly<\/code> properties with custom getters for values that are computed based on business logic but do not change over the object’s lifetime. This allows us to cache computed values while not modifying the object’s state.<\/p>\nreadonly<\/code> modifier helps with immutability, it does not automatically guarantee thread safety. If the code involves multithreading scenarios, we should ensure proper synchronization<\/a> when needed.<\/p>\n<\/a>Conclusion<\/h2>\n
readonly<\/code> allows us to enforce immutability and prevent unintended modifications, leading to a more manageable codebase.<\/p>\n","protected":false},"excerpt":{"rendered":"