Project Katana’ya Genel BakışAn Overview of Project Katana

Howard Dierkingby Howard Dierking

ASP.NET Framework on yıldan daha uzun süredir ve platform, sayaçsuz Web siteleri ve hizmetleri geliştirmeyi etkinleştirdi.The ASP.NET Framework has been around for over ten years, and the platform has enabled the development of countless Web sites and services. Web uygulaması geliştirme stratejileri geliştirmekle birlikte, Framework ASP.NET MVC ve ASP.NET Web API gibi teknolojilerle adım adım gelişiyor.As Web application development strategies have evolved, the framework has been able to evolve in step with technologies like ASP.NET MVC and ASP.NET Web API. Web uygulaması geliştirme, bir sonraki evde bulut bilgi işlem dünyasına sahip olduğu için, proje Katana bileşeni ASP.NET uygulamalarına, esnek, taşınabilir, hafif ve daha iyi performans sağlar. proje katana bulutu ASP.NET uygulamalarınızı en iyi duruma getirir.As Web application development takes its next evolutionary step into the world of cloud computing, project Katana provides the underlying set of components to ASP.NET applications, enabling them to be flexible, portable, lightweight, and provide better performance – put another way, project Katana cloud optimizes your ASP.NET applications.

Neden Katana: neden?Why Katana – Why Now?

Birinin bir geliştirici çerçevesini veya Son Kullanıcı ürününü ele almamasını ne olursa olsun, ürünün oluşturulması için temel alınan görüşmelerin ve ürünün ne şekilde oluşturulduğunu bilmenin bir parçası olduğunu anlamak önemlidir.Regardless whether one is discussing a developer framework or end-user product, it's important to understand the underlying motivations for creating the product – and part of that includes knowing who the product was created for. ASP.NET ilk olarak, aklınızda iki müşteriyle oluşturulmuştur.ASP.NET was originally created with two customers in mind.

İlk müşteri grubu klasik ASP geliştiricilerinden oluşur.The first group of customers was classic ASP developers. Bu sırada ASP, biçimlendirme ve sunucu tarafı komut dosyası aracılığıyla dinamik, veri odaklı web siteleri ve uygulamalar oluşturmaya yönelik birincil teknolojiden biridir.At the time, ASP was one of the primary technologies for creating dynamic, data-driven Web sites and applications by interweaving markup and server-side script. ASP çalışma zamanı, temel alınan HTTP protokolünün ve Web sunucusunun temel yönlerini soyutlan ve bu tür oturum ve uygulama durumu yönetimi, önbellek, vb. için erişim sağlayan bir nesne kümesiyle sunucu tarafı betiği sağladı. Güçlü, klasik ASP uygulamaları, boyut ve karmaşıklık bakımından Grey olarak yönetilmesi için bir zorluk haline geldi.The ASP runtime supplied server-side script with a set of objects that abstracted core aspects of the underlying HTTP protocol and Web server and provided access to additional services such session and application state management, cache, etc. While powerful, classic ASP applications became a challenge to manage as they grew in size and complexity. Bu, büyük olasılıkla kod ve biçimlendirmenin araya alınmasıyla sonuçlanan kod çoğaltmasıyla bağlanmış komut dosyası ortamlarında bulunan yapının olmamasından kaynaklanır.This was largely due to the lack of structure found in scripting environments coupled with the duplication of code resulting from the interleaving of code and markup. ASP.NET, klasik ASP 'nin güçlerinin bir kısmını ele alırken büyük bir süre içinde .NET Framework, Ayrıca sunucu tarafı programlama modelini koruyarak, nesne yönelimli diller tarafından sunulan kod kuruluşundan faydalanır. Klasik ASP geliştiricilerinin alışkın olduğu.In order to capitalize on the strengths of classic ASP while addressing some of its challenges, ASP.NET took advantage of the code organization provided by the object-oriented languages of the .NET Framework while also preserving the server-side programming model to which classic ASP developers had grown accustomed.

ASP.NET için hedef müşterilerin ikinci grubu Windows iş uygulaması geliştiricileri idi.The second group of target customers for ASP.NET was Windows business application developers. Klasik ASP geliştiricilerinin aksine, daha fazla HTML biçimlendirmesi oluşturmak üzere HTML biçimlendirme ve kod yazmaya alışkın olan, WinForms geliştiricileri (VB6 geliştiricileri gibi), bir tuval ve zengin bir kullanıcı kümesi içeren tasarım zamanı deneyimine alışkın arabirim denetimleri.Unlike classic ASP developers, who were accustomed to writing HTML markup and the code to generate more HTML markup, WinForms developers (like the VB6 developers before them) were accustomed to a design time experience that included a canvas and a rich set of user interface controls. ASP.NET 'in ilk sürümü: "Web Forms" olarak da bilinen, sorunsuz bir geliştirici deneyimi oluşturmak için Kullanıcı arabirimi bileşenleri için sunucu tarafı olay modeliyle birlikte benzer bir tasarım zamanı deneyimi ve bir altyapı özellikleri kümesi (ViewState gibi) sağladı istemci ve sunucu tarafı programlama arasında.The first version of ASP.NET – also known as "Web Forms" provided a similar design time experience along with a server-side event model for user interface components and a set of infrastructure features (such as ViewState) to create a seamless developer experience between client and server side programming. Web Forms, Web 'in, WinForms geliştiricilere tanıdık gelen durum bilgisi olan bir olay modeli altında durum bilgisiz bir şekilde gizledi.Web Forms effectively hid the Web's stateless nature under a stateful event model that was familiar to WinForms developers.

Geçmiş modeli tarafından oluşturulan sorunlarChallenges Raised by the Historical Model

Net sonuç, çok, özellik açısından zengin bir çalışma zamanı ve geliştirici programlama modelidir.The net result was a mature, feature-rich runtime and developer programming model. Bununla birlikte, bu özellik zenginleştirme, birkaç önemli zorluk ile karşılaşıyor.However, with that feature-richness came a couple notable challenges. İlk olarak, Framework tek parçalı olarak, aynı System. Web. dll derlemesinde sıkı bir şekilde farklı işlev birimleri (örneğin, Web Forms çerçevesi olan çekirdek HTTP nesneleri) ile tek parçalıolarak çalışır.Firstly, the framework was monolithic, with logically disparate units of functionality being tightly coupled in the same System.Web.dll assembly (for example, the core HTTP objects with the Web forms framework). İkinci olarak, ASP.NET daha büyük .NET Framework bir parçası olarak eklenmiştir, bu da yayınlar arasındaki sürenin yıl düzeninde olması anlamına gelir.Secondly, ASP.NET was included as a part of the larger .NET Framework, which meant that the time between releases was on the order of years. Bu, hızlı bir şekilde gelişen Web geliştirmede gerçekleşen tüm değişikliklerle çalışmaya devam etmesini ASP.NET için zorlaştırıyor.This made it difficult for ASP.NET to keep pace with all of the changes happening in rapidly evolving Web development. Son olarak, System. Web. dll ' nin kendisi belirli bir Web barındırma seçeneğine birkaç farklı yolla bağlanmış: Internet Information Services (IIS).Finally, System.Web.dll itself was coupled in a few different ways to a specific Web hosting option: Internet Information Services (IIS).

