DotNet
객체지향 프로그래밍 (OOP)
OOP 설계
디자인 패턴
구조패턴
Private Class Data

Private Class Data

Private Class Data 패턴이란?

Private Class Data 패턴은 캡슐화를 강화하여 클래스의 내부 데이터를 외부에서 직접적으로 접근하지 못하도록 하고, 데이터를 보호하면서 관리하는 디자인 패턴입니다. 이 패턴은 클래스의 멤버 변수와 이를 처리하는 로직을 분리하여, 데이터를 안전하게 관리할 수 있도록 도와줍니다. 데이터를 직접 접근하는 대신, 적절한 접근자 메서드를 통해 데이터를 제어하여 불필요한 변경을 방지하고 보안을 강화합니다.

Private Class Data 패턴 구조

D2 Diagram

  • Client → Context
    • 클라이언트는 Context 객체의 메서드를 호출하여 데이터를 처리하거나 수정합니다.
    • Context는 데이터를 직접 노출하지 않고, 관련 작업만 제공합니다.
  • Context → PrivateData
    • Context는 내부적으로 PrivateData 객체를 통해 데이터를 관리합니다.
    • 데이터는 PrivateData 클래스에서만 접근 가능하며, Context는 이를 간접적으로 조작합니다.
  • PrivateData
    • 데이터와 관련된 세부사항Field, Property은 모두 PrivateData 클래스에 캡슐화됩니다.
    • 데이터에 대한 직접적인 접근은 불가능하며, 데이터 무결성이 보장됩니다.

Private Class Data 패턴의 특징

캡슐화 강화

Private Class Data 패턴은 클래스의 데이터를 외부로부터 보호하는 데 중점을 둡니다. 데이터를 메서드를 통해서만 접근할 수 있게 하여, 불필요한 데이터 수정이나 접근을 방지합니다.

데이터 보호

클래스 내의 데이터를 직접 접근하지 않고, 제어 가능한 메서드를 통해 데이터를 관리함으로써, 외부에서 데이터의 변경을 제한할 수 있습니다.

불변성 유지

클래스의 내부 데이터를 변경하지 않고, 불변성immutability을 유지하는 구조를 쉽게 구현할 수 있습니다. 불변 객체는 특히 멀티스레드 환경에서 유용합니다.

Private Class Data 패턴 적용

Private Class Data 패턴의 필요성

복잡한 시스템에서 클래스의 상태나 데이터를 외부에서 직접 접근하여 변경하면, 예기치 않은 오류가 발생하거나 시스템이 불안정해질 수 있습니다. Private Class Data 패턴은 이러한 위험을 줄이기 위해 데이터를 보호하고, 클래스의 상태를 명확하게 관리할 수 있도록 도와줍니다.

잘못된 처리

다음은 Private Class Data 패턴을 적용하지 않은 경우의 코드입니다.

public class Car
{
    public string Engine;
    public string Model;
    
    public Car(string engine, string model)
    {
        Engine = engine;
        Model = model;
    }
}
  • 데이터의 노출 : Engine과 Model 필드가 외부에 노출되어 있어, 누구든지 접근하여 값을 수정할 수 있습니다.
  • 데이터 무결성 침해 : 외부에서 직접 데이터를 수정하는 경우, 잘못된 값으로 인해 시스템의 무결성이 손상될 수 있습니다.

Private Class Data 패턴 적용 예시

Private Class Data 패턴을 적용하여 데이터를 보호하고, 외부에서의 불필요한 접근을 차단하는 방식입니다.

// Private Class Data
public class CarData
{
    private string Engine;
    private string Model;
    public CarData(string engine, string model)
    {
        Engine = engine;
        Model = model;
    }
    public string GetEngine() => Engine;
    public string GetModel() => Model;
}
// Main Class
public class Car
{
    private CarData carData;
    public Car(string engine, string model)
    {
        carData = new CarData(engine, model);
    }
    public string GetCarDetails() => $"Engine: {carData.GetEngine()}, Model: {carData.GetModel()}";
}

