Question 1

C# attributes: to which program elements can attributes be applied from the following list — Method, Class, Assembly, Namespace, Enum?

Accepted Answer

Introduction / Context: Attributes in C# provide declarative metadata attached to code elements. They can influence compile-time behavior, runtime behavior, tooling, and frameworks. Knowing which language constructs accept attributes is fundamental. Given Data / Assumptions: The candidate targets are: Method (1), Class (2), Assembly (3), Namespace (4), Enum (5). We are using standard C# attribute application syntax with square brackets or assembly-level attribute syntax. Concept / Approach: Attributes may be applied to assemblies, modules, types (classes, structs, enums, interfaces, delegates), members (methods, properties, events, fields), parameters, return values, and more. Namespaces, however, cannot directly have attributes in C#. Step-by-Step Solution: Method → allowed (e.g., [Obsolete] on a method).Class → allowed (e.g., [Serializable] on a class).Assembly → allowed (e.g., [assembly: AssemblyTitle(""... "")]).Namespace → not a valid attribute target in C#.Enum → allowed (enums are types; e.g., [Flags] on an enum). Verification / Alternative check: Examine the C# specification or IntelliSense quick info; attempting to attach an attribute directly to a namespace yields a compilation error. Why Other Options Are Wrong: Options excluding Enum omit a valid target. The “All listed targets” option incorrectly includes Namespace. The pair (Namespace, Enum) is wrong because Namespace is invalid. Common Pitfalls: Confusing namespace-level using directives and extern alias with attribute application. Assembly-level attributes use a special target specifier inside the brackets (assembly: …). Final Answer: Method, Class, Assembly, and Enum (1, 2, 3, 5)

Question 2

After attributes are applied in a .NET application, which of the following cannot inspect or read those attributes?

Accepted Answer

Introduction / Context: Attributes are stored as metadata in the compiled assembly. Various parts of the .NET toolchain and runtime can read this metadata for diagnostics, code generation, runtime behavior changes, and framework integration. Given Data / Assumptions: Attributes are compiled into assembly metadata. We consider which components typically read or react to attributes. Concept / Approach: The CLR and frameworks (e.g., ASP.NET) commonly use reflection to read attributes at runtime. Compilers and tooling (e.g., Visual Studio analyzers) can interpret attributes at compile-time or design-time to produce warnings, errors, or scaffolding. A traditional “linker” in .NET does not generally inspect attributes to drive behavior in the way the CLR, compilers, or runtimes do. Step-by-Step Solution: CLR → can inspect attributes via reflection at runtime.ASP.NET Runtime → commonly uses attributes (e.g., WebMethod, Route attributes) to wire behaviors.Visual Studio .NET → tooling and designers can read attributes to influence design-time experience.Language compilers → read attributes (e.g., Obsolete) to emit warnings/errors.Linker → not the component that inspects attributes in typical .NET build/run flows; its role does not include interpreting application-specific attribute metadata. Verification / Alternative check: Use reflection (GetCustomAttributes) at runtime to confirm CLR accessibility. Mark members with [Obsolete] and watch the compiler react at compile-time. Why Other Options Are Wrong: They all are known to read attributes in their respective phases. Common Pitfalls: Assuming attribute processing is only runtime; in .NET it spans compile-time, design-time, and runtime. Final Answer: Linker

Question 3

Applying a custom attribute Tested(name, testgrade): which applications are correct for assembly-level and class-level usage?

Accepted Answer

Introduction / Context: Custom attributes in C# are user-defined classes derived from System.Attribute. Once created, they can be applied to a variety of targets, including assemblies and classes, provided their AttributeUsage allows those targets. Given Data / Assumptions: The custom attribute is named Tested and takes two arguments: a tester's name and a testgrade enum value. Two example applications are shown: one at assembly level and one at class level. There are also claims that attributes cannot be applied to assemblies or classes/methods. Concept / Approach: Assembly-level attributes use the special target specifier inside the brackets: [assembly: …]. Class-level attributes are placed directly above the class declaration. Both are standard and valid, assuming AttributeUsage supports those targets. Step-by-Step Solution: Check assembly-level usage → [assembly: Tested(""..."", testgrade.Good)] is valid.Check class-level usage → [Tested(""..."" , testgrade.Excellent)] before a class is valid.Claims that attributes cannot be applied to assembly/class/method are false in general C#. Verification / Alternative check: Create a minimal TestedAttribute : Attribute class with [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)], apply at assembly and class scope, and compile successfully. Why Other Options Are Wrong: They assert impossibilities (e.g., cannot apply to assemblies or classes) that contradict the attribute system. Common Pitfalls: Forgetting the assembly target specifier; assuming attributes default to all targets without AttributeUsage configuration. Final Answer: [assembly: Tested('Sachin', testgrade.Good)] and [Tested('Virat', testgrade.Excellent)] class Customer { /.../ } are both valid usages

