Question 1

C#.NET — About the delegate declaration below, which statements are correct?  delegate void del(int i);  Consider: 1) Declaring the delegate creates a class named del. 2) The signature of del need not match the method's signature. 3) The generated d…

Accepted Answer

Introduction / Context: C# delegates are type-safe function pointers. The compiler generates a sealed class behind the scenes for each delegate type. Understanding this generation helps reason about compatibility and invocation. Given Data / Assumptions: Delegate declaration: delegate void del(int i); We evaluate five statements about what the compiler emits and what methods a delegate can target. Concept / Approach: Declaring a delegate produces a class with the same name that derives from MulticastDelegate. Methods assigned to that delegate must be signature-compatible (parameter list and return type). Delegates can reference static or instance methods. The generated delegate type exposes a constructor that takes the target (object for instance methods or null for static) and a method pointer, and it provides an Invoke method matching the delegate signature. Step-by-Step Solution: 1) True — a compiler-generated class named del appears.2) False — signatures must be compatible to assign/subscribe.3) True — all C# delegate types derive from MulticastDelegate.4) False — both static and instance methods can be targets.5) True — the delegate exposes a specific constructor and an Invoke method. Verification / Alternative check: Use reflection at runtime (typeof(del)) to see its BaseType (MulticastDelegate) and methods (Invoke, BeginInvoke/EndInvoke in older patterns). Why Other Options Are Wrong: A includes statement 2 which is false. C/D include false claims about signatures or static methods. E is incorrect because 2 and 4 are false. Common Pitfalls: Assuming any method can be assigned to a delegate regardless of signature; in C#, type safety is enforced. Final Answer: 1, 3 and 5 only

Question 2

C#.NET — Delegates: In which of the following areas are delegates most commonly used?  Remoting  Serialization  File Input/Output  Multithreading  Event handling

Accepted Answer

Introduction / Context: This question focuses on understanding the core application areas of delegates in C#. Delegates are reference types that are central to event-driven and asynchronous programming in .NET. Recognizing where they are most useful helps in writing cleaner, modular, and flexible code. Given Data / Assumptions: Delegates are function pointers in managed code, providing type safety. Delegates are often compared with callbacks in other languages. Common application areas are considered. Concept / Approach: Delegates are not typically used in remoting, serialization, or file I/O directly. They shine in asynchronous programming (multithreading) and event handling. Event handlers in GUI frameworks like Windows Forms and WPF rely on delegates. Similarly, asynchronous task execution often leverages delegates for callbacks. Step-by-Step Solution: (1) Remoting — handled by proxies and serializers, not direct delegate usage → Not primary. (2) Serialization — typically handled by formatters, attributes, and reflection → Not delegate-specific. (3) File I/O — managed with streams, readers, and writers → No strong delegate usage. (4) Multithreading — delegates allow callback execution and asynchronous invocation → Valid use case. (5) Event handling — the most common use case of delegates in C# → Valid use case. Verification / Alternative check: In WinForms: button.Click += new EventHandler(MyHandler); This line relies on delegates. In threading: BeginInvoke/EndInvoke patterns also rely on delegates. Why Other Options Are Wrong: Options A and C include incorrect use cases. Option B ignores multithreading. Option E overstates usage, including irrelevant scenarios. Common Pitfalls: Believing delegates are used for every runtime service; confusing their broad utility with core framework mechanisms like serialization and I/O. Final Answer: 4 and 5 only

Question 3

C#.NET — Delegates: Identify the incorrect statement.

Accepted Answer

Introduction / Context: This question tests fundamental knowledge about delegates in C#. Delegates are central to implementing callbacks and events, and it is important to differentiate their capabilities from older language constructs like function pointers. Given Data / Assumptions: Delegates are reference types and part of the object-oriented nature of C#. They are strongly type-safe, enforcing matching signatures. They allow multicasting. Concept / Approach: The false statement among the options is that only one method can be bound to a delegate. In fact, C# supports multicast delegates, which can call multiple methods in an invocation list. Step-by-Step Solution: A — True: delegates are reference types. B — True: delegates fit within the object-oriented paradigm of C#. C — True: they are type-safe; the method signature must match the delegate signature. D — True: they serve a role similar to function pointers in unmanaged languages. E — False: delegates can point to multiple methods, making them multicast. Verification / Alternative check: Create a delegate and use += to attach multiple methods. All methods execute in sequence when invoked, proving the incorrectness of option E. Why Other Options Are Wrong: All others accurately describe delegates. Only E contradicts the multicast feature. Common Pitfalls: Assuming delegates work exactly like C pointers; forgetting multicast behavior. Final Answer: Only one method can be called using a delegate.

Question 4

C#.NET — Which of the following is a necessary condition for implementing delegates?

Accepted Answer

Introduction / Context: Delegates in C# act as type-safe function pointers. Understanding what condition is needed for delegates helps clarify their design principles in the .NET runtime. Given Data / Assumptions: Delegates must match method signatures at compile-time. Delegates enforce type safety. Concept / Approach: Delegates rely on compile-time polymorphism (static binding of method signatures) to ensure that assigned methods match their declared signature. Unlike inheritance or runtime polymorphism, delegates work by creating callable objects bound to methods that satisfy the signature contract. Step-by-Step Solution: Check A: Class declaration — Not mandatory; delegates are standalone types. Check B: Inheritance — Not needed for delegates to work. Check C: Run-time polymorphism — Delegates don’t rely on virtual/override mechanisms. Check D: Exceptions — Unrelated to delegates. Check E: Compile-time polymorphism — Correct; ensures method signature compliance. Verification / Alternative check: Try assigning a method with mismatched signature to a delegate; compiler error confirms compile-time enforcement. Why Other Options Are Wrong: They introduce unrelated concepts (inheritance, exceptions, runtime polymorphism). Common Pitfalls: Confusing delegate type-safety with runtime polymorphism. Delegates are strongly checked at compile-time. Final Answer: Compile-time polymorphism

