Question 1

C#.NET enums — analyze the following declaration: enum color : byte { red = 500, green = 1000, blue = 1500 } Which statement about this code is correct?

Accepted Answer

Introduction / Context:In C#, an enum’s underlying type controls the representable range of its named constants. This question checks if you remember that constraint. Given Data / Assumptions: The enum underlying type is byte (range 0..255). Assigned values are 500, 1000, 1500. Concept / Approach:Enum members must be compile-time constants convertible to the underlying type without overflow. Assigning a value outside the underlying type’s range is a compile-time error. Step-by-Step Solution: Check range: 500, 1000, 1500 > 255 → not representable as byte.Compiler emits an error for each out-of-range assignment. Verification / Alternative check:Change the underlying type to int or reduce constants to within 0..255 to make it compile. Why Other Options Are Wrong:(a) is false — you can assign compatible constants; (b) successive values are not required; (d) underlying type can be any integral type except char by default (int if unspecified); (e) access modifiers on enum members are not used — they are constants. Common Pitfalls:Assuming the compiler silently wraps values; it does not for enum member declarations. Final Answer:Since 500, 1000, 1500 exceed the valid range of byte, the compiler will report an error.

Question 2

C#.NET enums — given: enum per { married, unmarried, divorced, spinster } per.married = 10; Console.WriteLine(per.unmarried); Which statement describes the program's behavior?

Accepted Answer

Introduction / Context:Enum members in C# are named constants, not variables. This question assesses understanding of enum immutability and default value assignment. Given Data / Assumptions: per has default underlying type int and default values 0, 1, 2, 3 for the listed members. A subsequent line attempts per.married = 10; Concept / Approach:Enum members are compile-time constants. You cannot assign to them at runtime or change their values outside of the enum declaration. Such an assignment is a compile-time error. Step-by-Step Solution: The compiler parses per.married = 10; and flags an error because per.married is a constant, not a writable l-value.Since compilation fails, no runtime output occurs. Verification / Alternative check:To assign explicit values, you must do so inside the enum declaration, e.g., married = 10. Why Other Options Are Wrong:They assume the program runs and prints numeric values. It will not compile due to the invalid assignment. Common Pitfalls:Confusing enum constants with static fields; they are not mutable fields. Final Answer:The program will report an error since an enum element cannot be assigned a value outside the enum declaration.

Question 3

C#.NET enums — what is printed by: enum color { red, green, blue } color c; c = color.red; Console.WriteLine(c);

Accepted Answer

Introduction / Context:Printing enum values in C# often surprises newcomers. Does it print the underlying number or the name? Given Data / Assumptions: color has implicit underlying type int with values red=0, green=1, blue=2. Variable c is assigned color.red. Concept / Approach:Console.WriteLine calls ToString() on the argument. Enum.ToString() returns the named constant (e.g., "red") if it matches an exact named value. Therefore, the printed output is the name, not the numeric value. Step-by-Step Solution: Assign c = color.red;Print c → calls Enum.ToString() → returns "red". Verification / Alternative check:Cast to int ((int)c) to print 0. Without the cast, the name is printed. Why Other Options Are Wrong:1 or 0 would be printed only if explicitly cast. -1 is irrelevant. color.red is not the string returned by ToString(). Common Pitfalls:Assuming enums always print their numeric value. Final Answer:red

Question 4

C#.NET Enums and reflection: what will this program print for the first enum name?  enum color {  red,  green,  blue }  color c = color.red; Type t; t = c.GetType(); string[] str; str = Enum.GetNames(t); Console.WriteLine(str[0]);

Accepted Answer

Introduction / Context:This question tests understanding of C#.NET enumerations (enum) and the reflection-based helper methods on the System.Enum class, specifically Enum.GetNames(Type). It also touches on how enum member names and their underlying integer values are different concepts. Given Data / Assumptions: An enum named color is declared with members red, green, and blue. A variable c of type color is assigned color.red. t = c.GetType() obtains the runtime type of the enum instance. Enum.GetNames(t) returns an array of the enum member names as strings in declaration order. Console.WriteLine(str[0]) prints the first name in that array. Concept / Approach:For any enum type, Enum.GetNames returns a string array of the symbolic names in the order they are defined in code. Index 0 will therefore be the first declared name. Numeric values are not returned by GetNames; you would use GetValues or casts for underlying integral values. Step-by-Step Solution: The declared order is: red, green, blue.Calling Enum.GetNames(typeof(color)) returns { "red", "green", "blue" }.Therefore, str[0] is "red". Verification / Alternative check:You can print all names using a loop over Enum.GetNames(typeof(color)). You can also verify the underlying values with Enum.GetValues(typeof(color)) which by default are 0, 1, 2. Why Other Options Are Wrong:0, 1, and -1 are integers, not names returned by GetNames. color.red is the fully qualified enum field, not the string name produced by GetNames. Common Pitfalls:Confusing enum names (strings) with their underlying numeric values. Also, assuming GetNames returns numeric strings; it does not. Final Answer:red