Question 4

Custom attributes in C#: which of the following cannot be a valid attribute target?

Accepted Answer

Introduction / Context: Attributes annotate program elements to add metadata used by compilers, tools, and runtime frameworks. Not every syntactic element supports attribute application in C#. Given Data / Assumptions: Potential targets include: enum, event, delegate, interface, and namespace. We are using C# attribute syntax with square brackets. Concept / Approach: In C#, attributes can target assemblies, modules, types (classes, structs, enums, interfaces, delegates), and members (methods, properties, events, fields), as well as parameters and return values. Namespaces are not valid attribute targets. Step-by-Step Solution: Enum → valid (e.g., [Flags]).Event → valid (attributes can decorate an event declaration).Delegate → valid (delegates are types).Interface → valid (interfaces are types).Namespace → invalid target in C#. Verification / Alternative check: Try applying an attribute directly to a namespace block; the compiler rejects it. Applying attributes to any of the other four compiles if AttributeUsage permits. Why Other Options Are Wrong: They list elements that are indeed valid attribute targets in C#. Common Pitfalls: Confusing assembly-level attributes with namespace annotations; only assemblies/modules accept those dedicated target specifiers. Final Answer: Namespace

Question 5

At what phase is the [Serializable] attribute considered by the .NET platform for (de)serialization behavior?

Accepted Answer

Introduction / Context: The [Serializable] attribute marks a type as eligible for serialization by formatters (e.g., binary formatter, SOAP, custom serializers) and certain frameworks. Understanding when this attribute is honored clarifies its role in application behavior. Given Data / Assumptions: We are considering the standard .NET serialization mechanisms that check for [Serializable]. No custom source generators or compile-time transforms are assumed. Concept / Approach: While attributes are emitted into metadata at compile-time, the decision to serialize an object of a given type is made at run-time by the serializer. The serializer examines the type’s metadata using reflection to verify that [Serializable] is present (or that a custom contract applies). Step-by-Step Solution: Compilation emits [Serializable] into the assembly’s metadata.At run-time, when a formatter attempts to serialize the object, it queries the type for [Serializable].If present (and fields are serializable or marked [NonSerialized] as needed), serialization proceeds; otherwise, a run-time exception occurs. Verification / Alternative check: Attempt to serialize a class without [Serializable]; you will receive a run-time error. Add [Serializable] and the same code succeeds, demonstrating run-time inspection. Why Other Options Are Wrong: Compile-time/design-time/linking-time do not perform serialization; they only record metadata. The decisive check is performed by the run-time serializer. Common Pitfalls: Assuming that merely compiling with [Serializable] guarantees correct serialization; non-serializable members must be handled with [NonSerialized] or custom serialization patterns (ISerializable). Final Answer: Run-time

Question 6

Choose the correct way to apply a WebService attribute to a class in C# (considering named parameters for Name and Description).

Accepted Answer

Introduction / Context: Attributes in C# use square brackets and named arguments with the equals sign. This question contrasts correct C# syntax with VB-like syntax or invalid named argument tokens. Given Data / Assumptions: We want to apply a WebService attribute to a class. We are writing C#, not VB.NET. Concept / Approach: In C#, attributes are written as [AttributeName(arg1, NamedProperty = value, ...)] preceding the declaration. Inheritance is expressed with a colon (:) and the base type name. VB.NET uses angle brackets and different keywords (Inherits) and named argument syntax (:=). Step-by-Step Solution: Option A: Correct C# syntax — brackets, Name =, Description =, and class : WebService.Option B: VB-like angle brackets and “inherits” keyword; not C#.Option C: VB-like attribute brackets and “extends” (Java); not C#.Option D: Mixes C# brackets with VB named-argument token := and VB “inherits”; invalid. Verification / Alternative check: Paste Option A into a C# project with the appropriate using directives (System.Web.Services) and it compiles. Others will not compile in C#. Why Other Options Are Wrong: They either use the wrong language syntax (VB.NET/Java) or invalid tokens for C# named arguments. Common Pitfalls: Copying snippets between languages without adjusting syntax; confusing attribute positional parameters with named properties. Final Answer: [WebService(Name = 'CuriousTab', Description = 'CURIOUSTAB WebService')]
class AuthenticationService : WebService { / ... */ }