개선사항

데이터 보호

Private Class Data 패턴을 사용하면, 데이터가 캡슐화되어 외부에서 임의로 수정할 수 없습니다. 모든 데이터 접근은 관리된 메서드를 통해 이루어지므로 데이터 보호가 강화됩니다.

유지보수성 향상

데이터 접근 방식이 통제되기 때문에, 시스템 유지보수가 쉬워집니다. 데이터 접근 로직을 변경해야 하는 경우에도 하나의 메서드만 수정하면 됩니다.

데이터 무결성 보장

데이터가 외부에서 임의로 변경되지 않으므로, 클래스 내에서 데이터 무결성을 보장할 수 있습니다.

Private Class Data 패턴 구성 요소

Private Class Data 객체

데이터를 실제로 보관하는 객체로, 외부에서는 직접적으로 접근할 수 없으며, 메서드를 통해서만 접근이 가능합니다.

Main Class

Private Class Data 객체를 사용하는 메인 클래스입니다. 이 클래스는 외부로부터 데이터를 캡슐화하고, 필요한 경우에만 적절한 접근 메서드를 통해 데이터를 노출합니다.

Private Class Data 패턴과 캡슐화

Private Class Data 패턴은 일반적인 캡슐화 개념을 확장하여 데이터의 불변성을 더욱 강조하는 디자인 패턴입니다. 일반적인 캡슐화와 비교할 때, Private Class Data 패턴은 데이터를 보호하는 방식에서 차별화된 접근을 취합니다.

일반적인 캡슐화

  • 개념: 객체 지향 프로그래밍에서 캡슐화는 데이터(필드)와 메서드(행동)를 하나의 클래스 내에 묶고, 외부에서 직접적으로 데이터를 수정하거나 접근하지 못하도록 제한하는 개념입니다.
  • 구현 방식: 보통 클래스 필드를 private로 선언하고, 외부에서 필드에 접근할 수 있는 getter와 setter 메서드를 제공하여 데이터를 간접적으로 조작할 수 있게 합니다.
  • 특징:
    • 데이터 보호를 위한 접근 제어 (주로 private, protected 키워드를 사용)
    • 메서드를 통해 데이터를 수정하거나 조회할 수 있음

Private Class Data 패턴

  • 개념: Private Class Data 패턴은 데이터를 보호하고 불변성immutability을 더 엄격히 유지하는 데 목적이 있습니다. 이 패턴은 데이터에 대한 수정 가능성을 최소화하고, 객체가 데이터를 직접 변경할 수 없도록 하여 변경의 통제를 강화합니다.
  • 구현 방식: 클래스 내에 데이터 자체를 감추는 Data Class를 만들어, 외부에서는 해당 데이터를 수정하지 못하게 하며, 데이터를 변경할 필요가 있을 경우 매우 제한된 방식으로만 가능하도록 설계합니다. 변경 가능성을 최소화하기 위해 데이터 필드에 대한 setter 메서드를 제공하지 않는 경우가 많습니다.
  • 특징:
    • 데이터를 변경할 수 있는 통로를 엄격히 제한함 (변경할 수 없거나, 아주 제한적인 경우에만 변경 가능)
    • setter 메서드를 사용하지 않거나, 필요한 경우에만 메서드를 제공
    • 데이터의 불변성을 보장하기 위해 객체 초기화 시 데이터 설정 후 더 이상 변경하지 않음
    • 데이터 수정이 불가피할 경우 새로운 인스턴스를 만들어 수정된 데이터를 제공하는 방식

주요 차이점

불변성 강조

  • 캡슐화는 데이터를 외부에서 직접적으로 수정할 수 없도록 막지만, Private Class Data 패턴은 데이터의 불변성을 더욱 강조합니다.
  • 캡슐화는 데이터를 보호하되 변경할 수 있는 인터페이스를 제공하는 반면, Private Class Data 패턴은 가능한 한 데이터의 변경을 허용하지 않거나 제한된 상황에서만 허용합니다.

