Type Members

A property is a get/set accessor pair giving controlled access to state. An auto-property { get; set; } makes the compiler generate a hidden backing field. Unlike a public field, a property is a method pair, so you can add validation or logic in set, expose it read-only, or change the implementation later without breaking callers.

A const is a compile-time constant: it must be assigned a literal at declaration, is implicitly static, and its value is baked directly into every caller's compiled code. A readonly field is set once at runtime — either at declaration or in a constructor — can differ per instance, and may hold a non-literal value. Changing a const requires recompiling all consumers; a readonly does not.

Both pass an alias to the caller's variable rather than a copy, so the method reads and writes the same storage. A ref argument must be initialized before the call, since the method may read it. An out argument need not be initialized beforehand, but the method MUST assign it before returning. Use out to return extra values; use ref for two-way exchange.

An enum is a named set of integral constants. Its underlying type defaults to int, and the first member defaults to value 0 unless you assign explicit values. [Flags] marks the enum as a bit field, so members assigned distinct powers of two can be combined with bitwise | and tested with &, and ToString then formats combinations as a comma-separated list.

An extension method is a static method in a static class whose first parameter is prefixed with this, like this T x. The compiler lets you call it as if it were an instance method on T, so you can add methods to a type — including an interface like IEnumerable<T> — without modifying or subclassing it. LINQ operators are extension methods, found by using the namespace.

Because string is immutable, each + in a loop cannot modify the existing string — it allocates a brand-new string and copies all prior characters, so concatenating n times is O(n²) work and floods the GC with throwaway strings. StringBuilder holds a mutable, growable buffer and appends in place, making the build O(n). Call ToString() once at the end to materialize the result.

An event wraps a delegate field but exposes only += and -= to outside code, so subscribers can attach and detach handlers but cannot invoke the delegate or overwrite the whole list. Only the declaring type may raise the event or reassign it. This encapsulates the publisher/subscriber pattern: it prevents a subscriber from clearing other subscribers or firing the event on the publisher's behalf.

partial lets a single class, struct, interface, or method be split across multiple source files, which the compiler merges into one type at build time. Every part must use partial and share the same name and namespace. Its main use is keeping machine-generated code — designer files or source-generator output — in a separate file from hand-written code, so regeneration never overwrites your edits.

An indexer lets instances of a type be accessed with [] bracket syntax, as in obj[i], the way an array is. It is declared with the this keyword, like public T this[int i] { get; set; }. An indexer is essentially a property that takes parameters: it has get/set accessors but no name, and it can be overloaded on different parameter types such as this[string key].