Impara Access Modifiers Deep Dive | Class Design and Encapsulation

Access modifiers in C# are keywords that control the visibility and accessibility of classes, methods, fields, and other members. The most commonly used access modifiers include public, private, protected, internal, and protected internal. Understanding how each modifier works is essential for designing robust and secure classes.

LibraryBook.cs


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
            
using System;

namespace ConsoleApp
{
    public class LibraryBook
    {
        // Public field: accessible from anywhere
        public string Title;

        // Private field: accessible only within this class
        private string author;

        // Protected field: accessible within this class and derived classes
        protected int yearPublished;

        // Internal field: accessible within the same assembly
        internal string libraryCode;

        // Protected internal field: accessible within the same assembly or from derived classes
        protected internal bool isCheckedOut;

        // Public method: can be called from anywhere
        public void DisplayInfo()
        {
            Console.WriteLine("Title: " + Title);
            Console.WriteLine("Author: " + author);
        }

        // Private method: can only be called within this class
        private void SetAuthor(string name)
        {
            author = name;
        }

        // Protected method: can be called within this class and derived classes
        protected void SetYearPublished(int year)
        {
            yearPublished = year;
        }

        // Internal method: can be called within the same assembly
        internal void AssignLibraryCode(string code)
        {
            libraryCode = code;
        }

        // Protected internal method: can be called within the same assembly or from derived classes
        protected internal void MarkAsCheckedOut()
        {
            isCheckedOut = true;
        }

        // Constructor to initialize the book
        public LibraryBook(string title, string authorName, int year)
        {
            Title = title;
            SetAuthor(authorName);
            SetYearPublished(year);
            isCheckedOut = false;
        }
    }

    public class Program
    {
        public static void Main()
        {
            LibraryBook book = new LibraryBook("1984", "George Orwell", 1949);
            book.DisplayInfo();
            book.AssignLibraryCode("LB-001");
            book.MarkAsCheckedOut();
            Console.WriteLine("Library code: " + book.libraryCode);
            Console.WriteLine("Checked out: " + book.isCheckedOut);
        }
    }
}

In the LibraryBook example, each access modifier determines how fields and methods can be accessed. The Title field and DisplayInfo method are marked as public, so you can access them from anywhere in your code. The author field and SetAuthor method are private, meaning they are only accessible inside the LibraryBook class itself. The yearPublished field and SetYearPublished method are protected, so they can be accessed by LibraryBook and any class that inherits from it. The libraryCode field and AssignLibraryCode method use internal, making them available to any code within the same assembly. The isCheckedOut field and MarkAsCheckedOut method are protected internal, which allows access from derived classes or any code within the same assembly.

Choosing the correct access modifier is crucial for encapsulation and security. For instance, you would use private to hide implementation details, public for members intended to be part of the class's interface, protected to allow derived classes to interact with base class members, and internal when you want to restrict access to the current assembly.

NonRunnableExample.cs


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
// This code is for demonstration and does not contain a Main method.

namespace ConsoleApp
{
    public class BaseClass
    {
        protected int protectedValue;
        internal int internalValue;

        protected void ProtectedMethod()
        {
            // Logic for derived classes
        }

        internal void InternalMethod()
        {
            // Logic for same assembly
        }
    }

    public class DerivedClass : BaseClass
    {
        public void AccessMembers()
        {
            // Can access protectedValue and internalValue
            protectedValue = 10;
            internalValue = 20;

            // Can call protected and internal methods
            ProtectedMethod();
            InternalMethod();
        }
    }

    public class UnrelatedClass
    {
        public void TryAccess()
        {
            BaseClass baseObj = new BaseClass();

            // baseObj.protectedValue; // Not accessible
            // baseObj.ProtectedMethod(); // Not accessible

            baseObj.internalValue = 5; // Accessible within assembly
            baseObj.InternalMethod();  // Accessible within assembly
        }
    }
}

When working with class hierarchies, protected members are accessible to derived classes, while internal members are accessible to any class within the same assembly. In the non-runnable example, the DerivedClass can access both protected and internal members of BaseClass, but an unrelated class can only access the internal members, not the protected ones.

