Vue d’ensemble du projet KatanaAn Overview of Project Katana

par Howard Dierkingby Howard Dierking

L’infrastructure ASP.NET existe depuis plus de dix ans, et la plateforme a activé le développement d’innombrables sites et services Web.The ASP.NET Framework has been around for over ten years, and the platform has enabled the development of countless Web sites and services. Comme les stratégies de développement d’applications Web ont évolué, l’infrastructure a été capable d’évoluer à l’étape des technologies telles que ASP.NET MVC et API Web ASP.NET.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. Développement d’applications Web utilise son étape suivante dans le monde du cloud computing, projet Katana fournit le jeu sous-jacent de composants pour les applications ASP.NET, leur permettant d’être flexible et portable léger et offrent de meilleures performances : autrement dit, le projet Katana cloud permet d’optimiser vos applications ASP.NET.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.

Pourquoi Katana – pourquoi maintenant ?Why Katana – Why Now?

Qu’un parle d’un produit de framework ou de l’utilisateur final de développeur, il est important de comprendre les motivations sous-jacentes pour la création du produit et une partie de permet de savoir qui a le produit a été créé pour.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 a été créée avec deux de vos clients à l’esprit.ASP.NET was originally created with two customers in mind.

Le premier groupe de clients a été les développeurs ASP classiques.The first group of customers was classic ASP developers. Dans le temps, ASP était une des principales technologies pour la création d’applications et des sites Web dynamiques, pilotés par les données par l’entrelacement de balisage et le script côté serveur.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. Le runtime ASP fourni un script côté serveur avec un ensemble d’objets qui les aspects principaux du protocole HTTP sous-jacent et le serveur Web et les mettre en cache, fournie par l’accès à d’autres services telle session état des applications, etc. Bien que puissante, les applications ASP classiques est devenu difficile de gérer le fil de l’augmentation de la taille et la complexité.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. Cela a été en grande partie en raison de l’absence de structure trouvée dans des environnements associés à la duplication de code résultant de l’entrelacement de code et le balisage de script.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. Afin de profiter des avantages de l’ASP classique tout en répondant à ses défis, ASP.NET a tiré parti de l’organisation du code fournie par les langages orientés objet du .NET Framework tout en conservant le modèle de programmation côté serveur à quels ASP classique développeurs avaient pris l’habitude.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.

Le deuxième groupe de clients cible pour ASP.NET a été développeurs d’applications métier Windows.The second group of target customers for ASP.NET was Windows business application developers. Contrairement aux développeurs ASP classiques, qui étaient habitués à écrire un balisage HTML et le code pour générer un balisage HTML plus, les développeurs de WinForms (comme les développeurs VB6 avant eux) étaient habitués à un processus de conception qui comprenait une zone de dessin et un ensemble complet de l’utilisateur contrôles d’interface.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. La première version d’ASP.NET – également appelé « Web Forms » fourni un processus similaire de conception, ainsi que d’un modèle d’événements côté serveur pour les composants d’interface utilisateur et un ensemble de fonctionnalités d’infrastructure (par exemple, ViewState) pour créer une expérience de développement FLUIDE entre le client et la programmation du côté serveur.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 hid efficacement la nature sans état d’un site Web sous un modèle d’événement avec état qui était familière aux développeurs de WinForms.Web Forms effectively hid the Web's stateless nature under a stateful event model that was familiar to WinForms developers.

Défis déclenchés par le modèle historiqueChallenges Raised by the Historical Model

Le résultat net est un runtime mature et riche en fonctionnalités et le modèle de programmation de développeur.The net result was a mature, feature-rich runtime and developer programming model. Toutefois, cette richesse des fonctionnalités provenait quelques défis importants.However, with that feature-richness came a couple notable challenges. Tout d’abord, l’infrastructure a été monolithique, avec des unités logiquement disparates de fonctionnalités être étroitement couplé dans le même assembly System.Web.dll (par exemple, les objets de base HTTP avec l’infrastructure de formulaires Web).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). Ensuite, ASP.NET a été inclus dans le cadre du plus grand .NET Framework, ce qui signifiait que le temps entre les versions a été l’ordre des années.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. Cela rendait difficile pour ASP.NET pour s’adapter à toutes les modifications qui se produisent dans le développement Web en constante évolution.This made it difficult for ASP.NET to keep pace with all of the changes happening in rapidly evolving Web development. Enfin, System.Web.dll lui-même a été couplée de différentes manières sur une option d’hébergement de Web spécifique : 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).

Étapes : ASP.NET MVC et API Web ASP.NETEvolutionary steps: ASP.NET MVC and ASP.NET Web API