getter와 setter의 차이

  • 캡슐화에서는 보통 getter와 setter 메서드를 제공해 데이터를 읽거나 수정할 수 있게 합니다.
  • Private Class Data에서는 데이터에 대한 setter 메서드를 아예 제공하지 않거나, 최소한으로 제한해 데이터 수정 가능성을 줄입니다. 데이터는 객체 생성 시에만 설정되며 이후에는 변경되지 않는 경우가 많습니다.

데이터 변경 통제

  • 캡슐화는 주로 접근 제어에 초점을 맞추고 있어, 메서드를 통해 데이터를 자유롭게 수정할 수 있습니다.
  • Private Class Data는 변경 통제에 더 중점을 두어, 데이터를 수정할 수 있는 권한을 엄격하게 제한합니다.

예시 코드

일반적인 캡슐화 

public class Person {
    private string name;
    public string GetName() {
        return name;
    }
    public void SetName(string name) {
        this.name = name;
    }
}
  • setter 메서드를 통해 name을 언제든지 변경할 수 있습니다.

Private Class Data 패턴 

public class PersonData {
    private readonly string name;
    public PersonData(string name) {
        this.name = name;
    }
    public string GetName() {
        return name;
    }
}
public class Person {
    private PersonData data;
    public Person(string name) {
        data = new PersonData(name);
    }
    public string GetName() {
        return data.GetName();
    }
    // 데이터 변경 불가 - name은 한번 설정되면 변경 불가
}
  • 데이터 불변성을 보장하기 위해 PersonData 객체의 필드는 readonly로 선언되고, 생성자를 통해서만 값을 설정할 수 있습니다. setter 메서드를 제공하지 않기 때문에 데이터 변경이 불가능합니다.

Private Class Data 패턴 장단점

장점

  • 데이터 보호 : Private Class Data 패턴은 클래스의 내부 데이터를 안전하게 보호하고, 데이터를 외부에서 임의로 수정하는 것을 방지합니다.
  • 유지보수성 향상 : 데이터를 한 곳에서 관리하므로, 시스템 변경 시 여러 곳에서 수정할 필요가 없어 유지보수가 용이합니다.
  • 데이터 무결성 유지 : 외부에서 데이터에 직접 접근하지 못하게 함으로써, 데이터 무결성을 유지할 수 있습니다.

단점

  • 복잡성 증가 : 데이터를 별도의 클래스로 분리하여 관리하기 때문에 코드가 복잡해질 수 있으며, 작은 규모의 애플리케이션에서는 과도할 수 있습니다.
  • 메모리 사용량 증가 : 데이터를 관리하는 객체가 추가로 생성되므로, 메모리 사용량이 증가할 수 있습니다.

맺음말

Private Class Data 패턴은 데이터를 안전하게 보호하고, 무결성을 유지하는 데 유용한 패턴입니다. 특히 복잡한 시스템에서 데이터가 외부에서 임의로 변경될 위험이 있을 때, 이 패턴을 사용하여 데이터를 캡슐화하고 관리할 수 있습니다.

심화 학습

Singleton 조합

Singleton 패턴은 클래스의 인스턴스를 단 하나만 생성하고, 이를 전역적으로 접근할 수 있게 하는 디자인 패턴입니다. Private Class Data 패턴과 Singleton을 함께 사용하면, 데이터를 안전하게 관리하면서 전역적으로 접근 가능한 상태를 유지할 수 있습니다.

사용 예시:

  • 애플리케이션 설정 관리: Singleton을 통해 전역 설정 객체를 하나만 유지하고, Private Class Data 패턴으로 설정 값을 캡슐화하여 외부에서의 수정이나 접근을 제한할 수 있습니다.
