Question 1

When redefining a virtual method from a base class in C#.NET, which modifier must the derived class use?

Accepted Answer

Introduction / Context:Polymorphism in C#.NET relies on virtual methods in a base class and overriding implementations in derived classes. This question checks knowledge of the correct modifier used when providing a new implementation. Given Data / Assumptions: The base class method is marked virtual/abstract. The derived class intends to supply its own implementation that participates in runtime polymorphism. Concept / Approach:Use the override keyword in the derived class to replace the virtual method’s implementation. The base class marks the method as virtual (or abstract), while new would hide rather than override. Step-by-Step Solution: If Base declares public virtual void M(), then Derived must write public override void M() to override.Using virtual in the derived class would declare a new virtual method rather than overriding without override.Keywords like overloads and overridable are VB.NET terms, not C# modifiers; base is used to call the base implementation, not to declare an override. Verification / Alternative check:Try calling a method via a base-class reference that points to a derived instance; only an override participates in dynamic dispatch. Why Other Options Are Wrong:overloads and overridable are not C# keywords; virtual alone is insufficient in the derived class; base is not a modifier. Common Pitfalls:Confusing method hiding (new) with overriding, or mixing VB.NET keyword vocabulary with C#. Final Answer:override

Question 2

C#.NET virtual members and overriding — which base-class modifier allows a derived instance to completely take over a member? In object-oriented C# design, a base class must opt-in to polymorphic override behavior. Choose the modifier the base class…

Accepted Answer

Introduction / Context:In C#.NET, runtime polymorphism depends on whether the base member is declared in a way that permits overriding. If the base member does not allow overrides, a derived class cannot truly replace its behavior polymorphically. Given Data / Assumptions: We are discussing class inheritance in C#. The goal is to allow a derived class to supply a replacing implementation. The replacement must work via base references at runtime. Concept / Approach:The base class must mark a method or property as virtual (or abstract). A derived class then uses override to supply the new implementation. Using new merely hides a member at compile time but does not participate in dynamic dispatch through a base reference. Step-by-Step Solution: 1) Base declares: virtual void M() { /* base */ }2) Derived declares: override void M() { /* derived */ }3) Calling M() through a Base reference bound to a Derived object invokes Derived.M(). Verification / Alternative check:Test with Base b = new Derived(); b.M(); and observe the derived implementation executing. Why Other Options Are Wrong: new: hides, not overrides. base: keyword to access base members, not a modifier to enable overriding. overloads: relates to method overloading (same name, different signatures). overrides: not a C# keyword (actual keyword is override, used in the derived class). Common Pitfalls:Confusing new with override leads to unexpected base behavior when using base-typed references. Final Answer:virtual

Question 3

Overriding rules in C#.NET — identify the correct statement about virtual/abstract methods and overrides. Select the statement that accurately reflects C# method overriding requirements.

Accepted Answer

Introduction / Context:Overriding in C#.NET lets a derived class provide a new implementation for a virtual (or abstract) member from a base class. Correct matching of signatures is essential. Given Data / Assumptions: We are dealing with instance methods in classes. Focus is on virtual/abstract semantics and overriding rules. Concept / Approach:To override, a base member must be virtual/abstract, and the derived method must use the override keyword. The method's name, return type, and parameter types and order must exactly match (excluding optional parameters metadata differences). Static members cannot be virtual; abstract methods are implicitly virtual and must be overridden in a non-abstract derived class. Step-by-Step Solution: 1) Check static: static cannot be virtual (so option A is false).2) Abstract methods are by definition virtual (option B is false).3) Overriding a virtual method is optional unless the method is abstract (option C is false).4) Overriding requires exact signature match (option D is true).5) Non-virtual methods cannot be overridden (option E is false). Verification / Alternative check:Compile small examples with and without matching signatures to see compiler diagnostics. Why Other Options Are Wrong:They contradict C# language rules on virtual and abstract members. Common Pitfalls:Confusing hiding (new) with overriding (override). Final Answer:When overriding, the method name and full signature must exactly match the virtual member being overridden.

Question 4

Operator overloading and member hiding in C#.NET — choose all correct statements (single best answer option lists all true ones).

Accepted Answer