Et un grand nombre de modifications qui se produisent dans le développement Web !And lots of change was happening in Web development! Applications Web ont été plus en plus en cours de développement comme ayant le focus une série de petits composants plutôt que de grandes infrastructures.Web applications were increasingly being developed as a series of small, focused components rather than large frameworks. Le nombre de composants, ainsi que la fréquence avec laquelle ils ont été publiés augmentaient à un rythme jamais plus rapide.The number of components as well as the frequency with which they were released was increasing at an ever faster rate. Il était clair qu’également suivre le rythme avec le Web nécessiterait des infrastructures d’obtenir des plus petites, découplé et plus ciblée au lieu de la plus grande et plus riche en, par conséquent le équipe ASP.NET a eu plusieurs étapes pour activer ASP.NET en tant qu’une famille de des composants enfichables Web plutôt que d’une infrastructure unique.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.

Une des premières modifications a été le succès croissant du modèle de conception model-view-controller (MVC) bien connu grâce aux infrastructures de développement Web comme Ruby on Rails.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. Ce style de la création d’applications Web a donné le développeur plus grand contrôle sur le balisage de l’application tout en conservant la séparation de balisage et la logique métier, qui était un des points de vente initiales pour ASP.NET.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. Pour répondre à la demande pour ce style de développement d’applications Web, Microsoft a eu la possibilité de se positionner mieux pour l’avenir en développement d’ASP.NET MVC hors bande (et ne pas l’inclure dans le .NET Framework).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 a été publié comme un téléchargement indépendant.ASP.NET MVC was released as an independent download. L’équipe d’ingénierie a donné la possibilité de fournir des mises à jour beaucoup plus fréquemment avait été possibles auparavant.This gave the engineering team the flexibility to deliver updates much more frequently than had been previously possible.

Un autre changement majeur dans le développement d’applications Web a été le passage des pages Web dynamiques générées par le serveur à initiale du balisage statique avec des sections dynamiques de la page générée à partir d’un script côté client communication avec les API Web principales via Les demandes AJAX.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. Ce changement architectural a permis à assurer la propulsion l’essor d’API Web et le développement de l’infrastructure de l’API Web ASP.NET.This architectural shift helped propel the rise of Web APIs, and the development of the ASP.NET Web API framework. Comme dans le cas d’ASP.NET MVC, la version de l’API Web ASP.NET fourni une autre possibilité d’évoluer ASP.NET davantage comme une infrastructure plus modulaire.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. L’équipe d’ingénierie a tiré parti de l’opportunité et générés API Web ASP.NET de sorte que qu’elle n’avait aucune dépendance sur un des types de framework core trouvés dans System.Web.dll.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. Cette option activée deux choses : tout d’abord, elle voulait dire que ASP.NET Web API susceptible d’évoluer de manière complètement autonome (et il peut continuer à effectuer une itération rapidement, car il est remis via NuGet).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). En second lieu, car il y a aucune dépendance externe à System.Web.dll et par conséquent, aucune dépendance sur IIS, ASP.NET Web API inclus la possibilité d’exécuter dans un hôte personnalisé (par exemple, une application console, service de Windows, etc.)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.)

L’avenir : Une infrastructure de rapiditéThe Future: A Nimble Framework

Par le découplage des composants du framework uns des autres et en les libérant ensuite sur NuGet, infrastructures pourraient désormais effectuer une itération de façon plus indépendante, plus rapidement.By decoupling framework components from one another and then releasing them on NuGet, frameworks could now iterate more independently and more quickly. En outre, la puissance et la flexibilité de la capacité d’auto-hébergement de l’API Web s’est avéré très attrayantes pour les développeurs qui souhaitaient un hôte petit et léger pour leurs services.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. Il s’est avéré si attrayante, en fait, que d’autres infrastructures souhaitait également cette fonctionnalité, et cela présenté un nouveau défi car chaque framework exécuté dans son propre processus d’hôte sur sa propre adresse de base et devait être géré (démarré, arrêté, etc.) indépendamment.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. Une application Web moderne prend généralement en charge l’envoi de fichier statique, la génération de page dynamique, API Web et plus récemment real-time/notifications push.A modern Web application generally supports static file serving, dynamic page generation, Web API, and more recently real-time/push notifications. Attend que chacun de ces services doit-elle être exécuté et géré indépendamment n’était tout simplement pas réaliste.Expecting that each of these services should be run and managed independently was simply not realistic.

Il fallait donc une simple abstraction d’hébergement qui pourraient permettre à un développeur composer une application à partir d’une variété de différents composants et infrastructures, puis exécuter cette application sur un hôte de prise en charge.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.

L’Interface Web ouverte pour .NET (OWIN)The Open Web Interface for .NET (OWIN)

