Detailed Explanation of Use of Private Class vs Private Method

Sanjay Kumar
Feb 19
530
7
2

Article

In C#, a private class refers to a nested class that is defined with the private access modifier within another class. This designation restricts access to the private class solely to the containing class, making it inaccessible from outside the enclosing class, even if other classes reside within the same namespace.

Use Cases for a Private Class

A private class serves valuable purposes in situations where it is necessary to,

Organizing Related Functions: When a collection of operations is interconnected (such as hashing and password verification), a private class effectively consolidates them in a logical manner.
State or Data Management: When operations necessitate the preservation of the internal state or the use of reusable configurations, employing a private class is more advantageous.
Future-Proofing: If there is a possibility that the logic will expand or require additional functionalities, a private class offers better maintainability.
Modular Architecture: To separate specific responsibilities, thereby enhancing the clarity and readability of the parent class.

Benefits of Implementing a Private Class

Encapsulation: Sensitive logic is concealed, minimizing the chances of unintentional misuse or interference.
Code Reusability: The private class can be utilized within the parent class for any operations related to passwords.
Separation of Concerns: By dedicating a separate class for password management, the parent class can concentrate exclusively on login functionalities.
Enhanced Security: Restricts external access to critical methods such as password hashing, thereby increasing the application's security.
Maintainability: Modifications to the password management logic can be executed within the private class without impacting the overall application.

Implementation

Step 1. Create a class as illustrated below.

using System.Security.Cryptography;
using System.Text;
using System.Windows;

namespace PrivateClassExample
{
    internal class PrivateClassAndMethodExample
    {
        // Dictionary to simulate a database of users
        private readonly Dictionary<string, string> userDatabase = new Dictionary<string, string>();

        // Public method to register a user
        public void RegisterUser(string username, string password)
        {
            string hashedPassword = PasswordManager.HashPassword(password);
            userDatabase[username] = hashedPassword;
            Console.WriteLine("User registered successfully.");
        }

        // Public method to authenticate a user
        public bool AuthenticateUser(string username, string password)
        {
            if (!userDatabase.ContainsKey(username))
            {
                Console.WriteLine("User not found.");
                return false;
            }

            string storedHash = userDatabase[username];
            return PasswordManager.VerifyPassword(password, storedHash);
        }

        // Private class for password management
        private static class PasswordManager
        {
            // Method to hash a password
            public static string HashPassword(string password)
            {
                using (SHA256 sha256 = SHA256.Create())
                {
                    byte[] hashedBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(password));
                    return Convert.ToBase64String(hashedBytes);
                }
            }

            // Method to verify a password
            public static bool VerifyPassword(string password, string storedHash)
            {
                string hashedInput = HashPassword(password);
                return hashedInput == storedHash;
            }
        }
    }
}

Step 2. The execution of the aforementioned class.

using System.Windows;

namespace PrivateClassExample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            PrivateClassAndMethodExample privateClassAndMethod = new PrivateClassAndMethodExample();

            // Simulate user registration
            string username = "user1";
            string password = "securepassword";
            privateClassAndMethod.RegisterUser(username, password);

            // Simulate user login
            bool isAuthenticated = privateClassAndMethod.AuthenticateUser(username, "securepassword");
            Console.WriteLine($"Authentication {(isAuthenticated ? "successful" : "failed")}");
        }
    }
}

Conclusion

Private Classes: These should be utilized for intricate, reusable, or stateful functionalities that require multiple operations or encapsulate both data and behavior.
Private Methods: These are best suited for straightforward, single-purpose tasks that are closely linked to the parent class.

The decision to use a private class or a private method hinges on the complexity and reusability of the logic involved. Private methods are adequate for simple operations, while private classes are preferable for more modular and scalable designs.