Question 5

C#.NET — Correct delegate call: Identify the correct way to invoke MyFun() in class Sample. class Sample { public void MyFun(int i, float j) { Console.WriteLine("Welcome to CuriousTab !"); } }

Accepted Answer

Introduction / Context: This tests how to correctly declare and use delegates to invoke a method with specific parameters in C#. Correct signature matching is crucial for delegates to work. Given Data / Assumptions: Class Sample has method MyFun(int i, float j). We want to call it using a delegate. Concept / Approach: Delegates must match the method signature exactly. MyFun takes two parameters: int and float. Therefore, the delegate must be declared as delegate void del(int, float). Step-by-Step Solution: Option A — Wrong: delegate has only int parameter, but method needs int and float. Option B — Correct: delegate matches method signature and properly instantiates with ref s.MyFun. Option C — Wrong: invalid syntax for delegate instantiation. Option D — Wrong: syntax error in parameter declaration. Verification / Alternative check: Compile and run with Option B, works correctly, printing the message. Why Other Options Are Wrong: Mismatched signatures or invalid syntax. Common Pitfalls: Forgetting that delegate parameters must exactly match target method parameters; confusing declaration and instantiation syntax. Final Answer: delegate void del(int i, float j); del d; Sample s = new Sample(); d = new del(ref s.MyFun); d(10, 1.1f);

Question 6

C#.NET delegates — Which of the following statements are correct?

Accepted Answer

Introduction / Context: Delegates in C#.NET are type-safe function pointers that encapsulate a method reference and, optionally, a target object. This question tests what delegates can and cannot invoke, and the importance of method signatures for delegate compatibility. Given Data / Assumptions: A delegate can reference static or instance methods. Delegate compatibility is based on matching signature (parameter types, order, and return type). Delegates can be multicast (invoke multiple compatible methods). Variable argument methods are supported when the delegate itself uses a matching params signature. Concept / Approach: The core rule is signature compatibility: a single delegate type can call any method whose signature matches the delegate’s signature. Static and instance targets are both supported. Claims that categorically deny static or instance method support are incorrect. Variable argument methods are possible if the delegate type is declared with a suitable params parameter. Step-by-Step Solution: Identify the true statement: methods with the same signature can be invoked through one delegate type.Eliminate false statements: delegates work with static and instance methods; variable arguments are supported through matching delegate signatures. Verification / Alternative check: Create delegate int Op(int x, int y); and point it to multiple methods Add and Subtract; both are callable if the signatures match. Why Other Options Are Wrong: Option A: Delegates can call static methods (target object is null internally). Option B: Delegates can represent methods with params when declared accordingly. Option D: Delegates can call instance methods (they capture a target object). Common Pitfalls: Assuming delegates ignore return type or that they can freely coerce mismatched signatures—C# requires type safety. Final Answer: If signatures of two methods are same they can be called through the same delegate object.

Question 7

Generics in C#.NET — For a generic class SortObjects that must compare any type (int, float, byte, etc.), which construct should be used to implement the comparison function cleanly and type-safely?

Accepted Answer

Introduction / Context: Sorting arbitrary objects generically in C#.NET requires a type-safe way to compare two instances. The question asks which construct best provides a reusable comparison contract for any T. Given Data / Assumptions: The class SortObjects should sort values of many types. We want a design that works across the .NET type system. Solutions should be type-safe and extensible. Concept / Approach: Interfaces such as IComparable and IComparer define comparison contracts. A generic sorter can rely on IComparable implemented by T, or accept an IComparer instance. This enables strong typing, reusability, and consistent semantics. While delegates like Comparison can be used for one-off comparisons, the canonical, framework-wide approach is through interfaces. Step-by-Step Solution: Define SortObjects.Sort using IComparer: public void Sort(IList items, IComparer cmp)Default to Comparer.Default which uses IComparable where available.Allow callers to pass custom comparers implementing IComparer. Verification / Alternative check: Use built-in List.Sort which follows the same pattern with IComparer or Comparison overloads. This demonstrates the interface-based design is standard. Why Other Options Are Wrong: Namespace/Attribute: metadata/organization concepts, not behavioral contracts. Encapsulation: a principle, not a comparison API. Delegate: useful for ad-hoc comparisons, but the long-term, reusable contract for generic sorting is via interfaces. Common Pitfalls: Hard-coding comparisons for each type or using object and casting, which sacrifices type safety. Final Answer: Interface

Question 8

C#.NET delegates — Which statement is incorrect about a delegate?

Accepted Answer

Introduction / Context: C# delegates are central to events, callbacks, and LINQ expression trees. This question asks you to identify a false statement regarding delegate characteristics. Given Data / Assumptions: Delegates can be multicast. Type safety requires signature compatibility. Delegates are reference types generated by the compiler. Concept / Approach: Delegates are sealed reference types deriving from MulticastDelegate. They are not value types. Multicast invocation lists allow one delegate instance to call multiple compatible methods. Type safety demands that the target method’s parameter and return types match the delegate declaration. Step-by-Step Solution: Check each option against delegate semantics.A: True (multicast delegates).B: “Shared” commonly means reusable instances—possible; nothing forbids reuse.C: False — delegates are reference types.D: True — they wrap function pointers with type safety.E: True — signatures must match. Verification / Alternative check: Reflect on typeof(Action) to see BaseType = MulticastDelegate and reference-type behavior. Why Other Options Are Wrong: They accurately describe real delegate features in C#. Common Pitfalls: Confusing structs (value types) with delegates, which are classes. Final Answer: Delegate is a value type.

Delegates Questions