Inspirés par les avantages obtenus par Rack dans la Communauté Ruby, plusieurs membres de la Communauté .NET décidé de créer une abstraction entre les serveurs Web et les composants framework.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. Deux objectifs de conception pour l’abstraction OWIN ont été que c’était simple et qu’il a fallu peu de dépendances possible sur d’autres types de framework.Two design goals for the OWIN abstraction were that it was simple and that it took the fewest possible dependencies on other framework types. Ces deux objectifs afin de garantir :These two goals help ensure:

  • Nouveaux composants peuvent plus facilement développés et consommées.New components could be more easily developed and consumed.
  • Applications peuvent être déplacées plus facilement entre les hôtes et les systèmes potentiellement entière d’exploitation/plateformes.Applications could be more easily ported between hosts and potentially entire platforms/operating systems.

L’abstraction qui en résulte se compose de deux éléments principaux.The resulting abstraction consists of two core elements. Le premier est le dictionnaire d’environnement.The first is the environment dictionary. Cette structure de données est chargée de stocker l’ensemble de l’état nécessaire pour le traitement d’une requête HTTP et de réponse, ainsi que n’importe quel état du serveur approprié.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. Le dictionnaire d’environnement est défini comme suit :The environment dictionary is defined as follows:

IDictionary<string, object>

Un serveur Web compatible avec OWIN est chargé de remplir le dictionnaire d’environnement avec des données telles que le flux du corps et les collections d’en-têtes pour une requête et réponse HTTP.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. Il est ensuite la responsabilité des composants d’application ou une infrastructure pour remplir ou de mettre à jour le dictionnaire avec des valeurs supplémentaires et d’écrire dans le flux du corps de réponse.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.

En plus de spécifier le type pour le dictionnaire d’environnement, la spécification OWIN définit une liste de paires clé-valeur de dictionnaire principal.In addition to specifying the type for the environment dictionary, the OWIN specification defines a list of core dictionary key value pairs. Par exemple, le tableau suivant montre les clés de dictionnaire requis pour une requête HTTP :For example, the following table shows the required dictionary keys for an HTTP request:

Nom de cléKey Name Description de la valeurValue Description
"owin.RequestBody" Un Stream avec le corps de la demande, le cas échéant.A Stream with the request body, if any. Stream.Null peut être utilisé comme un espace réservé s’il n’existe aucun corps de la demande.Stream.Null MAY be used as a placeholder if there is no request body. Consultez corps de la demande.See Request Body.
"owin.RequestHeaders" Un IDictionary<string, string[]> des en-têtes de demande.An IDictionary<string, string[]> of request headers. Consultez en-têtes.See Headers.
"owin.RequestMethod" Un string contenant la méthode de demande HTTP de la demande (par exemple, "GET", "POST").A string containing the HTTP request method of the request (e.g., "GET", "POST").
"owin.RequestPath" Un string contenant le chemin d’accès de la demande.A string containing the request path. Le chemin d’accès doit être relatif à la « racine » du délégué d’application ; consultez chemins d’accès.The path MUST be relative to the "root" of the application delegate; see Paths.
"owin.RequestPathBase" Un string contenant la partie du chemin d’accès de demande correspondant à la « racine » du délégué d’application ; consultez chemins d’accès.A string containing the portion of the request path corresponding to the "root" of the application delegate; see Paths.
"owin.RequestProtocol" Un string contenant le nom de protocole et la version (par exemple, "HTTP/1.0" ou "HTTP/1.1").A string containing the protocol name and version (e.g. "HTTP/1.0" or "HTTP/1.1").
"owin.RequestQueryString" Un string contenant le composant de chaîne de requête de l’URI, de la requête HTTP sans le caractère de début « ? » (par exemple, "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"). La valeur peut être une chaîne vide.The value may be an empty string.
"owin.RequestScheme" Un string contenant le schéma d’URI utilisé pour la demande (par exemple, "http", "https") ; consultez schéma d’URI.A string containing the URI scheme used for the request (e.g., "http", "https"); see URI Scheme.

Le deuxième élément clé du OWIN est le délégué d’application.The second key element of OWIN is the application delegate. Il s’agit d’une signature de fonction qui sert d’interface principale entre tous les composants dans une application OWIN.This is a function signature which serves as the primary interface between all components in an OWIN application. La définition pour le délégué d’application est la suivante :The definition for the application delegate is as follows:

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

Ensuite, le délégué d’application est simplement une implémentation du type de délégué Func où la fonction accepte le dictionnaire d’environnement en tant qu’entrée et retourne une tâche.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. Cette conception a plusieurs conséquences pour les développeurs :This design has several implications for developers:

  • Il existe un très petit nombre de dépendances de type nécessaire pour écrire des composants OWIN.There are a very small number of type dependencies required in order to write OWIN components. Cela augmente considérablement l’accessibilité d’OWIN pour les développeurs.This greatly increases the accessibility of OWIN to developers.
  • La conception asynchrone permet l’abstraction d’être efficaces avec sa gestion des ressources informatiques, en particulier dans des opérations gourmandes en e/s plus.The asynchronous design enables the abstraction to be efficient with its handling of computing resources, particularly in more I/O intensive operations.
  • Étant donné que le délégué d’application est une unité atomique de l’exécution et parce que le dictionnaire d’environnement est transmis sous la forme d’un paramètre sur le délégué, composants OWIN peuvent facilement être chaînés ensemble pour créer des pipelines de traitement de HTTP complex.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.