Question 7

Custom attribute targets in C#: how do you specify what elements an attribute can be applied to?

Accepted Answer

Introduction / Context: When you create a custom attribute in C#, you typically want to control where it can be used (e.g., on classes, methods, properties). This is done with AttributeUsage. Given Data / Assumptions: The attribute class derives from System.Attribute. We need to set allowed targets and other options (AllowMultiple, Inherited). Concept / Approach: Apply [AttributeUsage(...)] or its full name [AttributeUsageAttribute(...)] to the attribute class definition. Both forms are equivalent because of the C# attribute naming convention that allows omitting the trailing “Attribute”. Step-by-Step Solution: Use [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)] above the attribute class.This precisely controls valid targets and behavior.UsageAttribute does not exist; the automatic “applies to all targets” behavior is false. Verification / Alternative check: Attempt to apply the attribute to a disallowed target; the compiler will emit an error referencing AttributeUsage settings. Why Other Options Are Wrong: “UsageAttribute” is not a framework attribute. Attributes do not default to “all targets.” Common Pitfalls: Forgetting that AttributeUsage controls inheritance and multiplicity; omitting it leads to default values (AttributeTargets.All, AllowMultiple = false, Inherited = true for some cases), which might not match your intent. Final Answer: By applying AttributeUsage to the custom attribute class definition

Question 8

Attributes in C#.NET: which statements are correct about compilation, reflection, and parameters?

Accepted Answer

Introduction / Context: Attributes provide declarative metadata in .NET. Understanding their lifecycle—from source code to compiled assembly to runtime inspection—is important for using frameworks and tooling effectively. Given Data / Assumptions: We consider what happens at compile time and how attributes are accessed at runtime. We consider whether attributes can have parameters (positional and named). Concept / Approach: When a C# program is compiled, attributes are emitted as metadata in the resulting assembly (DLL/EXE). At runtime (and design-time), reflection APIs can read those attributes. Attributes support positional constructor arguments and named property/field assignments. Step-by-Step Solution: Compilation → attribute usages are preserved in metadata.Runtime → use reflection (MemberInfo.GetCustomAttributes) to query attributes.Parameters → attributes can accept constructor arguments and named arguments for public writeable properties/fields. Verification / Alternative check: Create a custom attribute with a constructor and a named property; apply it; then use reflection to retrieve and read both the positional and named values at runtime. Why Other Options Are Wrong: Options asserting deletion or non-reflectability misunderstand the metadata model; attributes are not “thrown away.” Common Pitfalls: Confusing attribute constructor parameters with named property initializers; forgetting that attributes are read-only at runtime in terms of behavior—they annotate, they don’t execute themselves. Final Answer: Attributes are recorded into assembly metadata; they can be read via reflection; attributes can take parameters

Question 9

What does the standard C# file AssemblyInfo.cs primarily contain in a typical project?

Accepted Answer

Introduction / Context: Many C# project templates include a file named AssemblyInfo.cs (or equivalent in SDK-style projects via attributes in the .csproj). Understanding its purpose helps you know where common metadata is defined. Given Data / Assumptions: We are using a classic .NET project template with AssemblyInfo.cs present. We want to identify the typical content and purpose of this file. Concept / Approach: AssemblyInfo.cs contains assembly-level attributes such as AssemblyTitle, AssemblyDescription, AssemblyCompany, AssemblyProduct, AssemblyVersion, and others. These attributes define metadata for the entire assembly and are emitted at the assembly scope. Step-by-Step Solution: Inspect a default AssemblyInfo.cs → see attributes like [assembly: AssemblyTitle(""... "")], [assembly: AssemblyVersion(""... "")].These are not method/class/struct/namespace-level attributes; they apply to the assembly as a whole.Modern SDK-style projects may move some of these into the project file via MSBuild properties, but the concept of assembly-level attributes remains the same. Verification / Alternative check: Open a standard .NET Framework project and review AssemblyInfo.cs; the attributes are clearly marked with the assembly: target specifier. Why Other Options Are Wrong: Method/class/struct/namespace attributes exist but live in code near those declarations, not in AssemblyInfo.cs by default. Common Pitfalls: Assuming AssemblyInfo.cs is mandatory in all templates; SDK-style projects may auto-generate attributes or place them in the .csproj, but they are still assembly-level. Final Answer: Assembly-level attributes (e.g., title, version, company)

