C\#의 async 와 await 를 이해 하 는 글

12110 단어 c#asyncawait
머리말
본문 은 async/Task 를 소개 합 니 다.이 지식 을 공부 하 는 과정 에서 반드시 모든 예시 에 따라 코드,집행,출력 결 과 를 작성 하고 스스로 사고방식 을 분석 해 야 한다.
async
마이크로소프트 문서:async 수식 자 를 사용 하면 방법,lambda 표현 식 또는 익명 방법 을 비동기 로 지정 할 수 있 습 니 다.
async 수식 방법 을 사용 하여 비동기 방법 이 라 고 합 니 다.
예 를 들 면:
규범 을 명명 하기 위해 서 는 async 수식 방법 을 사용 하고 방법 이름 뒤에 Async 를 추가 해 야 합 니 다.

public async Task<int> TestAsync()  
{  
    // . . . .  
}
Lambda :


        static void Main()
        {
            Thread thread = new Thread(async () =>
            {
                await Task.Delay(0);
            });
        }
        public static async Task<int> TestAsync() => 666;

await
마이크로소프트 문서:await 연산 자 는 자신 이 속 한 async 방법 에 대한 값 을 잠시 멈 추고 동작 수가 표시 하 는 비동기 작업 이 완 료 될 때 까지 합 니 다.
비동기 작업 이 완료 되면 await 연산 자 는 작업 의 결 과 를 되 돌려 줍 니 다(있 으 면).
네,여기까지 입 니 다.async 와 await,공식 문서 에 대한 설명 이 이렇게 많 습 니 다.
이전의 지식 으로 부터 유도 하 다.
여기 서 우 리 는 문서 와 책의 자 료 를 참고 하지 않 습 니 다.문서 와 책의 예 시 를 보지 마 십시오.우 리 는 작업(Task)의 동기 화 비동기 에서 시작 하여 천천히 모색 해 야 합 니 다.async 와 await 두 키 워드 는 우리 의 비동기 프로 그래 밍 에 어떤 편 의 를 가 져 왔 는 지 분석 합 니 다.
비동기 작업 생 성
장면:토요일 방학 이 라 왕 자 를 때 릴 수 있 지만 어제 옷 은 아직 빨 지 않 았 습 니 다.그래서 세탁기 로 빨래 를 하고 세탁 하 는 동안 왕 자 를 만 들 었 습 니 다.
우 리 는 다음 과 같은 방법 을 만 들 수 있다.

        static void Main()
        {
            Console.WriteLine("     ");

            //           
            Task<int> task = new Task<int>(() =>
            {
                //         
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });

            Console.WriteLine("     ");

            //        
            task.Start();

            Console.WriteLine("     ,       ");
            //    
            Thread.Sleep(TimeSpan.FromSeconds(4));
            Console.WriteLine("     ,      ?");

            Console.WriteLine(task.IsCompleted);
            if (task.IsCompleted)
                Console.WriteLine("       :" + task.Result);
            else
            {
                Console.WriteLine("         ");
                task.Wait();
                Console.WriteLine("       :" + task.Result);
            }
            Console.WriteLine("   ,    ,   ,      ");
        }