Du point de vue de l’implémentation, OWIN est une spécification (http://owin.org/html/owin.html).From an implementation perspective, OWIN is a specification (http://owin.org/html/owin.html). Son objectif doit ne pas être l’infrastructure Web suivante, mais plutôt une spécification pour l’interagissent des infrastructures Web et les serveurs Web.Its goal is not to be the next Web framework, but rather a specification for how Web frameworks and Web servers interact.

Si vous avez examiné OWIN ou Katana, vous avez pouvez également remarquer les package NuGet de Owin et Owin.dll.If you've investigated OWIN or Katana, you may also have noticed the Owin NuGet package and Owin.dll. Cette bibliothèque contient une seule interface, IAppBuilder, qui formalise et codifie décrite dans la séquence de démarrage section 4 de la spécification OWIN.This library contains a single interface, IAppBuilder, which formalizes and codifies the startup sequence described in section 4 of the OWIN specification. Bien que non obligatoire pour générer des serveurs OWIN, les IAppBuilder interface fournit un point de référence concret, et il est utilisé par les composants du projet Katana.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.

Projet KatanaProject Katana

Tandis qu’à la fois le OWIN spécification et Owin.dll sont détenus et Communauté exécuter efforts open source, le Katana projet représente l’ensemble des OWIN composants qui, lors de la source de toujours ouverte, sont créées et publiées par Microsoft.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. Ces composants incluent les composants d’infrastructure, tels que les ordinateurs hôtes et serveurs, ainsi que des composants fonctionnels, tels que les composants de l’authentification et de liaisons aux infrastructures telles que SignalR et Web ASP.NET API.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. Le projet comporte les trois objectifs de haut niveau suivants :The project has the following three high level goals:

  • Portable – composants doivent pouvoir être facilement remplacée pour les nouveaux composants qu’elles sont disponibles.Portable – Components should be able to be easily substituted for new components as they become available. Cela inclut tous les types de composants, à partir de l’infrastructure pour le serveur et l’hôte.This includes all types of components, from the framework to the server and host. La conséquence de cet objectif est que tiers infrastructures peuvent en toute transparence s’exécuter sur les serveurs Microsoft tandis que les infrastructures de Microsoft peuvent éventuellement l’exécuter sur les hôtes et des serveurs tiers.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.
  • Modulaire/flexible– Contrairement à nombreuses infrastructures qui comprennent une multitude de fonctionnalités qui sont activées par défaut, les composants du projet Katana doivent être réduite et focalisée, ce qui donne un contrôle au développeur d’applications pour déterminer quels composants de utiliser dans son application.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.
  • Lightweight et performante/plus évolutif : en divisant la notion d’une infrastructure traditionnelle en un ensemble de petits, concentré de composants qui sont ajoutés explicitement par le développeur d’applications, une application de Katana qui en résulte peut consommer moins de l’informatique ressources et par conséquent, la gestion des charges plus, qu’avec d’autres types de serveurs et d’infrastructures.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. Comme la configuration requise de l’application à la demande davantage de fonctionnalités à partir de l’infrastructure sous-jacente, ceux peuvent être ajoutés au pipeline OWIN, mais qui doit être explicitement la décision de part le développeur d’applications.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. En outre, la possibilité de substituer des composants de niveau inférieur signifie que lorsqu’elles sont disponibles, nouveaux serveurs hautes performances peuvent en toute transparence être introduites pour améliorer les performances des applications OWIN sans arrêt de ces applications.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.

Mise en route avec les composants KatanaGetting Started with Katana Components

Quand il a été introduite, un aspect de la Node.js framework qu’immédiatement que vous avez dessinée l’attention a été la simplicité avec laquelle un peut créer et exécuter un serveur Web.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. Si les objectifs de Katana ont été insérées dans la lumière de Node.js, un peut les résumer en disant que Katana apporte de nombreux avantages de Node.js (et les infrastructures comme il) sans obliger le développeur parler tout ce dont elle sait sur le développement d’applications Web ASP.NET.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. Pour cette instruction contenir la valeur est true, mise en route avec le projet Katana doit être tout aussi simple de nature à Node.js.For this statement to hold true, getting started with the Katana project should be equally simple in nature to Node.js.

Création de « Hello World ! »Creating "Hello World!"

Une différence notable entre JavaScript et le développement .NET est la présence (ou non) d’un compilateur.One notable difference between JavaScript and .NET development is the presence (or absence) of a compiler. Par conséquent, le point de départ pour un simple serveur Katana est un projet Visual Studio.As such, the starting point for a simple Katana server is a Visual Studio project. Toutefois, nous pouvons commencer par le plus minimal des types de projets : l’Application Web ASP.NET vide.However, we can start with the most minimal of project types: the Empty ASP.NET Web Application.

Ensuite, nous allons installer le Microsoft.Owin.Host.SystemWeb package NuGet dans le projet.Next, we will install the Microsoft.Owin.Host.SystemWeb NuGet package into the project. Ce package fournit un serveur OWIN qui s’exécute dans le pipeline de demande ASP.NET.This package provides an OWIN server that runs in the ASP.NET request pipeline. Il se trouve sur le galerie NuGet et peut être installé à l’aide de la boîte de dialogue Gestionnaire de package Visual Studio ou de la console du Gestionnaire de package avec la commande suivante :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

L’installation de le Microsoft.Owin.Host.SystemWeb package installe quelques packages supplémentaires en tant que dépendances.Installing the Microsoft.Owin.Host.SystemWeb package will install a few additional packages as dependencies. Une de ces dépendances est Microsoft.Owin, une bibliothèque qui fournit plusieurs types d’assistance et des méthodes pour le développement d’applications OWIN.One of those dependencies is Microsoft.Owin, a library which provides several helper types and methods for developing OWIN applications. Nous pouvons utiliser ces types pour écrire rapidement le serveur suivant de « hello world ».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!");
      });
   }
}