Evoluo adımları: ASP.NET MVC ve ASP.NET Web API 'SIEvolutionary steps: ASP.NET MVC and ASP.NET Web API

Web geliştirmede çok sayıda değişiklik oluyordu!And lots of change was happening in Web development! Web uygulamaları, büyük çerçeveler yerine bir dizi küçük, odaklanmış bileşen olarak geliştirilmiştir.Web applications were increasingly being developed as a series of small, focused components rather than large frameworks. Bileşenlerin sayısı ve serbest bırakıldığı sıklık, çok daha hızlı bir hızda arttı.The number of components as well as the frequency with which they were released was increasing at an ever faster rate. Web ile hızlanmasını sağlamak, çerçevelerin daha büyük ve daha zengin özelliklere sahip olmak yerine daha küçük, ayrılmış ve daha fazla odaklı olmasını gerektirdiğinden, ASP.NET ekibi tek bir çerçeve yerine ASP.net 'i takılabilir bir Web bileşenleri ailesi olarak etkinleştirmek için birkaç bağımsız adımattı.It was clear that keeping pace with the Web would require frameworks to get smaller, decoupled and more focused rather than larger and more feature-rich, therefore the ASP.NET team took several evolutionary steps to enable ASP.NET as a family of pluggable Web components rather than a single framework.

İlk değişikliklerden biri, iyi bilinen model-görünüm-denetleyici (MVC) tasarım deseninin en çok popülerliği olan, Ruby on rayları gibi web geliştirme çerçeveleri sayesinde artmıştı.One of the early changes was the rise in popularity of the well-known model-view-controller (MVC) design pattern thanks to Web development frameworks like Ruby on Rails. Bu Web uygulamaları oluşturma stili, ASP.NET için ilk satış noktalarından biri olan biçimlendirme ve iş mantığı ayrımı devam ederken geliştirici üzerinde uygulamanın biçimlendirmesi üzerinde daha fazla denetim vermiştir.This style of building Web applications gave the developer greater control over her application's markup while still preserving the separation of markup and business logic, which was one of the initial selling points for ASP.NET. Bu Web uygulaması geliştirme tarzının talebini karşılamak için, Microsoft, bant dışı ASP.NET MVC 'yi (.NET Framework dahil değil) geliştirerek daha sonra bir daha iyi konuma yerleştirme fırsatı aldı.To meet the demand for this style of Web application development, Microsoft took the opportunity to position itself better for the future by developing ASP.NET MVC out of band (and not including it in the .NET Framework). ASP.NET MVC bağımsız bir indirme olarak yayımlandı.ASP.NET MVC was released as an independent download. Bu, mühendisliğe daha önce mümkün olandan çok daha sık sunma esnekliği verdi.This gave the engineering team the flexibility to deliver updates much more frequently than had been previously possible.

Web uygulaması geliştirmede bir diğer büyük kaydırma, dinamik, sunucu tarafından oluşturulan Web sayfalarından, Ajax istekleri aracılığıyla arka uç Web API 'leri ileiletişim kuran istemci tarafı komut dosyası tarafından oluşturulan sayfanın dinamik bölümlerine statik ilk biçimlendirmeye kadar geçiydi.Another major shift in Web application development was the shift from dynamic, server-generated Web pages to static initial markup with dynamic sections of the page generated from client-side script communicating with backend Web APIs through AJAX requests. Bu mimari SHIFT, Web API 'Lerinin yüksemine ve ASP.NET Web API çerçevesinin geliştirilmesine yardımcı oldu.This architectural shift helped propel the rise of Web APIs, and the development of the ASP.NET Web API framework. ASP.NET MVC 'de olduğu gibi, ASP.NET Web API 'sinin yayını daha fazla modüler bir çerçeve olarak ASP.NET daha fazla gelişmeye yönelik başka bir fırsat sağlamıştır.As in the case of ASP.NET MVC, the release of ASP.NET Web API provided another opportunity to evolve ASP.NET further as a more modular framework. Mühendislik ekibi, fırsattan ve yerleşik ASP.NET Web API 'sinin avantajlarından yararlanarak System. Web. dll ' de bulunan herhangi bir çekirdek çerçeve türünün bağımlılığı yoktur.The engineering team took advantage of the opportunity and built ASP.NET Web API such that it had no dependencies on any of the core framework types found in System.Web.dll. Bu iki şeyi etkinleştirdi: ilk olarak, ASP.NET Web API 'sinin tamamen kendi kendine bağımsız olarak gelişebileceği anlamına gelir (ve NuGet aracılığıyla teslim edildiği için hızlı bir şekilde yinelenemeye devam edebilir).This enabled two things: first, it meant that ASP.NET Web API could evolve in a completely self-contained manner (and it could continue to iterate quickly because it is delivered via NuGet). İkincisi, System. Web. dll ' ye yönelik dış bağımlılıklar olmadığından ve bu nedenle, IIS 'de hiçbir bağımlılık olmadığından, ASP.NET Web API 'SI özel bir konakta (örneğin, bir konsol uygulaması, Windows hizmeti vb.) çalıştırma özelliğini içeriyordu.Second, because there were no external dependencies to System.Web.dll, and therefore, no dependencies to IIS, ASP.NET Web API included the capability to run in a custom host (for example, a console application, Windows service, etc.)

Gelecek: A Işlemlerimizin FrameworkThe Future: A Nimble Framework

Framework bileşenlerini diğerinden ayırarak ve sonra NuGet üzerinde serbest bırakarak, çerçeveler artık daha bağımsız ve daha hızlı bir şekilde yineleyebilir.By decoupling framework components from one another and then releasing them on NuGet, frameworks could now iterate more independently and more quickly. Ayrıca, Web API 'sinin kendi kendine barındırma yeteneğinin gücü ve esnekliği, Hizmetleri için küçük ve hafif bir ana bilgisayar isteyen geliştiricilere çok çekici bir şekilde sahiptir.Additionally, the power and flexibility of Web API's self-hosting capability proved very attractive to developers who wanted a small, lightweight host for their services. Benzer şekilde, diğer çerçevelerin de bu özelliği istediği ve bu şekilde her bir Framework 'ün kendi temel adresinde kendi ana bilgisayar işleminde çalıştığı ve bağımsız olarak yönetilmek için gereken yeni bir zorluk ortaya çıkması.It proved so attractive, in fact, that other frameworks also wanted this capability, and this surfaced a new challenge in that each framework ran in its own host process on its own base address and needed to be managed (started, stopped, etc.) independently. Modern bir Web uygulaması genellikle statik dosya hizmeti, dinamik sayfa oluşturma, Web API ve daha yeni gerçek zamanlı/anında iletme bildirimleri destekler.A modern Web application generally supports static file serving, dynamic page generation, Web API, and more recently real-time/push notifications. Bu hizmetlerin her birinin çalıştırılması ve ayrı olarak yönetilmesi gerekir.Expecting that each of these services should be run and managed independently was simply not realistic.