Question 10

C#.NET — Inspecting attributes: at which stages can attributes be examined or queried? Choose all that truly apply: 1) Link-time 2) Compile-time 3) Run-time 4) Design-time (e.g., by tooling in IDEs)

Accepted Answer

Introduction / Context: Attributes in C#.NET are metadata attached to code elements (assemblies, types, members, parameters, etc.). Understanding when and how they can be inspected helps developers choose the right mechanism (reflection, analyzers, or tooling) for validation, diagnostics, and behavior changes. Given Data / Assumptions: We are considering standard .NET attribute usage. “Inspection” means reading attribute metadata. Stages under consideration: link-time, compile-time, run-time, and design-time. Concept / Approach: Attributes are stored in metadata and can be retrieved via reflection at run-time. Many IDEs and tools (design-time) read attributes to alter experience (e.g., designers, code generators). While compilers may react to certain attributes, general attribute inspection is typically done at run-time or by design-time tools. Step-by-Step Solution: Evaluate 1) Link-time: .NET does not have a separate “linker-inspection” phase for attributes in typical workflows; not generally applicable.Evaluate 2) Compile-time: Some attributes influence compilation (e.g., Obsolete), but broad attribute inspection is not generally performed by user code at compile-time.Evaluate 3) Run-time: Reflection (MemberInfo.GetCustomAttributes, etc.) reads attributes. This is a standard and widely used mechanism.Evaluate 4) Design-time: Visual designers and analyzers can read attributes to guide tooling behavior, so design-time inspection is valid. Verification / Alternative check: Write a short program that calls GetCustomAttributes on a type or member at run-time; observe returned attribute instances. In IDEs, attributes like Browsable or DisplayName change designer behavior at design-time. Why Other Options Are Wrong: Link-time: not a standard inspection phase in managed .NET builds. “All of the above” overstates link/compile-time general inspection. Common Pitfalls: Confusing compiler reaction to specific attributes with general-purpose attribute inspection available to user code. Final Answer: 3, 4

Question 11

C#.NET — Pick the correct syntax to apply an attribute to a class (example: Serializable).

Accepted Answer

Introduction / Context: Attributes in C# use square-bracket syntax and are placed immediately before the declaration they annotate. This question checks recognition of the precise syntax. Given Data / Assumptions: Attribute being applied: Serializable. Target: a class declaration. Concept / Approach: The correct form is: [Serializable] or [Serializable()] placed before the class declaration. Parentheses are optional if there are no arguments. Step-by-Step Solution: Reject angle-bracket forms (not C# attribute syntax).Reject parenthesized-only forms; attributes require square brackets.Accept square-bracket form: [ Serializable() ] class sample { ... } Verification / Alternative check: Compile a minimal class annotated with [Serializable] and confirm no errors; other forms will cause syntax errors. Why Other Options Are Wrong: Angle brackets and bare parentheses are not valid C# attribute delimiters; misspellings like “Serializablef)” are invalid. Common Pitfalls: Confusing XML-like angle-brackets with C# attribute brackets; forgetting that parentheses are optional when there are no parameters. Final Answer: [ Serializable() ] class sample { /* ... */ }

Question 12

C#.NET — Attributes: identify the correct statement about custom attributes and runtime behavior.

Accepted Answer