Introduction / Context:This item checks understanding of method overloading, operator overloading constraints, and the use of the new modifier for hiding. Given Data / Assumptions: User-defined types may overload selected operators. new can hide members (including nested types). Overloading (methods) vs operator overloading (operators) have different rules. Concept / Approach:In C#, not all operators are overloadable (for example, new, sizeof, =, && cannot be overloaded). Operator overloads must be static and at least one operand must be the declaring type. Method overloading allows multiple methods with the same name but different signatures. Step-by-Step Solution: 1) Option A: false — not all operators are overloadable; operands cannot both be unrelated types.2) Option B: true statement, but does not alone capture all requirements of the question.3) Option C: true for method overloading.4) Option D: true and the most complete/precise operator-overloading rule (best single answer).5) Option E: false — at least one operand must be the containing type (often exactly that). Verification / Alternative check:Implement a simple struct with operator + and confirm that the overload must be static and include the struct as an operand. Why Other Options Are Wrong:A and E violate language rules; B and C are correct statements but D is the most complete and directly addresses operator overloading constraints. Common Pitfalls:Equating new (hiding) with override (polymorphism), and assuming all operators can be overloaded. Final Answer:Operator overloading permits using symbolic operators to express computations for a user-defined type; at least one operand must be the containing type.

Question 5

Unary operator overloading in C#.NET — which unary operators among the list are overloadable?

Accepted Answer

Introduction / Context:C# permits overloading many unary operators to customize semantics for user-defined types. Given Data / Assumptions: Operators under consideration: true, false, +, new, is. Concept / Approach:Overloadable unary operators include +, -, !, ~, ++, --, true, and false. Keywords new and is are not overloadable operators. Step-by-Step Solution: 1) true/false: overloadable to support custom truthiness on types.2) unary +: overloadable; often paired with binary + overloads.3) new: not an operator you can overload.4) is: not overloadable. Verification / Alternative check:Compile a struct with public static bool operator true(...) and public static bool operator false(...). Why Other Options Are Wrong:B and D include non-overloadable keywords; C is incomplete. Common Pitfalls:Confusing language keywords with overloadable operators. Final Answer:true, false, and unary + can be overloaded.

Question 6

Preventing further overrides in C#.NET — which modifier stops virtual inheritance (no further overriding) in a derived class?

Accepted Answer

Introduction / Context:Sometimes a derived class wants to stop the override chain. C# provides a modifier for this purpose. Concept / Approach:Use sealed on an override (sealed override) to prevent further overriding down the inheritance chain. Why Other Options Are Wrong:They are not C# modifiers applicable to method overriding. Final Answer:sealed

Question 7

Non-overloadable operators in C#.NET — identify which among the list cannot be overloaded.

Accepted Answer

Introduction / Context:C# restricts which operators can be overloaded. Knowing the non-overloadable ones is important. Concept / Approach:Operators like +, -, *, /, %, &, |, ^, ~, !, ++, --, true, false, and conversion operators (implicit/explicit) are overloadable. new and sizeof are not overloadable. Why Other Options Are Wrong:true and false are overloadable; ~ is overloadable; hence A and B are incorrect. D is incorrect because not all are overloadable. E is incorrect since true is overloadable. Final Answer:new and sizeof

Question 8

Hiding vs overriding — what does the derived method do in this code? public class Sample { public int x; public virtual void fun() { } } public class DerivedSample : Sample { new public void fun() { } }

Accepted Answer

Introduction / Context:In C#, new hides a base member; override replaces it polymorphically. This question distinguishes hiding from overriding. Given Data / Assumptions: Base fun() is virtual. Derived fun() uses new, not override. Concept / Approach:Using new creates a new member that hides the base member when the variable is typed as DerivedSample. Calls through a Sample reference still bind to the base virtual unless the derived used override. Step-by-Step Solution: 1) Hide: new public void fun() — compile-time hiding.2) Override would be: public override void fun() — runtime polymorphism. Why Other Options Are Wrong: B: Through a Sample reference, the base virtual dispatch targets the base unless override is used. C: Hiding does not replace for all calls. D: You can hide without new; the compiler warns but still hides. Common Pitfalls:Assuming new implies override-like behavior. Final Answer:DerivedSample hides the fun() method of the base class.

Question 9

Keyword used to replace base-class behavior with a derived implementation (polymorphic override) in C#.NET.

Accepted Answer

Introduction / Context:Polymorphism requires a base virtual member and a derived override. This distinguishes override from hiding. Concept / Approach:Use override in the derived class to supply a replacement for a base virtual/abstract member. Why Other Options Are Wrong:new hides; base accesses base implementations; overloads refers to method overloading; overridable is not a C# keyword. Final Answer:override

