Wykrywanie klasy początkowej interfejsu OWIN

Artykuł
07/13/2023

W tym samouczku pokazano, jak skonfigurować, która klasa uruchamiania OWIN jest ładowana. Aby uzyskać więcej informacji na temat OWIN, zobacz Omówienie projektu Katana. Ten samouczek został napisany przez Ricka Andersona ( @RickAndMSFT ), Praburaj Thiagarajan i Howarda Dierkinga ( @howard_dierking ).

Wymagania wstępne

Visual Studio 2017

Wykrywanie klasy początkowej interfejsu OWIN

Każda aplikacja OWIN ma klasę uruchamiania, w której określasz składniki potoku aplikacji. Istnieją różne sposoby łączenia klasy startowej ze środowiskiem uruchomieniowym, w zależności od wybranego modelu hostingu (OwinHost, IIS i IIS-Express). Klasa uruchamiania pokazana w tym samouczku może być używana w każdej aplikacji hostingowej. Klasę uruchamiania można połączyć ze środowiskiem uruchomieniowym hostingu przy użyciu jednej z następujących metod:

Konwencja nazewnictwa: Katana szuka klasy o nazwie Startup w przestrzeni nazw zgodnej z nazwą zestawu lub globalną przestrzenią nazw.
OwinStartup Attribute: jest to podejście, które większość deweloperów podejmie, aby określić klasę uruchamiania. Następujący atrybut ustawi klasę uruchamiania na klasę TestStartupStartupDemo w przestrzeni nazw.
```
[assembly: OwinStartup(typeof(StartupDemo.TestStartup))]
```
Atrybut OwinStartup zastępuje konwencję nazewnictwa. Można również określić przyjazną nazwę za pomocą tego atrybutu, jednak użycie przyjaznej nazwy wymaga również użycia appSetting elementu w pliku konfiguracji.

Element appSetting w pliku konfiguracji: appSetting element zastępuje konwencję atrybutu OwinStartup i nazewnictwa. Można mieć wiele klas uruchamiania (z których każda używa atrybutu OwinStartup ) i skonfigurować, która klasa uruchamiania zostanie załadowana w pliku konfiguracji przy użyciu znaczników podobnych do następujących:

<appSettings>  
  <add key="owin:appStartup" value="StartupDemo.ProductionStartup" />
</appSettings>

Poniższy klucz, który jawnie określa klasę uruchamiania i zestaw można również użyć:

<add key="owin:appStartup" value="StartupDemo.ProductionStartup, StartupDemo" />

Poniższy kod XML w pliku konfiguracji określa przyjazną nazwę klasy uruchamiania .ProductionConfiguration

<appSettings>  
  <add key="owin:appStartup" value="ProductionConfiguration" />       
</appSettings>

Powyższy znacznik musi być używany z następującym OwinStartup atrybutem, który określa przyjazną nazwę i powoduje ProductionStartup2 uruchomienie klasy.

[assembly: OwinStartup("ProductionConfiguration", typeof(StartupDemo.ProductionStartup2))]

namespace StartupDemo
{
    public class ProductionStartup
    {
        public void Configuration(IAppBuilder app)
        {
            app.Run(context =>
            {
                string t = DateTime.Now.Millisecond.ToString();
                return context.Response.WriteAsync(t + " Production OWIN App");
            });
        }
    }
    public class ProductionStartup2
    {
        public void Configuration(IAppBuilder app)
        {
            app.Run(context =>
            {
                string t = DateTime.Now.Millisecond.ToString();
                return context.Response.WriteAsync(t + " 2nd Production OWIN App");
            });
        }
    }
}

Aby wyłączyć odnajdywanie uruchamiania OWIN, dodaj appSetting owin:AutomaticAppStartup element z wartością "false" w pliku web.config.
```
<add key="owin:AutomaticAppStartup" value="false" />
```

Tworzenie aplikacji internetowej ASP.NET przy użyciu uruchamiania OWIN

Utwórz pustą aplikację internetową Asp.Net i nadaj jej nazwę StartupDemo. — Zainstaluj Microsoft.Owin.Host.SystemWeb przy użyciu menedżera pakietów NuGet. Z menu Narzędzia wybierz pozycję Menedżer pakietów NuGet, a następnie pozycję Konsola menedżera pakietów. Wprowadź następujące polecenie:
```
Install-Package Microsoft.Owin.Host.SystemWeb
```
Dodaj klasę uruchamiania OWIN. W programie Visual Studio 2017 kliknij prawym przyciskiem myszy projekt i wybierz polecenie Dodaj klasę. W oknie dialogowym Dodawanie nowego elementu wprowadź wartość OWIN w polu wyszukiwania i zmień nazwę na Startup.cs, a następnie wybierz pozycję Dodaj.

