C# 기본 지식 편집: C# 클래스 및 구조(4)

1. 인터페이스란 무엇인가요? 특징? 코드를 구현하시겠습니까?
인터페이스는 인터페이스 키워드를 사용하여 정의되며, 클래스 멤버의 조합으로 구성되며 일부 기능을 설명하는 사양 집합입니다. C#에서 볼 수 있듯이 시스템의 일부 인터페이스 이름은 IComparable(유형 비교 방법), ICloneable(복제 지원), IDisposable(리소스 해제) 등으로 명명됩니다. I는 인터페이스를 나타내며,able은 인터페이스의 특성을 반영합니다. 인터페이스. : "Can..."은 이 사양 집합이 수행할 수 있는 작업을 나타냅니다.
(1), 인터페이스 구현

   public interface IPrintAble
    {
        void PrintString();

        void PrintInt();

        void PrintBool();
    }

    public interface IComputeAble
    {
        void HandlerString();

        void HandlerInt();

        void HandlerBool();
    }

    public class MyInplementInterface : IPrintAble, IComputeAble
    {
        //隐式实现
        public void PrintString()
        {
            Console.WriteLine(@"1");
        }

        public void PrintInt()
        {
            Console.WriteLine(1);
        }

        public void PrintBool()
        {
            Console.WriteLine(true);
        }

        public void HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        public void HandlerInt()
        {
            Console.WriteLine(1 + 1);
        }

        public void HandlerBool()
        {
            Console.WriteLine(true || false);
        }

        //显示实现
        //void IComputeAble.HandlerString()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerInt()
        //{
        //    throw new NotImplementedException();
        //}

        //void IComputeAble.HandlerBool()
        //{
        //    throw new NotImplementedException();
        //}
    }
      class Program
    {
        static void Main(string[] args)
        {
            MyInplementInterface imple = new MyInplementInterface();

            imple.PrintString();

            imple.PrintInt();

            imple.PrintBool();

            imple.HandlerString();

            imple.HandlerInt();

            imple.HandlerBool();

            Console.ReadLine();
        }
    }

결과:

(2) 전용 인터페이스 구현, 즉 이미 C#에서 정의한 인터페이스
예:

    public class ImplementSysInterface : IComparable
    {
        public int CompareTo(object obj)
        {
            //可以根据需要实现自己的比较方法
            return 0;
        }

        private void UsingMenthod()
        {
            //报错，因为NoIDisposeableClass没有实现IDisposable接口，所以不支持using
            //using (NoIDisposeableClass my = new NoIDisposeableClass())
            //{

            //}
            //实现IDisposable接口后，可以使用using
            using (IDisposeableClass my = new IDisposeableClass())
            {

            }
        }
    }

    public class NoIDisposeableClass
    {

    }

    public class IDisposeableClass : IDisposable
    {
        #region IDisposable 成员

        public void Dispose()
        {
            
        }

        #endregion
    }

인터페이스에는 다음과 같은 특징이 있습니다.
a. 인터페이스는 추상 기본 클래스와 유사하며 인터페이스의 메서드는 모두 추상 메서드이며, 해당 클래스를 구현하는 모든 비추상 유형입니다. 인터페이스는 인터페이스의 모든 멤버를 구현해야 합니다.
b. 인터페이스의 멤버가 명시적으로 구현되면 구현된 멤버는 클래스 인스턴스를 통해 액세스할 수 없고 인터페이스 인스턴스를 통해서만 액세스할 수 있습니다.
예:

   public class MyInplementInterface2 : IComputeAble
    {
        void IComputeAble.HandlerString()
        {
            Console.WriteLine(@"1" + "1");
        }

        void IComputeAble.HandlerInt()
        {
            Console.WriteLine(true || false);
        }

        void IComputeAble.HandlerBool()
        {
            Console.WriteLine(true || false);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IComputeAble imple2 = new MyInplementInterface2();

            imple2.HandlerString();

            Console.ReadLine();
        }
    }

c. 인터페이스의 멤버가 암시적으로 구현되는 경우 구현된 멤버는 클래스 인스턴스 또는 인터페이스 인스턴스를 통해 액세스할 수 있지만 구현된 멤버는 공개되어야 합니다.
d. 인터페이스는 상수, 필드, 연산자, 인스턴스 생성자, 소멸자 또는 유형을 포함할 수 없으며 정적 멤버를 포함할 수 없습니다.
e. 인터페이스 멤버는 자동으로 공개되며 액세스 한정자를 포함할 수 없습니다.
f. 인터페이스 자체는 여러 인터페이스에서 상속할 수 있으며 클래스와 구조는 여러 인터페이스에서 상속할 수 있지만 인터페이스는 클래스에서 상속할 수 없습니다.

2. 제네릭이란 무엇입니까? 제네릭의 장점은 무엇입니까?
소위 제네릭은 .NET에 유형 매개변수 개념을 도입하고 매개변수화된 유형을 통해 동일한 코드에서 여러 데이터 유형의 작동을 실현합니다. 참조 유형이자 힙 객체입니다.
사실 저는 Java를 배울 때 처음으로 제네릭을 배웠습니다. 당시에는 제네릭이 불필요하고 객체로 할 수 있다고 생각했습니다. 예를 들어, 다음과 같이 누군가가 유형의 값을 인쇄하고 싶어하므로 객체가 구현됩니다.

    public class Test
    {
        private object model;

        public object Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public Test(object model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
   class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            Test testI = new Test(recordI);

            testI.ShowRecord();

            Test testB = new Test(recordB);

            testB.ShowRecord();

            Console.ReadLine();
        }
    }

그러나 자세히 알아보면 여전히 특정 문제가 있다는 것을 알게 될 것입니다. 먼저 boxing의 문제가 있는데, Int는 값형이다. 객체형에 값을 할당할 때 boxing 연산을 완료해야 한다. 크레이팅이란 무엇입니까? 새로운 객체가 할당한 공간에 RecordI 값을 복사하는 것입니다. 시간과 성능을 낭비했습니다. 따라서 제네릭에는 여전히 역할이 있습니다. 그러면 제네릭을 사용하여 다음을 구현합니다.

  public class TestGeneric<T>
    {
        private T model;

        public T Model
        {
            get
            {
                return model;
            }

            set
            {
                model = value;
            }
        }

        public TestGeneric(T model)
        {
            this.Model = model;
        }

        public void ShowRecord()
        {
            Console.WriteLine(model);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            int recordI = 2;

            bool recordB = true;

            TestGeneric<int> testGI = new TestGeneric<int>(recordI);

            testGI.ShowRecord();

            TestGeneric<bool> testGB = new TestGeneric<bool>(recordB);

            testGB.ShowRecord();

            Console.ReadLine();
        }
    }

이런 식으로 TestGeneric testGI = new TestGeneric(recordI)일 때 T가 int이면 Boxed로 옷을 입힐 필요가 없습니다. .
물론 제네릭은 단순히 복싱 문제를 해결하는 것이 아닙니다.
a. 성능을 향상시키는 복싱 및 언박싱을 피하세요.
c. , 컴파일 중에 감지되므로 유형이 안전합니다.
d. 자신만의 일반 인터페이스, 일반 클래스, 일반 메서드, 일반 이벤트 및 일반 대리자를 만들 수 있습니다.
위 내용은 C# 기본 지식을 정리한 것입니다: C# 클래스 및 구조(4). 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!