Question 10

Choose the correct statement about member hiding and operator overloading in C#.NET.

Accepted Answer

Introduction / Context:Member hiding and operator overloading are common advanced topics in C#.NET. Given Data / Assumptions: We are comparing correctness of several statements. Concept / Approach:Hiding uses the new modifier. Operator overloads must be static and follow the same rules for structs and classes. Conversion operators (implicit/explicit) are overloadable. Step-by-Step Solution: 1) Option A: Correct — new explicitly hides a base member.2) Option B: Incorrect — rules are essentially the same for structs and classes.3) Option C: Incorrect — operator overloads must be static.4) Option D: Incorrect — conversion operators can be overloaded (implicit/explicit). Why Other Options Are Wrong:They contradict C# operator overloading specifications. Final Answer:Using the new modifier explicitly hides an inherited member from a base class.

Question 11

Virtual method behavior when not overridden in a derived class — choose the correct statement.

Accepted Answer

Introduction / Context:Understanding default virtual method behavior is key to predicting runtime dispatch in C#. Given Data / Assumptions: We have a base class with a virtual member. The derived class may or may not override it. Concept / Approach:If the derived class does not provide an override, the base virtual implementation is used for calls, including those made through base references. Why Other Options Are Wrong: A: Abstract classes cannot be instantiated at all. B: Methods are non-virtual by default unless marked virtual/abstract/override. D: Omitting override does not auto-override; it either hides (with new) or just defines a separate member. E: Derived classes can provide their own overrides. Final Answer:If a derived class does not override a virtual method, the base class implementation is used.

Question 12

In C# operator overloading, which of the following statements is correct?

Accepted Answer

Introduction / Context:This question tests precise knowledge of what C# allows (and forbids) in operator overloading. Many developers conflate operator overloading rules with behavior in other languages, so clarity here is essential for writing maintainable, correct code. Given Data / Assumptions: C# supports overloading many operators using the 'operator' keyword. Some operators cannot be overloaded at all, while others are indirectly supported. Equality and relational operators have special rules to avoid infinite recursion and inconsistencies. Concept / Approach:Remember two key facts: (1) You cannot overload the conditional logical operators '&&' and '||' directly; instead, overloading '&' and '|' plus providing 'true' and 'false' operators enables short-circuit semantics. (2) Compound assignments (+=, -=, etc.) are not overloaded separately; they are translated by the compiler into the underlying binary operator plus assignment. Step-by-Step Solution: Evaluate A: Correct. '&&' and '||' cannot be overloaded directly; you overload '&'/'|' and optionally 'true'/'false'.Evaluate B: Incorrect. You do not overload '+='; the compiler rewrites 'x += y' into 'x = x + y' (using your overloaded '+').Evaluate C: Incorrect. Calling the same '==' inside your '==' will recurse. Use ReferenceEquals or compare fields directly.Evaluate D: Incorrect. Any eligible type (including public reference types) may overload '=='/'!=', following the rules.Evaluate E: Incorrect. You cannot overload '[]'; you implement indexers instead (this is a language feature separate from operator overloading). Verification / Alternative check:Try declaring 'public static Type operator &&(Type a, Type b)'; the compiler rejects it. Implement an indexer with 'this[int i]'; no operator method is involved. Why Other Options Are Wrong:B misunderstands compound assignments; C leads to recursion; D is overly restrictive; E confuses indexers with operator overloading. Common Pitfalls:Assuming every visible operator token is overloadable; forgetting the special semantics for equality and conditional operators. Final Answer:The conditional logical operators && and || cannot be overloaded directly.

Question 13

C# syntax check: choose the correct way to overload the + operator for a user-defined type 'sample'.

Accepted Answer

Introduction / Context:Operator overloading in C# uses a very specific signature. Getting the modifiers and placement right is essential to compile and achieve the intended behavior. Given Data / Assumptions: The type name is 'sample'. We need the correct C# signature for overloading the binary '+' operator. Concept / Approach:All overloaded operator methods must be public static and must return the containing type (or another appropriate return type, depending on the operator). They cannot be abstract or instance methods. The method name is the keyword 'operator' followed by the operator symbol. Step-by-Step Solution: Valid pattern: public static operator +(sample a, sample b) { /* ... */ }Option D matches this pattern exactly.Option A is missing 'static'.Options B and C wrongly use 'abstract'; operators cannot be abstract and must provide a body.Option E cannot be correct because A–C contain errors. Verification / Alternative check:Attempt to compile A–C and note the compiler errors. D compiles and can be exercised with 'var s = a + b;' Why Other Options Are Wrong:They violate the 'public static' requirement or misuse 'abstract' for operators. Common Pitfalls:Forgetting 'static', returning the wrong type, or mismatching parameter types. Final Answer:public static sample operator + (sample a, sample b)