Przy następnym dodaniu klasy startowej Owin będzie ona dostępna z menu Dodaj .

Alternatywnie możesz kliknąć projekt prawym przyciskiem myszy i wybrać polecenie Dodaj, a następnie wybrać pozycję Nowy element, a następnie wybrać klasę startową Owin.

Zastąp wygenerowany kod w pliku Startup.cs następującym kodem:
```
using System;
using System.Threading.Tasks;
using Microsoft.Owin;
using Owin;
using System.IO;

//[assembly: OwinStartup(typeof(StartupDemo.Startup))]

namespace StartupDemo
{
   public class Startup
   {
      public void Configuration(IAppBuilder app)
      {
         app.Use((context, next) =>
         {
            TextWriter output = context.Get<TextWriter>("host.TraceOutput");
            return next().ContinueWith(result =>
            {
               output.WriteLine("Scheme {0} : Method {1} : Path {2} : MS {3}",
               context.Request.Scheme, context.Request.Method, context.Request.Path, getTime());
            });
         });

         app.Run(async context =>
         {
            await context.Response.WriteAsync(getTime() + " My First OWIN App");
         });
      }

      string getTime()
      {
         return DateTime.Now.Millisecond.ToString();
      }
   }
}
```
Wyrażenie app.Use lambda służy do rejestrowania określonego składnika oprogramowania pośredniczącego w potoku OWIN. W tym przypadku konfigurujemy rejestrowanie żądań przychodzących przed udzieleniem odpowiedzi na żądanie przychodzące. Parametr next jest delegate ( Func<Task> ) do następnego składnika w potoku. Wyrażenie app.Run lambda podłącza potok do żądań przychodzących i udostępnia mechanizm odpowiedzi.

Uwaga

W powyższym kodzie oznaczyliśmy OwinStartup jako komentarz atrybut i polegamy na konwencji uruchamiania klasy o nazwie Startup .- Naciśnij klawisz F5 , aby uruchomić aplikację. Kilka razy naciśnij pozycję Odśwież.

Uwaga: liczba wyświetlana na obrazach w tym samouczku nie będzie zgodna z widoczną liczbą. Ciąg milisekundowy służy do wyświetlania nowej odpowiedzi podczas odświeżania strony. Informacje o śledzeniu są widoczne w oknie Dane wyjściowe .

Dodawanie większej liczby klas uruchamiania

W tej sekcji dodamy kolejną klasę startupu. Do aplikacji można dodać wiele klas startowych OWIN. Możesz na przykład utworzyć klasy uruchamiania na potrzeby programowania, testowania i produkcji.

Utwórz nową klasę startową OWIN i nadaj jej ProductionStartupnazwę .

Zastąp wygenerowany kod następującym kodem:

using System;
using System.Threading.Tasks;
using Microsoft.Owin;
using Owin;

[assembly: OwinStartup(typeof(StartupDemo.ProductionStartup))]

namespace StartupDemo
{
    public class ProductionStartup
    {
        public void Configuration(IAppBuilder app)
        {
            app.Run(context =>
            {
                string t = DateTime.Now.Millisecond.ToString();
                return context.Response.WriteAsync(t + " Production OWIN App");
            });
        }
    }
}

Naciśnij klawisz Control F5, aby uruchomić aplikację. Atrybut OwinStartup określa, że jest uruchamiana klasa uruchamiania produkcyjnego.
Utwórz inną klasę początkową OWIN i nadaj jej TestStartupnazwę .

Zastąp wygenerowany kod następującym kodem:

using System;
using System.Threading.Tasks;
using Microsoft.Owin;
using Owin;

[assembly: OwinStartup("TestingConfiguration", typeof(StartupDemo.TestStartup))]

namespace StartupDemo
{
    public class TestStartup
    {
        public void Configuration(IAppBuilder app)
        {
            app.Run(context =>
            {
                string t = DateTime.Now.Millisecond.ToString();
                return context.Response.WriteAsync(t + " Test OWIN App");
            });
        }
    }
}

Przeciążenie OwinStartup atrybutu powyżej określa TestingConfiguration jako przyjazną nazwę klasy Startup.