Ce serveur Web très simple peut maintenant être exécuté à l’aide de Visual Studio F5 commande et inclut la prise en charge complète pour le débogage.This very simple Web server can now be run using Visual Studio's F5 command and includes full support for debugging.

Hôtes de commutationSwitching hosts

Par défaut, l’exemple « hello world » précédent s’exécute dans le pipeline de demande ASP.NET, qui utilise System.Web dans le contexte d’IIS.By default, the previous "hello world" example runs in the ASP.NET request pipeline, which uses System.Web in the context of IIS. Cela peut par lui-même ajouter une valeur ajoutée considérable car elle permet de tirer parti de la flexibilité et la composabilité d’un pipeline OWIN avec les fonctionnalités de gestion et de maturité globale d’IIS.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. Toutefois, il peut arriver dans lequel les avantages fournis par IIS ne sont pas nécessaires et le désir est destiné à un hôte de plus petit et plus léger.However, there may be cases where the benefits provided by IIS are not required and the desire is for a smaller, more lightweight host. Ensuite, ce qui est nécessaire pour exécuter notre serveur Web simple en dehors d’IIS et System.Web ?What is needed, then, to run our simple Web server outside of IIS and System.Web?

Pour illustrer l’objectif de la portabilité, le passage d’un hôte de serveur Web vers un hôte de la ligne de commande nécessite simplement en ajoutant les nouvelles dépendances de serveur et l’hôte au dossier de sortie du projet, puis en démarrant l’ordinateur hôte.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. Dans cet exemple, nous allons héberger notre serveur Web dans un hôte Katana appelé OwinHost.exe et utilisera le serveur basée sur Katana HttpListener.In this example, we'll host our Web server in a Katana host called OwinHost.exe and will use the Katana HttpListener-based server. De même pour les autres composants Katana, il seront acquis à partir de NuGet à l’aide de la commande suivante :Similarly to the other Katana components, these will be acquired from NuGet using the following command:

install-package OwinHost

À partir de la ligne de commande, nous pouvons puis accédez au dossier projet racine et exécutez simplement le OwinHost.exe (qui a été installé dans le dossier Outils de son package NuGet respectif).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). Par défaut, OwinHost.exe est configuré pour rechercher le serveur HttpListener et aucune configuration supplémentaire n’est donc nécessaire.By default, OwinHost.exe is configured to look for the HttpListener-based server and so no additional configuration is needed. Navigation dans un navigateur Web pour http://localhost:5000/ montre l’application en cours d’exécution via la console.Navigating in a Web browser to http://localhost:5000/ shows the application now running through the console.

Architecture de KatanaKatana Architecture

L’architecture des composants Katana divise une application en quatre couches logiques, comme illustré ci-dessous : hôte, le serveur, intergiciel (middleware), et application.The Katana component architecture divides an application into four logical layers, as depicted below: host, server, middleware, and application. L’architecture des composants est conçue de telle façon que les implémentations de ces couches puissent être facilement remplacées, dans de nombreux cas, sans nécessiter de recompilation de l’application.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.

HôteHost