public class AppConfig
{
    private static AppConfig _instance;
    private readonly AppConfigData _data;
    private AppConfig() 
    {
        _data = new AppConfigData("localhost", "8080");
    }
    public static AppConfig Instance
    {
        get 
        {
            if (_instance == null)
            {
                _instance = new AppConfig();
            }
            return _instance;
        }
    }
    public string GetServerUrl() => _data.GetUrl();
}
public class AppConfigData
{
    private string ServerUrl;
    private string Port;
    public AppConfigData(string serverUrl, string port)
    {
        ServerUrl = serverUrl;
        Port = port;
    }
    public string GetUrl() => $"{ServerUrl}:{Port}";
}

Factory Method 패턴 조합

Factory Method 패턴은 객체 생성을 서브클래스에 위임하는 디자인 패턴입니다. Private Class Data 패턴과 결합하면, 객체 생성 시 필요한 데이터를 안전하게 제공하고 객체를 보호할 수 있습니다.

사용 예시

  • 객체 생성 시 데이터 보호: Private Class Data로 필요한 데이터를 보호하면서, Factory Method를 사용해 객체를 안전하게 생성합니다.
public abstract class CarFactory
{
    public abstract Car CreateCar(string model);
}
public class ConcreteCarFactory : CarFactory
{
    public override Car CreateCar(string model)
    {
        CarData carData = new CarData("V8", model);
        return new Car(carData);
    }
}
public class Car
{
    private CarData _carData;
    public Car(CarData carData)
    {
        _carData = carData;
    }
    public string GetDetails()
    {
        return $"Engine: {_carData.GetEngine()}, Model: {_carData.GetModel()}";
    }
}
public class CarData
{
    private string Engine;
    private string Model;
    public CarData(string engine, string model)
    {
        Engine = engine;
        Model = model;
    }
    public string GetEngine() => Engine;
    public string GetModel() => Model;
}

Observer 패턴 조합

Observer 패턴은 객체 간의 일대다 관계를 정의하여, 한 객체의 상태 변화가 있을 때 여러 객체에게 통지되는 구조입니다. Private Class Data 패턴과 Observer 패턴을 결합하면, 데이터가 변경될 때 이를 감시하고 알림을 보낼 수 있습니다.

사용 예시:

  • 데이터 변경 알림: Private Class Data로 데이터를 보호하면서, Observer 패턴을 통해 데이터 변경을 감지하고 적절한 동작을 실행할 수 있습니다.
public interface IObserver
{
    void Update();
}
public class DataObserver : IObserver
{
    public void Update()
    {
        Console.WriteLine("Data has been updated.");
    }
}
public class DataSubject
{
    private List<IObserver> _observers = new List<IObserver>();
    private Data _data;
    public DataSubject(Data data)
        => _data = data;
    public void AddObserver(IObserver observer)
        => _observers.Add(observer);
    public void NotifyObservers()
    {
        foreach (var observer in _observers)
        {
            observer.Update();
        }
    }
    public void SetData(string newValue)
    {
        _data.SetValue(newValue);
        NotifyObservers();
    }
}
public class Data
{
    private string Value;
    public Data(string value)
    {
        Value = value;
    }
    public void SetValue(string value) => Value = value;
    public string GetValue() => Value;
}

Immutable Object 패턴 조합

Immutable Object 패턴은 객체가 생성된 후 상태가 변경되지 않도록 하는 패턴입니다. Private Class Data와 함께 사용하면, 데이터의 캡슐화와 불변성을 유지하면서 안전한 객체 생성을 할 수 있습니다.

사용 예시

  • 불변 객체: Private Class Data를 사용하여 내부 데이터를 캡슐화하고, 객체가 불변 상태를 유지하도록 할 수 있습니다.
public class ImmutablePerson
{
    private readonly PersonData _data;
    public ImmutablePerson(string name, int age)
    {
        _data = new PersonData(name, age);
    }
    public string GetName() => _data.GetName();
    public int GetAge() => _data.GetAge();
}
public class PersonData
{
    private string Name;
    private int Age;
    public PersonData(string name, int age)
    {
        Name = name;
        Age = age;
    }
    public string GetName() => Name;
    public int GetAge() => Age;
}
Buy me a coffee Buy me a coffee
Proxy