Question 5

C#.NET enums with explicit and implicit values: what integers are printed?  enum color : int {  red,  green,  blue = 5,  cyan,  magenta = 10,  yellow }  Console.Write((int)color.green + ", "); Console.Write((int)color.yellow);

Accepted Answer

Introduction / Context:This item checks your knowledge of how C#.NET assigns underlying integer values to enum members when some are explicit and others are implicit. Given Data / Assumptions: red and green have no explicit values. blue = 5 is explicit. cyan follows blue without an explicit value. magenta = 10 is explicit, followed by yellow with no explicit value. Concept / Approach:Rules: the first unassigned enum member gets value 0; each subsequent unassigned member increases by 1 from the previous member’s value. When an explicit value appears, counting resumes from that value for subsequent unassigned members. Step-by-Step Solution: red → 0 (first implicit).green → 1 (implicit next).blue → 5 (explicit).cyan → 6 (implicit after 5).magenta → 10 (explicit).yellow → 11 (implicit after 10).Therefore, printing (int)color.green and (int)color.yellow yields 1, 11. Verification / Alternative check:Print all values via foreach (var x in Enum.GetValues(typeof(color))) Console.Write((int)x + " ");. Why Other Options Are Wrong:2, 11 and 2, 6 mis-assign the early implicit values. 1, 5 uses yellow as 5, ignoring the explicit magenta = 10. Common Pitfalls:Assuming implicit values reset after each explicit assignment or always start at 0 for each block; they continue from the last explicit value. Final Answer:1, 11

Question 6

C#.NET enum fundamentals: identify the correct facts about the enum keyword and the System.Enum class.

Accepted Answer

Introduction / Context:This conceptual question distinguishes the C# language keyword enum from the .NET base class System.Enum and clarifies namespaces. Given Data / Assumptions (Statements to evaluate): 1) To use the keyword enum, we should either use [enum] or System.Enum. 2) enum is a keyword. 3) Enum is a class declared in System.Type namespace. 4) Enum is a class declared in the current project's root namespace. 5) Enum is a class declared in System namespace. Concept / Approach:In C#, enum is a built-in language keyword for declaring enumerations. All enum types ultimately derive from System.Enum, which itself lives in the System namespace. There is no bracketed [enum] syntax in C#, and System.Enum is not in System.Type. Step-by-Step Solution: Statement 1 → False: There is no [enum] attribute; and using the enum keyword does not require referencing System.Enum explicitly.Statement 2 → True: enum is a reserved keyword.Statement 3 → False: System.Enum is in System, not System.Type.Statement 4 → False: It is in the System namespace, not your project root.Statement 5 → True: Correct location is System.Enum. Verification / Alternative check:Use an IDE tool-tip or documentation to confirm namespace and type hierarchy: Enum : ValueType : Object. Why Other Options Are Wrong:Any option including 1, 3, or 4 contains false statements about syntax or namespaces. Common Pitfalls:Confusing the language keyword (enum) with the System.Enum type or assuming special attribute-like syntax exists for enum declarations. Final Answer:2, 5

Question 7

C#.NET enum with negative starting value: what integers are printed?  enum color : int {  red = -3,  green,  blue }  Console.Write((int)color.red + ", "); Console.Write((int)color.green + ", "); Console.Write((int)color.blue);

Accepted Answer

Introduction / Context:This checks whether you know that enum underlying values in C# can be any valid integral values, including negatives, and that implicit members increment by 1 from the prior member. Given Data / Assumptions: red = -3 is explicitly assigned. green and blue are implicit following members. Underlying type is int. Concept / Approach:An enum member without an explicit value receives the value of the previous member plus 1, even when starting from a negative value. Step-by-Step Solution: red → -3 (explicit).green → -2 (implicit: -3 + 1).blue → -1 (implicit: -2 + 1).Printing yields -3, -2, -1. Verification / Alternative check:Cast each member to int in a quick console app, or iterate Enum.GetValues(typeof(color)) and print casted values. Why Other Options Are Wrong:-3, 0, 1 and 0, 1, 2 assume automatic reset at 0, which does not happen. red, green, blue and fully qualified names are not integers. Common Pitfalls:Thinking that enums must start at 0 or that negatives are disallowed; both are misconceptions. Final Answer:-3, -2, -1

Question 8

C#.NET enums: choose all correct placement and typing rules.

Accepted Answer

