Bird
Raised Fist0
C Sharp (C#)programming~5 mins

Access modifiers (public, private, internal) in C Sharp (C#)

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Introduction

Access modifiers control who can use parts of your code. They help keep your code safe and organized.

When you want everyone to use a class or method, make it public.
When you want only the current class to use a method or variable, make it private.
When you want to share code only inside the same project or assembly, use internal.
Syntax
C Sharp (C#)
public class MyClass {
    public int number;      // accessible everywhere
    private int secret;    // accessible only inside MyClass
    internal int shared;   // accessible inside the same assembly
}

public means anyone can access.

private means only the current class can access.

internal means only code in the same project or assembly can access.

Examples
This class shows all three access levels on different fields.
C Sharp (C#)
public class Car {
    public string Make;      // anyone can see
    private string Model;    // only inside Car
    internal int Year;       // inside same project
}
Private balance hides the money amount. Public methods let others add money or check balance safely.
C Sharp (C#)
public class BankAccount {
    private decimal balance;

    public void Deposit(decimal amount) {
        balance += amount;
    }

    public decimal GetBalance() {
        return balance;
    }
}
Sample Program

This program shows how public, private, and internal control access to Person's data.

C Sharp (C#)
using System;

public class Person {
    public string Name;          // anyone can access
    private int age;             // only inside Person
    internal string City;        // inside same assembly

    public Person(string name, int age, string city) {
        Name = name;
        this.age = age;
        City = city;
    }

    public void ShowAge() {
        Console.WriteLine($"Age is {age}");
    }
}

class Program {
    static void Main() {
        Person p = new Person("Alice", 30, "New York");
        Console.WriteLine(p.Name);      // works
        // Console.WriteLine(p.age);    // error: age is private
        p.ShowAge();                   // works, prints age
        Console.WriteLine(p.City);      // works inside same assembly
    }
}
OutputSuccess
Important Notes

Private members cannot be accessed outside their own class.

Internal members are accessible only within the same project or assembly.

Public members are accessible from anywhere.

Summary

Access modifiers control who can use your code parts.

Use public for open access, private for hiding inside a class, and internal for sharing inside a project.

Practice

(1/5)
1.

Which access modifier allows a class member to be accessed from any other code in the same project or assembly?

easy
A. internal
B. private
C. public
D. protected

Solution

  1. Step 1: Understand the meaning of internal

    The internal modifier allows access within the same assembly or project but not outside it.
  2. Step 2: Compare with other modifiers

    private restricts access to the same class only, public allows access from anywhere, and protected allows access in derived classes.
  3. Final Answer:

    internal -> Option A
  4. Quick Check:

    Access inside project = internal [OK]
Hint: Internal means accessible only within the same project [OK]
Common Mistakes:
  • Confusing internal with public
  • Thinking private allows access outside class
  • Mixing protected with internal
2.

Which of the following is the correct way to declare a private integer field named count in a class?

?
easy
A. internal count int;
B. int private count;
C. public int count;
D. private int count;

Solution

  1. Step 1: Recall correct syntax for access modifiers

    The access modifier comes first, then the type, then the variable name.
  2. Step 2: Check each option's order and keywords

    private int count; follows correct order: private int count;. Others have incorrect order or missing type.
  3. Final Answer:

    private int count; -> Option D
  4. Quick Check:

    Access modifier + type + name [OK]
Hint: Access modifier always comes before type in declaration [OK]
Common Mistakes:
  • Placing access modifier after type
  • Omitting the type
  • Using invalid order of keywords
3.

Consider the following code snippet:

class MyClass {
    private int secret = 42;
    public int GetSecret() {
        return secret;
    }
}

MyClass obj = new MyClass();
Console.WriteLine(obj.secret);

What will happen when this code runs?

medium
A. Runtime error: NullReferenceException
B. It prints 42
C. Compilation error: 'secret' is inaccessible due to its protection level
D. It prints 0

Solution

  1. Step 1: Identify access modifier of 'secret'

    The field secret is declared private, so it cannot be accessed outside MyClass.
  2. Step 2: Check code accessing 'secret'

    The code tries to access obj.secret outside the class, which is not allowed and causes a compile-time error.
  3. Final Answer:

    Compilation error: 'secret' is inaccessible due to its protection level -> Option C
  4. Quick Check:

    Private fields cannot be accessed outside class [OK]
Hint: Private members cannot be accessed from outside their class [OK]
Common Mistakes:
  • Assuming private fields are accessible outside class
  • Confusing runtime errors with compile errors
  • Thinking public methods expose private fields directly
4.

Given this code snippet, identify the error and fix it:

class Sample {
    internal int value;
}

class Test {
    void Show() {
        Sample s = new Sample();
        Console.WriteLine(s.value);
    }
}

Assuming these classes are in different projects, what is the problem?

medium
A. No error, code runs fine
B. Error: 'value' is inaccessible due to protection level; fix by changing 'internal' to 'public'
C. Error: 'value' must be private; fix by changing 'internal' to 'private'
D. Error: 'value' must be static; fix by adding 'static' keyword

Solution

  1. Step 1: Understand 'internal' access modifier scope

    internal allows access only within the same project or assembly.
  2. Step 2: Check class locations

    Since Sample and Test are in different projects, Test cannot access internal members of Sample.
  3. Step 3: Fix the access level

    Changing value to public allows access from other projects.
  4. Final Answer:

    Error: 'value' is inaccessible due to protection level; fix by changing 'internal' to 'public' -> Option B
  5. Quick Check:

    Internal = same project only; public = accessible everywhere [OK]
Hint: Internal limits access to same project; use public for cross-project [OK]
Common Mistakes:
  • Assuming internal allows cross-project access
  • Changing internal to private incorrectly
  • Confusing static with access modifiers
5.

You have a class library project with a class Helper that has a method Calculate() marked as internal. You want to allow another project in the same solution to use Calculate() without making it public. What is the best way to achieve this?

hard
A. Use the InternalsVisibleTo attribute to expose internal members to the other project
B. Change the method to public
C. Change the method to private and create a public wrapper
D. Move the method to the other project

Solution

  1. Step 1: Understand internal and project boundaries

    internal restricts access to the same assembly, so other projects cannot access it by default.
  2. Step 2: Use InternalsVisibleTo attribute

    This attribute allows you to specify friend assemblies that can access internal members without making them public.
  3. Step 3: Evaluate other options

    Changing to public exposes to all, private hides too much, moving method is impractical.
  4. Final Answer:

    Use the InternalsVisibleTo attribute to expose internal members to the other project -> Option A
  5. Quick Check:

    InternalsVisibleTo grants internal access to specific projects [OK]
Hint: Use InternalsVisibleTo to share internal members across projects [OK]
Common Mistakes:
  • Making method public unnecessarily
  • Thinking private allows cross-project access
  • Moving code instead of using attributes