Bir geliştiricinin birçok farklı bileşenden ve çerçevelerden bir uygulama oluşturup daha sonra bu uygulamayı destekleyen bir konakta çalıştırmasına imkan tanıyan tek bir barındırma soyutlaması gerekiyordu.What was needed was a single hosting abstraction that would enable a developer to compose an application from a variety of different components and frameworks, and then run that application on a supporting host.

.NET için açık Web arabirimi (OWıN)The Open Web Interface for .NET (OWIN)

Ruby topluluğundaki rafa göre elde edilen avantajlardan yararlanarak, .net Community 'nin birkaç üyesi, Web sunucuları ve çerçeve bileşenleri arasında bir soyutlama oluşturmak için ayarlanmıştır.Inspired by the benefits achieved by Rack in the Ruby community, several members of the .NET community set out to create an abstraction between Web servers and framework components. OWıN soyutlaması için iki tasarım hedefi basittir ve diğer çerçeve türlerinde mümkün olan en az bağımlılığı gerçekleştirmesidir.Two design goals for the OWIN abstraction were that it was simple and that it took the fewest possible dependencies on other framework types. Bu iki amaç sağlamaya yardımcı olur:These two goals help ensure:

  • Yeni bileşenler daha kolay geliştirilebilir ve tüketilebilir.New components could be more easily developed and consumed.
  • Uygulamalar, konaklar ve potansiyel olarak tüm platformlar/işletim sistemleri arasında daha kolay bir şekilde eklenebilir.Applications could be more easily ported between hosts and potentially entire platforms/operating systems.

Elde edilen soyutlama iki çekirdekli öğeden oluşur.The resulting abstraction consists of two core elements. İlki ortam sözlüğüdür.The first is the environment dictionary. Bu veri yapısı, bir HTTP isteğini ve yanıtını işlemek için gereken tüm durumu ve ilgili sunucu durumunu saklamaktan sorumludur.This data structure is responsible for storing all of the state necessary for processing an HTTP request and response, as well as any relevant server state. Ortam sözlüğü aşağıdaki gibi tanımlanır:The environment dictionary is defined as follows:

IDictionary<string, object>

Bir OWIN uyumlu Web sunucusu, ortam sözlüğünün bir HTTP isteği ve yanıtı için gövde akışları ve üst bilgi koleksiyonları gibi verilerle doldurulmasından sorumludur.An OWIN-compatible Web server is responsible for populating the environment dictionary with data such as the body streams and header collections for an HTTP request and response. Daha sonra, sözlüğü ek değerlerle doldurmak veya güncelleştirmek ve yanıt gövdesi akışına yazmak için uygulama veya çerçeve bileşenlerinin sorumluluğundadır.It is then the responsibility of the application or framework components to populate or update the dictionary with additional values and write to the response body stream.

Ortam sözlüğü için türü belirtmenin yanı sıra, OWıN belirtimi, temel sözlük anahtar değer çiftlerinin bir listesini tanımlar.In addition to specifying the type for the environment dictionary, the OWIN specification defines a list of core dictionary key value pairs. Örneğin, aşağıdaki tabloda bir HTTP isteği için gereken sözlük anahtarları gösterilmektedir:For example, the following table shows the required dictionary keys for an HTTP request:

Anahtar AdıKey Name Değer açıklamasıValue Description
"owin.RequestBody" Varsa istek gövdesine sahip bir akış.A Stream with the request body, if any. Stream. null, istek gövdesi yoksa bir yer tutucu olarak kullanılabilir.Stream.Null MAY be used as a placeholder if there is no request body. Istek gövdesinebakın.See Request Body.
"owin.RequestHeaders" İstek üst bilgilerinin IDictionary<string, string[]>.An IDictionary<string, string[]> of request headers. Bkz. üst bilgiler.See Headers.
"owin.RequestMethod" İsteğin HTTP istek yöntemini içeren bir string (örneğin, "GET", "POST").A string containing the HTTP request method of the request (e.g., "GET", "POST").
"owin.RequestPath" İstek yolunu içeren bir string.A string containing the request path. Yol, uygulama temsilcisinin "köküne" göre olmalıdır; bkz. yollar.The path MUST be relative to the "root" of the application delegate; see Paths.
"owin.RequestPathBase" Uygulama temsilcisinin "köküne" karşılık gelen istek yolunun bölümünü içeren bir string; bkz. yollar.A string containing the portion of the request path corresponding to the "root" of the application delegate; see Paths.
"owin.RequestProtocol" Protokol adı ve sürümünü içeren bir string (örn. "HTTP/1.0" veya "HTTP/1.1").A string containing the protocol name and version (e.g. "HTTP/1.0" or "HTTP/1.1").
"owin.RequestQueryString" Önde gelen "?" olmadan HTTP istek URI 'sinin sorgu dizesi bileşenini içeren string (örn. "foo=bar&baz=quux").A string containing the query string component of the HTTP request URI, without the leading "?" (e.g., "foo=bar&baz=quux"). Değer boş bir dize olabilir.The value may be an empty string.
"owin.RequestScheme" İstek için kullanılan URI şemasını içeren bir string (örneğin, "http", "https"); bkz. URI şeması.A string containing the URI scheme used for the request (e.g., "http", "https"); see URI Scheme.

OWIN 'ın ikinci anahtar öğesi uygulama temsilcisidir.The second key element of OWIN is the application delegate. Bu, bir OWıN uygulamasındaki tüm bileşenler arasında birincil arabirim görevi gören bir işlev imzasıdır.This is a function signature which serves as the primary interface between all components in an OWIN application. Uygulama temsilcisinin tanımı aşağıdaki gibidir:The definition for the application delegate is as follows:

Func<IDictionary<string, object>, Task>;

Daha sonra uygulama temsilcisi, işlevin ortam sözlüğünü girdi olarak kabul ettiği ve bir görev döndürdüğü Func temsilci türünün bir uygulamasıdır.The application delegate then is simply an implementation of the Func delegate type where the function accepts the environment dictionary as input and returns a Task. Bu tasarım, geliştiriciler için çeşitli etkilere sahiptir:This design has several implications for developers:

  • OWIN bileşenleri yazmak için gereken çok az sayıda tür bağımlılığı vardır.There are a very small number of type dependencies required in order to write OWIN components. Bu, OWIN 'un erişilebilirliğini büyük ölçüde geliştiricilere yükseltir.This greatly increases the accessibility of OWIN to developers.
  • Zaman uyumsuz tasarım, özellikle daha fazla g/ç yoğun işlemlerdeki bilgi işlem kaynaklarını işlemeye kadar verimli olmasını sağlar.The asynchronous design enables the abstraction to be efficient with its handling of computing resources, particularly in more I/O intensive operations.
  • Uygulama temsilcisi atomik bir yürütme birimidir ve ortam sözlüğü temsilci üzerinde bir parametre olarak yapıldığından, OWIN bileşenleri karmaşık HTTP işleme işlem hatları oluşturmak için kolayca birlikte zincirleme yapılabilir.Because the application delegate is an atomic unit of execution and because the environment dictionary is carried as a parameter on the delegate, OWIN components can be easily chained together to create complex HTTP processing pipelines.