Introduction / Context:This question validates knowledge of where enums can be declared and which underlying numeric types are allowed in C#.NET. Given Data / Assumptions (Statements): 1) An enum can be declared inside a class. 2) An enum can take Single, Double or Decimal values. 3) An enum can be declared outside a class. 4) An enum can be declared inside/outside a namespace. 5) An object can be assigned to an enum variable. Concept / Approach:Enums can be declared at namespace scope or nested inside classes/structs. Underlying types must be integral: byte, sbyte, short, ushort, int, uint, long, or ulong. Floating-point and decimal are not allowed. Enum variables must hold values of that enum’s underlying integral domain, not arbitrary object references. Step-by-Step Evaluation: 1) True: nested enums are valid.2) False: Single, Double, Decimal are not permitted as underlying types.3) True: enums can be declared at the top level (namespace scope).4) True: both inside a type and at namespace level are allowed.5) False: an object cannot be directly assigned to an enum variable. Verification / Alternative check:Declare test enums with : byte or : long to confirm valid underlying types. Attempting : float or : decimal results in a compile error. Why Other Options Are Wrong:Any choice including statement 2 or 5 is invalid due to incorrect typing rules for enums. Common Pitfalls:Assuming any numeric type works; only integral types are valid. Also, forgetting that nested enums default to member accessibility rules of the containing type. Final Answer:1, 3, 4

Question 9

C#.NET enum category: is an enum a value type or a reference type?

Accepted Answer

Introduction / Context:Understanding whether an enum is a value type or a reference type is fundamental to memory layout, assignment semantics, and performance in .NET. Given Data / Assumptions: You are classifying enums in C#. No unusual runtime features change the core type system. Concept / Approach:In .NET, every enum type inherits from System.Enum, which inherits from System.ValueType. Therefore, all enums are value types. Value types are typically stored inline (e.g., on the stack or inside containing objects) and copied by value semantics. Step-by-Step Reasoning: Enums map symbolic names to underlying integral values.The base hierarchy is System.Enum : System.ValueType : System.Object.Because they derive from ValueType, they are value types by definition. Verification / Alternative check:Reflect any enum in code and inspect typeof(MyEnum).IsValueType which returns true. IL disassembly also shows the inheritance tree. Why Other Options Are Wrong:Reference type is incorrect; enums are not classes. Size or project settings do not alter type category, and you cannot programmatically switch a type from value to reference. Common Pitfalls:Confusing enums with classes or assuming large enums might be treated as references. The category is fixed by the CLR type system. Final Answer:enum is a value type.

Question 10

C#.NET accessibility of enums: is an enum declared inside a class, struct, namespace, or interface automatically public?

Accepted Answer

Introduction / Context:This question focuses on default accessibility of enum declarations in different contexts (namespace scope vs. nested inside types) in C#.NET. Given Data / Assumptions: An enum may be declared inside a class, struct, interface, or at namespace scope. The claim is that such enums are treated as public by default. Concept / Approach:Default accessibility differs by context. At namespace scope, types (including enums) are internal by default. When nested inside a class or struct, the default accessibility is private (unless specified otherwise). Therefore, enums are not automatically public in all contexts. Step-by-Step Reasoning: Namespace-level enum with no modifier → internal by default.Nested enum in a class/struct with no modifier → private by default.Interfaces can contain nested types in C# 8+ scenarios, but accessibility still follows nesting rules, not unconditional public. Verification / Alternative check:Omit the access modifier and let your IDE show the inferred accessibility. Attempt external access from another assembly to confirm it is not public by default. Why Other Options Are Wrong:Marking the statement as True contradicts language rules for default accessibility. Common Pitfalls:Assuming all top-level declarations default to public as in some other languages; in C#, top-level types default to internal. Final Answer:False

Question 11

C#.NET enum placement and accessibility: choose the true statement.

Accepted Answer

Introduction / Context:Here we clarify where enums can be declared and what casting rules and access modifiers apply in C#. Given Data / Assumptions (Evaluate each claim): Implicit cast to convert enum to integral? Public/private/protected usage with enums? Placement inside a class or a namespace? Concept / Approach:Enums can be declared at namespace scope or nested within a class/struct. Casting from an enum to its underlying integral type requires an explicit cast, not implicit. Access modifiers apply like other types: a top-level enum can be public/internal; a nested enum can be private, protected, internal, protected internal, or private protected, depending on the containing type. Step-by-Step Evaluation: Option A → False: enum → int conversion requires explicit cast, e.g., (int)MyEnum.Value.Option B → False: top-level enums can be public; nested enums can also be declared public.Option C → False: nested enums can be private.Option D → True: enums are valid both inside a class and at namespace scope.Option E → False: nested enums may be protected in classes. Verification / Alternative check:Create a nested enum inside a class and vary the access modifiers to see compiler acceptance. Attempt int x = MyEnum.Value; without a cast to observe the compile-time error. Why Other Options Are Wrong:They conflict with the C# specification regarding explicit casting and permissible access modifiers. Common Pitfalls:Confusing implicit numeric promotions with enum conversions; enums are strongly typed and do not implicitly convert to integral types. Final Answer:An enum variable can be defined inside a class or a namespace.