Introduction / Context: Attributes are classes that carry metadata and, in many scenarios, drive runtime or framework behavior (serialization, remoting, interop, security, binding, etc.). This question distinguishes true facts from common misconceptions. Given Data / Assumptions: Custom attribute naming convention: “XAttribute” class can be used via [X] or [XAttribute]. Attributes are reference types deriving from System.Attribute. Constructors define required positional parameters; zero-argument constructors are optional. Concept / Approach: Only classes (not structs) derive from System.Attribute to create custom attributes. There is no IAttribute interface to implement. The runtime and frameworks often read attributes to change behavior (e.g., [Serializable], [NonSerialized], [DllImport], [Obsolete] affects compilation). Step-by-Step Solution: Option A: Incorrect. With a class BugFixAttribute, usage can be [BugFix] or [BugFixAttribute]; the compiler recognizes the “Attribute” suffix.Option B: Incorrect. Attributes must be classes, not structs.Option C: Incorrect. There is no required IAttribute interface.Option D: Incorrect. Only constructors actually declared are required; no mandatory parameterless constructor.Option E: Correct. Many attributes influence runtime or framework behavior. Verification / Alternative check: Declare a custom attribute deriving from System.Attribute and observe reflection and framework behaviors. Why Other Options Are Wrong: They contradict the attribute class model and naming conventions. Common Pitfalls: Assuming an interface-based attribute model or that parameterless constructors are mandated. Final Answer: The CLR can alter behavior based on the attributes applied to code.

Question 13

C#.NET — Applying an attribute to an assembly: choose the correct syntax.

Accepted Answer

Introduction / Context: Assembly-level attributes annotate the entire assembly (not a single type or member). They require a target specifier in attribute syntax. Given Data / Assumptions: Target is the assembly. Attribute example: AssemblyDescription. Concept / Approach: Assembly attributes use square brackets with a target prefix: [assembly: SomeAttribute(...)]. This is placed typically in AssemblyInfo files or any compilation unit. Step-by-Step Solution: Accept syntax with “assembly:” target in square brackets.Reject forms lacking the target specifier or using angle/round brackets. Verification / Alternative check: Place the line in a project’s AssemblyInfo.cs and build; it compiles and appears in assembly metadata. Why Other Options Are Wrong: They either omit the target or use invalid delimiters or identifiers. Common Pitfalls: Forgetting the target prefix (assembly:, module:, etc.). Final Answer: [ assembly : AssemblyDescription("DCube Component Library") ]

Question 14

C#.NET — How can parameters be passed to attributes? Identify the valid approaches.

Accepted Answer

Introduction / Context: Attribute constructors accept positional (ctor) arguments and optional named arguments that set public read/write properties or fields of the attribute instance. Given Data / Assumptions: We are talking about attribute parameter passing forms in C#. Attributes are instantiated by the compiler in metadata; user code does not pass references/addresses at run-time. Concept / Approach: Two valid forms exist: positional arguments (via constructor) and named arguments (via property/field assignment syntax). There is no “by ref” or “by address” parameter passing for attributes. Step-by-Step Solution: Positional: [MyAttr(10, "x")] calls a constructor MyAttr(int, string).Named: [MyAttr(10, Name = "x", Enabled = true)] sets writable members.Ref/out/address passing is not supported in attribute specifications. Verification / Alternative check: Try compiling examples using named and positional arguments; attempts to use ref/out will fail to compile. Why Other Options Are Wrong: “By reference” and “by address” are not part of attribute argument syntax. Common Pitfalls: Expecting arbitrary expressions or ref/out parameters in attribute arguments; attribute arguments must be compile-time constants or typeof/nameof where allowed. Final Answer: 4, 5

Question 15

C#.NET — AttributeUsage targeting: can a custom attribute be restricted to specific elements only?

Accepted Answer

Introduction / Context: When you create a custom attribute, you can restrict where it may be applied using the AttributeUsage attribute (AttributeTargets flags). Given Data / Assumptions: We want to scope an attribute to certain program elements. Typical targets include Class, Method, Property, Field, Parameter, ReturnValue, etc. Concept / Approach: Apply [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Field)] to limit where the custom attribute may appear. Thus it can be applied to classes, methods, and member variables (fields) if configured. Step-by-Step Solution: Define the attribute class deriving from System.Attribute.Annotate it with AttributeUsage specifying the allowed targets.Attempting to use the attribute elsewhere will produce a compile-time error. Verification / Alternative check: Try applying to a disallowed target and observe the compiler’s diagnostic. Why Other Options Are Wrong: Options that mention only a subset are possible but the question asks whether it is possible to target multiple specific elements (including fields), which is true. Common Pitfalls: Forgetting that AttributeTargets is a flags enum and can be combined with bitwise OR. Final Answer: Classes, Methods and Member-Variables

Attributes Questions