[C#] 인터페이스 (Interface)

 

인터페이스 - 인터페이스는 사용자 정의 자료형이며 메서드, 이벤트, 인덱서, 프로퍼티만을 가질 있지만 직접 구현하지 않고 단지 정의만을 갖는다.  그래서 인터페이스는 추상 멤버로만 구성된 추상 클래스와 개념적으로 유사하며, 클래스는 접근 제한 한정자로 수식하지 않으면 기본적으로 private로 선언되지만, 인터페이스는 접근 제한 한정자를 사용할 수 없고 모든 것이 public으로 선언된다. 또한 인스턴스도 만들 수 없으며, 클래스가 인터페이스를 가지는 경우 해당 인터페이스의 모든 멤버에 대한 구현을 제공해야 한다.

 

 

인터페이스 정의

 

인터페이스는 C# 키워드 interface를 사용하여 정의한다. 인터페이스 정의 시에는 내부 멤버들에 대해 public과 같은 접근 제한자를 사용하지 않는다. 

 

 

 

인터페이스 구현

 

C# 클래스가 인터페이스를 갖는 경우 인터페이스의 모든 멤버에 대한 구현을 제공해야 한다. 비록 인터페이스는 직접 new를 사용하여 인스턴스를 가질 수 없지만, 이 인스턴스를 상속받는 클래스의 인스턴스를 만드는 것은 가능하다. 

 

 

인터페이스는 인스턴스는 만들 수 없지만, 참조는 만들 수 있다. 이 참조에 Email 클래스(파생 클래스)의 객체의 위치를 담는다. 파생 클래스는 부모 클래스와 같은 형식으로 간주하기 때문에, 인터페이스와 인터페이스로부터 상속받는 클래스의 관계에도 그대로 적용된다. 

즉, Email의 객체는 ISendable의 객체로 취급할 수 있다. 

 

 

 

인터페이스는 약속

 

USB 포트는 USB 플래시를 넣으면 저장 장치로 쓸 수 있고, 키보드와 마우스를 꽂으면 입력 장치로 쓸 수 있다. USB 포트가 다양하게 사용될 수 있는 이유도 모두 USB 포트라는 약속을 따르기 때문이다. 인터페이스 또한 USB와 같은 역학을 한다. 클래스가 따라야 하는 약속인 셈이다. 이 약속은 인터페이스로부터 파생될 클래스가 어떤 메서드를 구현해야 할지를 정의한다. 

 

 

예제

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
using System.IO;
 
namespace Practice2
{
    public interface ILogger
    {
        void WriteLog(string message);
    }
    class ConSoleLogger : ILogger
    {
        public void WriteLog(string message)
        {
            WriteLine("{0} {1}", DateTime.Now.ToLocalTime(), message);
        }
    }
    class FileLogger : ILogger
    {
        private StreamWriter writer;
 
        public FileLogger(string path)
        {
            writer = File.CreateText(path);
            writer.AutoFlush = true;
        }
        public void WriteLog(string message)
        {
            writer.WriteLine("{0} {1}", DateTime.Now.ToShortTimeString(), message);
        }
    }
    class ClimateMonitor
    {
        private ILogger logger; // 인터페이스 변수 선언
        public ClimateMonitor(ILogger logger) // 인터페이스 객체
        {
            this.logger = logger;
        }
        public void start()
        {
            while(true)
            {
                Write("온도를 입력해주세요 : ");
                string temperature = ReadLine();
 
                if (temperature == "")
                    break;
                logger.WriteLog("현재 온도 : " + temperature);
            }
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            ClimateMonitor monitor = new ClimateMonitor(new FileLogger("MyLog.txt"));
            monitor.start();
        }
    }
}
 

 

실행

 

위 예제는  ILogger라는 인터페이스를 만들고, ConSoleLogger와 FileLogger는 ILogger를 상속하며, WriteLog() 메서드를 구현하며, FileLogger의 객체를 ClimateMonitor 생성자에 넘겨주면 monitor 객체는 파일에 로그를 저장하는 기능을 가질 수 있다.

 

 

 

인터페이스를 상속하는 인터페이스

 

인터페이스는 클래스뿐만 아니라 구조체는 물론이며, 인터페이스도 인터페이스를 상속할 수 있다. 기존의 인터페이스에 새로운 기능을 추가한 인터페이스를 만들고 싶을 때 인터페이스를 상속하는 인터페이스를 만들면 된다. 하지만 인터페이스를 수정할 수 없을 때에는 인터페이스를 상속하는 인터페이스를 이용해야 한다.

 

• 상속하려는 인터페이스가 소스 코드가 아닌 어셈블리로만 제공되는 경우
• 상속하려는 인터페이스의 소스 코드를 갖고 있어도 이미 인터페이스를 상속하는 클래스들이 존재하는 경우

클래스는 반드시 인터페이스의 모든 메서드와 프로퍼티를 구현해야 한다. 인터페이스에 사소한 수정이라도 이루어지면 이 인터페이스를 상속하는 기존 클래스들은 소스 코드를 빌드할 때 컴파일 에러를 내뱉을 것이다. 이런 상황에서 기존의 소스 코드에 영향을 주지 않고 새로운 기능을 추가하기 위해서는 인터페이스를 상속하는 인터페이스를 이용하는 편이 좋다. 

 

문법은 클래스의 문법과 똑같다. :을 찍고 그 오른편에 상속할 인터페이스의 이름을 붙여주면 된다. 

 

 

또한 파생 인터페이스는 부모 인터페이스에 선언된 모든 것을 그대로 물려받는다. 

 

 

ILogger2 인터페이스는 ILogger에 선언되어 있는 void WriteLog(string message)와 void WriteLog(string format, params object [] args) 메서드 두 개를 갖게 된다.

 

---

 

C#의 다중 상속

 

클래스는 여러 클래스를 한꺼번에 상속할 수 없다!(다중 상속 X) 왜냐하면 'The Deadly Diamond of Death' 죽음의 다이아몬드 문제 때문이다. 죽음의 다이아몬드란, 하나의 할아버지 클래스를 두 개의 파생 클래스가 상속하고, 이 두 개의 파생 클래스를 다시 하나의 자식 클래스가 상속하는 것을 말한다. 

 

죽음의 다이아몬드

 

위 그림처럼 ComboDrive가 어느 burn() 메서드를 물려받을지 모호하다는 것이다. 상속은 객체지향에서 없어서는 안 될 요소중 하나이지만 단점과 허점도 존재하는 속성이다. 

 

 

인터페이스의 상속

 

상속은 기본적으로 일반 클래스, 추상 클래스중 하나만 가능하며, 인터페이스를 추가로 더 상속할 수 있다. 인터페이스는 내용이 아닌 외형을 물려준다. 겉모습만큼은 자신을 닮기를 강제한다. 따라서 죽음의 다이아몬드 같은 문제도 발생하지 않는다. 

 

 

예제

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
using System.IO;
 
namespace Practice2
{
    interface IRunnable
    {
        void Run();
    }
    interface IFlyable
    {
        void Fly();
    }
    class FlyingCar : IRunnable, IFlyable
    {
        public void Run()
        {
            WriteLine("Run! Run!");
        }
        public void Fly()
        {
            WriteLine("Fly! Fly!");
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            FlyingCar car = new FlyingCar();
            car.Run();
            car.Fly();
 
            IRunnable runnable = car as IRunnable;
            runnable.Run();
 
            IFlyable flyable = car as IFlyable;
            flyable.Fly();
        }
    }
}

 

 

인터페이스 IRunnable과 IFlyable을 만들고 FlyingCar 클래스가 두 인터페이스를 상속받아 두 인터페이스의 메서드를 구현하였다. 

FlyingCar의 인스턴스를 만들어서 Run과 Fly를 호출하면 실제 메소드의 내용이 호출이 된다.

38번 줄의 IRunnable 인터페이스의 참조 변수 runnable을 만들고 car를 IRunnable로 형식 변환을 하여 저장하도록 한 것이다.