Property validation logic in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this property validation code?

Consider the following C# class with a property that validates input. What will be printed when the Main method runs?

C Sharp (C#)

using System;

class Person
{
    private int age;
    public int Age
    {
        get => age;
        set
        {
            if (value < 0 || value > 120)
                Console.WriteLine("Invalid age");
            else
                age = value;
        }
    }
}

class Program
{
    static void Main()
    {
        Person p = new Person();
        p.Age = 25;
        Console.WriteLine(p.Age);
        p.Age = -5;
        Console.WriteLine(p.Age);
    }
}

A 25\nInvalid age

B Invalid age\n0

C Invalid age\n25

D 25\nInvalid age\n25

💡 Hint

Think about when the age field is updated and when the message is printed.

The setter only updates the private field age if the value is valid. When setting -5, it prints "Invalid age" but does not change age. So the last printed age remains 25.

❓ Predict Output

intermediate

What error does this property validation code produce?

Examine this C# class with a property setter. What error will occur when compiling or running this code?

C Sharp (C#)

using System;

class Product
{
    private decimal price;
    public decimal Price
    {
        get { return price; }
        set
        {
            if (value < 0)
                throw new ArgumentException("Price cannot be negative");
            else
                Price = value;
        }
    }
}

A NullReferenceException at runtime

B StackOverflowException at runtime

C No error, runs fine

D Compile-time error: missing semicolon

💡 Hint

Look at how the setter assigns the value inside itself.

The setter calls Price = value; which calls the setter again, causing infinite recursion and a StackOverflowException at runtime.

🧠 Conceptual

advanced

Which property validation approach ensures thread safety?

You want to validate a property value and ensure that multiple threads can safely set and get it without causing inconsistent state. Which approach below best achieves this?

A Use a private field with lock statements in both getter and setter

B Use only a public auto-property with no validation

C Validate only in the constructor and make property read-only

D Use a static property with validation logic

💡 Hint

Think about how to prevent race conditions when multiple threads access the property.

Using a private field with lock in getter and setter ensures that only one thread accesses the field at a time, preventing inconsistent state.

🔧 Debug

advanced

Why does this property validation code fail to reject invalid input?

This C# class tries to reject negative values for the Score property, but it still allows negative values. Why?

C Sharp (C#)

using System;

class Game
{
    private int score;
    public int Score
    {
        get => score;
        set
        {
            if (value < 0)
                throw new ArgumentException("Score cannot be negative");
            score = value;
        }
    }
}

A The private field is not initialized

B The setter is missing a return statement

C The if condition checks the old value instead of the new value

D The property should be static

💡 Hint

Check what variable the if condition is testing.

The condition if (score < 0) checks the current field value, not the new value value. So negative inputs are not caught.

🚀 Application

expert

How many items are in the dictionary after this property validation code runs?

This C# class uses a property with validation to add entries to a dictionary. After running the Main method, how many items are in the dictionary?

C Sharp (C#)

using System;
using System.Collections.Generic;

class Registry
{
    private Dictionary<string, int> data = new();
    private int value;
    public int Value
    {
        get => value;
        set
        {
            if (value >= 0)
            {
                this.value = value;
                data[$"key{value}"] = value;
            }
        }
    }

    public int Count => data.Count;
}

class Program
{
    static void Main()
    {
        Registry r = new Registry();
        r.Value = 1;
        r.Value = 2;
        r.Value = -1;
        r.Value = 2;
        Console.WriteLine(r.Count);
    }
}

A 2

B 3

C 4

D 1

💡 Hint

Consider how dictionary keys behave when assigned multiple times.

The dictionary keys are "key1" and "key2" after valid assignments. The negative value is ignored. Assigning "key2" twice overwrites the same entry, so total count is 2.

Practice

1. What is the main purpose of adding validation logic inside a property setter in C#?

easy

A. To check and control the value before saving it to the field

B. To make the property read-only

C. To speed up the program execution

D. To automatically generate a default value

Solution

1. Step 1: Understand property setters

   Property setters allow you to assign values to private fields through a controlled interface.

2. Step 2: Role of validation logic

   Validation logic inside the setter checks if the value is valid before saving it, preventing invalid data.

3. Final Answer:

   To check and control the value before saving it to the field -> Option A

4. Quick Check:

   Validation in setter = control value before save [OK]

Hint: Validation logic in setter controls data before saving [OK]

Common Mistakes:

• Thinking validation makes property read-only
• Assuming validation speeds up code
• Confusing validation with default value assignment

2. Which of the following is the correct syntax to throw an exception inside a property setter when the value is invalid?

easy

A. set { if (value < 0) throw new Exception("Invalid value"); field = value; }

B. set { if (value < 0) return; field = value; }

C. set { if (value < 0) Console.WriteLine("Invalid"); field = value; }

D. set { if (value < 0) break; field = value; }

Solution

1. Step 1: Identify correct exception throwing syntax

   Throwing an exception uses the keyword 'throw' followed by 'new Exception(message)'.

2. Step 2: Check each option

   set { if (value < 0) throw new Exception("Invalid value"); field = value; } correctly throws an exception if value is less than zero. Others use invalid statements like return, Console.WriteLine, or break inside setter.

3. Final Answer:

   set { if (value < 0) throw new Exception("Invalid value"); field = value; } -> Option A

4. Quick Check:

   Throw exception = throw new Exception(...) [OK]

Hint: Use 'throw new Exception' to stop invalid values [OK]

Common Mistakes:

• Using 'return' instead of 'throw' in setter
• Trying to use 'break' inside setter
• Only printing error without stopping assignment

3. Consider this C# class snippet:

class Person {
  private int age;
  public int Age {
    get => age;
    set {
      if (value < 0) throw new ArgumentException("Age cannot be negative");
      age = value;
    }
  }
}

What happens if you run this code?
var p = new Person();
p.Age = -5;

medium

A. The age is set to -5 without error

B. An ArgumentException is thrown with message 'Age cannot be negative'

C. The program crashes with a NullReferenceException

D. The setter ignores the negative value and leaves age unchanged

Solution

1. Step 1: Analyze setter validation

   The setter checks if value is less than 0 and throws ArgumentException if true.

2. Step 2: Apply to given code

   Setting Age to -5 triggers the exception because -5 < 0.

3. Final Answer:

   An ArgumentException is thrown with message 'Age cannot be negative' -> Option B

4. Quick Check:

   Negative age triggers ArgumentException [OK]

Hint: Setter throws exception on invalid input [OK]

Common Mistakes:

• Assuming negative value is accepted
• Confusing exception type thrown
• Thinking setter silently ignores invalid values

4. Identify the error in this property setter code:

private string name;
public string Name {
  get { return name; }
  set {
    if (value == null || value == "")
      throw new ArgumentException("Name cannot be empty");
    name = value;
  }
}

medium

A. The setter does not assign the value to the field

B. The setter should use 'value.Equals("")' instead of 'value == ""'

C. The setter does not check for whitespace-only strings

D. The setter should not throw exceptions in property setters

Solution

1. Step 1: Review validation logic

   The setter checks if value is null or empty string but does not check if value is whitespace only.

2. Step 2: Understand missing validation

   Strings like " " (spaces) pass the check but are usually invalid for a name.

3. Final Answer:

   The setter does not check for whitespace-only strings -> Option C

4. Quick Check:

   Missing whitespace check in setter validation [OK]

Hint: Check for whitespace with string.IsNullOrWhiteSpace [OK]

Common Mistakes:

• Thinking '==' is wrong for string comparison here
• Believing exceptions should never be thrown in setters
• Forgetting to assign value to field

5. You want to create a property Score that only accepts values between 0 and 100 inclusive. If the value is outside this range, it should throw an ArgumentOutOfRangeException. Which of these implementations correctly applies this validation?

hard

A. private int score; public int Score { get => score; set { if (value < 0 && value > 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } }

B. private int score; public int Score { get => score; set { if (value <= 0 && value >= 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } }

C. private int score; public int Score { get => score; set { if (value > 0 || value < 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } }

D. private int score; public int Score { get => score; set { if (value < 0 || value > 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } }

Solution

1. Step 1: Understand the range condition

   The value must be between 0 and 100 inclusive, so invalid values are less than 0 or greater than 100.

2. Step 2: Analyze each condition

   private int score; public int Score { get => score; set { if (value < 0 || value > 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } } uses 'value < 0 || value > 100' which correctly checks invalid values. Options A, B, and D use incorrect logical operators or conditions.

3. Final Answer:

   private int score; public int Score { get => score; set { if (value < 0 || value > 100) throw new ArgumentOutOfRangeException("Score must be 0-100"); score = value; } } -> Option D

4. Quick Check:

   Use '||' for out-of-range checks [OK]

Hint: Use 'if (value < min || value > max)' for range validation [OK]

Common Mistakes:

• Using '&&' instead of '||' in range checks
• Reversing comparison operators
• Throwing wrong exception type