L’hôte est chargé de :The host is responsible for:

  • La gestion du processus sous-jacent.Managing the underlying process.

  • Orchestration de flux de travail qui entraîne la sélection d’un serveur et de la construction d’un pipeline OWIN via les demandes est traité.Orchestrating the workflow that results in the selection of a server and the construction of an OWIN pipeline through which requests will be handled.

    À l’heure actuelle, il existe 3 options d’hébergement principales pour les applications Katana :At present, there are 3 primary hosting options for Katana-based applications:

IIS/ASP.NET: Les pipelines OWIN à l’aide des types standard HttpModule et HttpHandler, peuvent exécuter sur IIS dans le cadre d’un flux de demande ASP.NET.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. Hébergement de prise en charge ASP.NET est activé en installant le package NuGet de Microsoft.AspNet.Host.SystemWeb dans un projet d’application Web.ASP.NET hosting support is enabled by installing the Microsoft.AspNet.Host.SystemWeb NuGet package into a Web application project. En outre, étant donné que IIS agit comme un hôte et un serveur, la distinction de serveur/hôte OWIN va de pair dans ce package NuGet, ce qui signifie que si vous utilisez l’hôte SystemWeb, un développeur ne peut pas remplacer une implémentation de l’autre serveur.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.

Hôte personnalisé: La suite de composants Katana donne au développeur la possibilité d’héberger des applications dans son propre processus personnalisé, si c’est une application console, un service de Windows, un périphérique. Cette fonctionnalité est similaire à la fonctionnalité Self-host fournie par l’API Web.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. L’exemple suivant montre un hôte personnalisé de code de l’API Web :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();
    }
}

Le programme d’installation Self-host pour une application de Katana est similaire :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();
    }
}

Une différence notable entre les API Web et Katana Self-host exemples est que le code de configuration de Web API est manquant dans l’exemple Self-host de Katana.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. Pour permettre la portabilité et composabilité, Katana sépare le code qui démarre le serveur à partir du code qui configure le pipeline de traitement de requête.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. Le code qui configure l’API Web, puis est contenu dans la classe de démarrage, qui est en outre spécifié comme paramètre de type dans WebApplication.Start.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);
    }
}

La classe de démarrage est abordée plus en détail plus loin dans l’article.The startup class will be discussed in greater detail later in the article. Toutefois, le code requis pour démarrer un processus Self-host est remarquablement similaire au code que vous utilisez peut-être dès aujourd'hui dans les applications ASP.NET Web API Self-host de Katana.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: Alors que certains souhaiterez écrire un processus personnalisé pour exécuter des applications Web de Katana, nombreuses préférez simplement lancer un exécutable prédéfini qui peut démarrer un serveur et exécuter leur application.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. Pour ce scénario, la suite de composants Katana inclut OwinHost.exe.For this scenario, the Katana component suite includes OwinHost.exe. Exécutée à partir d’un répertoire de projet racine, ce fichier exécutable démarre un serveur (il utilise le serveur HttpListener par défaut) et utiliser des conventions pour rechercher et exécuter la classe de démarrage de l’utilisateur.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. Pour un contrôle plus précis, l’exécutable fournit un nombre de paramètres de ligne de commande supplémentaires.For more granular control, the executable provides a number of additional command line parameters.

ServeurServer

Alors que l’hôte est responsable du démarrage et de gestion des processus dans lequel l’application s’exécute, la responsabilité du serveur pour ouvrir un socket réseau, écouter les demandes et les envoyer via le pipeline de composants OWIN spécifié par l’utilisateur (en tant que vous avez peut-être déjà remarqué, ce pipeline est spécifié dans la classe de démarrage du développeur de l’application).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). Actuellement, le projet Katana comprend deux implémentations de serveur :Currently, the Katana project includes two server implementations:

  • Microsoft.Owin.Host.SystemWeb: Comme mentionné précédemment, IIS conjointement avec les actes de pipeline ASP.NET comme un hôte et un serveur.Microsoft.Owin.Host.SystemWeb: As previously mentioned, IIS in concert with the ASP.NET pipeline acts as both a host and a server. Par conséquent, lors du choix de cette option d’hébergement, IIS à la fois gère les problèmes d’au niveau hôte, tels que l’activation des processus et écoute les requêtes HTTP.Therefore, when choosing this hosting option, IIS both manages host-level concerns such as process activation and listens for HTTP requests. Pour les applications Web ASP.NET, il envoie ensuite les demandes dans le pipeline ASP.NET.For ASP.NET Web applications, it then sends the requests into the ASP.NET pipeline. L’hôte Katana SystemWeb inscrit une ASP.NET HttpModule et un HttpHandler pour intercepter des requêtes car elles circulent dans le pipeline HTTP et les envoyer via le pipeline OWIN spécifié par l’utilisateur.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: Comme son nom l’indique, ce serveur Katana utilise HttpListener (classe) du .NET Framework pour ouvrir un socket et envoyer des demandes dans un pipeline OWIN spécifiés par les développeurs.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. Il s’agit actuellement la sélection de serveur par défaut pour les API d’auto-hébergement Katana et OwinHost.exe.This is currently the default server selection for both the Katana self-host API and OwinHost.exe.

