C#지식 범위

10521 단어

C#지식 범위


범용은 2.0 버전 C# 언어 및 공용 언어 라이브러리(CLR)의 새로운 기능입니다.범형은 유형 매개 변수의 개념을 도입한다.NET Framework, 유형 매개 변수는 다음과 같은 클래스와 방법을 설계할 수 있습니다. 클래스와 방법은 클라이언트 코드가 클래스나 방법을 설명하고 실례화할 때로 지정됩니다.예를 들어 일반 유형 매개 변수 T를 사용하면 실행 시 강제 변환이나 포장 작업의 비용이나 위험을 초래하지 않고 다른 클라이언트 코드가 사용할 수 있는 단일 클래스를 작성할 수 있습니다. 강제 유형 변환의 수요를 피하고 유형 안전성을 높일 수 있습니다.

일반 개요 및 장점


범형류와 범형방법은 중용성, 유형 안전과 효율이 높은 특징을 동시에 갖추고 있다.그것은 보통 집합과 집합에서 운행하는 방법에 쓰인다.NET 2.0 버전 라이브러리는 System이라는 새로운 이름을 제공합니다.Collections.Generic의 이름 공간입니다. 이 공간에는 여러 개의 새로운 범주 기반 집합 클래스가 포함되어 있습니다.
사용자 정의 일반 형식과 방법을 만들 수도 있습니다.
일반 클래스 및 메서드는 "유형 매개 변수"를 수신하여 작업할 객체의 유형을 지정합니다.
public class Test<T> {}
인스턴스화할 때 유형을 지정합니다.
Test<int> tree = new Test<int>(); 
일반 유형을 사용하면 다음과 같은 장점이 있습니다.
  • 일반 유형을 사용하면 코드를 최대한 재사용하고 유형의 안전을 보호하며 성능을 향상시킬 수 있다.
  • 범형의 가장 흔히 볼 수 있는 용도는 집합 클래스를 만드는 것이다.
  • .NET Framework 라이브러리는 System에 있습니다.Collections.Generic 네임스페이스에는 여러 개의 새로운 범주 컬렉션이 포함됩니다.가능한 한 이런 종류를 사용해서 일반적인 종류, 예를 들어 System을 대체해야 한다.Collections 네임스페이스의 ArrayList.
  • 당신은 자신의 범용 인터페이스, 범용 클래스, 범용 방법, 범용 이벤트와 범용 의뢰를 만들 수 있습니다.
  • 일반 클래스를 제약하여 특정한 데이터 형식에 접근할 수 있는 방법.
  • 일반 데이터 형식에 사용되는 유형에 대한 정보는 실행할 때 반사로 얻을 수 있다.

  • 범용의 유형 매개변수 T


    유형 매개 변수 T는 일반 클래스를 정의할 때 사용되는 자리 표시자입니다. 하나의 유형이 아니라 가능한 유형만 나타냅니다.정의할 때 T가 나타나는 위치는 어떤 종류로든 대체할 수 있습니다.

    언제 어디서 범형을 사용할지 결정하다


    다음 사항을 고려해야 합니다.
  • 사용자가 사용하는 형식은 집합 형식과 같이 지정되지 않은 데이터 형식을 포함하거나 조작합니까?만약 그렇다면, 일반 형식을 만들면 더 많은 장점을 제공할 수 있을 것이다.만약 형식이 단일한 지정한 형식만 조작한다면, 일반 클래스를 만들 필요가 없습니다. 
  • 만약에 당신의 유형이 조작치 유형을 사용한다면 포장과 해체 조작이 발생할 수 있으므로 포장과 해체 조작을 방지하기 위해 일반형을 사용하는 것을 고려해야 합니다. 
  • 일반적인 강력한 유형 검사는 오류를 신속하게 찾아내는 데 도움이 되고 버그 복구 주기를 단축시킨다.
  • 여러 종류의 여러 데이터 형식을 작성할 때'코드 팽창'문제에 부딪혔습니까(예를 들어 한 ArrayList는StreamReaders만 저장하고 다른 저장소는StreamWriters)?사실 코드를 한 번 작성해서 여러 데이터 형식에서 작업시키는 것은 매우 간단하다.
  • 범위는 코드를 더욱 뚜렷하게 한다.코드의 팽창을 없애고 강제 검사를 하면 코드를 더 쉽게 읽고 이해할 수 있습니다.

  • 클래스에 대한 범주


    서로 다른 유형의 수조를 대상으로 수조에 대한 '거품 정렬' 을 쓰십시오.

    사고의 방향

  • 유형에 대한 범형, 범형은 유형 옆에 있다.
  • '거품 정렬'에서 원소를 비교해야 하기 때문에 범형은 IComparable 인터페이스를 실현하는 인터페이스로 제약해야 한다
  • namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                SortHelper<int> isorter = new SortHelper<int>();
                int[] iarray = { 8, 7, 1, 2, 12 };
                isorter.BubbleSort(iarray);
                foreach (int item in iarray)
                {
                    Console.Write(item + ",");
                }
                Console.ReadKey();
            }
        }
    
        public class SortHelper<T> where T : IComparable
        {
            public void BubbleSort(T[] array)
            {
                int length = array.Length;
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
                        if (array[j].CompareTo(array[j - 1]) < 0)
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }
    }
    출력:

    일반 구속조건 정보

  • where T: IComparable는 T를 IComparable 인터페이스를 실현하는 것으로 제약한다
  • where T : class 
  • where T : struct 
  • where T: IComparable, new() 제약 범위는 구조 함수
  • 가 있어야 합니다.

    거품 알고리즘 정보

  • for(int i=0;i <=length-2;i++)의 이유는 경계 사고이다. 예를 들어 길이가 5인 수조가 있는데 0호위 요소가 최종적으로 4호위로 바뀌면 매번 4번을 거쳐야 4호위, 즉 for(int i=0;i <=5-2, i++)가 있고 i는 0, 1, 2, 4 순으로 4호위가 된다. 그 동안 4번을 겪었다.
  • for(int j=length-1;j>=1;j-) 순환은 마지막 원소부터 인덱스 1의 원소까지 매번 이전 위치의 원소와 비교한다.

  • 비교 정보


    int 형식을 비교할 수 있는 이유는 int 형식이 IComparable 인터페이스를 실현했기 때문이다.byte 타입도 마찬가지다.

    하나의 클래스를 사용자 정의하여 거품 알고리즘을 실현할 수 있도록 하다


    거품 알고리즘은 원소 비교와 관련이 있기 때문에 사용자 정의 클래스는 반드시 IComparable 인터페이스를 실현해야 한다.
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Book[] bookArray = new Book[2];
                Book book1 = new Book(100, "  ");
                Book book2 = new Book(80, "  ");
                bookArray[0] = book1;
                bookArray[1] = book2;
    
                Console.WriteLine("    :");
                foreach (Book b in bookArray)
                {
                    Console.WriteLine("  :{0},  :{1}", b.Title, b.Price);
                }
    
                SortHelper<Book> sorter = new SortHelper<Book>();
                sorter.BubbleSort(bookArray);
                Console.WriteLine("    :");
                foreach (Book b in bookArray)
                {
                    Console.WriteLine("  :{0},  :{1}", b.Title, b.Price);
                }
                Console.ReadKey();
            }
        }
    
        public class SortHelper<T> where T : IComparable
        {
            public void BubbleSort(T[] array)
            {
                int length = array.Length;
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
                        if (array[j].CompareTo(array[j - 1]) < 0)
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }
    
        //     IComparable  
        public class Book : IComparable
        {
            private int price;
            private string title;
    
            public Book(){ }
            public Book(int price, string title)
            {
                this.price = price;
                this.title = title;
            }
    
            public int Price
            {
                get 
                {
                    return this.price;
                }
            }
    
            public string Title
            {
                get
                {
                    return this.title;
                }
            }
    
            public int CompareTo(object obj)
            {
                Book book = (Book)obj;
                return this.Price.CompareTo(book.Price);
            }
        }
    }
    출력:

    방법에 대한 범용


    계속해서 위의 예를 들어 하나의 종류를 사용자 정의하고 일반적인 방법을 정의합니다.
    namespace ConsoleApplication1
    {
        //     
        public class MethodSortHelper
        {
            public void BubbleSort<T>(T[] array) where T : IComparable
            {
                int length = array.Length;
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
                        if (array[j].CompareTo(array[j - 1]) < 0)
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }
    }
    마스터 프로그램은 다음과 같습니다.
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Book[] bookArray = new Book[2];
                Book book1 = new Book(100, "  ");
                Book book2 = new Book(80, "  ");
                bookArray[0] = book1;
                bookArray[1] = book2;
    
                Console.WriteLine("    :");
                foreach (Book b in bookArray)
                {
                    Console.WriteLine("  :{0},  :{1}", b.Title, b.Price);
                }
    
                MethodSortHelper sorter = new MethodSortHelper();
                sorter.BubbleSort<Book>(bookArray);
                Console.WriteLine("    :");
                foreach (Book b in bookArray)
                {
                    Console.WriteLine("  :{0},  :{1}", b.Title, b.Price);
                }
                Console.ReadKey();
            }
        }
    
        //     IComparable  
        public class Book : IComparable
        {
            private int price;
            private string title;
    
            public Book() { }
            public Book(int price, string title)
            {
                this.price = price;
                this.title = title;
            }
    
            public int Price
            {
                get
                {
                    return this.price;
                }
            }
    
            public string Title
            {
                get
                {
                    return this.title;
                }
            }
    
            public int CompareTo(object obj)
            {
                Book book = (Book)obj;
                return this.Price.CompareTo(book.Price);
            }
        }
    }
    출력:
    범용 방법을 사용할 때 다음과 같은 경우를 제외하고는
    MethodSortHelper sorter = new MethodSortHelper();   
    sorter.BubbleSort<Book>(bookArray); 
    
    :
    MethodSortHelper sorter = new MethodSortHelper();   
    sorter.BubbleSort(bookArray); 
    
    에서 알 수 있듯이 범주형 방법은 데이터 실례에 따라 범주형이 조건에 만족하는지 여부를 은밀하게 추정할 수 있다.

    일반형의 기타 장점


    암시적 포장 및 포장 해제 방지


    다음은 암시적 포장 및 포장해제입니다.
    ArrayList list = new ArrayList();  
    for(int i = 0; i < 3; i++)  
    {  
      list.Add(i); //Add            object,           
    }  
    for(int i = 0; i < 3; i++)  
    {  
      int value = (int)list[i]; //          ,    
      Console.WriteLine(value);  
    } 
    
    스텔스 방식 포장 및 포장 풀기 방지를 위한 일반 사용:
    List<int> list = new List<int>();  
    for(int i = 0; i < 3; i++)  
    {  
      list.Add(i);  
    }  
    for(int i = 0; i < 3; i++)  
    {  
      int value = list[i];  
      Console.WriteLine(value);  
    } 
    

    컴파일하는 동안 제때에 오류를 발견할 수 있다


    범용을 사용하지 않고 컴파일하는 동안 오류가 발생하지 않는 예:
    List<int> list = new List<int>();  
    for(int i = 0; i < 3; i++)  
    {  
      list.Add(i);  
    }  
    for(int i = 0; i < 3; i++)  
    {  
      int value = list[i];  
      Console.WriteLine(value);  
    } 
    
    범용을 사용하여 컴파일하는 동안 오류를 적시에 발견:
    List<int> list = new List<int>();  
    int i = 100;  
    list.Add(i);  
    string value = (string)list[0]; 
    

    일반적인 기교를 사용하다


    현재 파일에서 범주에 별칭을 지정합니다.

    using IntList = List<int>;  
    IntList list = new IntList();  
    list.Add(1); 
    

    다른 파일에서 범용 별명을 사용하여 범용에서 클래스를 정의합니다

    public class IntList : List<int>{}

    좋은 웹페이지 즐겨찾기