Question 12

C#.NET enums: select all correct statements about their nature and printing behavior.

Accepted Answer

Introduction / Context:This checks foundational facts about enums in C#.NET: their inheritance, value/reference nature, printing, and default underlying type. Given Data / Assumptions (Statements): 1) Every enum is derived from Object. 2) Every enum is a value type. 3) There is no way to print an enum element as a string. 4) Every enum is a reference type. 5) The default underlying datatype of an enum is int. Concept / Approach:An enum type ultimately derives from System.Enum, which inherits from System.ValueType, then System.Object. Therefore, enums are value types. The default underlying type is int unless specified otherwise. Enum values can be converted to strings via .ToString() or Enum.GetName. Step-by-Step Evaluation: 1) True: All types ultimately derive from System.Object.2) True: Enums are value types by definition (ValueType).3) False: myEnumValue.ToString() prints the name; formatting options exist.4) False: Enums are not reference types.5) True: Default underlying type is int. Verification / Alternative check:Run Console.WriteLine(MyEnum.SomeValue.ToString()) or use Enum.GetNames(typeof(MyEnum)) to list names. Why Other Options Are Wrong:Any option containing 3 or 4 contradicts well-documented enum behavior in .NET. Common Pitfalls:Confusing the ability to print names with numeric casts; both are available but serve different purposes. Final Answer:1, 2, 5

Question 13

C#.NET enums: which underlying datatype is not permitted for an enum?

Accepted Answer

Introduction / Context:This question verifies your knowledge of which underlying types are valid for C#.NET enums. Picking an invalid type demonstrates understanding of the integral-only rule. Given Data / Assumptions: Options include integral types and a floating-point type. Enums in C# require an underlying integral type. Concept / Approach:In C#, an enum's underlying type must be one of: byte, sbyte, short, ushort, int, uint, long, or ulong. Floating-point (float, double) and decimal are not allowed. Step-by-Step Reasoning: Check each candidate:byte → valid.short → valid.float → invalid (not integral).int → valid and is the default when unspecified. Verification / Alternative check:Attempt enum E : float { A } in a test project; the compiler reports that the underlying type must be an integral type. Why Other Options Are Wrong:They list integral types that are explicitly allowed by the language specification. Common Pitfalls:Assuming any numeric type is acceptable or thinking that decimal/float work because they are “numbers.” Enums are intended to map names to discrete integral constants. Final Answer:float

Question 14

C#.NET Enums — identify the correct statement about default values and member rules. Consider general behavior of enum members in C#.NET (underlying integral types, default starting value, naming rules, and assignment constraints). Choose the single…

Accepted Answer

Introduction / Context:Enums in C#.NET provide a named set of integral constants. Understanding their default underlying values, naming rules, and the compile-time constant requirement is essential. Given Data / Assumptions: Default underlying type is int. First member defaults to 0. Members increment by 1 unless overridden. Names must be valid identifiers. Initializers must be compile-time constants. Concept / Approach:Members are sequentially numbered starting at 0 unless explicitly given a constant. Non-const variables are invalid at declaration, but values can be cast from database data at runtime. Final Answer:By default, the first enumerator has the value 0 (unless an explicit value is provided).

Question 15

C#.NET Enums — determine what happens when enum members are initialized with variables. Given: int a = 10; int b = 20; int c = 30; enum color : byte { red = a, green = b, blue = c }

Accepted Answer

Introduction / Context:Enum member initializers in C#.NET must be compile-time constants. Variables cannot be used directly. Step-by-Step: 1) a, b, c are variables, not constants.2) Compiler requires const expressions for enum members.3) Declaring them const fixes the error. Final Answer:Variables cannot be assigned to enum elements.

Question 16

C#.NET — working with private enums in classes. Given a private enum declared inside class Sample, determine how it can be accessed in Main() of another class.

Accepted Answer

Introduction / Context:Access modifiers affect whether an enum inside a class can be used outside it. Key Rule:A private enum is scoped only to its containing class. To use it externally, it must be declared public. Final Answer:We must declare enum color as public to use it outside Sample.

Question 17

C#.NET — Can an enum be declared inside class, struct, namespace, or interface?

Accepted Answer

Introduction / Context:Enums are versatile types and can be declared at multiple levels. Fact:C# allows enums inside classes, structs, namespaces, and interfaces. Final Answer:True

Enumerations Questions

Questions

Practice smarter