Uygulama perspektifinden, OWıN bir belirtimdir (http://owin.org/html/owin.html).From an implementation perspective, OWIN is a specification (http://owin.org/html/owin.html). Hedefi bir sonraki Web çerçevesi değil, Web çerçeveleri ve Web sunucularının nasıl etkileşim kurabileceğine ilişkin bir belirtim değil.Its goal is not to be the next Web framework, but rather a specification for how Web frameworks and Web servers interact.

Owın veya Katana'ı araştırdıysanız, Owın NuGet paketini ve Owin. dll dosyasını da fark etmiş olabilirsiniz.If you've investigated OWIN or Katana, you may also have noticed the Owin NuGet package and Owin.dll. Bu kitaplık, OWIN belirtiminin 4. bölümünde açıklanan başlangıç dizisini şekillendirir ve coleştirir. tek bir arabirim olan ıappbuilder.This library contains a single interface, IAppBuilder, which formalizes and codifies the startup sequence described in section 4 of the OWIN specification. OWıN sunucularını derlemek için gerekli olmasa da, ıappbuilder arabirimi somut bir başvuru noktası sağlar ve bu, Katana proje bileşenleri tarafından kullanılır.While not required in order to build OWIN servers, the IAppBuilder interface provides a concrete reference point, and it is used by the Katana project components.

Proje KatanaProject Katana

Hem Owin belirtimi hem de Owin. dll , topluluk sahipliğinde ve topluluk açık kaynaklı çalışmalardır, Katana proje, hala açık kaynak olan Owin bileşenleri kümesini temsil eder, Microsoft tarafından oluşturulup serbest bırakılır.Whereas both the OWIN specification and Owin.dll are community owned and community run open source efforts, the Katana project represents the set of OWIN components that, while still open source, are built and released by Microsoft. Bu bileşenler, ana bilgisayarlar ve sunucular gibi altyapı bileşenlerinin yanı sıra, SignalR ve ASP.NET Web APIgibi çerçeveler için kimlik doğrulama bileşenleri ve bağlamaları gibi işlevsel bileşenleri içerir.These components include both infrastructure components, such as hosts and servers, as well as functional components, such as authentication components and bindings to frameworks such as SignalR and ASP.NET Web API. Proje aşağıdaki üç üst düzey hedefle sahiptir:The project has the following three high level goals:

  • Taşınabilir – bileşenler kullanılabilir hale geldiğinde yeni bileşenleri kolayca yerine yenilerini yerleştiribilmelidir.Portable – Components should be able to be easily substituted for new components as they become available. Bu, çerçeveden sunucuya ve ana bilgisayara kadar tüm bileşen türlerini içerir.This includes all types of components, from the framework to the server and host. Bu hedefin etkili olması, Microsoft çerçeveleri üçüncü taraf sunucularında ve konaklarda çalışırken, üçüncü taraf çerçevelerin Microsoft sunucularında sorunsuz bir şekilde çalışmasını sağlamaktır.The implication of this goal is that third party frameworks can seamlessly run on Microsoft servers while Microsoft frameworks can potentially run on third party servers and hosts.
  • Modüler/esnek– varsayılan olarak açık olan çok sayıda çerçevenin aksine, Katana proje bileşenleri küçük ve odaklanmış olmalıdır ve uygulamada hangi bileşenlerin kullanılacağını belirlemede uygulama geliştiricisi üzerinde denetim sağlar.Modular/flexible– Unlike many frameworks which include a myriad of features that are turned on by default, Katana project components should be small and focused, giving control over to the application developer in determining which components to use in her application.
  • Hafif/ performans ve ölçeklenebilir – bir çerçevenin geleneksel kavramının uygulama geliştiricisi tarafından açıkça eklenen küçük, odaklanmış bileşenlere bölünmesi sayesinde, sonuçta elde edilen bir katana uygulama daha az bilgi işlem kaynağı tüketebilir ve sonuç olarak diğer sunucu ve çerçeve türleriyle daha fazla yük işleyebilir.Lightweight/performant/scalable – By breaking the traditional notion of a framework into a set of small, focused components which are added explicitly by the application developer, a resulting Katana application can consume fewer computing resources, and as a result, handle more load, than with other types of servers and frameworks. Uygulamanın gereksinimleri temel altyapıdan daha fazla özellik talep ettiği için, bunlar OWıN ardışık düzenine eklenebilir, ancak bu, uygulama geliştiricisi kapsamında açık bir karar olmalıdır.As the requirements of the application demand more features from the underlying infrastructure, those can be added to the OWIN pipeline, but that should be an explicit decision on the part of the application developer. Ek olarak, alt düzey bileşenlerin substitutability, kullanılabilir hale geldiği anlamına gelir, bu uygulamaları bozmadan OWıN uygulamalarının performansını artırmak için yeni yüksek performanslı sunucuların sorunsuz bir şekilde tanıtılabilir.Additionally, the substitutability of lower level components means that as they become available, new high performance servers can seamlessly be introduced to improve the performance of OWIN applications without breaking those applications.

Katana bileşenleriyle çalışmaya başlamaGetting Started with Katana Components

İlk kez sunulmasından sonra, bir Web sunucusunu yazıp çalıştırabileceği için, en kısa şekilde, insanların dikkatini çekecek olan Node. js çerçevesinin bir yönü.When it was first introduced, one aspect of the Node.js framework that immediately drew people's attention was the simplicity with which one could author and run a Web server. Katana hedefleri Node. js' nin hafif şekilde çerçevelediği takdirde, bu, katkı ana 'nın, geliştiricilerin ASP.NET Web uygulamaları geliştirmeye yönelik her şeyi oluşturmasını zorlamadan, bu verileri, tek bir deyişle Node. js ' nin (ve gibi çerçeveler) sağladığı avantajlardan haberdar ederek özetleyebilir.If Katana goals were framed in light of Node.js, one might summarize them by saying that Katana brings many of the benefits of Node.js (and frameworks like it) without forcing the developer to throw out everything she knows about developing ASP.NET Web applications. Bu deyimin doğru olması için, Katana proje ile çalışmaya başlamak, Node. js' nin doğası gereği aynı şekilde basittir.For this statement to hold true, getting started with the Katana project should be equally simple in nature to Node.js.

"Merhaba Dünya!" oluşturuluyorCreating "Hello World!"

JavaScript ve .NET geliştirme arasındaki bir önemli farkı, bir derleyicinin varlığı (veya yokludır).One notable difference between JavaScript and .NET development is the presence (or absence) of a compiler. Bu nedenle, bir basit Katana sunucu için başlangıç noktası bir Visual Studio projem.As such, the starting point for a simple Katana server is a Visual Studio project. Ancak, en az proje türüyle başlayabiliriz: boş ASP.NET Web uygulaması.However, we can start with the most minimal of project types: the Empty ASP.NET Web Application.

Ardından, Microsoft. Owin. Host. SystemWeb NuGet paketini projeye yükleyeceğiz.Next, we will install the Microsoft.Owin.Host.SystemWeb NuGet package into the project. Bu paket, ASP.NET istek ardışık düzeninde çalışan bir OWıN sunucusu sağlar.This package provides an OWIN server that runs in the ASP.NET request pipeline. Bu, NuGet galerisinde bulunabilir ve Visual Studio Paket Yöneticisi iletişim kutusu ya da Paket Yöneticisi konsolu kullanılarak aşağıdaki komutla yüklenebilir:It can be found on the NuGet gallery and can be installed using either the Visual Studio package manager dialog or the package manager console with the following command:

install-package Microsoft.Owin.Host.SystemWeb

Microsoft.Owin.Host.SystemWeb paketini yüklemek, birkaç ek paketi bağımlılıklar olarak yükler.Installing the Microsoft.Owin.Host.SystemWeb package will install a few additional packages as dependencies. Bu bağımlılıklardan biri, OWıN uygulamalarının geliştirilmesi için çeşitli yardımcı türler ve yöntemler sağlayan bir kitaplık olan Microsoft.Owin.One of those dependencies is Microsoft.Owin, a library which provides several helper types and methods for developing OWIN applications. Aşağıdaki "Hello World" sunucusunu hızlı bir şekilde yazmak için bu türleri kullanabiliriz.We can use those types to quickly write the following "hello world" server.

public class Startup
{
   public void Configuration(IAppBuilder app)
   {
      app.Run(context =>
      {
         context.Response.ContentType = "text/plain";
         return context.Response.WriteAsync("Hello World!");
      });
   }
}

Bu çok basit Web sunucusu artık Visual Studio F5 komutu kullanılarak çalıştırılabilir ve hata ayıklama için tam destek içerir.This very simple Web server can now be run using Visual Studio's F5 command and includes full support for debugging.

Konakları değiştirmeSwitching hosts

Varsayılan olarak, önceki "Hello World" örneği, IIS bağlamında System. Web kullanan ASP.NET istek ardışık düzeninde çalışır.By default, the previous "hello world" example runs in the ASP.NET request pipeline, which uses System.Web in the context of IIS. Bu, kendi kendine bir OWıN ardışık düzeninin esneklik ve yeteneklerini, IIS 'nin genel olarak vadede sağladığı esneklikten faydalanabilir.This can by itself add tremendous value as it enables us to benefit from the flexibility and composability of an OWIN pipeline with the management capabilities and overall maturity of IIS. Ancak, IIS tarafından sunulan avantajların gerekmediği ve istenen daha küçük, daha hafif bir ana bilgisayar için olduğu durumlar olabilir.However, there may be cases where the benefits provided by IIS are not required and the desire is for a smaller, more lightweight host. Ne gerekir, daha sonra basit Web sunucunuzu IIS ve System. Web dışında çalıştırmak için?What is needed, then, to run our simple Web server outside of IIS and System.Web?

Taşınabilirlik hedefini göstermek için, bir Web sunucusu konaktan bir komut satırı ana bilgisayarına geçiş yapmak için, yeni sunucu ve ana bilgisayar bağımlılıklarını projenin çıkış klasörüne eklemek ve ardından ana bilgisayarı başlatmak gerekir.To illustrate the portability goal, moving from a Web-server host to a command line host requires simply adding the new server and host dependencies to project's output folder and then starting the host. Bu örnekte, Web sunucunuzu OwinHost.exe adlı bir katana konakta barındıracağız ve Katana HttpListener tabanlı sunucuyu kullanacaksınız.In this example, we'll host our Web server in a Katana host called OwinHost.exe and will use the Katana HttpListener-based server. Diğer Katana bileşenlere benzer şekilde, bunlar aşağıdaki komutu kullanarak NuGet 'den elde edilir:Similarly to the other Katana components, these will be acquired from NuGet using the following command:

install-package OwinHost

Daha sonra, komut satırından proje kök klasörüne gidebilir ve OwinHost.exe (ilgili NuGet paketinin Araçlar klasörüne yüklenmiş olan) çalıştırmanız yeterlidir.From the command line, we can then navigate to the project root folder and simply run the OwinHost.exe (which was installed in the tools folder of its respective NuGet package). Varsayılan olarak, OwinHost.exe HttpListener tabanlı sunucuyu aramak için yapılandırılır ve ek bir yapılandırma gerekmez.By default, OwinHost.exe is configured to look for the HttpListener-based server and so no additional configuration is needed. http://localhost:5000/ için bir Web tarayıcısında gezinmek, şimdi konsolundan çalıştırılan uygulamayı gösterir.Navigating in a Web browser to http://localhost:5000/ shows the application now running through the console.

Katana mimarisiKatana Architecture

Katana bileşen mimarisi, bir uygulamayı aşağıda gösterildiği gibi dört mantıksal katmana böler: ana bilgisayar, sunucu, ara yazılım ve uygulama.The Katana component architecture divides an application into four logical layers, as depicted below: host, server, middleware, and application. Bileşen mimarisi, bu katmanların uygulamalarının, uygulamanın yeniden derlenmesi gerekmeden birçok durumda kolayca yerine geçen bir şekilde katılabilmesini sağlayabilir.The component architecture is factored in such a way that implementations of these layers can be easily substituted, in many cases, without requiring recompilation of the application.

Ana bilgisayarHost

Konağın sorumludur:The host is responsible for:

  • Temel alınan işlemi yönetme.Managing the underlying process.

  • Bir sunucu seçimine ve isteklerin işlenebileceği bir OWıN işlem hattının oluşturulmasını sağlayan iş akışını düzenleyin.Orchestrating the workflow that results in the selection of a server and the construction of an OWIN pipeline through which requests will be handled.

    Mevcut olduğunda, Katana tabanlı uygulamalar için 3 birincil barındırma seçeneği vardır:At present, there are 3 primary hosting options for Katana-based applications:

IIS/ASP. net: Standart HttpModule ve HttpHandler türlerini kullanma, owın ardışık düzenleri, ASP.NET istek akışının bir PARÇASı olarak IIS üzerinde çalışabilir.IIS/ASP.NET: Using the standard HttpModule and HttpHandler types, OWIN pipelines can run on IIS as a part of an ASP.NET request flow. ASP.NET barındırma desteği, Microsoft. AspNet. Host. SystemWeb NuGet paketini bir Web uygulaması projesine yükleyerek etkinleştirilir.ASP.NET hosting support is enabled by installing the Microsoft.AspNet.Host.SystemWeb NuGet package into a Web application project. Ayrıca, IIS hem ana bilgisayar hem de sunucu olarak davrandığı için, OWıN sunucu/ana bilgisayar ayrımı bu NuGet paketinde bir bütün olarak belirlenir, yani SystemWeb ana bilgisayarı kullanılıyorsa bir geliştirici alternatif sunucu uygulamasını yerine geçemez.Additionally, because IIS acts as both a host and a server, the OWIN server/host distinction is conflated in this NuGet package, meaning that if using the SystemWeb host, a developer cannot substitute an alternate server implementation.

Özel ana bilgisayar: Katana bileşen paketi, bir geliştiricinin bir konsol uygulaması, Windows hizmeti vb. gibi kendi özel işleminde uygulamaları barındırmasını sağlar. Bu yetenek, Web API 'SI tarafından sunulan Self-Host özelliğine benzer.Custom Host: The Katana component suite gives a developer the ability to host applications in her own custom process, whether that is a console application, Windows service, etc. This capability looks similar to the self-host capability provided by Web API. Aşağıdaki örnek Web API kodunun özel bir konağını göstermektedir:The following example shows a custom host of Web API code:

static void Main()
{
    var baseAddress = new Uri("http://localhost:5000");

    var config = new HttpSelfHostConfiguration(baseAddress);
    config.Routes.MapHttpRoute("default", "{controller}");
       
    using (var svr = new HttpSelfHostServer(config))
    {
        svr.OpenAsync().Wait();
        Console.WriteLine("Press Enter to quit.");
        Console.ReadLine();
    }
}

Katana uygulamaya yönelik Self-Host kurulumu benzerdir:The self-host setup for a Katana application is similar:

static void Main(string[] args)
{
    const string baseUrl = "http://localhost:5000/";

    using (WebApplication.Start<Startup>(new StartOptions { Url = baseUrl })) 
    {
        Console.WriteLine("Press Enter to quit.");
        Console.ReadKey();
    }
}

Web API 'si ile Katana konak örnekleri arasındaki bir önemli farkı, Web API yapılandırma kodunun Katana Self-Host örneğinde eksik olması gerektiğidir.One notable difference between the Web API and Katana self-host examples is that the Web API configuration code is missing from the Katana self-host example. Hem taşınabilirlik hem de bileşim sağlamak için, Katana, sunucuyu başlatan kodu istek işleme ardışık düzenini yapılandıran koddan ayırır.In order to enable both portability and composability, Katana separates the code that starts the server from the code that configures the request processing pipeline. Web API 'sini yapılandıran kod, daha sonra WebApplication. Start içinde tür parametresi olarak belirtilen sınıf başlangıcında bulunur.The code that configures Web API, then is contained in the class Startup, which is additionally specified as the type parameter in WebApplication.Start.

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        var config = new HttpConfiguration();
        config.Routes.MapHttpRoute("default", "{controller}");
        app.UseWebApi(config);
    }
}