Middleware/frameworkMiddleware/framework

Comme mentionné précédemment, lorsque le serveur accepte une demande d’un client, il est responsable de la transmission via un pipeline de composants OWIN, qui sont spécifiées par le code de démarrage du développeur.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. Ces composants de pipeline sont connus comme intergiciel (middleware).These pipeline components are known as middleware.
À un niveau très fondamental, un composant d’intergiciel (middleware) OWIN doit simplement implémenter le délégué d’application OWIN afin qu’il soit pouvant être appelé.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>

Toutefois, afin de simplifier le développement et la composition des composants d’intergiciel (middleware), Katana prend en charge un certain nombre de conventions et types d’assistance pour les composants d’intergiciel (middleware).However, in order to simplify the development and composition of middleware components, Katana supports a handful of conventions and helper types for middleware components. La plus courante de ces est la OwinMiddleware classe.The most common of these is the OwinMiddleware class. Un composant d’intergiciel (middleware) personnalisé créé à l’aide de cette classe serait similaire à ce qui suit :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");
    }
}

Cette classe est dérivée de OwinMiddleware, implémente un constructeur qui accepte une instance de l’intergiciel suivant dans le pipeline en tant qu’un de ses arguments et puis le passe au constructeur de base.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. Arguments supplémentaires utilisés pour configurer l’intergiciel (middleware) sont également déclarés en tant que paramètres de constructeur après le paramètre d’intergiciel (middleware) suivant.Additional arguments used to configure the middleware are also declared as constructor parameters after the next middleware parameter.

Lors de l’exécution, l’intergiciel (middleware) est exécutée via substituées Invoke (méthode).At runtime, the middleware is executed via the overridden Invoke method. Cette méthode accepte un seul argument de type OwinContext.This method takes a single argument of type OwinContext. Cet objet de contexte est fourni par le Microsoft.Owin package NuGet décrits précédemment et fournit l’accès fortement typé pour le dictionnaire de demande, de réponse et d’environnement, ainsi que de quelques types d’assistance supplémentaires.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.

La classe d’intergiciel (middleware) peut être facilement ajoutée au pipeline OWIN dans le code de démarrage de l’application comme suit :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());

   }
}

Étant donné que l’infrastructure de Katana génère simplement un pipeline de composants d’intergiciel (middleware) OWIN, et étant donné que les composants doivent simplement prendre en charge le délégué d’application pour participer le pipeline, les composants d’intergiciel (middleware) peuvent varier en complexité de simple enregistreurs d’événements à des infrastructures entières comme ASP.NET, API Web, ou SignalR.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. Par exemple, l’ajout d’API Web ASP.NET au pipeline OWIN précédent nécessite l’ajout le code de démarrage suivant :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            
   }
}

L’infrastructure de Katana générera le pipeline de composants d’intergiciel (middleware) selon l’ordre dans lequel ils ont été ajoutés à l’objet d’IAppBuilder dans la méthode de Configuration.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. Puis, dans notre exemple, LoggerMiddleware peut gérer toutes les demandes qui transitent par le pipeline, quelle que soit la façon dont ces demandes sont finalement gérées.In our example, then, LoggerMiddleware can handle all requests that flow through the pipeline, regardless of how those requests are ultimately handled. Cela permet des scénarios puissants où un composant d’intergiciel (middleware) (par exemple, un composant d’authentification) peut traiter les demandes d’un pipeline qui comprend plusieurs composants et frameworks (par exemple, API Web ASP.NET SignalR et un serveur de fichiers statiques).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).

ApplicationsApplications