Question 14

In C#, which keyword is used in method declarations to overload operators for user-defined types?

Accepted Answer

Introduction / Context:Operator overloading syntax hinges on one specific keyword in C#: 'operator'. This question confirms that you know the correct keyword to declare overloaded operators. Given Data / Assumptions: You are writing a user-defined type and want to overload an operator such as +, -, ==, etc. Concept / Approach:The general pattern is 'public static ReturnType operator +(Type a, Type b)'. Only the 'operator' keyword is valid here; there are no alternative or alias keywords for this purpose. Step-by-Step Solution: Check options for exact C# keyword: 'operator' is the only correct one.All other choices (op, opoverload, operatoroverload, udoperator) are fictitious names and not valid C# syntax. Verification / Alternative check:Create a minimal class and attempt to compile with each proposed keyword; only 'operator' compiles. Why Other Options Are Wrong:They do not exist in the C# language specification. Common Pitfalls:Confusing C# syntax with other languages or inventing pseudo-keywords. Final Answer:operator

Question 15

Run-time polymorphism (method overriding) in C#: which statements are required/true?

Accepted Answer

Introduction / Context:Run-time polymorphism in C# occurs when a base-class reference invokes an overridden method on a derived object. Understanding the rules for 'virtual', 'override', and accessibility ensures correct behavior and avoids compiler errors. Given Data / Assumptions:Statements (paraphrased): 1) The overridden base method must be virtual, abstract, or already override. 2) The override method must have the same access level as the base virtual method. 3) An override declaration can change the accessibility of the virtual method. 4) An abstract inherited property cannot be overridden in a derived class. 5) An abstract method is implicitly virtual. Concept / Approach:C# requires base methods to be marked virtual/abstract/override to be overridden. Overridden members must keep the same accessibility, and abstract methods (and properties) are implicitly virtual and must be overridden (unless the derived class is abstract too). Step-by-Step Solution: Statement 1: True. Without virtual/abstract/override in the base, the derived cannot override.Statement 2: True. Accessibility cannot be changed (e.g., protected virtual cannot become public override).Statement 3: False. Overriding cannot widen/narrow accessibility.Statement 4: False. Abstract properties are intended to be overridden.Statement 5: True. Abstract implies virtual. Verification / Alternative check:Create a protected virtual method in the base and attempt to override as public; the compiler errors on accessibility change. Override an abstract property; compilation is required unless the derived class remains abstract. Why Other Options Are Wrong:Options including 3 or 4 contradict C# rules; only 1, 2, and 5 stand together correctly. Common Pitfalls:Confusing 'new' (method hiding) with 'override' (polymorphism), and forgetting abstract members are implicitly virtual. Final Answer:1, 2, and 5

Question 16

In a C# class, which members can be declared as virtual (eligible for overriding)?

Accepted Answer

Introduction / Context:Virtual members enable derived classes to provide specialized behavior. Misunderstanding which members can be marked virtual leads to incorrect designs and compiler errors. Given Data / Assumptions: C# allows virtual on instance members that support overriding. Fields (including static fields) cannot be virtual. Concept / Approach:Virtual is permitted on methods, properties, and events. Fields store data and do not participate in polymorphic dispatch, therefore they cannot be virtual. Static members also do not participate in instance polymorphism. Step-by-Step Solution: Evaluate methods → can be virtual.Evaluate properties → can be virtual (their accessors can be overridden).Evaluate events → can be virtual.Evaluate fields (instance/static) → cannot be virtual. Verification / Alternative check:Try compiling 'public virtual int x;' or 'public virtual static int y;'; both will fail. 'public virtual int P { get; set; }' compiles and can be overridden. Why Other Options Are Wrong:Any option listing fields or static fields as virtual is invalid in C#. Common Pitfalls:Assuming virtual applies to data the same way as to behavior; forgetting that polymorphism targets methods (including property/event accessors). Final Answer:Methods, properties, and events

Polymorphism Questions

Questions

Practice smarter