ASP.NET MVC 4 Sürümünde Zaman Uyumsuz Metotlar KullanmaUsing Asynchronous Methods in ASP.NET MVC 4

Rick Anderson tarafındanby Rick Anderson

Bu öğretici, Microsoft Visual Studio ücretsiz bir sürümü olan Web için Visual Studio Express 2012kullanarak zaman uyumsuz BIR ASP.NET MVC web uygulaması oluşturma hakkında temel bilgileri öğretir.This tutorial will teach you the basics of building an asynchronous ASP.NET MVC Web application using Visual Studio Express 2012 for Web, which is a free version of Microsoft Visual Studio. Visual Studio 2012' i de kullanabilirsiniz.You can also use Visual Studio 2012.

Bu öğretici için GitHub 'da bir örnek verilmiştir https://github.com/RickAndMSFT/Async-ASP.NET/A complete sample is provided for this tutorial on github https://github.com/RickAndMSFT/Async-ASP.NET/

.Net 4,5 birleşimi IÇINDEKI ASP.NET MVC 4 Denetleyici sınıfı, görev<ActionResult>türünde bir nesne döndüren zaman uyumsuz eylem yöntemleri yazmanızı sağlar.The ASP.NET MVC 4 Controller class in combination .NET 4.5 enables you to write asynchronous action methods that return an object of type Task<ActionResult>. .NET Framework 4, görev olarak adlandırılan bir zaman uyumsuz programlama kavramı sunmuştur ve ASP.NET MVC 4 görevidestekler.The .NET Framework 4 introduced an asynchronous programming concept referred to as a Task and ASP.NET MVC 4 supports Task. Görevler, görev türü ve System. Threading. Tasks ad alanındaki ilgili türler tarafından temsil edilir.Tasks are represented by the Task type and related types in the System.Threading.Tasks namespace. .NET Framework 4,5, görev nesneleriyle çalışmayı önceki zaman uyumsuz yaklaşımlardan çok daha az karmaşık olan await ve Async anahtar sözcükleriyle bu zaman uyumsuz destek üzerinde oluşturulur.The .NET Framework 4.5 builds on this asynchronous support with the await and async keywords that make working with Task objects much less complex than previous asynchronous approaches. Await anahtar sözcüğü, kod parçasının zaman uyumsuz olarak başka bir kod parçasına beklemesi gerektiğini belirten sözdizimsel bir toplu özelliktir.The await keyword is syntactical shorthand for indicating that a piece of code should asynchronously wait on some other piece of code. Async anahtar sözcüğü, yöntemleri görev tabanlı zaman uyumsuz yöntemler olarak işaretlemek için kullanabileceğiniz bir ipucunu temsil eder.The async keyword represents a hint that you can use to mark methods as task-based asynchronous methods. Await, Asyncve Task nesnesinin birleşimi, .NET 4,5 'e zaman uyumsuz kod yazmanızı çok daha kolay hale getirir.The combination of await, async, and the Task object makes it much easier for you to write asynchronous code in .NET 4.5. Zaman uyumsuz yöntemlere yönelik yeni model görev tabanlı zaman uyumsuz model (tap) olarak adlandırılır.The new model for asynchronous methods is called the Task-based Asynchronous Pattern (TAP). Bu öğreticide, await ve Async anahtar sözcüklerini ve görev ad alanını kullanarak zaman uyumsuz programlama hakkında bazı benzerlik olduğunu varsaymaktadır.This tutorial assumes you have some familiarity with asynchronous programing using await and async keywords and the Task namespace.

Await ve Async anahtar sözcüklerini ve görev ad alanını kullanma hakkında daha fazla bilgi için aşağıdaki başvurulara bakın.For more information on the using await and async keywords and the Task namespace, see the following references.

Isteklerin Iş parçacığı havuzu tarafından nasıl IşlendiğiHow Requests Are Processed by the Thread Pool

Web sunucusunda .NET Framework, ASP.NET isteklerine hizmet vermek için kullanılan iş parçacıklarının havuzunu tutar.On the web server, the .NET Framework maintains a pool of threads that are used to service ASP.NET requests. Bir istek geldiğinde, bu isteği işlemek için havuzdan bir iş parçacığı gönderilir.When a request arrives, a thread from the pool is dispatched to process that request. İstek zaman uyumlu olarak işleniyorsa, istek işlenirken isteği işleyen iş parçacığı meşgul olur ve bu iş parçacığı başka bir isteğe hizmet edemez.If the request is processed synchronously, the thread that processes the request is busy while the request is being processed, and that thread cannot service another request.