Başlangıç sınıfı, makalenin ilerleyen kısımlarında daha ayrıntılı olarak ele alınacaktır.The startup class will be discussed in greater detail later in the article. Ancak, bir katana Self-Host işlemini başlatmak için gereken kod, ASP.NET Web API Self-Host uygulamalarında, bugün kullanmakta olduğunuz koda benzer şekilde görünür.However, the code required to start a Katana self-host process looks strikingly similar to the code that you may be using today in ASP.NET Web API self-host applications.

Owinhost. exe: bazıları, Katana Web uygulamalarını çalıştırmak için özel bir işlem yazmak isteymekle çalışırken, bir sunucu başlatabilir ve uygulamalarını çalıştırabilecek önceden oluşturulmuş bir yürütülebilir dosya başlatmayı tercih eder.OwinHost.exe: While some will want to write a custom process to run Katana Web applications, many would prefer to simply launch a pre-built executable that can start a server and run their application. Bu senaryoda, Katana bileşen paketi OwinHost.exeiçerir.For this scenario, the Katana component suite includes OwinHost.exe. Bir projenin kök dizininden çalıştırıldığında, bu yürütülebilir bir sunucu başlatır (varsayılan olarak HttpListener sunucusunu kullanır) ve kullanıcının başlangıç sınıfını bulmak ve çalıştırmak için kuralları kullanır.When run from within a project's root directory, this executable will start a server (it uses the HttpListener server by default) and use conventions to find and run the user's startup class. Daha ayrıntılı denetim için, çalıştırılabilir bir dizi ek komut satırı parametresi sağlar.For more granular control, the executable provides a number of additional command line parameters.