Otwórz plik web.config i dodaj klucz uruchamiania aplikacji OWIN, który określa przyjazną nazwę klasy Startup:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="owin:appStartup" value="TestingConfiguration" />
  </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5" />
    <httpRuntime targetFramework="4.5" />
  </system.web>
</configuration>

Naciśnij klawisz Control F5, aby uruchomić aplikację. Element ustawień aplikacji ma precedens, a konfiguracja testu jest uruchamiana.
Usuń przyjazną nazwę z atrybutu OwinStartupTestStartup w klasie.
```
[assembly: OwinStartup(typeof(StartupDemo.TestStartup))]
```
Zastąp klucz uruchamiania aplikacji OWIN w pliku web.config następującym kodem:
```
<add key="owin:appStartup" value="StartupDemo.TestStartup" />
```

OwinStartup Przywróć atrybut w każdej klasie do domyślnego kodu atrybutu wygenerowanego przez program Visual Studio:

[assembly: OwinStartup(typeof(StartupDemo.Startup))]
[assembly: OwinStartup(typeof(StartupDemo.ProductionStartup))]
[assembly: OwinStartup(typeof(StartupDemo.TestStartup))]

Każdy z poniższych kluczy uruchamiania aplikacji OWIN spowoduje uruchomienie klasy produkcyjnej.

<add key="owin:appStartup" value="StartupDemo.ProductionStartup" />
<add key="owin:appStartup" value="StartupDemo.ProductionStartup, StartupDemo" />
<add key="owin:appStartup" value="StartupDemo.ProductionStartup.Configuration, StartupDemo" />

Ostatni klucz uruchamiania określa metodę konfiguracji uruchamiania. Poniższy klucz uruchamiania aplikacji OWIN umożliwia zmianę nazwy klasy konfiguracji na MyConfiguration .

<add key="owin:appStartup" value="StartupDemo.ProductionStartup2.MyConfiguration" />

Korzystanie z Owinhost.exe

Zastąp plik Web.config następującym znacznikiem:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
   <appSettings>
      <add key="owin:appStartup" value="StartupDemo.Startup" />
      <add key="owin:appStartup" value="StartupDemo.TestStartup" />
   </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5" />
    <httpRuntime targetFramework="4.5" />
  </system.web>
</configuration>

Ostatni klucz wygrywa, więc w tym przypadku TestStartup jest określony.

Zainstaluj platformę Owinhost z poziomu kontrolera PMC:
```
Install-Package OwinHost
```

Przejdź do folderu aplikacji (folderu zawierającego plik Web.config ) i w wierszu polecenia i wpisz:

..\packages\Owinhost<Version>\tools\Owinhost.exe

Zostanie wyświetlone okno polecenia:

C:\StartupDemo\StartupDemo>..\packages\OwinHost.2.0.0\tools\Owin
Host.exe
Starting with the default port: 5000 (http://localhost:5000/)
Started successfully
Press Enter to exit

Uruchom przeglądarkę z adresem URL http://localhost:5000/.

OwinHost honorował konwencje uruchamiania wymienione powyżej.
W oknie polecenia naciśnij klawisz Enter, aby zamknąć OwinHost.
ProductionStartup W klasie dodaj następujący atrybut OwinStartup, który określa przyjazną nazwę ProductionConfiguration.
```
[assembly: OwinStartup("ProductionConfiguration", 
           typeof(StartupDemo.ProductionStartup))]
```
W wierszu polecenia i wpisz:
```
..\packages\OwinHost.2.0.0\tools\OwinHost.exe ProductionConfiguration
```
Załadowana jest klasa początkowa Production.

Nasza aplikacja ma wiele klas uruchamiania, a w tym przykładzie odroczyliśmy klasę uruchamiania do załadowania do czasu wykonania.

Przetestuj następujące opcje uruchamiania środowiska uruchomieniowego:

..\packages\OwinHost.2.0.0-rc1\tools\OwinHost.exe StartupDemo.TestStartup
..\packages\OwinHost.2.0.0-rc1\tools\OwinHost.exe "StartupDemo.TestStartup,StartupDemo"
..\packages\OwinHost.2.0.0-rc1\tools\OwinHost.exe StartupDemo.TestStartup.Configuration
..\packages\OwinHost.2.0.0-rc1\tools\OwinHost.exe "StartupDemo.TestStartup.Configuration,StartupDemo"

Wykrywanie klasy początkowej interfejsu OWIN

Wymagania wstępne