Comme illustré dans les exemples précédents, OWIN et le projet Katana ne doivent pas être considérés comme un nouveau modèle de programmation d’application, mais plutôt comme une abstraction de dissocier les modèles de programmation d’application et les infrastructures de serveur et l’infrastructure d’hébergement.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. Par exemple, lorsque vous générez des applications API Web, le framework developer continue à utiliser l’infrastructure API Web ASP.NET, quel que soit ou non, l’application s’exécute dans un pipeline OWIN à l’aide de composants à partir du projet Katana.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. L’endroit où code lié à OWIN seront visible par le développeur d’applications sera le code de démarrage d’application, où le développeur compose le pipeline OWIN.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. Dans le code de démarrage, le développeur inscrira une série d’instructions UseXx, généralement un pour chaque composant d’intergiciel (middleware) qui traitera les demandes entrantes.In the startup code, the developer will register a series of UseXx statements, generally one for each middleware component that will process incoming requests. Cette expérience aura le même effet que l’enregistrement des modules HTTP dans le monde actuel de System.Web.This experience will have the same effect as registering HTTP modules in the current System.Web world. En règle générale, une plus grande infrastructure intergiciel (middleware), telles que les API Web ASP.NET ou SignalR sera inscrit à la fin du pipeline.Typically, a larger framework middleware, such as ASP.NET Web API or SignalR will be registered at the end of the pipeline. Composants d’intergiciel transversales, telles que celles pour l’authentification ou la mise en cache, sont généralement enregistrés vers le début du pipeline afin qu’ils traitent les demandes pour toutes les infrastructures et les composants enregistrés ultérieurement dans le pipeline.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. Cette séparation des composants d’intergiciel (middleware) de l’autre et à partir des composants d’infrastructure sous-jacent permet aux composants d’évoluer à des vitesses élevées différents tout en garantissant que l’ensemble du système reste stable.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.

Composants : les Packages NuGetComponents – NuGet Packages

Comme de nombreuses bibliothèques actuels et infrastructures, les composants du projet Katana sont fournies sous la forme d’un ensemble de packages NuGet.Like many current libraries and frameworks, the Katana project components are delivered as a set of NuGet packages. Pour la prochaine version 2.0, le graphique de dépendance de package Katana se présente comme suit.For the upcoming version 2.0, the Katana package dependency graph looks as follows. (Cliquez sur l’image pour l’agrandir.)(Click on image for larger view.)

Presque chaque package dans le projet Katana dépend, directement ou indirectement, le package Owin.Nearly every package in the Katana project depends, directly or indirectly, on the Owin package. Vous vous souvenez peut-être qu’il s’agit du package qui contient l’interface IAppBuilder, qui fournit une implémentation concrète de la séquence de démarrage d’application décrite dans la section 4 de la spécification OWIN.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. En outre, la plupart des packages dépendent de Microsoft.Owin, qui fournit un ensemble de types d’assistance pour l’utilisation des requêtes et réponses HTTP.Additionally, many of the packages depend on Microsoft.Owin, which provides a set of helper types for working with HTTP requests and responses. Le reste du package peut être classé en tant que packages infrastructure (serveurs ou hôtes) hébergement ou intergiciel (middleware).The remainder of the package can be classified as either hosting infrastructure packages (servers or hosts) or middleware. Packages et dépendances externes au projet Katana sont affichés en orange.Packages and dependencies that are external to the Katana project are displayed in orange.

L’infrastructure d’hébergement pour Katana 2.0 inclut le SystemWeb et serveurs HttpListener, le package OwinHost pour exécuter des applications OWIN à l’aide de OwinHost.exe et le package Microsoft.Owin.Hosting pour l’hébergement automatique des applications OWIN dans un hôte personnalisé (par exemple, application console, service de Windows, etc.)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, les composants d’intergiciel (middleware) sont principalement destinés à fournir différents moyens d’authentification.For Katana 2.0, the middleware components are primarily focused on providing different means of authentication. Un composant d’intergiciel (middleware) supplémentaires pour les diagnostics est fourni, ce qui permet la prise en charge pour une page de démarrage et d’erreur.One additional middleware component for diagnostics is provided, which enables support for a start and error page. Que OWIN augmente dans l’abstraction d’hébergement de fait, l’écosystème de composants d’intergiciel (middleware), c'est-à-dire ceux développés par Microsoft et tiers, également croître dans le nombre.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.

ConclusionConclusion

À partir de son début, les objectifs du projet Katana n’a pas été de créer et de forcer ainsi aux développeurs pour en savoir encore une autre infrastructure Web.From its beginning, the Katana project's goal has not been to create and thereby force developers to learn yet another Web framework. Au lieu de cela, l’objectif a été de créer une abstraction pour donner aux développeurs d’applications Web .NET plus de choix qu’il a précédemment été possible.Rather, the goal has been to create an abstraction to give .NET Web application developers more choice than has previously been possible. En décomposant les couches logiques d’une pile d’applications Web typique dans un ensemble de composants remplaçables, le projet Katana permet aux composants dans toute la pile pour améliorer à quel que soit le taux de sens pour ces composants.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. En créant tous les composants de l’abstraction OWIN simple, Katana permet d’infrastructures et les applications reposant sur les soit portable sur une variété de différents serveurs et ordinateurs hôtes.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. En plaçant le développeur dans le contrôle de la pile, Katana permet de s’assurer que le développeur fait le choix ultimate sur comment léger ou comment riche sa pile Web doit correspondre.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.

Pour plus d’informations sur KatanaFor more information about Katana

RemerciementsAcknowledgements