{"id":56,"date":"2014-05-23T06:53:00","date_gmt":"2014-05-23T05:53:00","guid":{"rendered":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/23\/what-is-difference-between-constants-and-read-only\/"},"modified":"2024-09-27T15:35:58","modified_gmt":"2024-09-27T14:35:58","slug":"what-is-difference-between-constants-and-read-only","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/23\/what-is-difference-between-constants-and-read-only\/","title":{"rendered":"Difference Between const and readonly in C#"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>4 Minute, 15 Second <\/div>\n\n <\/div>

In C#, both const<\/code> and readonly<\/code> are used to define variables whose values cannot be changed after assignment. However, there are significant differences between the two in terms of behavior, usage, and when the value is assigned.<\/p>\n

1. Declaration and Initialization<\/h3>\n
    \n
  • Constants (const<\/code>)<\/strong>:\n
      \n
    • Must be declared and initialized at the time of declaration.<\/li>\n
    • The value is fixed at compile time and cannot be changed later.<\/li>\n
    • const<\/code> is implicitly static<\/code>, meaning it belongs to the type, not the instance.<\/li>\n
    • Can only hold primitive types, enums, or strings.<\/li>\n<\/ul>\n<\/li>\n
    • Read-Only (readonly<\/code>)<\/strong>:\n
        \n
      • Can be initialized either at the time of declaration or in the constructor of the class.<\/li>\n
      • The value is set at runtime and can vary depending on the constructor used.<\/li>\n
      • readonly<\/code> variables can be instance-level (non-static) or static.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n

        Examples:<\/h4>\n
        \r\n\/\/ const\r\npublic const int MaxValue = 100;  \/\/ Must be initialized at declaration\r\n\r\n\/\/ readonly\r\npublic readonly int MaxValue;\r\npublic MyClass() {\r\n    MaxValue = 100;  \/\/ Initialized in the constructor\r\n}\r\n<\/code><\/pre>\n
        2. Value Assignment<\/h3>\n
          \n
        • Constants (const<\/code>)<\/strong>:\n
            \n
          • Value is assigned at compile time<\/strong>.<\/li>\n
          • Cannot assign a value after declaration, and it is substituted directly into the compiled code.<\/li>\n<\/ul>\n<\/li>\n
          • Read-Only (readonly<\/code>)<\/strong>:\n
              \n
            • Value is assigned at runtime<\/strong>.<\/li>\n
            • Can be assigned in the constructor and can vary depending on the instance or constructor logic.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
              3. Usage<\/h3>\n
                \n
              • Constants (const<\/code>)<\/strong>: Used for values known at compile time and will never change (e.g., mathematical constants, app settings).<\/li>\n
              • Read-Only (readonly<\/code>)<\/strong>: Used for values that may not be known until runtime (e.g., configurations, input-based values).<\/li>\n<\/ul>\n
                Examples:<\/h4>\n
                \r\n\/\/ const usage\r\npublic const double Pi = 3.14159;  \/\/ Known value at compile time\r\n\r\n\/\/ readonly usage\r\npublic readonly int RuntimeValue;\r\npublic MyClass(int value) {\r\n    RuntimeValue = value;  \/\/ Assigned during runtime\r\n}\r\n<\/code><\/pre>\n
                4. Static Context<\/h3>\n
                  \n
                • Constants (const<\/code>)<\/strong>: Implicitly static<\/code> and belongs to the type, not the instance.<\/li>\n
                • Read-Only (readonly<\/code>)<\/strong>: Can be either instance-level or static<\/code>. A static readonly<\/code> can be assigned in a static constructor.<\/li>\n<\/ul>\n
                  Examples:<\/h4>\n
                  \r\n\/\/ const (implicitly static)\r\npublic const int MaxConnections = 100;\r\n\r\n\/\/ static readonly\r\npublic static readonly string AppName;\r\nstatic MyClass() {\r\n    AppName = \"My Application\";  \/\/ Set at runtime in static constructor\r\n}\r\n<\/code><\/pre>\n
                  5. Flexibility<\/h3>\n
                    \n
                  • Constants (const<\/code>)<\/strong>:\n
                      \n
                    • Less flexible as they must be initialized at compile time.<\/li>\n
                    • Can only be used with basic types (e.g., int<\/code>, string<\/code>, double<\/code>).<\/li>\n<\/ul>\n<\/li>\n
                    • Read-Only (readonly<\/code>)<\/strong>:\n
                        \n
                      • More flexible since the value can be set at runtime.<\/li>\n
                      • Can hold complex types such as objects, arrays, and collections.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                        Example:<\/h4>\n
                        \r\n\/\/ readonly with complex types\r\npublic readonly DateTime CreatedAt;\r\npublic MyClass() {\r\n    CreatedAt = DateTime.Now;  \/\/ Set during runtime\r\n}\r\n<\/code><\/pre>\n
                        6. Memory Efficiency<\/h3>\n
                          \n
                        • Constants (const<\/code>)<\/strong>:\n
                            \n
                          • Stored as part of the metadata in the compiled assembly.<\/li>\n
                          • The value is substituted directly into the code wherever it\u2019s used, leading to efficient memory usage but possible versioning issues if a library changes a constant value.<\/li>\n<\/ul>\n<\/li>\n
                          • Read-Only (readonly<\/code>)<\/strong>:\n
                              \n
                            • Stored as fields in memory, like normal variables.<\/li>\n
                            • Because they are not substituted directly into the code, versioning issues are avoided.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                              Real-World Analogy<\/h3>\n
                                \n
                              • Constants (const<\/code>)<\/strong>: Think of a birthdate. It is fixed and cannot change. Once set, it stays the same for the rest of your life.\n
                                public const string Birthdate = \"January 1, 1990\";<\/code><\/pre>\n<\/li>\n
                              • Read-Only (readonly<\/code>)<\/strong>: Think of an ID card number. It is assigned at some point in time (when the card is issued) but cannot change afterward.\n
                                public readonly string IDNumber;\r\npublic Person(string id) {\r\n    IDNumber = id;  \/\/ Set when issued\r\n}\r\n<\/code><\/pre>\n<\/li>\n<\/ul>\n
                                Key Differences<\/h3>\n\n\n\n\n\n\n\n\n\n\n
                                Feature<\/th>\nconst<\/code><\/th>\nreadonly<\/code><\/th>\n<\/tr>\n<\/thead>\n
                                Initialization<\/strong><\/td>\nMust be initialized at declaration<\/td>\nCan be initialized at declaration or in constructor<\/td>\n<\/tr>\n
                                Assignment<\/strong><\/td>\nAssigned at compile time<\/td>\nAssigned at runtime<\/td>\n<\/tr>\n
                                Modification<\/strong><\/td>\nCannot be modified after declaration<\/td>\nCannot be modified after initialization<\/td>\n<\/tr>\n
                                Types Allowed<\/strong><\/td>\nPrimitive types, strings, enums<\/td>\nAll types, including complex types<\/td>\n<\/tr>\n
                                Implicitly Static<\/strong><\/td>\nYes<\/td>\nNo (must be declared static<\/code>)<\/td>\n<\/tr>\n
                                Usage<\/strong><\/td>\nUsed for constants known at compile time<\/td>\nUsed for values determined at runtime<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                Important and Tricky Q&A<\/h3>\n
                                Q1: Can a const<\/code> be assigned a value in a constructor?<\/h4>\n
                                Answer<\/strong>: No, const<\/code> values must be assigned at the time of declaration, and they cannot be changed later. They are set at compile time.<\/p>\n
                                Q2: Can a readonly<\/code> value be changed after initialization in the constructor?<\/h4>\n
                                Answer<\/strong>: No, once a readonly<\/code> value is initialized in the constructor, it cannot be modified afterward.<\/p>\n
                                Q3: Why would you choose readonly<\/code> over const<\/code>?<\/h4>\n
                                Answer<\/strong>: Choose readonly<\/code> when you need to set the value at runtime (e.g., based on constructor logic or external input) or when working with non-primitive types. Use const<\/code> when the value is constant and known at compile time.<\/p>\n
                                Q4: Can readonly<\/code> be static<\/code>?<\/h4>\n
                                Answer<\/strong>: Yes, readonly<\/code> can be either instance-level or static<\/code>. If it\u2019s static, the value is shared across all instances and can only be assigned in a static constructor.<\/p>\n
                                Q5: Can const<\/code> be used for complex types like arrays or objects?<\/h4>\n
                                Answer<\/strong>: No, const<\/code> can only be used for primitive types, strings, and enums. Use readonly<\/code> if you need to work with complex types like objects or arrays.<\/p>\n
                                Conclusion<\/h3>\n
                                Use const<\/code><\/strong> when the value is fixed at compile time and will never change. Use readonly<\/code><\/strong> when the value is determined at runtime but should not be modified afterward. Understanding the differences between these two is crucial for writing maintainable and efficient code in C#.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                In C#, both const and readonly are used to define variables whose values cannot be changed after assignment. However, there are significant differences between the two in terms of behavior, usage, and when the value is assigned. 1. Declaration and Initialization Constants (const): Must be declared and initialized at the time of declaration. The value […]<\/p>\n","protected":false},"author":43,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[23,24,188,161],"tags":[201,200],"class_list":["post-56","post","type-post","status-publish","format-standard","hentry","category-asp-net","category-c-net","category-technical-explorations","category-top-100-qa","tag-constants","tag-readonly"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"In C#, both const and readonly are used to define variables whose values cannot be changed after assignment. However, there are significant differences between the two in terms of behavior, usage, and when the value is assigned. 1. Declaration and Initialization Constants (const): Must be declared and initialized at the time of declaration. The value…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/56"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=56"}],"version-history":[{"count":2,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/56\/revisions"}],"predecessor-version":[{"id":809,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/56\/revisions\/809"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=56"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=56"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=56"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}