Deciding which access modifier to use depends on how much you want to expose or hide your class members. Use private for strict encapsulation, protected when you expect inheritance, internal to limit access to your assembly, and public for members that form the interface of your class. The protected internal modifier combines the flexibility of both protected and internal, but should be used thoughtfully to avoid unintended exposure.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 5

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain the difference between `protected` and `internal` in more detail?

When should I use `protected internal` instead of just `protected` or `internal`?

Can you give more examples of when to use each access modifier?

Scorri per mostrare il menu

LibraryBook.cs


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
            
using System;

namespace ConsoleApp
{
    public class LibraryBook
    {
        // Public field: accessible from anywhere
        public string Title;

        // Private field: accessible only within this class
        private string author;

        // Protected field: accessible within this class and derived classes
        protected int yearPublished;

        // Internal field: accessible within the same assembly
        internal string libraryCode;

        // Protected internal field: accessible within the same assembly or from derived classes
        protected internal bool isCheckedOut;

        // Public method: can be called from anywhere
        public void DisplayInfo()
        {
            Console.WriteLine("Title: " + Title);
            Console.WriteLine("Author: " + author);
        }

        // Private method: can only be called within this class
        private void SetAuthor(string name)
        {
            author = name;
        }

        // Protected method: can be called within this class and derived classes
        protected void SetYearPublished(int year)
        {
            yearPublished = year;
        }

        // Internal method: can be called within the same assembly
        internal void AssignLibraryCode(string code)
        {
            libraryCode = code;
        }

        // Protected internal method: can be called within the same assembly or from derived classes
        protected internal void MarkAsCheckedOut()
        {
            isCheckedOut = true;
        }

        // Constructor to initialize the book
        public LibraryBook(string title, string authorName, int year)
        {
            Title = title;
            SetAuthor(authorName);
            SetYearPublished(year);
            isCheckedOut = false;
        }
    }

    public class Program
    {
        public static void Main()
        {
            LibraryBook book = new LibraryBook("1984", "George Orwell", 1949);
            book.DisplayInfo();
            book.AssignLibraryCode("LB-001");
            book.MarkAsCheckedOut();
            Console.WriteLine("Library code: " + book.libraryCode);
            Console.WriteLine("Checked out: " + book.isCheckedOut);
        }
    }
}

NonRunnableExample.cs


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
            
// This code is for demonstration and does not contain a Main method.

namespace ConsoleApp
{
    public class BaseClass
    {
        protected int protectedValue;
        internal int internalValue;

        protected void ProtectedMethod()
        {
            // Logic for derived classes
        }

        internal void InternalMethod()
        {
            // Logic for same assembly
        }
    }

    public class DerivedClass : BaseClass
    {
        public void AccessMembers()
        {
            // Can access protectedValue and internalValue
            protectedValue = 10;
            internalValue = 20;

            // Can call protected and internal methods
            ProtectedMethod();
            InternalMethod();
        }
    }

    public class UnrelatedClass
    {
        public void TryAccess()
        {
            BaseClass baseObj = new BaseClass();

            // baseObj.protectedValue; // Not accessible
            // baseObj.ProtectedMethod(); // Not accessible

            baseObj.internalValue = 5; // Accessible within assembly
            baseObj.InternalMethod();  // Accessible within assembly
        }
    }
}

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 5

Access Modifiers Deep Dive

1. What does the protected access modifier allow?

2. Which access modifier is the most restrictive?

3. When would you use `internal` instead of `public`?

Access Modifiers Deep Dive

1. What does the protected access modifier allow?

2. Which access modifier is the most restrictive?

3. When would you use `internal` instead of `public`?

Access Modifiers Deep Dive

1. What does the protected access modifier allow?

2. Which access modifier is the most restrictive?

3. When would you use internal instead of public?

Access Modifiers Deep Dive

1. What does the protected access modifier allow?

2. Which access modifier is the most restrictive?

3. When would you use internal instead of public?

3. When would you use `internal` instead of `public`?

3. When would you use `internal` instead of `public`?