SunucuServer

Ana bilgisayar, uygulamanın çalıştırıldığı işlemin başlatılması ve bakımında sorumlu olsa da, sunucunun sorumluluğu bir ağ yuvası açmak, istekleri dinlemek ve Kullanıcı tarafından belirtilen OWIN bileşenleri işlem hattı aracılığıyla göndermektir (sizin tarafınızdan zaten fark görmüş olabilir, bu işlem hattı uygulama geliştiricisinin başlangıç sınıfında belirtilir).While the host is responsible for starting and maintaining process within which the application runs, the responsibility of the server is to open a network socket, listen for requests, and send them through the pipeline of OWIN components specified by the user (as you may have already noticed, this pipeline is specified in the application developer's Startup class). Şu anda, Katana proje iki sunucu uygulaması içerir:Currently, the Katana project includes two server implementations:

  • Microsoft. Owin. Host. SystemWeb: daha önce belirtildiği gibi, ASP.NET ardışık DÜZENINDE bulunan IIS, hem konak hem de sunucu olarak davranır.Microsoft.Owin.Host.SystemWeb: As previously mentioned, IIS in concert with the ASP.NET pipeline acts as both a host and a server. Bu nedenle, bu barındırma seçeneğini seçerken IIS, işlem etkinleştirme ve HTTP isteklerini dinler gibi ana bilgisayar düzeyinde sorunları yönetir.Therefore, when choosing this hosting option, IIS both manages host-level concerns such as process activation and listens for HTTP requests. ASP.NET Web uygulamaları için, istekleri ASP.NET işlem hattına gönderir.For ASP.NET Web applications, it then sends the requests into the ASP.NET pipeline. Katana SystemWeb ana makinesi, HTTP işlem hattı üzerinden akar ve Kullanıcı tarafından belirtilen OWıN ardışık düzeninde yollayarak istekleri ele almak için bir ASP.NET HttpModule ve HttpHandler kaydeder.The Katana SystemWeb host registers an ASP.NET HttpModule and HttpHandler to intercept requests as they flow through the HTTP pipeline and send them through the user-specified OWIN pipeline.
  • Microsoft. Owin. Host. HttpListener: adı gösterildiği üzere bu Katana sunucu, bir yuva açmak ve istekleri geliştirici tarafından belirtilen bir owın ardışık düzenine göndermek Için .NET Framework HttpListener sınıfını kullanır.Microsoft.Owin.Host.HttpListener: As its name indicates, this Katana server uses the .NET Framework's HttpListener class to open a socket and send requests into a developer-specified OWIN pipeline. Bu, şu anda hem Katana Self-Host API 'SI hem de OwinHost. exe için varsayılan sunucu seçiminizdir.This is currently the default server selection for both the Katana self-host API and OwinHost.exe.

Ara yazılım/çerçeveMiddleware/framework

Daha önce belirtildiği gibi, sunucu bir istemciden bir istek kabul ettiğinde, bunu geliştiricinin başlangıç kodu tarafından belirtilen bir işlem hattı ile geçirmekten sorumludur.As previously mentioned, when the server accepts a request from a client, it is responsible for passing it through a pipeline of OWIN components, which are specified by the developer's startup code. Bu işlem hattı bileşenleri, ara yazılım olarak bilinir.These pipeline components are known as middleware.
En temel düzeyde, bir OWIN ara yazılım bileşeninin, çağrılabilir olması için OWıN uygulama temsilcisini uygulaması gerekir.At a very basic level, an OWIN middleware component simply needs to implement the OWIN application delegate so that it is callable.

Func<IDictionary<string, object>, Task>

Ancak, bir ara yazılım bileşenlerinin geliştirilmesini ve birleşimini basitleştirmek için, Katana, ara yazılım bileşenleri için el ile yapılan kuralları ve yardımcı türleri destekler.However, in order to simplify the development and composition of middleware components, Katana supports a handful of conventions and helper types for middleware components. Bunların en yaygın sürümü OwinMiddleware sınıfıdır.The most common of these is the OwinMiddleware class. Bu sınıf kullanılarak oluşturulan özel bir ara yazılım bileşeni, aşağıdakine benzer şekilde görünür:A custom middleware component built using this class would look similar to the following:

public class LoggerMiddleware : OwinMiddleware
{
    private readonly ILog _logger;
 
    public LoggerMiddleware(OwinMiddleware next, ILog logger) : base(next)
    {
        _logger = logger;
    }
 
    public override async Task Invoke(IOwinContext context)
    {
        _logger.LogInfo("Middleware begin");
        await this.Next.Invoke(context);
        _logger.LogInfo("Middleware end");
    }
}

Bu sınıf OwinMiddlewaretüretilir, ardışık düzendeki bir sonraki ara yazılımın bir örneğini bağımsız değişkenlerinden biri olarak kabul eden bir Oluşturucu uygular ve ardından bunu temel oluşturucuya geçirir.This class derives from OwinMiddleware, implements a constructor that accepts an instance of the next middleware in the pipeline as one of its arguments, and then passes it to the base constructor. Ara yazılımı yapılandırmak için kullanılan ek bağımsız değişkenler, sonraki ara yazılım parametresinden sonra Oluşturucu parametreleri olarak da bildirilmiştir.Additional arguments used to configure the middleware are also declared as constructor parameters after the next middleware parameter.

Çalışma zamanında, ara yazılım geçersiz kılınan Invoke yöntemi aracılığıyla yürütülür.At runtime, the middleware is executed via the overridden Invoke method. Bu yöntem OwinContexttüründe tek bir bağımsız değişken alır.This method takes a single argument of type OwinContext. Bu bağlam nesnesi, daha önce açıklanan Microsoft.Owin NuGet paketi tarafından sağlanır ve istek, yanıt ve ortam sözlüğüne, bazı ek yardımcı türlerle birlikte kesin olarak yazılmış erişim sağlar.This context object is provided by the Microsoft.Owin NuGet package described earlier and provides strongly-typed access to the request, response and environment dictionary, along with a few additional helper types.

Ara yazılım sınıfı, uygulama başlangıç kodundaki OWıN ardışık düzenine aşağıdaki gibi kolayca eklenebilir:The middleware class can be easily added to the OWIN pipeline in the application startup code as follows:

public class Startup
{
   public void Configuration(IAppBuilder app)
   {
      app.Use<LoggerMiddleware>(new TraceLogger());

   }
}

Katana altyapı bir OWıN ara yazılım bileşenlerini bir işlem hattı oluşturduğundan ve bileşenlerin işlem hattına katılmak için uygulama temsilcisini desteklemesi gerektiğinden, ara yazılım bileşenleri basit günlükçülerin ASP.NET, Web API veya SignalRgibi tüm çerçevelere kadar karmaşıklık halinde değişebilir.Because the Katana infrastructure simply builds up a pipeline of OWIN middleware components, and because the components simply need to support the application delegate to participate in the pipeline, middleware components can range in complexity from simple loggers to entire frameworks like ASP.NET, Web API, or SignalR. Örneğin, ASP.NET Web API 'sini önceki OWıN ardışık düzenine eklemek için aşağıdaki başlangıç kodunun eklenmesi gerekir:For example, adding ASP.NET Web API to the previous OWIN pipeline requires adding the following startup code:

public class Startup
{
   public void Configuration(IAppBuilder app)
   {
      app.Use<LoggerMiddleware>(new TraceLogger());

      var config = new HttpConfiguration();
      // configure Web API 
      app.UseWebApi(config);

      // additional middleware registrations            
   }
}

Katana altyapısı, yapılandırma yöntemindeki ıappbuilder nesnesine eklendikleri sıraya göre ara yazılım bileşenlerinin işlem hattını oluşturur.The Katana infrastructure will build the pipeline of middleware components based on the order in which they were added to the IAppBuilder object in the Configuration method. Bizim örneğimizde, Loggerara yazılımı, bu isteklerin sonunda nasıl işlendiği bağımsız olarak, işlem hattı üzerinden akan tüm istekleri işleyebilir.In our example, then, LoggerMiddleware can handle all requests that flow through the pipeline, regardless of how those requests are ultimately handled. Bu, bir ara yazılım bileşeninin (örn. bir kimlik doğrulama bileşeni) birden çok bileşen ve çerçeve (ör. ASP.NET Web API 'SI, SignalR ve statik dosya sunucusu) içeren bir işlem hattı için istekleri işleyebildiği güçlü senaryolar sunar.This enables powerful scenarios where a middleware component (e.g. an authentication component) can process requests for a pipeline that includes multiple components and frameworks (e.g. ASP.NET Web API, SignalR, and a static file server).

UygulamalarApplications

Önceki örneklerde gösterildiği gibi, OWıN ve Katana proje yeni bir uygulama programlama modeli olarak düşünülmemelidir, ancak uygulama programlama modellerini ve çerçevelerini sunucu ve barındırma altyapısından ayırmak için bir soyutlama değil.As illustrated by the previous examples, OWIN and the Katana project should not be thought of as a new application programming model, but rather as an abstraction to decouple application programming models and frameworks from server and hosting infrastructure. Örneğin, Web API uygulamaları oluştururken, geliştirici çerçevesi, uygulamanın Katana projeden bileşenler kullanılarak OWıN ardışık düzeninde çalışıp çalışmadığını bağımsız olarak ASP.NET Web API çerçevesini kullanmaya devam edecektir.For example, when building Web API applications, the developer framework will continue to use the ASP.NET Web API framework, irrespective of whether or not the application runs in an OWIN pipeline using components from the Katana project. OWıN ile ilgili kodun uygulama geliştiricisi tarafından görülebileceği tek bir konum, geliştiricinin OWıN ardışık düzenini yerleştirmekte olduğu uygulama başlangıç kodu olacaktır.The one place where OWIN-related code will be visible to the application developer will be the application startup code, where the developer composes the OWIN pipeline. Başlangıç kodunda, geliştirici, genellikle gelen istekleri işleyecek her bir ara yazılım bileşeni için bir dizi UseXx ifadesi kaydeder.In the startup code, the developer will register a series of UseXx statements, generally one for each middleware component that will process incoming requests. Bu deneyim, geçerli System. Web dünyasında HTTP modüllerini kaydetme ile aynı etkiye sahip olacaktır.This experience will have the same effect as registering HTTP modules in the current System.Web world. Genellikle, ASP.NET Web API 'SI veya SignalR gibi daha büyük bir Framework ara yazılımı, işlem hattının sonuna kaydedilir.Typically, a larger framework middleware, such as ASP.NET Web API or SignalR will be registered at the end of the pipeline. Kimlik doğrulama veya önbelleğe alma gibi çapraz kesme ara yazılım bileşenleri genellikle işlem hattının sonuna doğru kaydedilir, böylece işlem hattında daha sonra kaydedilen tüm çerçeveler ve bileşenler için istekleri işleyirler.Cross-cutting middleware components, such as those for authentication or caching, are generally registered towards the beginning of the pipeline so that they will process requests for all of the frameworks and components registered later in the pipeline. Ara yazılım bileşenlerinin birbirleriyle ve temel alınan altyapı bileşenlerinden bu şekilde ayrılması, bileşenlerin, genel sistemin kararlı kalmasını sağlarken farklı Velde gelişmesine olanak sağlar.This separation of the middleware components from each other and from the underlying infrastructure components enables the components to evolve at different velocities while ensuring that the overall system remains stable.

Bileşenler – NuGet paketleriComponents – NuGet Packages

Birçok geçerli kitaplık ve çerçeve gibi, Katana proje bileşenleri bir NuGet paketleri kümesi olarak dağıtılır.Like many current libraries and frameworks, the Katana project components are delivered as a set of NuGet packages. Yaklaşan sürüm 2,0 için, Katana paket bağımlılık grafiği aşağıdaki gibi görünür.For the upcoming version 2.0, the Katana package dependency graph looks as follows. (Daha büyük görünüm için görüntüye tıklayın.)(Click on image for larger view.)

Katana projesindeki neredeyse her paket, Owın paketinde doğrudan veya dolaylı olarak bağlıdır.Nearly every package in the Katana project depends, directly or indirectly, on the Owin package. Bu, OWIN belirtiminin 4. bölümünde açıklanan uygulama başlatma sırasının somut bir uygulamasını sağlayan ıappbuilder arabirimini içeren paket olduğunu unutmayın.You may remember that this is the package that contains the IAppBuilder interface, which provides a concrete implementation of the application startup sequence described in section 4 of the OWIN specification. Ayrıca, paketlerin birçoğu, HTTP istekleri ve yanıtları ile çalışmaya yönelik bir dizi yardımcı türü sağlayan Microsoft. Owin 'a bağımlıdır.Additionally, many of the packages depend on Microsoft.Owin, which provides a set of helper types for working with HTTP requests and responses. Paketin geri kalanı, barındırma altyapısı paketleri (sunucular veya konaklar) veya ara yazılım olarak sınıflandırılabilir.The remainder of the package can be classified as either hosting infrastructure packages (servers or hosts) or middleware. Katana proje dışındaki paketler ve bağımlılıklar turuncu olarak görüntülenir.Packages and dependencies that are external to the Katana project are displayed in orange.

Katana 2,0 barındırma altyapısı hem SystemWeb hem de HttpListener tabanlı sunucuları, OwinHost. exe ' yi kullanarak OWıN uygulamalarını çalıştırmaya yönelik Owınhost paketini ve bir üzerinde kendi kendine barındırma uygulamaları için Microsoft. Owin. Hosting paketini içerir. özel ana bilgisayar (ör. konsol uygulaması, Windows hizmeti vb.)The hosting infrastructure for Katana 2.0 includes both the SystemWeb and HttpListener-based servers, the OwinHost package for running OWIN applications using OwinHost.exe, and the Microsoft.Owin.Hosting package for self-hosting OWIN applications in a custom host (e.g. console application, Windows service, etc.)

Katana 2,0 için, ara yazılım bileşenleri temelde farklı kimlik doğrulama yöntemi sağlamaya odaklanılmıştır.For Katana 2.0, the middleware components are primarily focused on providing different means of authentication. Tanılama için bir ek ara yazılım bileşeni sağlanır ve bu, başlangıç ve hata sayfası desteğini sunar.One additional middleware component for diagnostics is provided, which enables support for a start and error page. OWIN, Microsoft ve üçüncü taraflar tarafından geliştirilen bir ara yazılım bileşenlerinin ekosistemi olan soyutlamadır.As OWIN grows into the de facto hosting abstraction, the ecosystem of middleware components, both those developed by Microsoft and third parties, will also grow in number.

SonuçConclusion

En baştan, Katana Projenin hedefi oluşturmamıştır ve böylece geliştiricilerin henüz başka bir Web çerçevesini öğrenmelerine izin vermez.From its beginning, the Katana project's goal has not been to create and thereby force developers to learn yet another Web framework. Bunun yerine, amaç .NET Web uygulaması geliştiricilerine daha önce mümkün olandan daha fazla seçenek sunmak için bir soyutlama oluşturmaktır.Rather, the goal has been to create an abstraction to give .NET Web application developers more choice than has previously been possible. Normal bir Web uygulaması yığınının mantıksal katmanlarını değiştirilebilen bir bileşen kümesine bölerek, Katana proje, bu bileşenlere ilişkin her türlü bir fiyata yönelik olarak yığının tamamında bulunan bileşenlerin kullanımını sağlar.By breaking up the logical layers of a typical Web application stack into a set of replaceable components, the Katana project enables components throughout the stack to improve at whatever rate makes sense for those components. Katana soyutlamadaki tüm bileşenleri derleyerek, Katana çerçeveleri ve bunların üzerine inşa olan uygulamaların çeşitli farklı sunucular ve konaklar arasında taşınabilir olmasını sağlar.By building all components around the simple OWIN abstraction, Katana enables frameworks and the applications built on top of them to be portable across a variety of different servers and hosts. Katana, geliştiriciyi yığının denetimine yerleştirerek, geliştiricinin basit veya özellik açısından zengin Web yığınının nasıl olması gerektiği hakkında üstün seçim yapmalarını sağlar.By putting the developer in control of the stack, Katana ensures that the developer makes the ultimate choice about how lightweight or how feature-rich her Web stack should be.

Katana hakkında daha fazla bilgi içinFor more information about Katana

BildirimlerAcknowledgements