İş parçacığı havuzu çok sayıda meşgul iş parçacığına uyum sağlayacak kadar büyük hale getirilbildiğinden bu bir sorun olmayabilir.This might not be a problem, because the thread pool can be made large enough to accommodate many busy threads. Ancak, iş parçacığı havuzundaki iş parçacıklarının sayısı sınırlıdır (.NET 4,5 için varsayılan en yüksek 5.000 ' dir).However, the number of threads in the thread pool is limited (the default maximum for .NET 4.5 is 5,000). Uzun süreli çok sayıda istek olan büyük uygulamalarda, kullanılabilir tüm iş parçacıkları meşgul olabilir.In large applications with high concurrency of long-running requests, all available threads might be busy. Bu koşul, iş parçacığı başlangıçadı olarak bilinir.This condition is known as thread starvation. Bu koşula ulaşıldığında, Web sunucusu istekleri sıralar.When this condition is reached, the web server queues requests. İstek sırası dolarsa, Web sunucusu istekleri HTTP 503 durumu (sunucu çok meşgul) ile reddeder.If the request queue becomes full, the web server rejects requests with an HTTP 503 status (Server Too Busy). CLR iş parçacığı havuzunda yeni iş parçacığı kısıtlamalarıyla ilgili sınırlamalar vardır.The CLR thread pool has limitations on new thread injections. Eşzamanlılık burstise (yani, Web siteniz çok fazla sayıda istek alabilir) ve yüksek gecikme süresine sahip arka uç çağrıları nedeniyle tüm kullanılabilir istek iş parçacıkları meşgul olur, sınırlı iş parçacığı ekleme oranı uygulamanızın yanıt vermesini çok kötü hale getirir.If concurrency is bursty (that is, your web site can suddenly get a large number of requests) and all available request threads are busy because of backend calls with high latency, the limited thread injection rate can make your application respond very poorly. Ayrıca, iş parçacığı havuzuna eklenen her yeni iş parçacığının ek yükü vardır (1 MB yığın bellek gibi).Additionally, each new thread added to the thread pool has overhead (such as 1 MB of stack memory). Zaman uyumlu yöntemler kullanan bir Web uygulaması iş parçacığı havuzunun .NET 4,5 varsayılan en yüksek değeri olan 5 ' e kadar büyüdüğü yüksek gecikme süreli çağrılara hizmet verebilir zaman uyumsuz yöntemler ve yalnızca 50 iş parçacığı.A web application using synchronous methods to service high latency calls where the thread pool grows to the .NET 4.5 default maximum of 5, 000 threads would consume approximately 5 GB more memory than an application able the service the same requests using asynchronous methods and only 50 threads. Zaman uyumsuz iş yaparken her zaman bir iş parçacığı kullanmıyoruz.When you're doing asynchronous work, you're not always using a thread. Örneğin, zaman uyumsuz bir Web hizmeti isteği yaptığınızda, ASP.NET zaman uyumsuz Yöntem çağrısı ve awaitarasında herhangi bir iş parçacığı kullanmaz.For example, when you make an asynchronous web service request, ASP.NET will not be using any threads between the async method call and the await. İş parçacığı havuzunun yüksek gecikme süresine sahip isteklere kullanımı, büyük bir bellek parmak izine ve sunucu donanımının kötü kullanımına neden olabilir.Using the thread pool to service requests with high latency can lead to a large memory footprint and poor utilization of the server hardware.

Zaman uyumsuz Istekleri işlemeProcessing Asynchronous Requests

Başlangıçta çok sayıda eşzamanlı istek sunan veya bir bursty yüküne sahip olan bir Web uygulamasında (eşzamanlılık aniden arttığında), Web hizmeti çağrılarının zaman uyumsuz yapılması uygulamanın yanıt hızını arttırır.In a web app that sees a large number of concurrent requests at start-up or has a bursty load (where concurrency increases suddenly), making web service calls asynchronous increases the responsiveness of the app. Zaman uyumsuz bir istek, zaman uyumlu bir istek olarak işlemek için aynı süreyi alır.An asynchronous request takes the same amount of time to process as a synchronous request. İstek iki saniyelik bir Web hizmeti çağrısı yapıyorsa, istek zaman uyumlu veya zaman uyumsuz olarak yapılıp yapılmadıklarında iki saniye sürer.If a request makes a web service call that requires two seconds to complete, the request takes two seconds whether it's performed synchronously or asynchronously. Ancak zaman uyumsuz bir çağrı sırasında, bir iş parçacığının, ilk isteğin tamamlanmasını beklediği sırada diğer isteklere yanıt vermemesi engellenmez.However during an asynchronous call, a thread isn't blocked from responding to other requests while it waits for the first request to complete. Bu nedenle, uzun süre çalışan işlemleri çağıran çok sayıda eşzamanlı istek olduğunda zaman uyumsuz istekler istek sıraya alma ve iş parçacığı havuzunun büyümesini önler.Therefore, asynchronous requests prevent request queuing and thread pool growth when there are many concurrent requests that invoke long-running operations.

Zaman uyumlu veya zaman uyumsuz eylem yöntemleri seçmeChoosing Synchronous or Asynchronous Action Methods

Bu bölümde, zaman uyumlu veya zaman uyumsuz eylem yöntemlerinin ne zaman kullanılacağı hakkındaki yönergeler listelenmiştir.This section lists guidelines for when to use synchronous or asynchronous action methods. Bunlar yalnızca kılavuzlardır; zaman uyumsuz yöntemlerin performansla yardım edilip edilmeyeceğini öğrenmek için her uygulamayı ayrı ayrı inceleyin.These are just guidelines; examine each application individually to determine whether asynchronous methods help with performance.

Genel olarak, aşağıdaki koşullar için zaman uyumlu yöntemleri kullanın:In general, use synchronous methods for the following conditions:

  • İşlemler basit veya kısa çalışıyor.The operations are simple or short-running.
  • Basitlik, verimlilik açısından daha önemlidir.Simplicity is more important than efficiency.
  • İşlemler, yoğun disk veya ağ yükü içeren işlemler yerine öncelikle CPU operasyonlardır.The operations are primarily CPU operations instead of operations that involve extensive disk or network overhead. CPU 'ya bağlı işlemlerde zaman uyumsuz eylem yöntemlerinin kullanılması, hiçbir avantaj sağlamaz ve daha fazla yüke neden olur.Using asynchronous action methods on CPU-bound operations provides no benefits and results in more overhead.

Genel olarak, aşağıdaki koşullar için zaman uyumsuz yöntemleri kullanın:In general, use asynchronous methods for the following conditions:

  • Zaman uyumsuz yöntemler aracılığıyla tüketilen hizmetleri arıyorsanız ve .NET 4,5 veya üzeri bir sürümü kullanıyorsunuz.You're calling services that can be consumed through asynchronous methods, and you're using .NET 4.5 or higher.
  • İşlemler, CPU ile bağlantılı olarak ağ bağlantılı veya g/ç-bağlantılı.The operations are network-bound or I/O-bound instead of CPU-bound.
  • Paralellik, kod basitliği dışında daha önemlidir.Parallelism is more important than simplicity of code.
  • Kullanıcıların uzun süre çalışan bir isteği iptal etmelerini sağlayan bir mekanizma sağlamak istiyorsunuz.You want to provide a mechanism that lets users cancel a long-running request.
  • İş parçacıklarını anahtarlama avantajı, bağlam anahtarı maliyetini ortaya çıktı.When the benefit of switching threads outweighs the cost of the context switch. Genel olarak, zaman uyumlu yöntem ASP.NET istek iş parçacığı üzerinde bekliyorsa bir yöntemi zaman uyumsuz yapmanız gerekir.In general, you should make a method asynchronous if the synchronous method waits on the ASP.NET request thread while doing no work. Çağrıyı zaman uyumsuz yaparak, ASP.NET istek iş parçacığı, Web hizmeti isteğinin tamamlanmasını beklerken hiçbir iş yapılmaz.By making the call asynchronous, the ASP.NET request thread is not stalled doing no work while it waits for the web service request to complete.
  • Test, engelleme işlemlerinin site performansı açısından bir performans sorunu olduğunu ve IIS 'nin bu engelleme çağrıları için zaman uyumsuz yöntemleri kullanarak daha fazla istek hizmet verebilir olduğunu gösterir.Testing shows that the blocking operations are a bottleneck in site performance and that IIS can service more requests by using asynchronous methods for these blocking calls.

İndirilebilir örnek, zaman uyumsuz eylem yöntemlerinin etkin bir şekilde nasıl kullanılacağını gösterir.The downloadable sample shows how to use asynchronous action methods effectively. Belirtilen örnek, .NET 4,5 kullanılarak ASP.NET MVC 4 ' te zaman uyumsuz programlama basit bir gösterimi sağlamak üzere tasarlanmıştır.The sample provided was designed to provide a simple demonstration of asynchronous programming in ASP.NET MVC 4 using .NET 4.5. Örnek, ASP.NET MVC 'de zaman uyumsuz programlama için başvuru mimarisi olmak üzere tasarlanmamıştır.The sample is not intended to be a reference architecture for asynchronous programming in ASP.NET MVC. Örnek program, görevi çağıran ASP.NET Web API yöntemlerini çağırır. uzun süre çalışan Web hizmeti çağrılarına benzetim yapmak için gecikme .The sample program calls ASP.NET Web API methods which in turn call Task.Delay to simulate long-running web service calls. Çoğu üretim uygulaması, zaman uyumsuz eylem yöntemlerinin kullanımı için bu tür açık avantajları göstermez.Most production applications will not show such obvious benefits to using asynchronous action methods.

Birkaç uygulama tüm eylem yöntemlerinin zaman uyumsuz olmasını gerektirir.Few applications require all action methods to be asynchronous. Genellikle, birkaç zaman uyumlu eylem yönteminin zaman uyumsuz yöntemlere dönüştürülmesi, gereken iş miktarı için en iyi verimlilik artışı sağlar.Often, converting a few synchronous action methods to asynchronous methods provides the best efficiency increase for the amount of work required.

Örnek uygulamaThe Sample Application

Örnek uygulamayı GitHub sitesindeki https://github.com/RickAndMSFT/Async-ASP.NET/ indirebilirsiniz.You can download the sample application from https://github.com/RickAndMSFT/Async-ASP.NET/ on the GitHub site. Depo üç projeden oluşur:The repository consists of three projects:

  • Mvc4Async: Bu öğreticide kullanılan kodu IÇEREN ASP.NET MVC 4 projesi.Mvc4Async: The ASP.NET MVC 4 project that contains the code used in this tutorial. WebAPIpgw HIZMETINE Web API çağrıları yapar.It makes Web API calls to the WebAPIpgw service.
  • WebAPIpgw: Products, Gizmos and Widgets denetleyicilerini uygulayan ASP.NET MVC 4 Web API projesi.WebAPIpgw: The ASP.NET MVC 4 Web API project that implements the Products, Gizmos and Widgets controllers. WebAppAsync projesi ve Mvc4Async projesi için verileri sağlar.It provides the data for the WebAppAsync project and the Mvc4Async project.
  • WebAppAsync: ASP.NET Web Forms projesi başka bir öğreticide kullanılır.WebAppAsync: The ASP.NET Web Forms project used in another tutorial.

Şeyler Synchronous ACTION yöntemiThe Gizmos Synchronous Action Method

Aşağıdaki kod, bir şeyler listesini göstermek için kullanılan zaman uyumlu Gizmos eylem yöntemini gösterir.The following code shows the Gizmos synchronous action method that is used to display a list of gizmos. (Bu makale için, Gizmo kurgusal bir makine aygıtıdır.)(For this article, a gizmo is a fictional mechanical device.)

public ActionResult Gizmos()
{
    ViewBag.SyncOrAsync = "Synchronous";
    var gizmoService = new GizmoService();
    return View("Gizmos", gizmoService.GetGizmos());
}

Aşağıdaki kod, Gizmo hizmetinin GetGizmos yöntemini gösterir.The following code shows the GetGizmos method of the gizmo service.

public class GizmoService
{
    public async Task<List<Gizmo>> GetGizmosAsync(
        // Implementation removed.
       
    public List<Gizmo> GetGizmos()
    {
        var uri = Util.getServiceUri("Gizmos");
        using (WebClient webClient = new WebClient())
        {
            return JsonConvert.DeserializeObject<List<Gizmo>>(
                webClient.DownloadString(uri)
            );
        }
    }
}

GizmoService GetGizmos yöntemi bir URI 'yi bir ASP.NET Web API HTTP hizmetine geçirir ve bu, şeyler verilerinin bir listesini döndürür.The GizmoService GetGizmos method passes a URI to an ASP.NET Web API HTTP service which returns a list of gizmos data. WebAPIpgw projesi, Web API gizmos, widget ve product denetleyicilerinin uygulamasını içerir.The WebAPIpgw project contains the implementation of the Web API gizmos, widget and product controllers.
Aşağıdaki görüntüde örnek projeden şeyler görünümü gösterilmektedir.The following image shows the gizmos view from the sample project.

Şeyler

Zaman uyumsuz şeyler Action yöntemi oluşturmaCreating an Asynchronous Gizmos Action Method

Örnek, zaman uyumsuz programlama için gereken karmaşık dönüştürmeleri sürdürmekten önce derleyicinin sorumlu olmasını sağlamak için yeni Async ve await anahtar sözcüklerini (.NET 4,5 ve Visual Studio 2012 ' de kullanılabilir) kullanır.The sample uses the new async and await keywords (available in .NET 4.5 and Visual Studio 2012) to let the compiler be responsible for maintaining the complicated transformations necessary for asynchronous programming. Derleyici, zaman uyumlu denetim akış yapılarını kullanarak C#kod yazmanızı sağlar ve derleyici, iş parçacıklarını engellemeyi önlemek için geri çağırmaları kullanmak için gereken dönüştürmeleri otomatik olarak uygular.The compiler lets you write code using the C#'s synchronous control flow constructs and the compiler automatically applies the transformations necessary to use callbacks in order to avoid blocking threads.

Aşağıdaki kod, zaman uyumlu Gizmos yöntemi ve GizmosAsync zaman uyumsuz yöntemi gösterir.The following code shows the Gizmos synchronous method and the GizmosAsync asynchronous method. Tarayıcınız HTML 5 <mark> öğesinidestekliyorsa, GizmosAsync değişiklikleri sarı vurgulamada görürsünüz.If your browser supports the HTML 5 <mark> element, you'll see the changes in GizmosAsync in yellow highlight.

public ActionResult Gizmos()
{
    ViewBag.SyncOrAsync = "Synchronous";
    var gizmoService = new GizmoService();
    return View("Gizmos", gizmoService.GetGizmos());
}
public async Task<ActionResult> GizmosAsync()
{
    ViewBag.SyncOrAsync = "Asynchronous";
    var gizmoService = new GizmoService();
    return View("Gizmos", await gizmoService.GetGizmosAsync());
}

GizmosAsync zaman uyumsuz olarak izin vermek için aşağıdaki değişiklikler uygulandı.The following changes were applied to allow the GizmosAsync to be asynchronous.

  • Yöntemi Async anahtar sözcüğüyle işaretlenir, bu da derleyiciye gövdenin parçaları için geri çağrılar oluşturmasını ve döndürülen bir Task<ActionResult> otomatik olarak oluşturmasını söyler.The method is marked with the async keyword, which tells the compiler to generate callbacks for parts of the body and to automatically create a Task<ActionResult> that is returned.
  • "zaman uyumsuz" metot adına eklendi."Async" was appended to the method name. "Async" eklenmesi gerekli değildir, ancak zaman uyumsuz yöntemler yazılırken kuralıdır.Appending "Async" is not required but is the convention when writing asynchronous methods.
  • Dönüş türü, ActionResult Task<ActionResult>olarak değiştirildi.The return type was changed from ActionResult to Task<ActionResult>. Task<ActionResult> dönüş türü, devam eden çalışmayı temsil eder ve zaman uyumsuz işlemin tamamlanmasını beklemek için bir tanıtıcı ile metodun çağıranlarını sağlar.The return type of Task<ActionResult> represents ongoing work and provides callers of the method with a handle through which to wait for the asynchronous operation's completion. Bu durumda, çağıran Web hizmetidir.In this case, the caller is the web service. Task<ActionResult>, ActionResult. sonucuyla devam eden işi temsil ederTask<ActionResult> represents ongoing work with a result of ActionResult.
  • Await anahtar sözcüğü Web hizmeti çağrısına uygulandı.The await keyword was applied to the web service call.
  • Zaman uyumsuz Web hizmeti API 'SI çağrıldı (GetGizmosAsync).The asynchronous web service API was called (GetGizmosAsync).

GetGizmosAsync yönteminin içinde başka bir zaman uyumsuz yöntem GetGizmosAsync çağırılır.Inside of the GetGizmosAsync method body another asynchronous method, GetGizmosAsync is called. GetGizmosAsync hemen, veriler kullanılabilir olduğunda sonunda tamamlanacak bir Task<List<Gizmo>> döndürür.GetGizmosAsync immediately returns a Task<List<Gizmo>> that will eventually complete when the data is available. Gizmo verilerine sahip olana kadar başka bir şey yapmak istemediğiniz için, kod görevi bekler ( await anahtar sözcüğünü kullanarak).Because you don't want to do anything else until you have the gizmo data, the code awaits the task (using the await keyword). Await anahtar sözcüğünü yalnızca Async anahtar sözcüğüyle açıklama eklenen yöntemlerde kullanabilirsiniz.You can use the await keyword only in methods annotated with the async keyword.

Await anahtar sözcüğü, görev tamamlanana kadar iş parçacığını engellemez.The await keyword does not block the thread until the task is complete. Görevin geri kalanını görevde geri çağırma olarak imzalar ve hemen döndürür.It signs up the rest of the method as a callback on the task, and immediately returns. Beklenen görev sonunda tamamlandığında, bu geri aramayı çağırır ve bu nedenle, yöntemin hemen kapandığı yerde yürütmeye devam eder.When the awaited task eventually completes, it will invoke that callback and thus resume the execution of the method right where it left off. Await ve Async anahtar sözcüklerini ve görev ad alanını kullanma hakkında daha fazla bilgi için bkz. Async References.For more information on using the await and async keywords and the Task namespace, see the async references.

Aşağıdaki kod, GetGizmos ve GetGizmosAsync yöntemlerini göstermektedir.The following code shows the GetGizmos and GetGizmosAsync methods.

public List<Gizmo> GetGizmos()
{
    var uri = Util.getServiceUri("Gizmos");
    using (WebClient webClient = new WebClient())
    {
        return JsonConvert.DeserializeObject<List<Gizmo>>(
            webClient.DownloadString(uri)
        );
    }
}
public async Task<List<Gizmo>> GetGizmosAsync()
{
    var uri = Util.getServiceUri("Gizmos");
    using (HttpClient httpClient = new HttpClient())
    {
        var response = await httpClient.GetAsync(uri);
        return (await response.Content.ReadAsAsync<List<Gizmo>>());
    }
}

Zaman uyumsuz değişiklikler, yukarıdaki GizmosAsync yapılan değişikliklerle benzerdir.The asynchronous changes are similar to those made to the GizmosAsync above.

  • Yöntem imzasına zaman uyumsuz anahtar sözcüğüyle açıklama eklendi, dönüş türü Task<List<Gizmo>>olarak değiştirildi ve zaman uyumsuz Yöntem adına eklenmiş.The method signature was annotated with the async keyword, the return type was changed to Task<List<Gizmo>>, and Async was appended to the method name.
  • , WebClient sınıfı yerine zaman uyumsuz HttpClient sınıfı kullanılır.The asynchronous HttpClient class is used instead of the WebClient class.
  • Await anahtar sözcüğü HttpClient zaman uyumsuz yöntemlerine uygulandı.The await keyword was applied to the HttpClient asynchronous methods.

Aşağıdaki görüntüde zaman uyumsuz Gizmo görünümü gösterilmektedir.The following image shows the asynchronous gizmo view.

async

Şeyler verilerinin tarayıcılar sunumu, zaman uyumlu çağrı tarafından oluşturulan görünümle aynıdır.The browsers presentation of the gizmos data is identical to the view created by the synchronous call. Tek fark, zaman uyumsuz sürümdür ağır yüklerin altında daha performanslı olabilir.The only difference is the asynchronous version may be more performant under heavy loads.

Paralel olarak birden çok Işlem gerçekleştirmePerforming Multiple Operations in Parallel

Zaman uyumsuz eylem yöntemlerinin, bir eylemin birkaç bağımsız işlem gerçekleştirmesi gerektiğinde zaman uyumlu yöntemlerle önemli bir avantajı vardır.Asynchronous action methods have a significant advantage over synchronous methods when an action must perform several independent operations. Belirtilen örnekte, zaman uyumlu Yöntem PWG(ürünler, pencere öğeleri ve şeyler için), ürünlerin, pencere öğelerinin ve şeyler 'in bir listesini almak için üç Web hizmeti çağrısının sonuçlarını görüntüler.In the sample provided, the synchronous method PWG(for Products, Widgets and Gizmos) displays the results of three web service calls to get a list of products, widgets, and gizmos. Bu hizmetleri sağlayan ASP.NET Web API projesi, görevi kullanır . gecikme veya yavaş ağ çağrılarının benzetimini yapmak için gecikme.The ASP.NET Web API project that provides these services uses Task.Delay to simulate latency or slow network calls. Gecikme 500 milisaniyeye ayarlandığında, zaman uyumsuz PWGasync yöntemi, zaman uyumlu PWG sürümü 1.500 milisaniyeye göre daha fazla 500 milisaniyelik sürer.When the delay is set to 500 milliseconds, the asynchronous PWGasync method takes a little over 500 milliseconds to complete while the synchronous PWG version takes over 1,500 milliseconds. Zaman uyumlu PWG yöntemi aşağıdaki kodda gösterilmiştir.The synchronous PWG method is shown in the following code.

public ActionResult PWG()
{
    ViewBag.SyncType = "Synchronous";
    var widgetService = new WidgetService();
    var prodService = new ProductService();
    var gizmoService = new GizmoService();

    var pwgVM = new ProdGizWidgetVM(
        widgetService.GetWidgets(),
        prodService.GetProducts(),
        gizmoService.GetGizmos()
       );

    return View("PWG", pwgVM);
}

Zaman uyumsuz PWGasync yöntemi aşağıdaki kodda gösterilmiştir.The asynchronous PWGasync method is shown in the following code.

public async Task<ActionResult> PWGasync()
{
    ViewBag.SyncType = "Asynchronous";
    var widgetService = new WidgetService();
    var prodService = new ProductService();
    var gizmoService = new GizmoService();

    var widgetTask = widgetService.GetWidgetsAsync();
    var prodTask = prodService.GetProductsAsync();
    var gizmoTask = gizmoService.GetGizmosAsync();

    await Task.WhenAll(widgetTask, prodTask, gizmoTask);

    var pwgVM = new ProdGizWidgetVM(
       widgetTask.Result,
       prodTask.Result,
       gizmoTask.Result
       );

    return View("PWG", pwgVM);
}

Aşağıdaki görüntüde, Pwgasync yönteminden döndürülen görünüm gösterilmektedir.The following image shows the view returned from the PWGasync method.

pwgAsync

Iptal belirteci kullanmaUsing a Cancellation Token

Task<ActionResult>döndüren zaman uyumsuz eylem yöntemleri iptal edilir ve bu, AsyncTimeout özniteliğiyle birlikte sağlandığında bir CancellationToken parametresi alırlar.Asynchronous action methods returning Task<ActionResult>are cancelable, that is they take a CancellationToken parameter when one is provided with the AsyncTimeout attribute. Aşağıdaki kod, 150 milisaniye zaman aşımı ile GizmosCancelAsync yöntemini gösterir.The following code shows the GizmosCancelAsync method with a timeout of 150 milliseconds.

[AsyncTimeout(150)]
[HandleError(ExceptionType = typeof(TimeoutException),
                                    View = "TimeoutError")]
public async Task<ActionResult> GizmosCancelAsync(
                       CancellationToken cancellationToken )
{
    ViewBag.SyncOrAsync = "Asynchronous";
    var gizmoService = new GizmoService();
    return View("Gizmos",
        await gizmoService.GetGizmosAsync(cancellationToken));
}

Aşağıdaki kod, CancellationToken parametresini alan GetGizmosAsync aşırı yüklemesini gösterir.The following code shows the GetGizmosAsync overload, which takes a CancellationToken parameter.

public async Task<List<Gizmo>> GetGizmosAsync(string uri,
    CancellationToken cancelToken = default(CancellationToken))
{
    using (HttpClient httpClient = new HttpClient())
    {
        var response = await httpClient.GetAsync(uri, cancelToken);
        return (await response.Content.ReadAsAsync<List<Gizmo>>());
    }
}

Belirtilen örnek uygulamada, Iptal belirteci demo bağlantısını seçtiğinizde GizmosCancelAsync yöntemi çağrılıyordu ve zaman uyumsuz çağrının iptali gösterilmektedir.In the sample application provided, selecting the Cancellation Token Demo link calls the GizmosCancelAsync method and demonstrates the cancellation of the asynchronous call.

Yüksek eşzamanlılık/yüksek gecikmeli Web hizmeti çağrıları için sunucu yapılandırmasıServer Configuration for High Concurrency/High Latency Web Service Calls

Zaman uyumsuz bir Web uygulamasının avantajlarını gerçekleştirmek için, varsayılan sunucu yapılandırmasında bazı değişiklikler yapmanız gerekebilir.To realize the benefits of an asynchronous web application, you might need to make some changes to the default server configuration. Zaman uyumsuz Web uygulamanızı yapılandırırken ve stres testi yaparken aşağıdakileri aklınızda bulundurun.Keep the following in mind when configuring and stress testing your asynchronous web application.

  • Windows 7, Windows Vista ve tüm Windows istemci işletim sistemlerinde en fazla 10 eşzamanlı istek vardır.Windows 7, Windows Vista and all Windows client operating systems have a maximum of 10 concurrent requests. Yüksek yük altında zaman uyumsuz yöntemlerin avantajlarını görmek için bir Windows Server işletim sistemi gerekir.You'll need a Windows Server operating system to see the benefits of asynchronous methods under high load.

  • .NET 4,5 ' i yükseltilmiş bir komut isteminden IIS ile kaydedin:Register .NET 4.5 with IIS from an elevated command prompt:
    %windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regııs-ı%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis -i
    Bkz . asp.NET IIS Kayıt Aracı (Aspnet_regııs. exe)See ASP.NET IIS Registration Tool (Aspnet_regiis.exe)

  • Http. sys kuyruk sınırını 1.000 varsayılan değerinden 5.000 ' e artırmanız gerekebilir.You might need to increase the HTTP.sys queue limit from the default value of 1,000 to 5,000. Ayar çok düşükse, http 503 durumu ile http. sys Red isteklerini görebilirsiniz.If the setting is too low, you may see HTTP.sys reject requests with a HTTP 503 status. HTTP. sys kuyruk sınırını değiştirmek için:To change the HTTP.sys queue limit:

    • IIS Yöneticisi 'ni açın ve uygulama havuzları bölmesine gidin.Open IIS manager and navigate to the Application Pools pane.
    • Hedef uygulama havuzuna sağ tıklayın ve Gelişmiş ayarlar' ı seçin.Right click on the target application pool and select Advanced Settings.
      gelişmişadvanced
    • Gelişmiş ayarlar Iletişim kutusunda sıra uzunluğu değerini 1.000 5.000 olarak değiştirin.In the Advanced Settings dialog box, change Queue Length from 1,000 to 5,000.
      kuyruğu uzunluğuQueue length

    Yukarıdaki görüntülerde, uygulama havuzu .NET 4,5 kullanıyor olsa da, .NET Framework 'ün v 4.0 olarak listelendiğini göz önünde bulunur.Note in the images above, the .NET framework is listed as v4.0, even though the application pool is using .NET 4.5. Bu tutarsızlığı anlamak için aşağıdakilere bakın:To understand this discrepancy, see the following:

  • Uygulamanız HTTP üzerinden bir arka uçta iletişim kurmak için Web Hizmetleri veya System.NET kullanıyorsa, connectionManagement/maxconnection öğesini artırmanız gerekebilir.If your application is using web services or System.NET to communicate with a backend over HTTP you may need to increase the connectionManagement/maxconnection element. ASP.NET uygulamaları için bu, otomatik yapılandırma özelliği tarafından CPU sayısının 12 katı ile sınırlıdır.For ASP.NET applications, this is limited by the autoConfig feature to 12 times the number of CPUs. Yani, bir dört proc üzerinde en fazla 12 * 4 = 48 bir IP uç noktasına eşzamanlı bağlantı sağlayabilirsiniz.That means that on a quad-proc, you can have at most 12 * 4 = 48 concurrent connections to an IP end point. Bu, Otomatikolarak bağlı olduğundan, bir ASP.NET uygulamasında maxconnection artırmanın en kolay yolu, System .net. ServicePointManager. DefaultConnectionLimit ' i global. asax dosyasındaki from Application_Start yönteminde Program aracılığıyla ayarlamaya yönelik bir yöntemdir.Because this is tied to autoConfig, the easiest way to increase maxconnection in an ASP.NET application is to set System.Net.ServicePointManager.DefaultConnectionLimit programmatically in the from Application_Start method in the global.asax file. Örnek için bkz. örnek indirme.See the sample download for an example.

  • .NET 4,5 ' de, maxConcurrentRequestsPerCPU için 5000 varsayılan değer iyi olmalıdır.In .NET 4.5, the default of 5000 for MaxConcurrentRequestsPerCPU should be fine.