비동기 작업 을 만 들 고 작업 을 되 돌려 줍 니 다.
위의 예 는 비동기 적 으로 하나의 임 무 를 완 성 했 지만 이렇게 코드 를 모두 Main 에 두 면 가 독성 이 매우 떨 어 지고 다른 규범 과 같은 것 이 필요 하 며 우리 가 이런 쓰레기 코드 를 쓰 는 것 을 허락 하지 않 습 니 다.그래서 우 리 는 빨래 라 는 임 무 를 한 방법 에 봉 하여 Task 로 돌아 가면 된다.
프로그램 클래스 에 다음 과 같은 방법 을 추가 합 니 다.이 방법 은 비동기 임 무 를 수행 하고 Task 대상 으로 돌아 갑 니 다.

        /// <summary>
        ///       
        /// </summary>
        /// <returns></returns>
        public static Task<int> TestAsync()
        {
            Task<int> task = new Task<int>(() =>
            {
                //         
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task;
        }
주요 방법

        static void Main()
        {
            Console.WriteLine("     ");

            //           
            Task<int> task = TestAsync();
            ... ...

하지만 이들 의 차 이 는 크 지 않다.
비동기
우 리 는 빨래 하 는 임 무 를 수행 하기 위해 비동기 적 인 방법 을 만 들 었 다.게임 을 마 친 후 미 션 이 완성 되 었 는 지 확인 한 후에 야 다음 작업 을 할 수 있 는데 이때 동기 화 되 었 다.동기 화 와 실행 결 과 를 유지 하기 위해 서,우 리 는.Wait(),.Result 를 사용 했다.
여기 서 우 리 는 위의 조작 을 동기 화하 고 실행 결 과 를 얻 으 려 고 시도 합 니 다.

    class Program
    {
        static void Main()
        {
            int time = Test();
            // ... ...
        }

        /// <summary>
        ///       
        /// </summary>
        /// <returns></returns>
        public static int Test()
        {
            Task<int> task = new Task<int>(() =>
            {
                //         
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task.Result;
        }
    }

await Task 에 대해 서 얘 기해 주세요.
Task 와 Task,전 자 는 결 과 를 되 돌려 주지 않 은 임무 이 고,후 자 는 결 과 를 되 돌려 주 는 임무 입 니 다.앞의 글 에서 이미 대량의 예 시 를 사 용 했 습 니 다.여기 서 우 리 는 await 를 사용 하여 똑 같은 기능 을 완성 합 니 다.
Task:

        public static void T1()
        {
            Task task = new Task(() => { });
            task.Wait();
        }

        public static async void T2()
        {
            Task task = new Task(() => {  });
            await task;
        }
설명,await 는 프로그램 이 임 무 를 완성 할 때 까지 기다 릴 수 있 습 니 다.
Task

       public void T3()
       {
           //    Task     ,             
           Task<int> task = TestAsync();

           //         ,     
           //           ,     ,       
           //      

           Console.WriteLine(task.Result);
       }


        public async void T4()
        {
            //    await    ,        ,  
            int time = await TestAsync();
            Console.WriteLine(time);
        }
설명:await 는 프로그램 이 작업 이 완 료 될 때 까지 기다 리 게 하고 실행 결 과 를 얻 을 수 있 습 니 다.
봤 어?await 키워드,역할 은 당신 을 기다 리 게 하 는 것 입 니 다.동기 화 된 것 입 니 다.근본적으로 당신 의 임 무 를 비동기 배경 으로 만 드 는 것 이 아 닙 니 다.
그런데 왜 async,await 를 언급 했 습 니까?모두 비동기 와 관련 이 있다 고 말 합 니까?급 하지 않 아 요.
async Task
async Task방법 을 수정 하면 이 방법 은 await Task의 결 과 를 되 돌려 줍 니 다.

두 가지 동기 화 방식 의 예시 비교:

        public static int Test()
        {
            Task<int> task = new Task<int>(() =>
            {
                //         
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task.Result;
        }

        public static async Task<int> TestAsync()
        {
            Task<int> task = new Task<int>(() =>
            {
                //         
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            int time = await task;
            return time;
        }
동기 비동기?
―async 와 await 는 비동기 적 인 방법 과 관련 이 있 잖 아 요.왜 앞의 예제 에서 await 를 사 용 했 는 지 모두 동기 화 되 었 나 요?
―async 와 await 를 사용 하 는 방법 은 실행 과정 이 동기 화 되 는 것 입 니까?비동기 화 되 는 것 입 니까?
답:동기 비동기 다 좋 습 니 다.동기 화 하 시 겠 습 니까?비동기 화 하 시 겠 습 니까?모두 당신 의 손 에 달 려 있 습 니 다.
4.567917.당신 은 await 를 사용 하여 비동기 방법 을 호출 합 니 다.그 실행 과정 은 동기 화 입 니 다
  • 비동기 적 인 방법 으로 돌아 오 는 Task 는 비동기 입 니 다
  • 최근 에 필 자 는 일부 질문 을 받 았 다.일부 독자 들 은 async 와 await 를 사용 하여 업 무 를 작성 하고 비동기 적 이 며 성능 을 향상 시 킬 수 있다 고 생각 했다.실제 결 과 는 동기 화 되 고 성능 은 조금도 향상 되 지 않 았 다.아래 의 예 시 를 통 해 너 는 즉시 어떻게 사용 해 야 하 는 지 이해 할 것 이다.
    우선,async 와 await 키 워드 를 사용 하지 않 은 상태 에서 동기 화 와 비동기 화 기능 을 각각 실현 하 는 두 가지 방법 을 작 성 했 습 니 다.두 가지 방법 이 실 행 된 결 과 는 일치 합 니 다.
    
            /// <summary>
            ///   
            /// </summary>
            /// <returns></returns>
            public static int Test()
            {
                Task<int> task = new Task<int>(() =>
                {
                    return 666;
                });
                task.Start();
                return task.Result;
            }
            
            /// <summary>
            ///   
            /// </summary>
            /// <returns></returns>
            public static Task<int> TestAsync()
            {
                Task<int> task = new Task<int>(() =>
                {
                    return 666;
                });
                task.Start();
                return task;
            }
    
    두 가지 방법 을 합 칠 수 있 습 니까?동기 화 하려 면 동기 화,비동기 화 하려 면 비동기 화,그러면 두 가지 방법 을 쓸 필요 가 없습니다!
    네,괜찮아 요!async 와 await 키 워드 를 통 해 쉽게 실현 할 수 있 습 니 다!
    합병 후 코드 는 다음 과 같 습 니 다.
    
            /// <summary>
            ///       
            /// </summary>
            /// <returns></returns>
            public static async Task<int> TestAsync()
            {
                Task<int> task = new Task<int>(() =>
                {
                    return 666;
                });
                task.Start();
                return await task;
            }
    
    합병 후,우 리 는 어떻게 호출 할 때 동기 화 와 비동기 화 를 실현 해 야 합 니까?
    필 자 는 여기에 두 가지 예 를 제시 했다.
    
            // await       
            public async void T1()
            {
                //    await    ,        ,  
                int time = await TestAsync();
                Console.WriteLine(time);
            }
    
            //         Task,    
            public void T2()
            {
                //    Task     ,             
                Task<int> task = TestAsync();
    
                //         ,     
                //           ,     ,       
                //      
    
                Console.WriteLine(task.Result);
            }
    
    
    이로써 왜 async 와 await 를 사 용 했 는 지 이해 하고 실행 할 때 동기 화 되 었 죠?
    작업 패키지 비동기 작업
    앞에서 우 리 는 모두 new Task()를 사용 하여 작업 을 만 들 었 고 마이크로소프트 홈 페이지 는 대부분 Task.Run()을 사용 하여 async 와 await 의 예 를 만 들 었 습 니 다.
    따라서 우 리 는 앞의 비동기 임 무 를 수정 하여 다음 과 같이 바 꿀 수 있다.
    
            /// <summary>
            ///       
            /// </summary>
            /// <returns></returns>
            public static async Task<int> TestAsync()
            {
                return await Task.Run<int>(() =>
                {
                    return 666;
                });
            }
    
    await 변이 걸음 으로 뛰 기
    바 이 두 가 이 보 를 배 울 때 저 자 는 이 보 방법 에 들 어간 후에 코드 를 동기 화하 고 await 를 만나면 이 보 를 실행 하 라 고 말 합 니 다.
    물론 여러 가지 설 이 있다.
    우 리 는 이미 이렇게 많은 임무(Task)지식 을 배 웠 다 는 점 은 매우 쉽게 설명 할 수 있다.
    async 와 await 키 워드 를 사 용 했 기 때문에 코드 의 가장 깊 은 곳 에 Task 라 는 것 이 나타 날 것 입 니 다.Task 라 는 것 은 원래 비동기 입 니 다.await 에 부 딪 히 면 비동기 가 나타 나 는 것 은 await 의 역할 때 문 이 아니 라 맨 밑 에 Task 가 있 기 때문이다.

    왜 한 층 씩 await 가 나 와 요?
    서비스 제공 자 에 비해내 가 인 터 페 이 스 를 제공 해서 너 에 게 사용 해 야 하기 때문에 밑바닥 에 async,await 가 나타 난 후에 나 는 계속 방법 이 비동기(async)인 것 을 보류 하고 계속 봉인 할 것 이다.그러면 여러 층 의 호출 구조 가 있다.예 를 들 어 지난 소절 의 그림 이다.
    그러나 호출 자 에 게 왔 다 면 async,await 를 사용 하여 방법 을 만 드 는 것 이 아니 라 실제 상황 에 따라 동기 화 되 거나 비동기 화 되 어야 합 니 다.
    총결산
    이 C\#중 async 와 await 의 글 은 여기까지 소개 되 었 습 니 다.더 많은 관련 C\#중 async 와 await 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!

    좋은 웹페이지 즐겨찾기