Co, jednak jeśli twój kod pracuje asynchronicznie. Jak wtedy ustawić te rury LINQ, aby prze-mapować dane lub je przefiltrować. 

Z .NET 6 pojawiła się nowy interfejs "IAsyncEnumerable<T>", które zostały stworzone z myślą o tak zwanych asynchronicznych strumieniach". 

W esencji "IAsyncEnumerable<T>” działa tak samo, jak  IEnumerable<T> tylko każde elementy takiej strumieniowanej kolekcji wychodzą asynchronicznie. Co nie blokuje programu, gdy wyciągniecie każdego elementu ze strumienia może nawet trwać na przykład ponad sekundę.

Postanowiłem odświeżyć wątek asynchronicznego C# ponieważ wierz mi mamy jeszcze wiele tematów do omówienia.  Zobaczmy co potrafi IAsyncEnumerable<T>.

[more]

Dlaczego IAsyncEnumerable, a nie Task<IEnumerable<T>>

Wróćmy do podstaw IEnumerable<T>. Gdy jakaś metoda zwraca IEnumerable<T> to znaczy, że dana sekwencja elementów nie została jeszcze wygenerowana. 

Pętla foreach wyciągnie pojedyncze element z tego interfejsu, a operacja "Count()" wymusi przetworzenia całej kolekcji, gdyż inaczej nie można poznać całkowitej liczby elementów w takiej leniwej kolekcji.

Dodatkowo IEnumerable<T> daje możliwość tworzenia swoich kolekcji, które są wirtualne albo i nie.

Tutaj przykładowo opakowuje tylko listę elementów.

class MyObjects : IEnumerable<MyObject>
{
    List<MyObject> mylist = new List<MyObject>();

    public MyObject this[int index]  
    {  
        get { return mylist[index]; }  
        set { mylist.Insert(index, value); }  
    } 

    public IEnumerator<MyObject> GetEnumerator()
    {
        return mylist.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

Przy użyciu słowa kluczowego yield można tworzyć coś, co ja nazywam wirtualnymi kolekcjami.

Kod pochodzi z mojego starego wpisu.

static public IEnumerable<string> Napisy()
{
    yield return "Ala";
    yield return "ma";
    yield return "radioaktywnego";
    yield return "kota";
    yield return "z";
    yield return "Marsa";
}

static void Main(string[] args)
{
    int i = 0;
    foreach (var item in Napisy())
    {
        i++;
        Console.WriteLine(item);
    }
}

A tutaj przy pomocy słowa kluczowego "yield" tworzę wirtualną kolekcję, która jest nieskończona.

public static class YieldCollections
{
    public static IEnumerable<int> RandomNumberCollection()
    {
    
        while(true)
        {
            Random r = new Random(Guid.NewGuid()
                .GetHashCode());
    
            int number = r.Next();
    
            yield return number;
        }
    }
}

Ten kod pochodzi z tego wpisu.

Wracajmy jednak do naszego głównego tematu. Teraz gdy .NET 6 oferuje nam IAsyncEnumerable rodzi się pytanie, kiedy z niego skorzystać.

Może IAsyncEnumerable powinno zastąpić Task<List<T>> albo Task<IEnumerable<T>>?

A jeśli tak to dlaczego?

Moim zdaniem korzystanie z Task, gdy wykonujesz jakąś operację asynchroniczną per iteracje dla danej kolekcji jest w porządku.

Task też super się spełnia, gdy wiemy, że chcemy zwrócić jakąś kolekcję z góry która powstała w wyniku operacji asynchronicznej. 

Oto przykład takie scenariusza. Pobieramy listę tekstów z danego REST API, który zwróci tę listę tekstów w formacie JSON. Oczywiście ta operacja jest asynchroniczna.

async Task<List<string>> GetTexts()
{
    using var client = new HttpClient();

    var texts = await client.
        GetFromJsonAsync<List<string>>
        ("/api/texts");

    return texts;
}

Oto uruchomienie tej metody

await GetTexts();

IEnumerable<string> wydaje się bezsensowny. Iteracja asynchroniczna oczywiście nie zajdzie. Sam Task powinien nam zwrócić kompletną kolekcję i opakowanie tego w IEnumerable jest tylko iluzją 

async Task<IEnumerable<string>> GetTexts2()
{
    using var client = new HttpClient();
    var ids = new int[] { 11, 22, 33 };
    foreach (var id in ids)
    {
        var text = await client.
        GetFromJsonAsync<string>
            ($"/api/customers?id={id}");

        yield return text;
    }
}

Na szczęście zachowanie leniwego pobierania danych asynchronicznie można osiągnąć w takim sposób.

async IAsyncEnumerable<string> GetTexts3()
{
    using var client = new HttpClient();

    var ids = new int[] { 11, 22, 33, 44,
        55, 66, 77 ,88, 99 };

    foreach (var id in ids)
    {
        var text = await client.
            GetFromJsonAsync<string>
            ($"/api/texts?id={id}");

        yield return text;
    }
}

Jak każdą technikę asynchroniczną tak i IAsyncEnumerable można zepsuć. Ten przykład poniżej jest jeszcze okej. Co, jeśli jednak "nazwa gry" nie przekazywana, a jest wynikiem działania jeszcze innej metody asynchronicznej. 

async IAsyncEnumerable<string> GetTexts4(string game)
{
    using var client = new HttpClient();

    var ids = new int[] { 11, 22, 33 };

    foreach (var id in ids)
    {
        var text = await client.
            GetFromJsonAsync<string>
            ($"/api/texts?id={id}&game={game}");

        yield return text;
    }
}

Oto przykład takiej metody asynchronicznej.

async Task<string> GetGame()
{
    await Task.Delay(4000);
    return "Mortal Kombat 2";
}

Jak to można zrobić źle? Opakowanie IAsyncEnumerable w Task psuje cały mechanizm strumieniowania.

//BAD IDEA
async Task<IAsyncEnumerable<string>> GetTextsFromGame()
{
    var game = await GetGame();
    return GetTexts4(game);
}

Lepiej jest to zrobić tak. Pobrać asynchronicznie wszystkie potrzebne parametry, a potem zrobić await foreach.

//GOOD IDEA
async IAsyncEnumerable<string> GetTexts5()
{
    var game = await GetGame();
    await foreach (var c in GetTexts4(game))
    {
        yield return c;
    }
}

W ten sposób możemy skorzystać z "IAsyncEnumerable"

IAsyncEnumerable, a LINQ

Używanie LINQ na leniwych kolekcjach strumieniowych jest miejscami dziwne. Zobaczmy, o co chodzi. Oto przykład metody, która zwróci mi listę folderów.

async IAsyncEnumerable<string> GetFolders()
{
    List<string> folders = new List<string>()
    {
        @"D:\__zdjecia",
        @"D:\_smieciedoanalizy",
        @"D:\----------------",
        @"D:\00",
        @"D:\0Prezentacja",
        @"D:\Camera",
    };

    foreach (var item in folders)
    {
        await Task.Delay(4000);
        yield return item;
    }
}

Oto inna metoda, która zwróci mi listę informacji o plikach w danym folderze.

async IAsyncEnumerable<FileInfo> GetFilesInfoAsync(string folder)
{
    var directory = new DirectoryInfo(folder);

    foreach (var item in directory.
           GetFiles("*", SearchOption.TopDirectoryOnly))
    {
        await Task.Delay(100);
        yield return item;
    }

}

Oto podobna metoda do poprzedniej ta tylko zwraca Taska, a nie IAsyncEnumerable.

async Task<FileInfo[]> GetFilesInfoTaskAsync(string folder)
{
    await Task.Delay(100);
    var directory = new DirectoryInfo(folder);

    return directory.
           GetFiles("*", SearchOption.TopDirectoryOnly);
}

Stworzyłem też proste metody, które sprawdzają, czy dany plik jest podejrzany. Jedna metoda jest asynchroniczna, a druga nie 

async Task<bool> IsSusAsync(FileInfo file)
{
    await Task.Delay(2000);
    Random r = new Random();

    return r.Next(1, 10) > 8;
}

bool IsSus(FileInfo file)
{
    Random r = new Random();

    return r.Next(1, 10) > 8;
}

Całą kolekcję IAsyncEnumerable można w każdej chwili zamienić na listę korzystając z ToListAsync().

List<string> foldersExampleLinqAsync = await GetFolders().ToListAsync();

Alternatywnie można zawsze stworzyć swoją listę używając "await foreach".

List<string> folders = new List<string>();
await foreach (var folder in GetFolders())
{
    folders.Add(folder);
}

To jak to działa z LINQ. Mamy Select z Select, które wyciągają dane ze dwóch strumieni. 

var collection1_1 = GetFolders()
                    .Select(f => GetFilesInfoAsync(f))
                    .Select(f => f.Where(file => IsSus(file)));

Taki kod jest poprawny i LINQ takie, jakie jest da sobie radę. W końcu select z select robi dwie pętle await foreach pod stołem.

await foreach(var fileinfos in collection1_1)
{
    await foreach(var item in fileinfos)
    {
        Console.WriteLine(item.Name);
        Console.Write($" -> {item.Length}\n");
    }

}

Taki kod jest nadal w porządku.

var collection1_2 = folders
                    .Select(f => GetFilesInfoAsync(f))
                    .Select
                    (files => files.Select
                    (file =>
                        new
                        {
                            IsSus = IsSus(file),
                            Name = file.Name,
                            FullName = file.FullName,
                            Lenght = file.Length,
                        }
                    ));

Czy tu będą problemy? W końcu wewnątrz SELECT-a robimy tym razem operację sprawdzania pliku asynchronicznie. 

var collection2_2 = folders
                    .Select(f => GetFilesInfoAsync(f))
                    .Select
                    (files => files.Select
                    (async file =>
                        new
                        {
                            IsSus = await IsSusAsync(file),
                            Name = file.Name,
                            FullName = file.FullName,
                            Lenght = file.Length,
                        }
                    ));

Taki kod spokojnie się skompiluje i zadziała. 

Problemy zaczynają się, gdy próbujemy tę asynchroniczną metodę wykonać wewnątrz wyrażenia Where.

var collection2_1 = folders
                    .Select(f => GetFilesInfoAsync(f))
                    .Select(f =>
                    f.Where(async file => await IsSusAsync(file)));

Co wtedy nam pozostaje? Zamienić metodę asynchroniczną na synchroniczną blokującą poprzez właściwość Result. W akcje desperacji możemy się podjąć takiej akcji.

var collection2_1_1 = folders
                    .Select(f => GetFilesInfoAsync(f))
                    .Select(f => f.Where(file => IsSusAsync(file).Result));

var collection2_2_1 = folders
                    .Select(f => new DirectoryInfo(f).
                    GetFiles("*", SearchOption.TopDirectoryOnly))
                    .Select
                    (files => files.Select
                    (file => 
                        new 
                        {
                            IsSus = IsSusAsync(file).Result,
                            Name = file.Name,
                            FullName = file.FullName,
                            Lenght = file.Length,
                        }
                    ));

A jak to możemy zrobić lepiej? Wypadałoby napisać swoją metodę WhereAwait(), która by nie miała problemów z operacjami "async i await" wewnątrz wyrażenia lambda

Tylko po co coś takiego pisać, gdy zapewne jest na to paczka NuGet.

Oto przykład działania metody WhereAwait(). Dzięki niej cała ta operacja nadal jest asynchronicznym strumieniem.

IAsyncEnumerable<string> folders = GetFolders();

var collection3_1 = folders
                    .Select( f => GetFilesInfoAsync(f))
                    .Select(f => f.WhereAwait
                    (async file => await IsSusAsync(file)));

await foreach (var fileinfos in collection3_1)
{
    await foreach (var item in fileinfos)
    {
        Console.WriteLine(item.Name);
        Console.Write($" -> {item.Length}\n");
    }
}

Paczka ta także oferuję metodę SelectAwait. Ona na tym etapie skrystalizuje nas asynchroniczny strumień.

var collection3_2 = folders
                    .SelectAwait(async f => await GetFilesInfoAsync2(f))
                    .Select(f => f.WhereAwait
                    (async file => await IsSusAsync(file)));

Ta sama paczka NuGet ma metodę "ToAsyncEnumerable()" , która potrafi zamieniać normalne listy na kolekcję IAsyncEnumerable. 

Kiedy taka konwersja ma sens, o tym w następnym przykładzie.

var collection3_3 = folders
                    .SelectAwait(async f => await GetFilesInfoAsync2(f))
                    .Select(f => f.ToAsyncEnumerable().WhereAwait
                    (async file => await IsSusAsync(file)));

Asynchronicznie sekwencyjnie, asynchronicznie współbieżnie

Do następnego przykładu stworzyłem sobie listę stron internetowych. 

var urls = new List<string>()
{
    "https://cezarywalenciuk.pl/",
    "https://docs.microsoft.com/pl-pl/aspnet/core/blazor/",
    "https://angular.io/",
    "https://pl.reactjs.org/",
    "https://vuejs.org/",
    "https://svelte.dev/",
    "https://www.javascript.com/",
    "https://www.youtube.com/",
    "https://azure.microsoft.com/",
    "https://www.amazon.pl/",
    "https://zetcode.com/csharp/httpclient/",
    "https://stackoverflow.com/questions/55686928/using-stopwatch-in-c-sharp",
    "https://www.programmingwithwolfgang.com/replace-rabbitmq-azure-service-bus-queue/",
    "https://medium.com/dotnet-hub/use-azure-key-vault-with-net-or-asp-net-core-applications-read-azure-key-vault-secret-in-dotnet-fca293e9fbb3",
    "https://www.elastic.co/guide/en/elasticsearch/client/net-api/current/attribute-mapping.html",
    "https://www.nuget.org/packages/System.Linq.Async",
    "https://github.com/dotnet/reactive",
    "https://www.udemy.com/",
    "https://jquery.com/",
    "https://www.php.net/",
    "https://www.python.org/",
    "https://go.dev/",
    "https://docs.microsoft.com/pl-pl/dotnet/csharp/"

};

Moim zadaniem jest pobrać zawartość każdej strony internetowej z tej listy po to, aby mógł sprawdzić potem, czy te strony internetowe zawierają słowo podane przez użytkownika.

Oto rozwiązania numer 1 przy użyciu IAsyncEnumerable. Jak widzisz w tym przypadku użycie "ToAsyncEnumerable()" ma sens. Przy pomocy tej metody z Linq.Async zamieniam listę stron na asynchroniczny strumień, którego każdy elementy będzie wykonywał metodę GetStringAsync z klasy HttpClient.

async Task SolutionOne()
{
    using var client = new HttpClient();
    Console.WriteLine();
    Console.WriteLine("Wpisz szukane słowo");
    var word = Console.ReadLine();
    if (string.IsNullOrEmpty(word))
        return;

    var timer = new Stopwatch(); timer.Start();

    var results = urls.ToAsyncEnumerable()
            .SelectAwait(async url =>
                new {
                    Url = url,
                    Html = await client.GetStringAsync(url)
                })
            .Where(x => x.Html.Contains(word));


    await foreach (var result in results)
    {
        Console.ForegroundColor = ConsoleColor.Cyan;
        Console.WriteLine($"Znalezione {result.Url}");
        Console.ResetColor();
    }

    timer.Stop();
    Console.WriteLine(timer.ElapsedMilliseconds);
}

Jaki jest problem z tym rozwiązaniem. Specjalnie napisałem taki przykłady, aby pokazać, że IAsyncEnumerable nie w każdym scenariuszu jest użyteczne.

Strumień IAsyncEnumerable jest sekwencyjni. Znaczy to, że każda operacja asynchroniczna zapisana w taki sposób czeka na poprzednią.

Być może gdybyśmy szukali pierwszej lepszej strony internetowej gdzie pada dane słowo wtedy takie rozwiązanie miało sens. Przerywalibyśmy wtedy sekwencje.

My jednak wiemy, że pobierzemy zawsze wszystkie strony internetowe. Jeśli zależy nam na prędkości rozwiązania to oczywiście te strony chcemy pobrać współbieżnie, czyli równocześnie.

Oto przykład rozwiązania tego samego zadania, ale przy użyciu Task.WhenAll 

//Przetwarzanie sekwencji równolegle
async Task SolutionTwo()
{
    using var client = new HttpClient();
    Console.WriteLine();
    Console.WriteLine("Wpisz szukane słowo");
    var word = Console.ReadLine();
    if (string.IsNullOrEmpty(word))
    return;

    var tasks = urls
        .Select(async url => new
        {
            Url = url,
            Html = await client.GetStringAsync(url)
        });

    var timer = new Stopwatch(); timer.Start();

    var results2 = await Task.WhenAll(tasks);

    foreach (var result in results2.Where(x => 
        x.Html.Contains(word)))
    {
        Console.ForegroundColor = ConsoleColor.Cyan;
        Console.WriteLine($"Znalezione {result.Url}");
        Console.ResetColor();
    }

    timer.Stop();
    Console.WriteLine(timer.ElapsedMilliseconds);

}

Alternatywnie możemy skorzystać z ForEachAsync.

//Równolegle
async Task SolutionThree()
{
    using var client = new HttpClient();
    Console.WriteLine();
    Console.WriteLine("Wpisz szukane słowo");
    var word = Console.ReadLine();
    if (string.IsNullOrEmpty(word))
        return;

    var parallelOptions = new ParallelOptions() 
    { MaxDegreeOfParallelism = 4 };

    var timer = new Stopwatch(); timer.Start();

    await Parallel.ForEachAsync(urls, parallelOptions,
                async (url, ct) 
                => await FindMatch(url, word, client));

    timer.Stop();
    Console.WriteLine(timer.ElapsedMilliseconds);
}

async Task FindMatch(string url, string searchTerm, HttpClient client)
{
    var html = await client.GetStringAsync(url);
    if (html.Contains(searchTerm))
    {
        Console.ForegroundColor = ConsoleColor.Cyan;
        Console.WriteLine($"Znalezione {url}");
        Console.ResetColor();
    }
}

Co jest najszybsze? Na pewno nie "IAsyncEnumerable" po jest ono sekwencyjnie. 

Zostają więc dwaj kandydaci Task.WhenAll i Parallel.ForEachAsync. 

while (true)
{
    var options = Console.ReadKey();

    if (options.KeyChar == '1')
        await SolutionOne();
    else if (options.KeyChar == '2')
        await SolutionTwo();
    else if (options.KeyChar == '3')
        await SolutionThree();
}

W moich testach wychodzi, że to Task.WhenAll jest szybsze. Jednakże warto zaznaczyć, że operacja pobierania strony nie jest operacją deterministyczną i z różnych losowych przyczyn może ona raz zadziałać szybciej lub wolniej.

To wszystko, co musisz wiedzieć na temat IAsyncEnumerable.

Jeśli interesuje Cię ta część to proszę spójrz na ten wpis.

Nasz projekt wygląda tak:[more]

Teraz zobaczymy jak obsłużyć REST API z JWT służące nam do uwierzytelnienia w aplikacji Blazor. 

Jakie paczki NuGet ?

Od czego tutaj zacząć ? Otóż do nowego projektu trzeba dodać pewne paczki NuGet.

Na pewno będziemy potrzebowali paczki, która będzie nam deserializowała JSON z odpowiedzi HTTP. Klasy, które później wygenerujemy będą korzystać z tej paczki

Będziemy także potrzebować paczki "Microsoft.Extensions.Http", aby mieć większą kontrolę nad tworzeniem klasy HTTPClient.

Skoro używamy autoryzacji to potrzebujemy paczki "Microsoft.AspNetCore.Authorization", która została stworzona z myślą o Blazor.

Przejdźmy do naszych klas modeli.

ViewModels i Mapowanie

Jak pamiętasz z poprzedniego przykładu nasze REST API nie jest bogate w klasy. To dobrze, ponieważ nie musimy do nich tworzyć klasy "ViewModel".

O co chodzi? Otóż, aby moje projekty były bardziej elastyczne i niezależne od siebie to chce, aby każda obiekt, który wyjdzie z jako odpowiedź z REST API miał swoją klasę przeznaczoną do wyświetlania tych danych tylko po stronie widoku.

Jeśli coś zmienię w REST API np. definicję Warrior to szanse, że coś mi eksploduje po stronie UI Blazor będą dużo bardziej zmniejszone.

Oto wszystkie nasze ViewModele. Jak widzisz po stronie widoku będę chciał wyświetlić Użytkownika, przekazać dane do logowania oraz wyświetlić moich wojowników.

public class LoginBlazorVM
{
    public string Email { get; set; }
    public string Password { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Token { get; set; }
}

public class WarriorViewModel
{
    public string Name { get; set; }
    public string ImageUrl { get; set; }
    public int Age { get; set; }
}

Projekt jest mały, ale możemy skorzystać z AutoMapper, który automatycznie nam z mapuje nam obiekty klas, które wyjdą z REST API na nasze ViewModele.

Więcej o AutoMapper pisałem tutaj

Instalujemy odpowiednie paczki NuGet

Tworzymy definicję mapowania naszego wojownika w obie strony.

public MappingProfile()
{
    CreateMap<WarriorViewModel, Warrior>().ReverseMap();
}

A na końcu do klasy Program.cs dodajemy rejestracje naszego AutoMappera.

public static async Task Main(string[] args)
{
    var builder = WebAssemblyHostBuilder.CreateDefault(args);
    builder.RootComponents.Add<App>("#app");
    
    //builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
    builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());

Teraz gdy to mamy możemy przejść do najtrudniejszej części. Czyli do tego, jak te dane będziemy pobierać z REST API.

A może tak wygenerować sobie metody do HTTPClient

Gdy pisałem ten projekt na potrzeby prelekcji na Warszawskie Dni Informatyki naprawdę nie chciało mi się ręcznie pisać wywołań HTTPClinet do mojego REST API w aplikacji Blazor.

Na szczęście możemy wygenerować taki kod, ponieważ nasze REST API używa Swagger do dokumentacji i testu.

Na pomoc przychodzi NSwag narzędzie, które pozwoli nam wygenerować API 

Instalator do tego programu znajdziesz tutaj : https://github.com/RicoSuter/NSwag/wiki/NSwagStudio

Korzystanie z tego narzędzia jest bardzo proste. Podaje w odpowiednim miejscu definicję JSON swojego Swaggera, a po drugiej stronie mogę zobaczyć wygenerowane wywołanie HTTPClient do tych metod w moim REST API

Wygenerowana klasa jednak nie wyręcza mnie we wszystkim. Muszę ją trochę przerobić, aby JSON WEB Tokeny działały. Tego fragmentu kodu nie jestem w stanie wygenerować.

Do wygenerowanego interfejsu  IClient muszę dodać właściwość, która wystawi mi do użytku instancje HttpClienta

public partial interface IClient
{
    System.Net.Http.HttpClient HttpClient { get; }

...

Potem w wygenerowanej klasie muszę w konstruktorze dodać wstrzyknięcie tego HTTPClienta tak, aby miał nad nim większą kontrolę. To jest moja modyfikacja wygenerowanego kodu.

public partial class Client : IClient
{
    private string _baseUrl = "";
    private System.Net.Http.HttpClient _httpClient;
    private System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings;
    
    public Client(string baseUrl, System.Net.Http.HttpClient httpClient)
    {
        BaseUrl = baseUrl; 
        _httpClient = httpClient; 
        _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings);
    }

Dodatkowo z konstruktora wywalam baseUrl, gdyż tak naprawdę utrudnia mi to operację wstrzykiwania zależności. 

[System.CodeDom.Compiler.GeneratedCode("NSwag", "13.10.8.0 (NJsonSchema v10.3.11.0 (Newtonsoft.Json v12.0.0.0))")]
public partial class Client : IClient
{
    private string _baseUrl = "";
    private System.Net.Http.HttpClient _httpClient;
    private System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings;
    
    public Client(System.Net.Http.HttpClient httpClient)
    {
    
        _httpClient = httpClient;
        _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings);
    }

Cały wygenerowany kod wygląda tak.

namespace Samurai.UI.Services
{
    using System = global::System;

    [System.CodeDom.Compiler.GeneratedCode("NSwag", "13.10.8.0 (NJsonSchema v10.3.11.0 (Newtonsoft.Json v12.0.0.0))")]
    public partial interface IClient
    {
        System.Net.Http.HttpClient HttpClient { get; }

        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<AuthenticationResponse> AuthenticateAsync(AuthenticationRequest body);

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<AuthenticationResponse> AuthenticateAsync(AuthenticationRequest body, System.Threading.CancellationToken cancellationToken);

        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<RegistrationResponse> RegisterAsync(RegistrationRequest body);

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<RegistrationResponse> RegisterAsync(RegistrationRequest body, System.Threading.CancellationToken cancellationToken);

        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Warrior>> GetAllSamuraisAsync();

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Warrior>> GetAllSamuraisAsync(System.Threading.CancellationToken cancellationToken);

    }

    [System.CodeDom.Compiler.GeneratedCode("NSwag", "13.10.8.0 (NJsonSchema v10.3.11.0 (Newtonsoft.Json v12.0.0.0))")]
    public partial class Client : IClient
    {
        private string _baseUrl = "";
        private System.Net.Http.HttpClient _httpClient;
        private System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings;

        public Client(System.Net.Http.HttpClient httpClient)
        {

            _httpClient = httpClient;
            _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings);
        }
        public System.Net.Http.HttpClient HttpClient
        {
            get { return _httpClient; }
        }

        private Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
        {
            var settings = new Newtonsoft.Json.JsonSerializerSettings();
            UpdateJsonSerializerSettings(settings);
            return settings;
        }

        public string BaseUrl
        {
            get { return _baseUrl; }
            set { _baseUrl = value; }
        }

        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _settings.Value; } }

        partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);


        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public System.Threading.Tasks.Task<AuthenticationResponse> AuthenticateAsync(AuthenticationRequest body)
        {
            return AuthenticateAsync(body, System.Threading.CancellationToken.None);
        }

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public async System.Threading.Tasks.Task<AuthenticationResponse> AuthenticateAsync(AuthenticationRequest body, System.Threading.CancellationToken cancellationToken)
        {
            if (body == null)
                throw new System.ArgumentNullException("body");

            var urlBuilder_ = new System.Text.StringBuilder();
            urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Login/authenticate");

            var client_ = _httpClient;
            var disposeClient_ = false;
            try
            {
                using (var request_ = new System.Net.Http.HttpRequestMessage())
                {
                    var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(body, _settings.Value));
                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
                    request_.Content = content_;
                    request_.Method = new System.Net.Http.HttpMethod("POST");
                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));

                    PrepareRequest(client_, request_, urlBuilder_);

                    var url_ = urlBuilder_.ToString();
                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);

                    PrepareRequest(client_, request_, url_);

                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                    var disposeResponse_ = true;
                    try
                    {
                        var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                        if (response_.Content != null && response_.Content.Headers != null)
                        {
                            foreach (var item_ in response_.Content.Headers)
                                headers_[item_.Key] = item_.Value;
                        }

                        ProcessResponse(client_, response_);

                        var status_ = (int)response_.StatusCode;
                        if (status_ == 200)
                        {
                            var objectResponse_ = await ReadObjectResponseAsync<AuthenticationResponse>(response_, headers_, cancellationToken).ConfigureAwait(false);
                            if (objectResponse_.Object == null)
                            {
                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
                            }
                            return objectResponse_.Object;
                        }
                        else
                        {
                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
                        }
                    }
                    finally
                    {
                        if (disposeResponse_)
                            response_.Dispose();
                    }
                }
            }
            finally
            {
                if (disposeClient_)
                    client_.Dispose();
            }
        }

        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public System.Threading.Tasks.Task<RegistrationResponse> RegisterAsync(RegistrationRequest body)
        {
            return RegisterAsync(body, System.Threading.CancellationToken.None);
        }

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public async System.Threading.Tasks.Task<RegistrationResponse> RegisterAsync(RegistrationRequest body, System.Threading.CancellationToken cancellationToken)
        {
            if (body == null)
                throw new System.ArgumentNullException("body");

            var urlBuilder_ = new System.Text.StringBuilder();
            urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Login/register");

            var client_ = _httpClient;
            var disposeClient_ = false;
            try
            {
                using (var request_ = new System.Net.Http.HttpRequestMessage())
                {
                    var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(body, _settings.Value));
                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
                    request_.Content = content_;
                    request_.Method = new System.Net.Http.HttpMethod("POST");
                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));

                    PrepareRequest(client_, request_, urlBuilder_);

                    var url_ = urlBuilder_.ToString();
                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);

                    PrepareRequest(client_, request_, url_);

                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                    var disposeResponse_ = true;
                    try
                    {
                        var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                        if (response_.Content != null && response_.Content.Headers != null)
                        {
                            foreach (var item_ in response_.Content.Headers)
                                headers_[item_.Key] = item_.Value;
                        }

                        ProcessResponse(client_, response_);

                        var status_ = (int)response_.StatusCode;
                        if (status_ == 200)
                        {
                            var objectResponse_ = await ReadObjectResponseAsync<RegistrationResponse>(response_, headers_, cancellationToken).ConfigureAwait(false);
                            if (objectResponse_.Object == null)
                            {
                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
                            }
                            return objectResponse_.Object;
                        }
                        else
                        {
                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
                        }
                    }
                    finally
                    {
                        if (disposeResponse_)
                            response_.Dispose();
                    }
                }
            }
            finally
            {
                if (disposeClient_)
                    client_.Dispose();
            }
        }

        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Warrior>> GetAllSamuraisAsync()
        {
            return GetAllSamuraisAsync(System.Threading.CancellationToken.None);
        }

        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>Success</returns>
        /// <exception cref="ApiException">A server side error occurred.</exception>
        public async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Warrior>> GetAllSamuraisAsync(System.Threading.CancellationToken cancellationToken)
        {
            var urlBuilder_ = new System.Text.StringBuilder();
            urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/Samurai");

            var client_ = _httpClient;
            var disposeClient_ = false;
            try
            {
                using (var request_ = new System.Net.Http.HttpRequestMessage())
                {
                    request_.Method = new System.Net.Http.HttpMethod("GET");
                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));

                    PrepareRequest(client_, request_, urlBuilder_);

                    var url_ = urlBuilder_.ToString();
                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);

                    PrepareRequest(client_, request_, url_);

                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
                    var disposeResponse_ = true;
                    try
                    {
                        var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
                        if (response_.Content != null && response_.Content.Headers != null)
                        {
                            foreach (var item_ in response_.Content.Headers)
                                headers_[item_.Key] = item_.Value;
                        }

                        ProcessResponse(client_, response_);

                        var status_ = (int)response_.StatusCode;
                        if (status_ == 200)
                        {
                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Warrior>>(response_, headers_, cancellationToken).ConfigureAwait(false);
                            if (objectResponse_.Object == null)
                            {
                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
                            }
                            return objectResponse_.Object;
                        }
                        else
                        {
                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
                        }
                    }
                    finally
                    {
                        if (disposeResponse_)
                            response_.Dispose();
                    }
                }
            }
            finally
            {
                if (disposeClient_)
                    client_.Dispose();
            }
        }

        protected struct ObjectResponseResult<T>
        {
            public ObjectResponseResult(T responseObject, string responseText)
            {
                this.Object = responseObject;
                this.Text = responseText;
            }

            public T Object { get; }

            public string Text { get; }
        }

        public bool ReadResponseAsString { get; set; }

        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
        {
            if (response == null || response.Content == null)
            {
                return new ObjectResponseResult<T>(default(T), string.Empty);
            }

            if (ReadResponseAsString)
            {
                var responseText = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
                try
                {
                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
                    return new ObjectResponseResult<T>(typedBody, responseText);
                }
                catch (Newtonsoft.Json.JsonException exception)
                {
                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
                }
            }
            else
            {
                try
                {
                    using (var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
                    using (var streamReader = new System.IO.StreamReader(responseStream))
                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
                    {
                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
                        return new ObjectResponseResult<T>(typedBody, string.Empty);
                    }
                }
                catch (Newtonsoft.Json.JsonException exception)
                {
                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
                }
            }
        }

        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
        {
            if (value == null)
            {
                return "";
            }

            if (value is System.Enum)
            {
                var name = System.Enum.GetName(value.GetType(), value);
                if (name != null)
                {
                    var field = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
                    if (field != null)
                    {
                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field, typeof(System.Runtime.Serialization.EnumMemberAttribute))
                            as System.Runtime.Serialization.EnumMemberAttribute;
                        if (attribute != null)
                        {
                            return attribute.Value != null ? attribute.Value : name;
                        }
                    }

                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
                    return converted == null ? string.Empty : converted;
                }
            }
            else if (value is bool)
            {
                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
            }
            else if (value is byte[])
            {
                return System.Convert.ToBase64String((byte[])value);
            }
            else if (value.GetType().IsArray)
            {
                var array = System.Linq.Enumerable.OfType<object>((System.Array)value);
                return string.Join(",", System.Linq.Enumerable.Select(array, o => ConvertToString(o, cultureInfo)));
            }

            var result = System.Convert.ToString(value, cultureInfo);
            return result == null ? "" : result;
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.3.11.0 (Newtonsoft.Json v12.0.0.0)")]
    public partial class AuthenticationRequest
    {
        [Newtonsoft.Json.JsonProperty("email", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Email { get; set; }

        [Newtonsoft.Json.JsonProperty("password", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Password { get; set; }


    }

    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.3.11.0 (Newtonsoft.Json v12.0.0.0)")]
    public partial class AuthenticationResponse
    {
        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Id { get; set; }

        [Newtonsoft.Json.JsonProperty("userName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string UserName { get; set; }

        [Newtonsoft.Json.JsonProperty("email", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Email { get; set; }

        [Newtonsoft.Json.JsonProperty("token", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Token { get; set; }


    }

    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.3.11.0 (Newtonsoft.Json v12.0.0.0)")]
    public partial class RegistrationRequest
    {
        [Newtonsoft.Json.JsonProperty("firstName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string FirstName { get; set; }

        [Newtonsoft.Json.JsonProperty("lastName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string LastName { get; set; }

        [Newtonsoft.Json.JsonProperty("email", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Email { get; set; }

        [Newtonsoft.Json.JsonProperty("userName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string UserName { get; set; }

        [Newtonsoft.Json.JsonProperty("password", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Password { get; set; }


    }

    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.3.11.0 (Newtonsoft.Json v12.0.0.0)")]
    public partial class RegistrationResponse
    {
        [Newtonsoft.Json.JsonProperty("userId", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string UserId { get; set; }


    }

    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.3.11.0 (Newtonsoft.Json v12.0.0.0)")]
    public partial class Warrior
    {
        [Newtonsoft.Json.JsonProperty("name", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty("age", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public int Age { get; set; }


    }

    [System.CodeDom.Compiler.GeneratedCode("NSwag", "13.10.8.0 (NJsonSchema v10.3.11.0 (Newtonsoft.Json v12.0.0.0))")]
    public partial class ApiException : System.Exception
    {
        public int StatusCode { get; private set; }

        public string Response { get; private set; }

        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }

        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
        {
            StatusCode = statusCode;
            Response = response;
            Headers = headers;
        }

        public override string ToString()
        {
            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("NSwag", "13.10.8.0 (NJsonSchema v10.3.11.0 (Newtonsoft.Json v12.0.0.0))")]
    public partial class ApiException<TResult> : ApiException
    {
        public TResult Result { get; private set; }

        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
            : base(message, statusCode, response, headers, innerException)
        {
            Result = result;
        }
    }

}

W projekcie do pobranie zostawiłem też plik konfiguracyjny dla programu NSwag.

Tyle, jeśli chodzi o wywołania naszego REST API. Teraz jak będziemy przesyłać JSON WEB Tokeny do naszego REST API?

Jak będziemy dodawać tokeny do zapytania ?

Najpierw stworze sobie serwis, którego zadaniem będzie dodać do instancji wygenerowanego IClient i wewnątrz niego HTTPClient token autoryzujący. 

public interface IAddBearerTokenService
{
    Task AddBearerToken(IClient client);
}

Jego implementacja wygląda tak.

public class AddBearerTokenService : IAddBearerTokenService
{
    private readonly ILocalStorageService _localStorage;


    public AddBearerTokenService(ILocalStorageService localStorage)
    {
        _localStorage = localStorage;
    }

    public async Task AddBearerToken(IClient client)
    {
        if (await _localStorage.ContainKeyAsync("token"))
            client.HttpClient.DefaultRequestHeaders.Authorization
                = new AuthenticationHeaderValue("Bearer", await _localStorage.GetItemAsync<string>("token"));
    }
}

Skąd wzięło się "ILocalStorageService". Otóż ten interfejs pochodzi z paczki NuGet : "Blazored.LocalStorage".

Blazored.LocalStorage pozwoli nam przechowywać różne dane w trakcie działania aplikacji Blazor w tym właśnie nasz token autoryzujący. Ten token zostanie zapisany w przeglądarce i gdy użytkownik uruchomi naszą aplikację Blazor ponownie to nadal będzie on zalogowany.

Aby użytkownik mógł się wylogować to musi ten token skasować ze swojego lokalnego zapisu w przeglądarce.

[cloud-green Co to jest LocalStorage ?]Zapisane w localStorage obiekty służą do długotrwałego przechowywania danych i pozostają na dysku po zamknięciu przeglądarki.

W przeciwieństwie do cookies, obiekty z localStorage nie są automatycznie odczytywane przez serwer przy połączeniu

Firefox, Chrome i Opera rezerwują 10 MB na domenę, a Internet Explorer 100 MB na wszystkie przechowywane dane, przy czym wartość te można zmienić na maksymalnie 20 GB. Dane przechowywane są jako tablice asocjacyjne, których kluczem i wartością jest łańcuch znaków. 

LocalStorage pojawił się wraz ze standardem HTML 5.

[cg]

Pamiętaj, że każda aplikacja internetowa pisana JavaScript także ma dostęp do "localStorage"

Teraz stworzę serwis, który będzie wyciągał moich samurajów wojowników.

public interface ISamuraiService
{
    Task<List<WarriorViewModel>> GetAllWarriors();
}

Jego implementacja wygląda tak

public class SamuraiService : ISamuraiService
{
    private readonly IMapper _mapper;
    private IClient _client;
    private IAddBearerTokenService _addBearerTokenService;

    public SamuraiService(IClient client, IMapper mapper,
        IAddBearerTokenService addBearerTokenService)
    {
        _mapper = mapper;
        _client = client;
        _addBearerTokenService = addBearerTokenService;
    }

    public async Task<List<WarriorViewModel>> GetAllWarriors()
    {
        await _addBearerTokenService.AddBearerToken(_client);

        try
        {
            var allPosts = await _client.GetAllSamuraisAsync();
            var mappedPosts = _mapper.Map<ICollection<WarriorViewModel>>(allPosts);
            return mappedPosts.ToList();
        }
        catch (ApiException ex)
        {
            return new List<WarriorViewModel>();
        }
    }
}

Jak widzisz przed wywołaniem odpowiedniej metody z wygenerowanego kodu IClient spróbuje dodać wcześniej token autoryzujący. Jak pamiętasz mój serwis "IAddBearerTokenService" doda ten token do instancji HTTPClient tak, aby mógł on zostać wysłany wraz z zapytaniem HTTP. 

Jak będziemy się logować i pobierać ten token ?

A jak ten token pobierać ? To za chwilę, bo mamy ważniejsze pytanie.

Jak w Blazor przedstawić użytkownika, aby można było skorzystać z pewnych specjalnych opcji i ról w wewnątrz tej aplikacji. Nie chcemy takie weryfikacji od zera.  Zobaczmy co Blazor nam oferuje.

Do tej zabawy musimy stworzyć swoją implemtnację klasy abstrakcyjnej "AuthenticationStateProvider". Wygląda ona tak:

public class CustomAuthenticationStateProvider : AuthenticationStateProvider
{
    private readonly ILocalStorageService _localStorage;

    public CustomAuthenticationStateProvider(ILocalStorageService localStorage)
    {
        _localStorage = localStorage;
    }

    public override async Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var savedToken = await _localStorage.GetItemAsync<string>("token");

        if (string.IsNullOrWhiteSpace(savedToken))
        {
            return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
        }

        return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity(ParseTokenClaims(savedToken), "jwt")));
    }

    public void SetUserAuthenticated(string email)
    {
        var authUser = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, email) }, "apiauth"));
        var authState = Task.FromResult(new AuthenticationState(authUser));
        NotifyAuthenticationStateChanged(authState);
    }

    public void SetUserLoggedOut()
    {
        var anonUser = new ClaimsPrincipal(new ClaimsIdentity());
        var authState = Task.FromResult(new AuthenticationState(anonUser));
        NotifyAuthenticationStateChanged(authState);
    }

    private IEnumerable<Claim> ParseTokenClaims(string jwt)
    {
        var claims = new List<Claim>();
        var payload = jwt.Split('.')[1];
        var jsonBytes = ParseBase64WithoutPadding(payload);
        var keyValuePairs = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonBytes);

        keyValuePairs.TryGetValue(ClaimTypes.Role, out object roles);

        if (roles != null)
        {
            if (roles.ToString().Trim().StartsWith("["))
            {
                var parsedRoles = JsonSerializer.Deserialize<string[]>(roles.ToString());

                foreach (var parsedRole in parsedRoles)
                {
                    claims.Add(new Claim(ClaimTypes.Role, parsedRole));
                }
            }
            else
            {
                claims.Add(new Claim(ClaimTypes.Role, roles.ToString()));
            }

            keyValuePairs.Remove(ClaimTypes.Role);
        }

        claims.AddRange(keyValuePairs.Select(kvp => new Claim(kvp.Key, kvp.Value.ToString())));

        return claims;
    }

    private byte[] ParseBase64WithoutPadding(string base64)
    {
        switch (base64.Length % 4)
        {
            case 2: base64 += "=="; break;
            case 3: base64 += "="; break;
        }
        return Convert.FromBase64String(base64);
    }
}

W metodzie przeciążonej "GetAuthenticationStateAsync" zwracam stan zalogowanego użytkownika wraz z jego rolami.

public override async Task<AuthenticationState> GetAuthenticationStateAsync()
{
    var savedToken = await _localStorage.GetItemAsync<string>("token");

    if (string.IsNullOrWhiteSpace(savedToken))
    {
        return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
    }

    return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity(ParseTokenClaims(savedToken), "jwt")));
}

Pierwsza metoda pozwoli nam ustawić użytkownika w aplikacji Blazor, gdy go zweryfikujemy.

public void SetUserAuthenticated(string email)
{
    var authUser = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, email) }, "apiauth"));
    var authState = Task.FromResult(new AuthenticationState(authUser));
    NotifyAuthenticationStateChanged(authState);
}

public void SetUserLoggedOut()
{
    var anonUser = new ClaimsPrincipal(new ClaimsIdentity());
    var authState = Task.FromResult(new AuthenticationState(anonUser));
    NotifyAuthenticationStateChanged(authState);
}

Z drugiej metody skorzystamy, gdy będziemy chcieli użytkownika wylogować. Informując przy tym aplikację Blazor, że status się zmienił poprzez wywołanie metody NotifyAuthenticationStateChanged

A jak wygląda parsowanie JSON WEB Tokenu. Token jest zapisany specyficznie w Base64. Potem gdy uzyskam z tego tablice bajtów to mogę to z deserializować na słownik klucz / wartość.

private IEnumerable<Claim> ParseTokenClaims(string jwt)
{
    var claims = new List<Claim>();
    var payload = jwt.Split('.')[1];
    var jsonBytes = ParseBase64WithoutPadding(payload);
    var keyValuePairs = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonBytes);

    keyValuePairs.TryGetValue(ClaimTypes.Role, out object roles);

    if (roles != null)
    {
        if (roles.ToString().Trim().StartsWith("["))
        {
            var parsedRoles = JsonSerializer.Deserialize<string[]>(roles.ToString());

            foreach (var parsedRole in parsedRoles)
            {
                claims.Add(new Claim(ClaimTypes.Role, parsedRole));
            }
        }
        else
        {
            claims.Add(new Claim(ClaimTypes.Role, roles.ToString()));
        }

        keyValuePairs.Remove(ClaimTypes.Role);
    }

    claims.AddRange(keyValuePairs.Select(kvp => new Claim(kvp.Key, kvp.Value.ToString())));

    return claims;
}

private byte[] ParseBase64WithoutPadding(string base64)
{
    switch (base64.Length % 4)
    {
        case 2: base64 += "=="; break;
        case 3: base64 += "="; break;
    }
    return Convert.FromBase64String(base64);
}

Tak też wyciągam rolę zapisane w tym JSON WEB Tokenie.

Teraz oddalam się od tej wymaganej klasy przez Blazor i tworzę swój serwis autoryzujący z takimi metodami.

public interface IBlazorAuthenticationService
{
    Task<bool> Authenticate(string email, string password);
    Task<bool> Register(string firstName, string lastName, string userName, string email, string password);
    Task Logout();
}

Oto jego implementacja.

public class BlazorAuthenticationService : IBlazorAuthenticationService
{
    private readonly AuthenticationStateProvider _authenticationStateProvider;
    protected readonly ILocalStorageService _localStorage;

    protected IClient _client;

    public BlazorAuthenticationService(IClient client, ILocalStorageService localStorage,
        AuthenticationStateProvider authenticationStateProvider)
    {
        _authenticationStateProvider = authenticationStateProvider;
        _client = client;
        _localStorage = localStorage;
    }

    public async Task<bool> Authenticate(string email, string password)
    {
        try
        {
            AuthenticationRequest authenticationRequest = new AuthenticationRequest() { Email = email, Password = password };
            var authenticationResponse = await _client.AuthenticateAsync(authenticationRequest);

            if (authenticationResponse.Token != string.Empty)
            {
                await _localStorage.SetItemAsync("token", authenticationResponse.Token);
                ((CustomAuthenticationStateProvider)_authenticationStateProvider).SetUserAuthenticated(email);
                _client.HttpClient.DefaultRequestHeaders.Authorization
                    = new AuthenticationHeaderValue("bearer", authenticationResponse.Token);
                return true;
            }
            return false;
        }
        catch
        {
            return false;
        }
    }

    public async Task<bool> Register(string firstName, string lastName, string userName, string email, string password)
    {
        RegistrationRequest registrationRequest = new RegistrationRequest() { FirstName = firstName, LastName = lastName, Email = email, UserName = userName, Password = password };
        var response = await _client.RegisterAsync(registrationRequest);

        if (!string.IsNullOrEmpty(response.UserId))
        {
            return true;
        }
        return false;
    }

    public async Task Logout()
    {
        await _localStorage.RemoveItemAsync("token");
        ((CustomAuthenticationStateProvider)_authenticationStateProvider).SetUserLoggedOut();
        _client.HttpClient.DefaultRequestHeaders.Authorization = null;
    }
}

Jak wyciągamy Token z REST API ?

Korzystam z pewnej wygenerowanej metody "AuthenticateAsync" przez NSwag i potem zapisuje ten token w LocalStorage. 

public async Task<bool> Authenticate(string email, string password)
{
    try
    {
        AuthenticationRequest authenticationRequest = new AuthenticationRequest() { Email = email, Password = password };
        var authenticationResponse = await _client.AuthenticateAsync(authenticationRequest);

        if (authenticationResponse.Token != string.Empty)
        {
            await _localStorage.SetItemAsync("token", authenticationResponse.Token);
            ((CustomAuthenticationStateProvider)_authenticationStateProvider).SetUserAuthenticated(email);
            _client.HttpClient.DefaultRequestHeaders.Authorization
                = new AuthenticationHeaderValue("bearer", authenticationResponse.Token);
            return true;
        }
        return false;
    }
    catch
    {
        return false;
    }
}

Wylogowanie wygląda tak. Usuwam token z LocalStorage, a potem mój CustomAuthenticationStateProvider informuje Blazor o zmianie statusu użytkownika.

public async Task Logout()
{
    await _localStorage.RemoveItemAsync("token");
    ((CustomAuthenticationStateProvider)_authenticationStateProvider).SetUserLoggedOut();
    _client.HttpClient.DefaultRequestHeaders.Authorization = null;
}

Rejestracja to tylko wywołanie odpowiedniej wygenerowanej metody przez NSwag

public async Task<bool> Register(string firstName, string lastName, string userName, string email, string password)
{
    RegistrationRequest registrationRequest = new RegistrationRequest() { FirstName = firstName, LastName = lastName, Email = email, UserName = userName, Password = password };
    var response = await _client.RegisterAsync(registrationRequest);

    if (!string.IsNullOrEmpty(response.UserId))
    {
        return true;
    }
    return false;
}

Tak obecnie prezentuje się nasz projekt Blazor.

Korzystając z kontenera wstrzykiwania zależności zarejestrujmy te wszystkie mechanizmy w naszej aplikacji Blazor.

Jak widzisz ustawiamy tutaj także adres naszego REST API. Tę aplikację do testów uruchomię po localhost i pod portem 5001.

public class Program
{
    public static async Task Main(string[] args)
    {
        var builder = WebAssemblyHostBuilder.CreateDefault(args);
        builder.RootComponents.Add<App>("#app");

        //builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());
        builder.Services.AddBlazoredLocalStorage();

        builder.Services.AddSingleton(new HttpClient
        {
            BaseAddress = new Uri("https://localhost:5001")
        });

        builder.Services.AddHttpClient<IClient, Client>
        (client => client.BaseAddress = new Uri("https://localhost:5001"));

        builder.Services.AddScoped<ISamuraiService, SamuraiService>();

        //Auth
        builder.Services.AddScoped<IBlazorAuthenticationService,
        BlazorAuthenticationService>();
        builder.Services.AddScoped<AuthenticationStateProvider,
        CustomAuthenticationStateProvider>();
        builder.Services.AddScoped<IAddBearerTokenService,
        AddBearerTokenService>();

Teraz możemy przejść do naszych strony pisanych w Razor, czyli składni, która pozwala nam mieszać kod HTML z C# 

Razor, czyli strony

Oto mojego wszystkie strony.

Razor strony logującej wygląda tak. Jak widzisz pola InputText są powiązane, z jaką właściwością "@LoginViewModel.Password". 

Samo wywołanie formularza wywoła jakąś metodę "HandleValidSubmit". Gdzie ona jest ? Jest ona tak zwanym CodeBehind.

@page "/login"

<div class="mt-5 row">
    <div class="card col-12 col-lg-6 mr-auto ml-auto p-3">
        <h3 class="card-title">Zaloguj się Samuraju</h3>
        <div class="card-body">
            <EditForm Model="@LoginViewModel" OnValidSubmit="HandleValidSubmit">
                <div class="input-group row mt-2">
                    <label class="col-12 col-md-4 p-0" for="userName">Email:</label>
                    <InputText id="userName" class="col-12 col-md-8 login-field" @bind-Value="LoginViewModel.Email"></InputText>
                </div>
                <div class="input-group row mt-2">
                    <label class="col-12 col-md-4 p-0" for="password">Password:</label>
                    <InputText type="password" id="password" class="col-12 col-md-8 login-field" @bind-Value="@LoginViewModel.Password"></InputText>
                </div>
                <div class="input-group row mt-2">
                    <div class="">
                        <button class="m-4 p-2">Zaloguj</button>
                    </div>
                </div>
            </EditForm>
        </div>
    </div>
</div>

<span class="label label-error">@Message</span>

Kod poboczny, który obsłuży logikę tej strony wygląda następująco. Jak widzisz w kodzie pobocznym nie możemy zrobić wstrzykiwania zależności poprzez konstruktor.

Na pomoc przychodzi nam atrybut "[Inject]", który to za nas zrobi.

public partial class Login
{
    public LoginBlazorVM LoginViewModel { get; set; }

    [Inject]
    public NavigationManager NavigationManager { get; set; }
    public string Message { get; set; }

    [Inject]
    private IBlazorAuthenticationService AuthenticationService { get; set; }

    public Login()
    {

    }

    protected override void OnInitialized()
    {
        LoginViewModel = new LoginBlazorVM();
    }

    protected async void HandleValidSubmit()
    {
        if (await AuthenticationService.Authenticate
            (LoginViewModel.Email, LoginViewModel.Password))
        {
            NavigationManager.NavigateTo("adminoptions");
        }
        Message = "Username/password Coś jest źle";
    }
}

Nasza metoda "HandleValidSubmit" wykona zapytanie HTTP do naszego REST API i poprosi o token autoryzujący. Jeśli wszystko poszło zgodnie z planem to zostaniemy przekierowani na stronę "adminoptions".

Kontrola ról użytkowników

W Blazor istnieje także możliwość kontroli ról użytkowników. Próbowałem napisać taki kod i przynajmniej jestem w stanie Ci zagwarantować, że działa sprawdzenie, czy użytkownik w ogóle jest zalogowany.

Mam pewne problemy ze sprawdzeniem konkretnych ról i mam nadzieje, że kiedyś znajdę przyczynę tego błędu w kodzie

public class Program
{
    public static async Task Main(string[] args)
    {

        ...
        builder.Services.AddAuthorizationCore(config =>
        {
            config.AddPolicy(Policies.IsAdmin, Policies.IsUserLogged());
            config.AddPolicy(Policies.IsUserLog, Policies.IsUserLogged());
            config.AddPolicy(Policies.IsUser, Policies.IsUserPolicy());
            config.AddPolicy(Policies.IsClaim, Policies.IsClaimed());
        });

        await builder.Build().RunAsync();
    }
}

Warto stworzyć sobie taką klasę statyczną i weryfikować użytkowników w widoku Razor.

public static class Policies
{
    public const string IsAdmin = "IsAdmin";
    public const string IsUserLog = "IsUserLog";
    public const string IsUser = "IsUser";
    public const string IsClaim = "IsClaim";

    public static AuthorizationPolicy IsAdminPolicy()
    {
        return new AuthorizationPolicyBuilder().RequireAuthenticatedUser()

                                               .RequireRole("adminEdu")
                                               .Build();
    }

    public static AuthorizationPolicy IsUserLogged()
    {
        return new AuthorizationPolicyBuilder().RequireAuthenticatedUser()

                                               .Build();
    }

    public static AuthorizationPolicy IsClaimed()
    {
        return new AuthorizationPolicyBuilder().RequireAuthenticatedUser()
            .RequireClaim("MyCos", "MyValue")
            .Build();
    }

    public static AuthorizationPolicy IsUserPolicy()
    {
        return new AuthorizationPolicyBuilder().RequireAuthenticatedUser()
                                               .RequireRole("User")
                                               .Build();
    }
}

Wracamy do stron Razor

Teraz skorzystam z tej klasy statycznej "Policies". Oto kod Razor "NavMenu.razor"

<div class="top-row pl-4 navbar navbar-dark">
    <a class="navbar-brand" href="">Samurai.UI</a>
    <button class="navbar-toggler" @onclick="ToggleNavMenu">
        <span class="navbar-toggler-icon"></span>
    </button>
</div>

<div class="@NavMenuCssClass" @onclick="ToggleNavMenu">
    <ul class="nav flex-column">
        <li class="nav-item px-3">
            <NavLink class="nav-link" href="" Match="NavLinkMatch.All">
                <span class="oi oi-home" aria-hidden="true"></span> Home
            </NavLink>
        </li>
        <li class="nav-item px-3">
            <NavLink class="nav-link" href="login">
                <span class="oi oi-list-rich" aria-hidden="true"></span> Login
            </NavLink>
        </li>
        <li class="nav-item px-3">
            <NavLink class="nav-link" href="samurailist">
                <span class="oi oi-list-rich" aria-hidden="true"></span> Listy Samurajów
            </NavLink>
        </li>
        <li class="nav-item px-3" Policy="@Policies.IsAdmin">
            <NavLink class="nav-link" href="adminoptions">
                <span class="oi oi-list-rich" aria-hidden="true"></span> Admin
            </NavLink>
        </li>
    </ul>
</div>

@code {
    private bool collapseNavMenu = true;

    private string NavMenuCssClass => collapseNavMenu ? "collapse" : null;

    private void ToggleNavMenu()
    {
        collapseNavMenu = !collapseNavMenu;
    }
}

Jak widzisz próbuje w ten sposób ukryć jeden z linku w tej pasku nawigującym. 

<li class="nav-item px-3" Policy="@Policies.IsAdmin">
    <NavLink class="nav-link" href="adminoptions">
        <span class="oi oi-list-rich" aria-hidden="true"></span> Admin
    </NavLink>
</li>

W widoku można skorzystać z budowanych tagów w Razor, które ukryją odpowiednio zawartość strony przed nie zalogowany użytkownikiem.

Oto kod strony "AdminOptions.razor". Tutaj wyświetlę sobie zawartość całego tokenu JSON.

@page "/adminoptions"

<AuthorizeView Policy="@Policies.IsAdmin">
    <Authorized>

        <p class="back-to-catalog mt-3">
            <a class="back-link" @onclick="@NavigateToList">---- Zobacz listę samurajów ----</a>
        </p>
    </Authorized>
    <NotAuthorized>
        <p>Proszę się zalogować</p>
    </NotAuthorized>
</AuthorizeView>
<br />

<AuthorizeView Policy="@Policies.IsClaim">
    <Authorized>
        <p>@Policies.IsClaim : true</p>
    </Authorized>
    <NotAuthorized>
        <p>@Policies.IsClaim : false</p>
    </NotAuthorized>
</AuthorizeView>

Zawartość tokenu JSON
<p>
    @Data
</p>

<p class="back-to-catalog mt-3">
    <a class="back-link" @onclick="@DeleteToken">---- Skasuj token ----</a>
</p>

Kod poboczny strony wygląda tak. W trakcie ładowania strony wyświetlę sobie zawartość tokenu. Przy okazji oto prosty przykład jak w Blazor tworzyć dynamicznie kod HTML poprzez użycie klasy "MarkupString"

public partial class AdminOptions
{
    [Inject]
    public AuthenticationStateProvider _authenticationStateProvider { get; set; }

    [Inject]
    protected ILocalStorageService _localStorage { get; set; }

    public AdminOptions()
    {

    }

    [Parameter]
    public MarkupString Data { get; set; } = new MarkupString("");

    protected async override Task OnInitializedAsync()
    {
        var use = (await _authenticationStateProvider.GetAuthenticationStateAsync());

        StringBuilder sb = new StringBuilder();
        sb.AppendLine(use.User.Identity.Name);
        sb.Append("<br />");

        sb.AppendLine(" <ul> ");
        foreach (var item in use.User.Claims)
        {
            sb.Append(" <li> ");
            sb.Append(" <ol> ");
            sb.Append(" <li> ");
            sb.AppendLine(item.Type);
            sb.Append(" </li> ");
            sb.Append(" <li> ");
            sb.AppendLine(item.Value);
            sb.Append(" </li> ");
            sb.Append(" </ol> ");
            sb.Append(" </li> ");
        }
        sb.AppendLine(" </ul> ");
        sb.Append("<br /> Jest Adminiem");
        sb.AppendLine(use.User.IsInRole("Admin").ToString());
        sb.Append("<br /> Ma MyValue");
        sb.AppendLine(use.User.Claims.Any(p => p.Value == "MyValue").ToString());
        sb.Append("<br /> Ma Cos");
        sb.AppendLine(use.User.Claims.Any(p => p.Type == "MyCos").ToString());


        Data = new MarkupString(sb.ToString());
    }


    [Inject]
    public NavigationManager NavigationManager { get; set; }

    protected void DeleteToken()
    {
        _localStorage.RemoveItemAsync("token");
        NavigationManager.NavigateTo("/");
    }

    protected void NavigateToList()
    {
        NavigationManager.NavigateTo("/samurailist");
    }

}

Tak wygląda kod strony "SamuraiList.razor". Jej celem jest wyświetlenie wszystkich samurajów.

<AuthorizeView Policy="@Policies.IsAdmin">
    <Authorized>

        <h3>Samuraje</h3>

        @if (Warriors == null)
        {
            <p><em>Loading...</em></p>
        }
        else
        {
            <table>
                <thead>
                    <tr>
                        <th>Nazwa</th>
                        <th>Wiek</th>
                        <th></th>
                        <th></th>
                    </tr>
                </thead>
                <tbody>
                    @foreach (var p in Warriors)
                    {
                        <tr>

                            <td class="post-title">@p.Name </td>
                            <td class="post-title">@p.Age </td>
                            <td class="post-title">@p.ImageUrl</td>
                        </tr>
                    }
                </tbody>
            </table>
        }
    </Authorized>
    <NotAuthorized>
        <p>Proszę się zalogować. Samuraju</p>
    </NotAuthorized>
</AuthorizeView>

Oto kod poboczny tej strony. Pobieram samurajów w trakcie ładowania strony i potem przekazuje to co pobrałem do parametru.

public partial class SamuraiList
{
    [Inject]
    public ISamuraiService SamuraiService { get; set; }

    [Inject]
    public NavigationManager NavigationManager { get; set; }

    public ICollection<WarriorViewModel> Warriors { get; set; }

    protected async override Task OnInitializedAsync()
    {
        Warriors = await SamuraiService.GetAllWarriors();
    }

}

To wszystko, zanim uruchomimy naszą aplikację Blazor warto zmienić jej port. Zakładamy, że nasze REST API będzie działać pod portem 5001. To niech nasza aplikacja Blazor działa pod portem 5005.

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:50456",
      "sslPort": 44375
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}"
    },
    "Samurai.UI": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "dotnetRunMessages": "true",
      "applicationUrl": "https://localhost:5005;http://localhost:5006",
      "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}"
    }
  }
}

Oto chwila prawdy.

Zobaczmy jak to działa ?

Strona startowa wygląda tak:

Jak widać nie możemy zobaczyć listy samurajów przed zalogowaniem więc blokady nasze działają.

W panelu administratora jak widzisz nie mamy żadnych informacji.

Uruchamiamy nasze REST API, które stworzyliśmy w poprzednim wpisie.

Logujemy się. Mamy użytkownika eve@gmail.com z hasłem 12345

Możemy wyświetlić sobie zawartość naszego JSON WEB Tokenu.

Teraz gdy jesteśmy zalogowani to możemy zobaczyć listę samurajów.

To wszystko. Kod można pobrać tutaj PanNiebieski/example-JsonWebToken-with-Blazor-Samurai (github.com)

Zanim jednak tym architektem zostaniesz warto odpowiedzieć sobie na te pytanie.

Oto 6 pytań dla przyszłych architektów oprogramowania.

[more]

1. Czy w programowaniu istnieje srebrna kula ?

Nie ma srebrnej kuli w oprogramowaniu. Mógłbyś dojść do wniosku, że po 63 latach po wynalezieniu COBOL-a nasze oprogramowanie powinno dojść do fazy, w której istnieje idealne rozwiązanie. Tak jednak nie jest. 

Z mojego doświadczenia techniki programistyczne można podzielić na dwie kategorię:

• Fatalne
• i dobre, ale to zależy. No właśnie "to zależy". 

Warto o tym pamiętać, gdy będziesz miał obsesje nad swoim młotkiem i będziesz nim próbował montować kafelki, bo dla Ciebie wszystko jest teraz gwoździem. 

2. Czy kwestionujesz Hype ?

Ten problem dotyka całego obszaru IT i został on nazwany już wieloma śmiesznymi skrótami jak:

• "Hype Driven Development",
• "Conference Driven Development",
• "Loudest Guy Driven Descisions"
• i ostatnie najważniejsze "Resume Driven Development",

...czyli to jak nasze dążenie do dodawania fajnych nowych technologi do CV wpływa na tworzenie aplikacji w korporacjach. 

Każdy chce dodać nową technologię do CV, aby zwiększyć swoją wartość, ale aby to zrobić z czystym sumieniem, to trzeba taką aplikację stworzyć w swojej obecnej firmie. Znaczy to, że marketingowe kręcenie pewnych rozwiązań technologicznych pociąga wiele sznurków w tym trendy w CV i  potem te trendy wypluwają nie koniecznie dobre programistyczne twory.

To, że coś jest nowe, nie znaczy automatycznie, że jest to lepsze. To, że  coś jest popularne, nie znaczy, że automatycznie, że jest to perfekcyjne narzędzie, które rozwiąże twój konkretny problem. Tworzymy oprogramowanie, aby rozwiązywać problemy, a nie po to, aby dopisać sobie technologię do CV.

Dlatego warto kwestionować każde rozwiązanie, zwłaszcza jeśli to rozwiązanie jest dopiero w swojej fazie "rozgłosu" i nie zostało tak naprawdę sprawdzone na dużą skalę, a to zajmuje zazwyczaj danej technologi 3-4 lata. Nie dziw się, więc jeśli twój architekt nie podziela entuzjazmu twojego nowym rozwiązaniem, bo ma do tego swoje powody.

3. Czy kwestionujesz wzorce projektowe ?

Gdy zaczynałem programować z 10 lat temu, to byłem przekonany, że wzorce projektowe są kluczem do czystego, czytelnego kodu i znajomość tych wzorcu będzie mi otwierało możliwości zabłyśnięcia na rozmowach kwalifikacyjnych. 

Gdy już pracowałem, to kupiłem sobie książkę za 300 zł i myślałem, że tę cenę kupuje wręcz święty Gral programistyczny. Ta książka nie tylko opisywała wszystkie wzorce projektowe z "Gang of Four", ale także pokazała ich użycie w poszczególnych warstwach aplikacji ASP.NET Web Forms. 

Po krótkiej analizie książki doszedłem do wniosku, że połowa tych wzorców projektowych jest albo beznadziejna, albo bardzo sytuacyjna, albo już ktoś wymyślił coś lepszego. Potem lata mijały w mojej karierze programisty i najczęściej używanym wzorcem projektowym był tylko dekorator.

Mogłem, też zobaczyć jak pewien architekt zrobił bardzo nieczytelny kod, ponieważ użył wzorca projektowego "State", który jest w porządku, dopóki logika nie jest zarządzana przez 30 oddzielnych klas, które mają reprezentować, jak sama nazwa wzorca wskazuje, oddzielny stan i akcje dla danego elementu w tym stanie.

Ja jednak by wolał jeden plik, gdzie mogę wzrokiem zrozumieć, co ja właściwie robię, gdy takie i takie stany danego elementu występują. Niby to antywzorzec, ale przynajmniej bym wiedział, co ja właściwie robię. Teraz też wiem, że dobrą alternatywą dla wzorca "State" jest maszyna stanów, która nie była opisana w wielu książkach. 

To mnie nauczyło kwestionować rozwiązania programistyczne nawet te poparte autorytetem i ceną książki. 

4. Czy znasz prawo Conway'a ?

Jako programista zauważyłeś, że ostatnio bardzo stały się popularne mikroserwisy  oraz mikro-frontendy. Tak jak mówiłem wcześniej to, że coś jest popularne, to automatycznie nie znaczy, że są to rozwiązania dla Ciebie.

Ich popularność można tłumaczyć "Prawem Conway'a", które nam mówi, że naszego oprogramowanie będzie dążyć do struktury, jaką mamy w naszych zespołach w firmie. 

Skoro mamy małe zespoły po 3-5 osób to nasze oprogramowanie też chce dążyć do małych aplikacji backend i frontend.

Nie dlatego, że jest to uniwersalnie dobre, ale dlatego, że takie mamy podziały zespołów.

Prawa Conway's nie da się oszukać. Jest jak prawo grawitacji.  Jeśli mamy złą komunikację w zespołach albo struktura zespołów  jest jak przyciśnięcie wzajemnie do siebie pistoletów do głowy, to te wszystkie problemy wyjdą w oprogramowaniu. 

Przykład zbyt dużego zespołu. Jak myślisz działa on wydajnie ?

Dlatego architekci nie tylko robią diagramy projektów z kodem, ale także robią mapę kontekstów i zespołów, które w jakiś sposób ze sobą muszą się komunikować, aby firma jako cały puzzel lub organizm jakoś funkcjonowała.

Fachowo mówi się na to "Context Map".

Ciekawe, że można znaleźć problem w oprogramowaniu nie w kodzie, ale w relacjach między zespołami i być może w niedalekiej przyszłości jako architekt twoim zadaniem będzie włożyć kij w mrowisko polityki firmy, aby przyszłe oprogramowania był lepsze.

5. Czy to się skaluje ?

Gdy już znasz najlepsze z najlepszych praktyk w architekturze w twojej głowie na nie jednym spotkaniu pojawi się pytanie "Czy to się skaluje ?".

No cóż, żeby, to zweryfikować to trzeba napisać prototyp albo mieć już doświadczenie z daną techniką.

Ostatnio jednak pojawiło się wiele alarmów o odwrotnym problemie. Nie każdy z nas będzie tworzył drugiego Facebooka, to znaczy, że wiele genialnych praktyk będzie przerostem formy nad treścią naszego rozwiązania.

Mówi się na to " Overengineering". 

Dlatego, zamiast zadawać sobie pytanie ", Czy to się skaluje?" warto także zadać sobie pytanie "A co jeśli tyle mi wystarczy?".

Dodatkowo warto zaznaczyć, że genialna technika to jedno, ale jej dobra implementacja to drugie.  Wiesz mi, każdy programista wolałby aplikację CRUD niż źle napisaną aplikację CQRS z Event Sourcing. Dlatego skup się na jak najprostszych rozwiązaniach dopasowanych do skali swojego problemu.

6. Czy masz swoje zdanie ?

Warto weryfikować każdą technikę i uważać, aby nie stać się papugą, która powtarza to, co usłyszała na konferencji albo od innego kolesia, który głośnio krzyczy.

Ciągle się uczymy i niestety nic nie zastąpi twojej weryfikacji danej techniki z prawdziwym projektem biznesowym.

TL;DR Zawsze możesz też obejrzeć filmik na YT na ten temat :)

;

Czy można nadać nazwę według pewnego wzoru tym arkuszom? Tak

Oto zadanie, które miałem wykonać. Mam więc arkusz do kopiowania wygląda on tak. [more]

Każda kopia takiego arkusza musi mieć swoją nazwę według pewnego wzoru. Oto moja tabelka. 

Zanim więc przejdziemy do generowania takich arkuszy musi najpierw określić kod nazwy. Jego wzór jest następujący 

"4 pierwsze litery z miasta" + "_" + "Ostatnia cyfra z Numer1" + "_" + "Pierwsza cyfra z Numer 2" + "_" + "Kod Regionu"

Kod VBA, który takie napisy wygeneruje wygląda tak:

Sub DajKodDoArkuszu()

For x = 2 To 9
    
    Dim cellcity, cellnumber1, cellnumeber2, cellregion As String
    
    cellcity = "B" & x
    cellnumber1 = "C" & x
    cellnumeber2 = "D" & x
    cellregion = "E" & x
    
    Dim vcity, vnumber1, vnumber2, vregion As String
    
    vcity = Range(cellcity).Value
    vnumber1 = Range(cellnumber1).Value
    vnumber2 = Range(cellnumeber2).Value
    vregion = Range(cellregion).Value
       
    Dim lenghtcity
    lenghtcity = Len(vcity)
    
    If lenghtcity > 4 Then
        vcity = Left(vcity, 4)
    End If
    
    vnumber1 = Right(vnumber1, 1)
    vnumber2 = Left(vnumber2, 1)
    
    Dim result As String
    
    result = "cit_" & vcity & "_" & vnumber1 & "_" & vnumber2 & "_" & vregion
    result = LCase(result)
    
    Range("A" & x).Value = result

Next x

End Sub

Wbudowana funkcja Len określi mi ilość znaków w danym napisie. 

Dim lenghtcity
lenghtcity = Len(vcity)

If lenghtcity > 4 Then
    vcity = Left(vcity, 4)
End If

Korzystając z funkcji Left jestem w stanie wyciągnąć z danego napisu pierwsze 4 znaki.

vnumber1 = Right(vnumber1, 1)
vnumber2 = Left(vnumber2, 1)

Istnieje też podobna funkcja Right, która wyciągnie mi znaki od końca mojego napisu lub numeru.

result = "cit_" & vcity & "_" & vnumber1 & "_" & vnumber2 & "_" & vregion
result = LCase(result)
Range("A" & x).Value = result

Na koniec pozostało nam te napisy złączyć i umieścić ich zawartość do kolumny "A".

To był fragment naszego zadania. Teraz przechodzimy do generowania arkuszy przy użyciu VBA.

Cały ten wcześniejszy kod możemy przerobić na funkcje, która nam zwróci tablice wygenerowanych napisów. Ta tablica będzie nam potrzebna do generacji szablonów.

Function DajTabliceKodow() As String()

Dim arr(7) As String
Dim index As Integer
index = 0

For x = 2 To 9
    
    Dim cellcity, cellnumber1, cellnumeber2, cellregion As String
    
    cellcity = "B" & x
    cellnumber1 = "C" & x
    cellnumeber2 = "D" & x
    cellregion = "E" & x
    
    Dim vcity, vnumber1, vnumber2, vregion As String
    
    vcity = Range(cellcity).Value
    vnumber1 = Range(cellnumber1).Value
    vnumber2 = Range(cellnumeber2).Value
    vregion = Range(cellregion).Value
       
    Dim lenghtcity
    lenghtcity = Len(vcity)
    
    If lenghtcity > 4 Then
        vcity = Left(vcity, 4)
    End If
    
    vnumber1 = Right(vnumber1, 1)
    vnumber2 = Left(vnumber2, 1)
    
    Dim result As String
    
    result = "cit_" & vcity & "_" & vnumber1 & "_" & vnumber2 & "_" & vregion
    result = LCase(result)
    
    arr(index) = result
    index = index + 1
    
Next x

DajTabliceKodow = arr

End Function

Do działania będziemy też potrzebować innych pomocniczych funkcji. Potrzebujemy funkcji, która zwróci nam wielkość danej tablicy

Public Function GetArrLength(a As Variant) As Integer
   If IsEmpty(a) Then
      GetArrLength = 0
   Else
      GetArrLength = UBound(a) - LBound(a) + 1
   End If
End Function

Przyda nam się też funkcja, która sprawdzi dla bezpieczeństwa czy nie istnieje już taki arkusz o takiej nazwie.

Function Sheet_Exists(WorkSheet_Name As String) As Boolean
Dim Work_sheet As Worksheet
 
Sheet_Exists = False
 
For Each Work_sheet In ThisWorkbook.Worksheets
 
    If Work_sheet.Name = WorkSheet_Name Then
        Sheet_Exists = True
    End If
 
Next
 
End Function

Jak można dodać arkusz w VBA? Wystarczy taki fragment kodu

Sheets.Add.Name = "NowyArkusz"

Jeśli chcesz dodać arkusz przed lub po jakiś arkuszu to kod trochę ulega zmianie.

Sheets.Add After:=Sheets("Arkusz1") 'Dodaj po Arkuszu1'
Sheets.Add(After:=Sheets("Arkusz1")).Name = "NowyArkusz" 'Dodaj po Arkuszu1 i zmień nazwe'

Sheets.Add(Before:=Sheets(1)).Name = "FirstSheet 'Dodaj na początku'

Nas jednak interesuje kopiowanie i umieszczanie każdego kolejno takiego szablonu na końcu.

Kod generujący wygląda tak

Sub UtworzArkusze()

Dim arr() As String
arr = DajTabliceKodow()

Dim sizeArray
sizeArray = GetArrLength(arr)

For y = 0 To sizeArray - 1

    Dim Sheet_Name As String
    
    Sheet_Name = arr(y)
    
    If (Sheet_Exists(Sheet_Name) = False) Then
    
        Sheets("ArkuszDoKopiowania").Copy After:=Sheets(Sheets.Count)
        ActiveSheet.Name = Sheet_Name
        
    End If
Next y

End Sub

Jak widzisz dosyć łatwo jest utworzyć dynamicznie arkusze w VBA w Excelu.

Najbardziej interesuje cię zapewne ten fragment kodu. Metoda Copy utworzy kopię, a funkcja After ustawi nowo wygenerowany tak szablon na samym końcu.

Sheets("ArkuszDoKopiowania").Copy After:=Sheets(Sheets.Count)
ActiveSheet.Name = Sheet_Name

Gdy ten szablon się generuje to jest on w tym momencie aktywnym szablonem.  To daje nam możliwość odwołania się do niego i wtedy mam szanse zmienić jego nazwę.

To wszystko. Pamiętaj tylko o tym, aby aktywować/zaznaczyć odpowiedni arkusz, gdy uruchamiasz takie makro w VBA.

Dzisiaj dostałem takie wyzwanie związane z Excelem. Czy można w Excelu napisać makro w VBA, które za Ciebie wygeneruje wyrażenie "SUMA=" i do niego doklei za Ciebie wszystkie arkusze, jakie masz w danym zeszycie?

Oczywiście, że się da. Po napisaniu Makra w VBA nawet zdałem sobie sprawę, że ten problem można rozwiązać zapewne lepiej przy pomocy menadżera nazw oraz potęgi klawisza SHIFT do zaznaczania wielu arkuszy.

Ja jednak ponieważ jestem programistą to pokaże Ci jak szybko od podstaw  można nauczyć się pisania makr VBA  Excelu, tak jak ja to zrobiłem w 15 minut.[more]

Na początku w programie Excel musisz dodać do wstążki całą zakładkę Deweloper. Bez niej nic nie zrobisz.

Następnie z tego nowego pola we wstążce wybierz "Visual Basic".

W tym oknie teraz możesz deklarować nowe moduły. Do nich będziemy dodawać kod. Ten kod będziemy potem uruchamiać w specyficznym arkuszu w Excelu.

Dodawanie modułu wygląda tak

Pora napisać naszą pierwszą metodę w naszym module. Sub deklaruje nam funkcje o nazwie "GenerowanieSumy1".

Sub GenerowanieSumy1()
    Dim x, Formula
    Formula = "=SUM(" 'Formuła zaczyna się od =SUM('
    
    For x = 1 To (Sheets.Count - 1)
        Formula = Formula & Sheets(x).Name & "!A1," 'Dodaj Nazwę Arkusza i Komórkę i Przecinek'
    Next x
    
    Formula = Left(Formula, Len(Formula) - 1) & ")" 'Usuwanie przecinka i dodawanie nawiasów'
    Range("A1").Formula = Formula 'Gdzie chcesz umieścić tą formułę?'
End Sub

"Dim" oznacza deklarację zmiennej o danej nazwie. Potem w pętli FOR przejdę po wszystkich arkuszach oprócz ostatniego stąd -1 i wygeneruje się odpowiedni ciąg do formuły. Będzie to wyglądać ostatecznie tak:

=SUMA(Arkusz1!A1;Arkusz2!A1;Arkusz3!A1;Arkusz4!A1)

Gdzie przykładowo "akrusz5" będzie arkuszem ostatnim i do niego będę chciał dodać tą wygenerowaną formułę przez VBA. Na razie napisałem na sztywno komórkę "A1". Zobaczymy co możemy z tym zrobić dalej.

Jak tej metody użyć.

Wchodzimy na "arkusz5" czyli nasz ostatni arkusz i wciskamy ten guzik.

Teraz pojawi Ci się okno ze wszystkimi dostępnymi makrami. Ja mam ich więcej, ponieważ już dodałem do swojego modułu kolejne metody. 

Oto jak nasze makro działa w praktyce.

Oczywiście jest jeden problem z naszym makrem.

Na sztywno do niego dodaliśmy komórkę A1.

Co, jeśli chcielibyśmy tak generować sumy dla każdej komórki?

Możemy przerobić naszą metodę VBA tak, aby przyjmowała ona informacje o komórce jako napis String

Sub GenerowanieSumyZParametrem(CELL As String)
Dim x, Formula
Formula = "=SUM(" 'Formuła zaczyna się od =SUM('
For x = 1 To (Sheets.Count - 1)
    Formula = Formula & Sheets(x).Name & "!" & CELL & "," 'Dodaj Nazwę Arkusza i Komórkę i Przecinek'
Next x
Formula = Left(Formula, Len(Formula) - 1) & ")" 'Usuwanie przecinka i dodawanie nawiasów'
Range(CELL).Formula = Formula 'Gdzie chcesz umieścić tą formułę?'
End Sub

Niestety nie ma możliwości uruchomienia makra z parametrem bez tworzenia do niego jakieś formatki z przyciskiem.

Tworzenie też takich funkcji per komórka, też mija się z celem. Warto zaznaczyć, że jak uruchamiasz funkcje wewnątrz innej funkcji to najpierw musisz podać nazwę modułu tej funkcji. U mnie moduł nazywa się "GenerowanieSumy". 

Przeciwnym wypadku dostaniesz błąd : Expected Variable or Procedure, not Module.

Sub GenerowanieSumyA2()
    GenerowanieSumy.GenerowanieSumyZParametrem("A2")
End Sub

Sub GenerowanieSumyA1()
    Call GenerowanieSumy.GenerowanieSumyZParametrem(CELL:="A1")
End Sub

Na szczęście do problemu można podejść bardzo prymitywnie, ale też i skutecznie.

Przykładowo chce mieć sumy wartości komórek od C3 do N40. Jak to zrobić? Utworzyłem sobie tablice "CellsName", która zawiera nazwy komórek od C do N. Chociaż zaraz Ci pokaże jak to zrobić bez tworzenia takiej tablic.

Sub GenerowanieSumyC3toN40()
    
    Dim CellsName(1 To 12) As String
    CellsName(1) = "C"
    CellsName(2) = "D"
    CellsName(3) = "E"
    CellsName(4) = "F"
    CellsName(5) = "G"
    CellsName(6) = "H"
    CellsName(7) = "I"
    CellsName(8) = "J"
    CellsName(9) = "K"
    CellsName(10) = "L"
    CellsName(11) = "M"
    CellsName(12) = "N"
       
    For x = 3 To 40
        For y = 1 To 12
             Dim CELL As String
             CELL = CellsName(y) & x
             
             Call GenerowanieSumy.GenerowanieSumyZParametrem(CELL)

        Next y
    Next x

End Sub

Potem wykonuje pętle w pętli i tak dla każdej komórki od "C3 do N40" wykonam funkcję "GenerowanieSumyZParametrem".

Oto rezultat działanie tej metody

Jak widzisz funkcje nie są skomplikowane. Nawet taki prymitywnym podejściem można rozwiązać skomplikowany problem.

Visual Basic for Applications nie jest aż taki straszny

Czy można napisać ten kod inaczej? Mały tutorial. Oto jak możesz ustawić wartość komórki A2. 

Cells(2,1).Value = 1
Range("A2").Value = 1

W metodzie Cells w drugim parametrze podajesz kolumnę w formacie cyfrowej. Te dwie linki kodu robią dokładnie to samo

Cells("A1").Formula = Formula 'Gdzie chcesz umieścić tą formułę?'
Cells(1, 1).Formula = Formula 'Gdzie chcesz umieścić tą formułę?'

Wiedząc to możemy teraz zmodyfikować funkcje, która będzie generować te formuły. Jednakże do tego problemu możemy podejść jeszcze inaczej bez modyfikowania istniejącej już funkcji, która tworzy nam formułę

Do szczęścia potrzebujemy pomocniczej funkcję, która zamieni nam zapis cyfrowy kolumny na napis alfabetyczny.

Function Col_Letter(lngCol) As String
    Dim vArr
    vArr = Split(Cells(1, lngCol).Address(True, False), "$")
    Col_Letter = vArr(0)
End Function

Dzięki temu teraz stworzyć lepszą wersję metody, która zadziała dla komórek od C3 do N40. 

Sub GenerowanieSumy2C3toN40()
    
    For x = 3 To 40
        For y = 1 To 12
             ColumnLetter = GenerowanieSumy.Col_Letter(y)
            
             Dim CELL As String
             CELL = ColumnLetter & CStr(x)
             Call GenerowanieSumy.GenerowanieSumyWithParameter(CELL)

        Next y
    Next x

End Sub

To wszystko.

Brakuje mi też możliwość szybkiego obrotu poziomowego/pionowego zdjęcia oraz możliwości wycinania interesującego mnie fragmentu.

To nie są zaawansowane funkcje, ale nie chce otwierać edytora graficznego ("Paint.NET") , aby zrobić takie podstawowe operacje.

Próbowałem znaleźć program, który by mnie zadowolił.

InfraView to prawie jest to co chce, ale irytują mnie jego ikony, które są potem podpięte do każdego pliku z obrazkiem. Taki mam z nim problem chyba od 2008 roku.

Wiele innych programów odpadło, ponieważ mają one też sporą listę rzeczy, których nie chce mieć w takim programie. [more]

• Dodatkowych pod okien
  • Z informacją o tym, w jakim folderze obecnie się znajduje
• Zbyt rażących ikon
• Zbyt wielu przycisków, z których i tak nie skorzystam

Śmiechem, żartem kiedyś w akcji desperacji wygrzebałem program ACDSee Viewer, z którego korzystał jeszcze mój brat, gdy miał Windows 98. Potem jednak go zgubiłem po którymś formacie systemu. 

Postanowiłem dać szanse programowi  ImageGlass i sprawdziłem, czy spełnia on dla mnie wszystkie te warunki.

Oto jak wygląda przeglądanie na nim pliku przezroczystych plików .png

Warto zaznaczyć, że tę karuzelę (wszystkich obrazków w danym folderze) na dole można schować. Domyślnie jej nie ma.

Jest tylko obrazek. Powiększanie i przechodzenie do następnej ilustracji żaden sposób siebie nie blokuje. 

Gdy robiłem skany swoich notatek to sprawdziłem jak wygodnie jest obracać o 90 stopni obrazki i zapisać  te wprowadzone zmiany bez otwierania kolejnych edytorów graficznych. To samo dotyczy się wycinania.

Oficjalnie ten program dołączam do swoich programów. Program można pobrać tutaj https://imageglass.org/

Jakieś wady programu. Najlepiej przegląda się zdjęcia w trybie pełno ekranowym, gdyż powiększanie w trybie okna powoduje zmianę wielkość okna programu. Te zmiany wielkości dla niektórych może wyglądać jak migotanie. Nie wiem, czy jakiś inny program może obejść ten problem, czyli zmieniać swój rozmiar tak szybko, że nie widać tej operacji na monitorze.

Kolejna wada programu też polega na tym, że mimo iż istnieje w nim tryb "pokazów slajdów" to nigdzie w opcjach nie widzę możliwość ustawienia co ile sekund ma się zmienić następny obrazek.

Jeśli nie podobają Ci się ikony programu to możesz to zmienić instalując odpowiedni Theme. Mnie akurat te szare ikony się podobają. 

Gdybyś chciał zmienić skróty klawiszowe programu, jak i myszki to też masz taką możliwość,

A jak wyglądają ikony tego programu?

Jak widzisz ikony odpowiednio oznaczają typy obrazków. Jeśli więc potrzebujesz prostej przeglądarki do zdjęć to polecam ten program.

Jak najlepiej wyjaśnić ten wzorzec?

Najlepiej jest od razu przeskoczyć do przykładu.

Powiedzmy, że mamy następujące wyrażenie matematyczne, które dla ułatwienia składa się tylko z liczb (możliwie ułamkowych) i operatora odejmowania.

Oto przykład takiego wyrażenia : (1.0 - (2.0 - 3.0))

Chcemy teraz zapisać te wyrażenie matematyczne w sposób obiektowy. [more]

Na początku stwórzmy klasę abstrakcyjną, która będzie nam określała wszystkie możliwe wyrażenia. 

public abstract class Expression {  } 
//na razie puste

Teraz tworzymy klasę, która reprezentuje wyrażenie liczbowe.

public class DoubleExpression : Expression
{
    private double value;
    public DoubleExpression(double value) { this.value = value; }
}

Oto klasa, która określa wyrażenie odejmowania. Przyjmuje ona wartości po lewej i po prawej stronie.

public class SubtractionExpression : Expression
{
    private Expression left, right;
    public SubtractionExpression
        (Expression left, Expression right)
    {
        this.left = left;
        this.right = right;
    }
}

Wiemy, do czego chcemy dążyć. Interesują nasz teraz dwie rzeczy:

• Jak wydrukować te wyrażenie obiektowe jako tekst?
• Jak wykonać dane wyrażenie  obiektowe, aby otrzymać jego wynik

Istnieje wiele sposobów na rozwiązanie tych problemów.

Natrętny odwiedzający inaczej Intrusive Visitor

Najłatwiej by było dodać metodę drukującą do każdego wyrażenia. Tworząc metodę abstrakcyjną wymusimy takie zachowanie na każdym wyrażeniu zapisanym przy pomocy klas.

public abstract class Expression 
{
    public abstract void Print(StringBuilder sb);
} 

Pozostało nam teraz do klas dodać implementacje tej metod.

public class DoubleExpression : Expression
{
    public override void Print(StringBuilder sb)
    {
        sb.Append(value.ToString());
    }

    private double value;
    public DoubleExpression(double value) { this.value = value; }
}

Rekurencyjnie i poliformicznie wywołamy metodę "Print()" która ostatecznie stworzy nam kompletne wyrażenie w formie tekstowej.

public class SubtractionExpression : Expression
{
    public override void Print(StringBuilder sb)
    {
        sb.Append(value: "(");
        left.Print(sb);
        sb.Append(value: "-");
        right.Print(sb);
        sb.Append(value: ")");
    }

    private Expression left, right;
    public SubtractionExpression
        (Expression left, Expression right)
    {
        this.left = left;
        this.right = right;
    }
}

Sprawdźmy jak nasz kod działa.

var expression = new SubtractionExpression(
    left: new DoubleExpression(1),
    right: new SubtractionExpression(
    left: new DoubleExpression(2),
    right: new DoubleExpression(3)));

var sb = new StringBuilder();
expression.Print(sb);
Console.WriteLine(sb);

Wydaje się to łatwe, ale wyobraź sobie, że w tej hierarchii wyrażenia masz z 10 klas, które albo dziedziczą po sobie, albo są mniejszą częścią większego wyrażenia. Każda modyfikacji w tych klasach może wywołać reakcję łańcuchową, która przejdzie na wszystkie inne klasy co łamię zasadę "Otwarte-Zamknięte"  .

To jednak niejedyny problem

Kolejnym problemem jest złamana zasada "Pojedynczej odpowiedzialności" . W sumie każda klasa teraz  odpowiada za drukowanie całego wyrażenia.

Powinniśmy przedstawić oddzielną klasę, która skupi się tylko na drukowaniu. Potem też możemy stworzyć oddzielną klasę, która skupi się na rozwiązaniu całego wyrażenia.

Drukarka w stylu Reflective

Mamy więc swoje wyrażenie w postaci klasy abstrakcyjnej. Tym razem ona nic w sobie nie zawiera.

public abstract class Expression2
{

}

Nasze klasy wyglądają tak samo jak w pierwszym przykładzie.

public class SubtractionExpression : Expression2
{
    public Expression2  Right {get;set;}

    public Expression2 Left { get; set; }

    public SubtractionExpression
        (Expression2 left, Expression2 right)
    {
        this.Left = left;
        this.Right = right;
    }
}

public class DoubleExpression : Expression2
{
    public double Value { get; set; }
    public DoubleExpression(double value) { this.Value = value; }
}

Gdybyś chciał napisać swoją implementację drukowania to zapewne zrobiłbyś to tak

public static class ExpressionPrinter
{
    public static void Print(DoubleExpression e, StringBuilder sb)
    {
        sb.Append(e.Value);
    }
    public static void Print(SubtractionExpression ae, StringBuilder sb)
    {
        sb.Append("(");
        Print(ae.Left, sb); // to się nie kompiluje
        sb.Append("-");
        Print(ae.Right, sb); // to się nie kompiluje
        sb.Append(")");
    }
}

Aby jednak ten kod działał musielibyśmy ustalić, że wewnątrz wyrażenia odejmowania zawsze będą liczby ułamkowe. Co, jeśli będę chciał rozwijać swój program i będę tam w tym wyrażeniu odejmowania umieszczał jeszcze inne wyrażenia.

Nie możemy więc zmodyfikować klasy "SubtractionExpression"

Możemy stworzyć metodę drukującą wszystko i w niej będziemy sprawdzać, z jakim typem wyrażenia mamy do czynienia. 

public static class ExpressionPrinter
{
    public static void Print(Expression2 e, StringBuilder sb)
    {
        if (e is DoubleExpression de)
        {
            sb.Append(de.Value);
        }
        else if (e is SubtractionExpression ae)
        {
            sb.Append("(");
            Print(ae.Left, sb);
            sb.Append("+");
            Print(ae.Right, sb);
            sb.Append(")");
        }
    }
}

Jest to jakieś rozwiązanie.

var expression = new SubtractionExpression(
    left: new DoubleExpression(1),
    right: new SubtractionExpression(
    left: new DoubleExpression(2),
    right: new DoubleExpression(3)));

var sb = new StringBuilder();
ExpressionPrinter.Print(expression, sb);
Console.WriteLine(sb);

Te rozwiązanie oczywiście ma swoją wadę. Bez użycia refleksji w sumie nie masz jak sprawdzić, czy wszystkie możliwe warunki if-else dla wszystkich typów wyrażenia w programie biorą udział w drukowaniu.

Jeśli dojdzie nowe wyrażenie to oczywiście klasę "ExpressionPrinter" musisz zmodyfikować.

Czy można to zrobić lepiej?

Dynamiczny Odwiedzający : Dynamic Visitor

Na ratunek przychodzi słowo kluczowe "dynamic", które sprawia, że dany fragment kodu  zostanie sprawdzony, dopiero gdy ten kod się uruchomi.

Tradycyjnie sprawdzanie typów odbywa się w trakcie kompilacji programu.

Ten fragment kodu działa.

public class ExpressionPrinter2
{
    public void Print(SubtractionExpression se, StringBuilder sb)
    {
        sb.Append("(");
        Print((dynamic)se.Left, sb);
        sb.Append("+");
        Print((dynamic)se.Right, sb);
        sb.Append(")");
    }

    public void Print(DoubleExpression de, StringBuilder sb)
    {
        sb.Append(de.Value);
    }
}

Dalej już nic nie musimy zmieniać.

var sb = new StringBuilder();
ExpressionPrinter2 expressionPrinter2 
    = new ExpressionPrinter2();

expressionPrinter2.Print(expression, sb);

Console.WriteLine(sb);

Jakie są problemy z tym rozwiązaniem ?

• Program działa trochę wolniej niż wcześniej wynika to z działania kodu sposób dynamiczny
• Jeśli danej metody lub właściwości nie ma to oczywiście dostaniesz wyjątek RunTime Exception
• Mogą pojawić się problemy, gdy jeszcze nam dojdzie mechanizm dziedziczenia

Dynamiczny odwiedzający ma sens, gdy wiesz, że twoje wyrażenia nie będą aż tak skomplikowane oraz gdy wiesz, że dana metoda jak "Print" nie będzie wywoływana za często.

Przeciwnym wypadku twój system może mieć zbyt duże czkawki.

Klasyczny Odwiedzający : Classic Visitor

Jak wygląda klasyczne podejście do wzorca "Visitor". Otóż potrzebne są następujące metody

• Metoda Visit() wykona operacje wydruku albo liczenia. Nie chcemy mieć tej metod w każdym elemencie wyrażenie. Trzeba to jakoś wydzielić i zaraz Ci pokaże jak
• Metoda Accept() do sprawdzenia, czy metoda Visit() powinna się uruchomić. Ta metoda powinna się znajdować w każdym elemencie wyrażenia.

Tworzymy więc kolejną wersję naszej klasy abstrakcyjnej.

Tym razem każde wyrażenie musi mieć metodę "Accept()", która przyjmuje do siebie klasę, która będzie implementować interfejs "IExpressionVisitor".

public abstract class Expression3
{
    public abstract void Accept(IExpressionVisitor visitor);
}

Ten interfejs będzie miał w swoim kontrakcie wszystkie metody odwiedzające dla każdego wyrażenia.

public interface IExpressionVisitor
{
    void Visit(DoubleExpression de);
    void Visit(SubtractionExpression se);
}

Oto użycie naszej klasy abstrakcyjnej

public class SubtractionExpression : Expression3
{
    public Expression3 Right { get; set; }

    public Expression3 Left { get; set; }

    public SubtractionExpression
        (Expression3 left, Expression3 right)
    {
        this.Left = left;
        this.Right = right;
    }

    public override void Accept(IExpressionVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class DoubleExpression : Expression3
{
    public double Value { get; set; }
    public DoubleExpression(double value) { this.Value = value; }

    public override void Accept(IExpressionVisitor visitor)
    {
        visitor.Visit(this);
    }
}

O ile kod się powtarza teraz to też mamy możliwość dodania logiki blokującej wizytę danego elementu.

Teraz pozostało napisać nam trzecią wersję naszej drukarki, która będzie implementować interfejs "IExpressionVisitor"

public class ExpressionPrinter3 : IExpressionVisitor
{
    StringBuilder sb = new StringBuilder();

    public void Visit(DoubleExpression de)
    {
        sb.Append(de.Value);
    }
    public void Visit(SubtractionExpression se)
    {
        sb.Append("(");
        se.Left.Accept(this);
        sb.Append("+");
        se.Right.Accept(this);
        sb.Append(")");
    }
    public override string ToString() => sb.ToString();

}

Nie musimy też teraz korzystać ze słowa kluczowego dynamic, dzięki potędze słowa "this", która przekaże instancje naszej drukarki do innych metod.

var expression = new SubtractionExpression(
new DoubleExpression(1),
new SubtractionExpression(
new DoubleExpression(2),
new DoubleExpression(3)));

var ep = new ExpressionPrinter3();
Console.WriteLine($"{ep}");

Visitor / Odwiedzający do kalkulacji matematycznej

Zrobiliśmy przed chwilą drukowanie, a co z liczeniem danego wyrażenia? Nic nie stoi na przeszkodzie, aby napisać innego odwiedzającego, który właśnie to zrobi.

public class ExpressionCalculator : IExpressionVisitor
{
    public double Result;

    public void Visit(DoubleExpression de)
    {
        Result = de.Value;
    }
    public void Visit(SubtractionExpression se)
    {
        //za chwile
    }
}

Dla odejmowania zrobimy operacje odejmowania. Metoda Visit niczego nigdy nie powinna zwracać więc rezultat odejmowania idzie do innej właściwości.

public void Visit(SubtractionExpression se)
{
    se.Left.Accept(this);
    var a = Result;
    se.Right.Accept(this);
    var b = Result;
    Result = a - b;
}

Oto przykład naszego odwiedzającego, który umie interpretować wyrażenia matematyczne.

var expression = new SubtractionExpression(
new DoubleExpression(1),
new SubtractionExpression(
new DoubleExpression(2),
new DoubleExpression(3)));

var ep = new ExpressionPrinter3();

var calc = new ExpressionCalculator();
calc.Visit(expression);
Console.WriteLine($"{ep} = {calc.Result}");

Teraz możesz stworzyć według tego wzoru kolejnych odwiedzających, którzy będą operować na tych samym cegiełkach danego wyrażenia.

Co ciekawe każdy nowy odwiedzający nie będzie robił zmian w tych klasach reprezentujących dany elementy wyrażenia.

W ten sposób wiemy ,że zasada "Otwarte-Zamknięte" oraz zasada "Pojedynczej odpowiedzialności" jest spełniona. Co czyni kod czytelniejszym  i łatwym do zrozumienia.

Acykliczny Odwiedzający : Acyclic Visitor

Wzorzec projektowy Visitor, czyli odwiedzający ma jeszcze swoje dwa odłamy. 

• Cykliczny odwiedzający : polega na technice przeciążania metody/funkcji. Z tej techniki skorzystaliśmy do tej pory. Jednakże ten styl ma sens, gdy mamy styczność z hierarchią, która jest stabilna i się nie zmienia.
• Acykliczny odwiedzający : polega na rzutowaniu. Limitacje związane ze znajomością typu odwiedzającego znikają, ale idzie za tym koszt wydajności.

Zobaczmy jak możemy napisać Acyklicznego odwiedzającego:

W naszej drukarce nie potrzebujemy już metody Visit dla każdego typu. Możemy zrobić jedną metodę Visit, która rozmnoży się na inne metody generyczne w zależności od typu wyrażenia.

public interface IVisitor<TVisitable>
{
    void Visit(TVisitable obj);
}

Potrzebujemy też pusty interfejs, który określi nam to, że działamy ze wzorcem odwiedzającego. Poza oznaczeniem ten Interfejs nie robi nic.

public interface IVisitor { }

Tworzymy czwartą wersję klasy abstrakcyjne dla wszystkich wyrażeń. Jak widzisz poniższa metoda Accept jest wirtualna, a nie abstrakcyjna. Znaczy, to ,że patrzymy na domyślną implementację tej metody, chociaż możemy to zmienić poprzez przeciążenie tej metody

public abstract class Expression4
{
    public virtual void Accept(IVisitor visitor)
    {
        if (visitor is IVisitor<Expression4> typed)
            typed.Visit(this);
    }
}

Co tutaj się dzieje w tej nowej metodzie Accept ? Nasz parametr w tej metodzie musi implementować interfejs ogólny IVisitor. 

Później ten parametr spróbujemy z rzutować na interfejs IVisitor<T>, gdzie T będzie obecnym typem, w którym się znajdujemy.

Jeśli rzutowanie wykona się poprawnie wtedy wywołamy na tym typie metodę Visit().

Nasze elementy wyglądają tak samo. Pamiętaj, że każdy z nich ma tę domyślną implementację metody Visit() z możliwością przeciążenia.

public class SubtractionExpression : Expression4
{
    public Expression4 Right { get; set; }

    public Expression4 Left { get; set; }

    public SubtractionExpression
        (Expression4 left, Expression4 right)
    {
        this.Left = left;
        this.Right = right;
    }

}

public class DoubleExpression : Expression4
{
    public double Value { get; set; }
    public DoubleExpression(double value) { this.Value = value; }
}

Do sklejenia tego podejścia "Acyklicznego" potrzebujmy jeszcze drukarki, która nam wyświetli te wyrażenie w formie tekstowej. 

public class ExpressionPrinter : IVisitor,
IVisitor<Expression4>,
IVisitor<DoubleExpression>,
IVisitor<SubtractionExpression>
{
    StringBuilder sb = new StringBuilder();
    public void Visit(DoubleExpression de) {  }
    public void Visit(SubtractionExpression ae) {  }
    public void Visit(Expression4 obj)
    {
        // domyślne zachowanie if i else
    }
    public override string ToString() => sb.ToString();
}

Nasza drukarka musi implementować "IVisitor" i wszystkie generyczne pod typy interfejsu "IVisitor<T>" dla każdego wyrażenia, które istnieje systemu.

Niestety i tutaj pojawia się problem, z tym że nasze złożone wyrażenia zawierają po prostu definicję wyrażenia ogólnego "Expression4".

public class ExpressionPrinter4 : IVisitor,
IVisitor<Expression4>,
IVisitor<DoubleExpression>,
IVisitor<SubtractionExpression>
{
    StringBuilder sb = new StringBuilder();
    public void Visit(Expression4 obj)
    {
        if (obj is DoubleExpression)
            Visit(obj as DoubleExpression);
        if (obj is SubtractionExpression)
            Visit(obj as SubtractionExpression);
    }

    public void Visit(DoubleExpression de) 
    {
        sb.Append(de.Value);
    }
    public void Visit(SubtractionExpression se) 
    {
        sb.Append("(");
        se.Left.Accept(this);
        sb.Append("-");
        se.Right.Accept(this);
        sb.Append(")");
    }
    public override string ToString() => sb.ToString();
}

Znowu albo napiszemy if i else, aby obsłużyć taki problem ,albo skorzystam ze słowa kluczowego dynamic kosztem wydajności.

public void Visit(Expression4 obj)
{
    Visit((dynamic)obj);
}

Sprawdźmy, czy podejście acykliczne działa pisząc taki kod:

var expression4 = new SubtractionExpression(
    left: new DoubleExpression(1),
    right: new SubtractionExpression(
    left: new DoubleExpression(2),
    right: new DoubleExpression(3)));

ExpressionPrinter4 expressionPrinter4
    = new ExpressionPrinter4();

expressionPrinter4.Visit(expression4);
Console.WriteLine(expressionPrinter4);

Pamiętaj też, że w metodzie ogólnej Visit() w naszej drukarce możemy także wyrzucać wyjątki, gdy trafi się metoda Visit, którą nie obsługujemy. 

Podsumowanie

Wzorzec projektowy Visitor pozwala ci dodawać unikatowe zachowania dla każdego elementu danego wyrażenia, które też znajduje się w jakieś hierarchii. 

Oto na ile sposobów możesz skorzystać z tego wzorca :

• Intrusive : Dodajemy metodę do każdego elementu określającego cegiełki naszego wyrażenia. Później zgodnie z hierarchią wykonasz zbiór operacji na tych cegiełkach. Te podejście łamie zasadę otwarte-zamknięte oraz zasadę pojedynczej odpowiedzialności.
• Reflective : Dodajemy oddzielną klasę w tym przypadku klasę operacji drukowania tak, aby nie robić zmian w naszych element. Takich oddzielnych klas możesz mieć wiele. Przykładowo stworzyliśmy inną klasę, która wykonywała operacje matematyczne na naszym wyrażeniu.
• Dynamic : Zamiast pisać if i else możesz rzutować dany pod element na typ dynamiczny. To wszystko się stanie kosztem szybkości działania programu.
• Classic : Cała hierarchia elementów ulega zmianie tylko raz.  Każdy element ma metodę Accept(), która przyjmuje danego odwiedzającego. 
• Acyclic : Daje nam możliwość bardziej elastycznej relacji pomiędzy odwiedzającym a odwiedzanym.  Dzięki temu możemy mieć zbiór odwiedzających względem jednego zadania.

Wzorzec projektowy Visitor łączy się ze wzorcem Interpreter. Dlatego ta dwa wzorce zostawiłem sobie na koniec tego cyklu. 

Warto poznać podstawy tego wzorca, zanim skoczysz do wzorca Visitor stworzonych dla kompilatora Roslyn, który potrafi analizować składnie napisanego kodu, jak i ją modyfikować.

Ja mogę sobie gratulować, ponieważ w tym cyklu właśnie omówiliśmy wszystkie wzorce projektowe z Gang of Four. Pozostało mi przygotować jedno wielkie repozytorium GitHub z tymi wszystkim przykładami.

"Interpreter" jest powiązany z kompilatorem. Warto zaznaczyć, że oba pojęcia nie mówią dokładnie o tym samym, chociaż można ich używać zamiennie.  Przypadku języków programowania różnice są takie: [more]

• Kompilator : kompiluje język programowania do jakiegoś kodu maszynowego. Tak działają języki bazujące na C i C++ jak Java czy C#. W kompilatorze więc zawiera się Interpreter, bo w końcu coś musi zrozumieć składnie kodu, aby go przetransformować.
• Interpreter : nie przekształca kodu, tylko go uruchamia interpretując go. Tak działa Perl,Python, Matlab

Być może na studiach zostałeś zmuszony napisać prymitywny kompilator, aby zaliczyć przedmiot.  Tak pisanie kodu w innym języku programowania, aby potem dostać kod maszynowy w wyniku kompilacji, jest też formą wzorca "Interpreter".

"Interpreter" też może się ukrywać pod inną nazwą jak:

• "Parsers" tłumaczonych potocznie na polski parsery.
• oraz Analizatory składniowe

Jakie przykładowe parsery mamy w .NET i ogólnie w programowaniu:

Wyrażenia regularne (Regular expressions) : Co robimy, aby znaleźć specyficzne fragmenty tekstu ze skomplikowanymi zasadami.Przykładowo jakbyś napisał kod, który by wyszukał wszystkie wystąpienia adresów e-mail w tekście. Na pomoc przychodzą wyrażenia regularne, które mają swoja składnie i specyficzne zasady. Każde wyrażenie jak na przykład te...

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

...potrzebuje swojego interpretera.

Struktury danych jak CSV, XML, JSON, YAML wymagają odpowiedniego interpretera, aby mogły być odczytane i użyte.

Wyrażenia drzewiaste są kompilowane na wyrażenia lambda, czyli mają swojego interpretera. 

Każdy język programowania ma swój kompilator, który interpretuje kod i go transmituje na coś innego. Przykładowo TypeScript może być przetransformowany na język JavaScript poprzez interpretacje. 

Na potrzeby tego wpisu. Stwórzmy więc swój własny interpretator. Będziemy analizować tekst i zamieniać go na tokeny. Ta część programu nazywa się "Lexer". 

Później te tokeny zamienimy na poszczególne wartości, czyli będziemy "Parsować".

Co budujemy?

Naszym celem jest napisać program, który przetłumaczy tekst pisany w stylu "/u/l/{tekst" na wyrażenie HTML.

Oto dwa przykłady tego, jak ma mój program ma działać.

Przykład nie jest idealny, ale jeśli będziesz budował swój interpreter oto cegiełki do niego.

Lexing

Pierwsza operacja, która nas interesuje będzie polegać na zmianie polecenia tekstowego na zbiór tokenów.

Z czego powinien składać się nasz token. Powinien mieć informację o swoim typie oraz o przetrzymywanej wartości, która będzie oznacza różne rzeczy w zależności od kontekstu czy swojego typu.

public class Token
{
    public enum Type
    {
        Ul, Li, Text, 
    }

    public Type MyType;
    public string Text;
    public Token(Type type, string text)
    {
        MyType = type;
        Text = text;
    }
    public override string ToString()
    {
        return $"`{Text}`";
    }
}

Teraz musimy mieć metodę, która przetłumaczy te wyrażenie tekstowe na zbiór tokenów

IReadOnlyList<Token> Lex(string input)
{
    string[] words = input.Split("/");
    var result = new List<Token>();

    foreach (var word in words)
    {
        string text = "";
        if (word.Length > 1)
            text = word.Substring(1);
        if (word.Length == 0)
            continue;

        Token t;
        if (word[0] == 'u')
             t = new(Token.Type.Ul, text);
        else if(word[0] == 'l')
            t = new(Token.Type.Li, text);
        else if(word[0] == '{')
            t = new(Token.Type.Text, text);
        else
            t = new(Token.Type.Text, "");

        result.Add(t);
    }

    return result;
}

Logika jest następująca. Jeśli pierwszy znak to 'u' to wtedy uznaje, że chce wstawić element html <ul> gdzie dalszy tekst jest określeniem jego klasy CSS.

Analogicznie postępuje dla znaku 'l', który określa mi, że chce wstawić element html <li>.

Natomiast nawias klamrowy '{' mówi, że teraz mam wstawić token tekstowy. Mógłbym umieścić więcej typów tokenów, ale my chcemy prosty przykład, który pomoże ci w przyszłości napisać podobny kod.

Parsowanie

Parsowanie będzie polegało na transformacji uniwersalnych tokenów na dokładniejsze klasy, które określą nam potem ostateczny wynik tekstowy danego wyrażenia.

Pisząc taki interfejs łamię zasadę "Interface Segregation Principle".

Nie każda właściwość będzie używana przez klasy implementujące ten interfejs , ale tak mówiłem ten przykład nie jest idealny.

public interface IElement
{
    string Value { get; }

    string AfterValue { get; }

    public IElement Child { get; set; }
}

Teraz stwórzmy klasy, które będą określać zachowanie moich poszczególnych elementów wyrażenia.

Tak wygląda element tekstowy:

public class TextElement : IElement
{
    public TextElement(string value)
    {
        Value = "    "+ value;
    }
    public string Value { get; }

    public IElement Child { get; set; }

    public string AfterValue => "";
}

Tak będzie wyglądać element <li> i <ul>.

public class UlElement : IElement
{
    public UlElement(string cssclass)
    {
        if (!string.IsNullOrWhiteSpace(cssclass))
            Value = $"<ul class=\"{cssclass}\">";
        else
            Value = $"<ul>";

        AfterValue = "</ul>";
    }
    public string Value { get; }


    public IElement Child { get; set; }

    public string AfterValue { get; }
}

public class LiElement : IElement
{
    public LiElement(string cssclass)
    {
        if (!string.IsNullOrWhiteSpace(cssclass))
            Value = $"<li class=\"{cssclass}\">";
        else
            Value = $"<li>";

        AfterValue = "</li>";
    }
    public string Value { get; }

    public IElement Child { get; set; }

    public string AfterValue { get; }
}

Potrzebuje też klasy rodzica, który będzie mi przetrzymywać te wszystkie elementy, a potem całe te wyrażenia przetworzy na ostateczny tekst.

Ponieważ mamy element w elemencie to nie obędzie się bez rekurencji.

public class HtmlOperation : IElement
{
    public IElement Child { get; set; }
    public string Value
    {
        get
        {
            StringBuilder sb = new StringBuilder();

            sb = Rec(sb,Child);

            return sb.ToString();
        }
    }

    public string AfterValue => "";

    private StringBuilder Rec(StringBuilder sb, IElement e)
    {
        sb.AppendLine(e.Value);

        if (e.Child != null)
            Rec(sb, e.Child);

        if (e.AfterValue != null && e.AfterValue != "")
            sb.AppendLine(e.AfterValue);

        return sb;
    }
}

Teraz gdy mamy wszystkie elementy układanki to pozostało nam to napisać metodę, która zamieni te tokeny na nasze konkretne cegiełki HTML.

static HtmlOperation Parse(IReadOnlyList<Token> tokens)
{
    HtmlOperation root = new HtmlOperation(); 
    bool haveLHS = false;
    for (int i = 0; i < tokens.Count; i++)
    {
        var token = tokens[i];
        // look at the type of token
        switch (token.MyType)
        {
            case Token.Type.Text:
                Insert(root,new TextElement(token.Text));
                break;
            case Token.Type.Ul:
                Insert(root, new UlElement(token.Text));
                break;
            case Token.Type.Li:
                Insert(root, new LiElement(token.Text));
                break;
        }
    }
    return root;
}

Do tworzenia mojej struktury znowu będzie potrzebna rekurencja.

static IElement Insert(IElement root, IElement nextchild)
{
    if (root.Child != null)
        return Insert(root.Child, nextchild);
    else
    {
        root.Child = nextchild;
        return root;
    }
}

Program ten nie jest idealny. Po pierwsze nie łapie wszystkim możliwych nieprawidłowych wartości. Czy ten przykład można rozwijać? Oczywiście, że tak można do niego dodać kolejne tagi HTML i inne skrótowe oznaczenia, które wydrukują się specyficznie w tekście końcowym.

Użycie naszego Parsera i Lexera. 

Oto użycie naszego Parsera i Lexera. Program działać jak na obrazkach powyżej.

var input = "/ucssklaska/ltotezklaska/{tekst";

var tokens = Lex(input);

var parsed = Parse(tokens);

Console.WriteLine($"Ten zapis :\n");
Console.WriteLine($"{input} = \n");
Console.WriteLine($"Daje to :\n");
Console.WriteLine($"{parsed.Value}");

Podsumowanie

Wzorzec projektowy "Interpreter" jest bardzo rzadki. Pisanie swoich parserów zazwyczaj dotyczy jakiś błahych przykładów więc nie trzeba pisać tylu klas, aby wykonać swoje zadanie.

Nawet ten prosty przykład wzorca można było napisać po prostu dużą grupą warunków if i else. Chociaż z drugiej strony, jeśli planuje swojego Interpretera rozwijać to rozbicie tego kodu na tokeny i elementy do parsowania ma moim zdaniem sens.

Jeśli interesuje Cię tematyka pisania własnych kompilatorów to trochę źle trafiłeś. Mogę Cię odesłać do frameworków jak "Lex/Yacc" i "ANTLR".

Swoją przygodę też możesz zacząć od pisania pluginów do analizy kodu w samym Visual Studio.

Kompilator Roslyn to też temat rzeka, który nawet mnie kiedyś wciągnął do generowania dynamicznego całych projektów z kodem w Visual Studio.

Gdyby pada słowo "Proxy" to zazwyczaj mówimy o pośredniku komunikacyjnym między serwerami, które gadają do siebie.

Wzorzec projektowy Proxy też jest takim pośrednikiem między obiektami i jego rola polega na zabezpieczeniu,rozszerzeniu, zmodyfikowaniu jakieś innej funkcji systemu, która jest  pod nim.

W zależności od celu wzorzec ten będzie miał inną implementację. Dlatego nie ma on jednego dobrego podejścia.

Spójrz więc na te różne podejścia do tego wzorca. [more]:

• Protection Proxy,
• Property Proxy,
• Virtual Proxy 
• Communication Proxy
• i wiele innych, które możesz znaleźć w sieci

Protection Proxy

Idea "Protection proxy" jak sama nazwa wskazuje polega na zabezpieczeniu pewnego obiektu przed jakimś warunkiem biznesowym.

Mam więc komputer, który potrafi uruchamiać kod.

public class Computer : IComputer 
{
    public void RunCode()
    {
        Console.WriteLine("WriteCode");
    }
}

Później stwierdziłem, że nie każdy programista przed komputerem będzie mógł swój kod uruchomić. Wymyśliłem taką zasadę biznesową, że jeśli jesteś programistą XML lub HTML to niestety komputer powinien odmówić uruchomienia twojego kodu.

Z jakiegoś powodu nie mogę zmienić już swojej klasy Computer, aby to zrobić. Przyzwyczaja się do tego, bo zazwyczaj przez to, że nie możemy czegoś zmienić tworzymy klasy Proxy w każdym przykładzie w tym wpisie.

Postanowiłem napisać interfejs, który w żaden sposób nie modyfikuje już istniejącej klasy Computer.

public interface IComputer
{
    void RunCode();
}

Nasze proxy będzie zależne od "programisty". Ma on informację o tym, w czym on programuje.

public class Programer
{
    public PrograminLanguage Language { get; set; }
    public Programer(PrograminLanguage programinLanguage)
    {
        Language = programinLanguage;
    }
}

public enum PrograminLanguage
{
    JavaScript,
    CSharp,
    Java,
    HTML,
    XML
}

Jak wygląda nasze proxy? Jak widzisz pobieram sobie w konstruktorze instancje danego programisty. 

public class ComputerProxy : IComputer
{
    private Computer computer = new Computer();
    private Programer _programer;

    public ComputerProxy(Programer programer)
    {
        _programer = programer;
    }

    public void RunCode()
    {
        if (_programer.Language == PrograminLanguage.HTML)
        {
            Console.WriteLine("Html nie jest językiem programowania więc tego nie uruchamiam");
            return;
        }
        if (_programer.Language == PrograminLanguage.XML)
        {
            Console.WriteLine("XML nie jest językiem programowania więc tego nie uruchamiam");
            return;
        }

        computer.RunCode();
    }
}

Później w zależności od tego, w czym nasz programista programuje to albo uruchomimy kod, albo wyświetliły wiadomość o tym właśnie naszym zabezpieczeniu przed programistami XML i HTML.

Oto jak wygląda użycie naszego proxy.

IComputer com = new ComputerProxy
    (new Programer(PrograminLanguage.HTML));
com.ExecuteCode();

Czy ten wzorzec jest dobry? Wiesz, że lubię zadawać takie pytania. Największy problem tego wzorca leży w tym, że o ile może się wydawać, że klasy Computer i ComputerProxy są podobne to mają zupełnie inne konstruktory.

Czyli jeśli ComputerProxy ma służy za rozszerzenie istniejącej już funkcjonalności to ciężko tobię będzie zastąpić istniejące już użycia klasy Computer w systemie.

Zwłaszcza jeśli nie korzystałeś ze wstrzykiwania zależności i musi teraz taką poprawę zrobić w całym systemie.

Ten wzorzec ma sens, jeśli masz kontener wstrzykiwania zależności w przeciwnym wypadku niczego tak naprawdę nie rozwiązujesz i tak naprawdę tworzysz sobie kolejny problem na przyszłość.

Property Proxy

W C# korzysta z właściwości, które tak naprawdę są dobrze opakowanymi metodami GET i SET dla danego pola.

Czasami chcesz, aby twoje właściwości robiły coś jeszcze, gdy następuje proces przypisania wartość lub jej pobierania.

Dla tego przykładu chcemy zablokować przypisanie wartości do naszej właściwości, gdy próbujemy ustawić jej wartość na domyślną albo na null.

Korzystając z tego faktu możemy także w konsoli wyświetlić jakie wartości są w ogóle przypisywane do naszej właściwości.

Moglibyśmy skorzystać z normalnych właściwości, aby osiągnąć ten cel, ale my chcemy zobaczyć użycie wzorca Proxy, który nazywa się Property Proxy.

Property Proxy opakuje nam każdą właściwości, abyśmy od razu mieli takie zachowanie. Potem będziemy mogli skorzystać z naszej klasy "Property Proxy" w wielu miejscach.

To oczywiście odbije się kosztem wydajności, ale załóżmy, że nagle musimy do 1000 właściwości w różnych klasach takie zachowanie dopisać i musisz tę zmianę w kodzie jakoś zautomatyzować do dalszych poprawek.

Oto jak wygląda nasza klasa, która stworzy nam "Property Proxy".

public class Property<T> where T : new()
{
    private T value;
    private readonly string name;
    public T Value
    {
        get => value;
        set
        {
            if (Equals(this.value, value)) return;
            if (value == null || value.Equals(default(T))) return;

            Console.WriteLine($"Assigning {value} to {name}");
            this.value = value;
        }
    }
    public Property() : this(default(T)) { }
    public Property(T value, string name = "")
    {
        this.value = value;
        this.name = name;
    }

Zwróć uwagę na blokadę uzupełniania wartości w tej klasie.

set
{
    if (Equals(this.value, value)) return;
    if (value == null || value.Equals(default(T))) return;

    Console.WriteLine($"Assigning {value} to {name}");
    this.value = value;
}

...

Musi on zawierać jawną konwersję na typ, który będziemy opakowywać.

public static implicit operator T(Property<T> property)
{
    return property.Value; 
}
public static implicit operator Property<T>(T value)
{
    return new Property<T>(value); 
}

Pozostało nam już użyć tego wzorca:

public class Programer
{
    public Property<int> Luck
      = new Property<int>(10, nameof(Luck));

    public Property<int> Wisdom
        = new Property<int>(6, nameof(Wisdom));

    public Property<int> Intelligence
        = new Property<int>(7, nameof(Intelligence));
}

Niestety takie podejście nie działa. Ten kod nie zrobi nic.

var p = new Programer();
p.Wisdom = 12;
p.Luck = 12;
p.Intelligence = 0;

Problem leży w jawnej konwersji naszego proxy, która niestety nie potrafi modyfikować istniejącej właściwości. Taki kod zadziała, ale nie o to nam chodzi:

var p1 = new Programer();
p1.Wisdom.Value = 12;
p1.Luck.Value = 12;
p1.Intelligence.Value = 0;

Rozwiązanie polega na stworzeniu pól, które będą opakowane naszym proxy, a te pola będą referować się do istniejących już właściwości 

public class Programer2
{
    public readonly Property<int> luck
    = new Property<int>(10, nameof(luck));

    public readonly Property<int> wisdom = 
        new Property<int>(6, nameof(wisdom));

    public readonly Property<int> intelligence =
    new Property<int>(7, nameof(intelligence));

    public int Luck
    {
        get => luck.Value;
        set => luck.Value = value;
    }

    public int Wisdom
    {
        get => wisdom.Value;
        set => wisdom.Value = value;
    }

    public int Intelligence
    {
        get => intelligence.Value;
        set => intelligence.Value = value;
    }
}

Teraz ten kod zadziała. 

var p2 = new Programer2();
p2.Wisdom = 12;
p2.Luck = 12;
p2.Intelligence = 0;

Ten wzorzec wygląda kiepsko, ponieważ trzeba stworzyć oddzielną klasę do tego wzorca, jak i zmodyfikować istniejący już kod, a tego właśnie chcieliśmy uniknąć używając wzorca Proxy.

Te problemy mogą wynikać z ograniczeń języka C#, ale ciężko jest obronić ten wzorzec. Zmodyfikowaliśmy lekko kod, aby w teorii nie pisać jeszcze więcej kodu, który będzie się powtarzać, ale to od Ciebie zależy decyzja czy ten wzorzec ma sens.

Virtual Proxy

Virtual Proxy już istnieje i nazywa się Lazy<T>.

Lazy<T> utworzy Ci instancje obiektu, gdy ten będzie potrzebny. Chodzi o to, aby uniknąć czkawki przy pierwszym uruchomieniu całego systemu, gdy wszystkie obiekty się tworzą.

Na potrzeby wpisu szybko utworzę swoje Wirtualne Proxy.

interface IFile
{
    void Show();
}

Rola "Virtual Proxy" polega na użyciu oryginalnego API tak, aby stworzyć iluzję jego instancji. A tak naprawdę to oryginalne API zostanie utworzone, dopiero gdy będzie ono potrzebne.

Oto klasa, która odczyta plik tekstowy. Jak widzisz operację odczytu pliku zrobi się już w konstruktorze.

class TextFile : IFile
{
    private readonly string _path;

    private readonly List<string> _texts;

    private int _lines;
    public TextFile(string path)
    {
        this._path = path;
        _texts = new List<string>();

        using (StreamReader file = new StreamReader(_path))
        {
            int counter = 0;
            string ln;

            while ((ln = file.ReadLine()) != null)
            {
                _texts.Add(ln);
                counter++;
            }
            file.Close();
            _lines = counter;

        }
    }

    public void Show()
    {
        foreach (var item in _texts)
        {
            Console.WriteLine("===========");
            Console.WriteLine(item);
        }
        Console.WriteLine($"How many lines : {_lines}");
    }
}

Chcielibyśmy jednak aby ten konstruktor nie próbował otworzyć pliku natychmiast.

TextFile file = new TextFile(@"D:\text.txt");

Załóżmy, że nie możemy zmieniać tej istniejącej klasy, czyli musimy napisać swoje proxy, które nam zmodyfikuje takie zachowanie.

Oto nasze "Virtual Proxy"

class LazyTextFile : IFile
{
    private readonly string _path;

    private TextFile _textFile;

    public LazyTextFile(string path)
    {
        this._path = path;
    }

    public void Show()
    {
        if (_textFile == null)
            _textFile = new TextFile(this._path);

        _textFile.Show();
    }
}

Ta klasa stworzy instancje "TextFile" gdy ten będzie potrzebny, gdy skorzystamy z metody "Show()".

Obie klasy korzystają z tego samego interfejsu i mają taki sam konstruktor. Znaczy to, że łatwo możesz podmienić implementacje.

LazyTextFile file = new LazyTextFile(@"D:\text.txt");

file.Show();

Communication Proxy

Zadaniem tego proxy jest zasymulować zachowanie pewnego serwisu i jego metody, gdy ten znajduje się gdzieś w innym zasobie sieciowym.

Oto prosty przykład takiego proxy. Mamy interfejs, który sprawdza, czy dany serwis działa.

interface ICheck
{
    string Check(string message);
}

W aplikacji ASP.NET Core te sprawdzenie wyglądałoby tak.

[Route("api/[controller]")]
public class HomeController : ICheck
{
    [HttpGet("{message}")]
    public string Check(string message)
    {
        return message + "pong";
    }
}

W innej aplikacji chcemy uruchomić tę metodę. Tylko dla niej te API istnieje jako zasób sieciowy, który żyje pod jakiś adresem.

class RemoteHomeCheck : ICheck
{
    public string Check(string message)
    {
        string uri = "http://localhost:7149/api/home/" + message;
        return new WebClient().DownloadString(uri);
    }
}

Nasze "Communication Proxy" ten problem rozwiąże i z punktu widzenia użytkownika tworzymy iluzję tego, że ta usługa jest w naszej aplikacji. 

Chociaż tak naprawdę wysyłamy zapytanie HTTP, aby otrzymać rezultat oryginalnego API. 

Podsumowanie

W tym wpisie pokazałem Ci wiele różnych proxy. W przeciwieństwie do dekoratora Proxy nie wystawia publicznie oryginalnego API, które on przykrywa.

Zazwyczaj nie wymaga on modyfikacji oryginalnego kodu, ale jak sam się przekonałeś nie zawsze tak jest. 

Analogicznie możemy napisać "Logging Proxy", który jak się domyślasz przykrywa oryginalne API tylko po to, aby dodać informację o logowaniu.

Istnieje mnóstwo wzorców "Proxy". Istnieje szansa, że sam napisałeś w jakimś celu Proxy i nawet o tym nie wiedziałeś, że jest to oficjalny wzorzec projektowy. 

Spójrz na poniższy przykład [more]

Miliard kontraktów z wartościami, które będą się powtarzać

Wyobraź sobie, że mamy aplikację, w której mamy milion użytkowników i każdy z nich ma po 20 różnych kontraktów. Już na podstawie tej informacji wiemy, że pewne informacje będą się powtarzać. 

Imiona i nazwiska jak "Jan Kowalski" są bardzo popularne, więc i tu będą powtórzenia, nawet gdy mówimy o osobnych użytkownikach względem wszystkich kontraktów.

Ciągle też dochodzą inne typy umów więc ich wszystkich nigdy nie zdefiniowaliśmy, ale wiemy, że się powtarzają wśród wszystkich użytkowników.

Co możemy z tym zrobić? Pomyśl w teorii obecnie istnieje nawet szansa powtórzenia kontraktu, dla którego klient ma imie i nazwisko "Jan Kowalski" i ma typ umów "QWERT SMALL 1289".

Oczywiście, żeby wyróżnić unikatowych kontrakt dla konkretnego klient, to powinniśmy mieć jakiś jeszcze unikatowy identyfikator jak PESEL.

My jednak mówimy tutaj o problemie związany z tym, że te wszystkie wartości, które się powtarzają będą zajmować miejsce w pamięci.

Tradycyjnie taką klasę byśmy napisali tak:

public class Contract
{
    public string CustomerFullName { get;  }

    public string TypeDeal { get; }

    public Contract(string fullname, string typedeal)
    {
        CustomerFullName = fullname;
        TypeDeal = typedeal;
    }
}

Musimy taką klasę napisać inaczej. 

public class Contract2
{
    private static List<string> _cachedNames = new List<string>();
    private int[] flyweightsNames;

    private static List<string> _cachedTypeDeal = new List<string>();
    private int[] flyweightsTypeDeal;

Możemy wszystkie imiona i typy umów, które będą latać w naszej aplikacji przechowywać w statycznej liście. Co więcej, my chcemy zachować poszczególne wyraz w imionach i nazwiskach oraz typach umów i szukać tam duplikatów.

Znaczy to, że będziemy mogli przechowywać w jednym miejscu w pamięci wszystkich Janów i Darków niezależnie od tego, jakie mają nazwisko.

To samo tyczy się typów umów. Dla typu kontraktu "QWERT SMALL 1289" i "HALO SMALL" będziemy mogli współdzielić wyraz "SMALL".

Czym jest "Flyweight" w tym kontekście?

Jest nim tablica indeksów, która będzie referować się do specyficznych wartości w tych statycznych listach. Tablica indeksów typu Int32 będzie zajmować dużo mniej pamięci niż całe wyrazy wewnątrz naszego konkretnego kontraktu.

public Contract2(string fullname, string typedeal)
{
    int getOrAdd(string s, List<string> cache)
    {
        int idx = cache.IndexOf(s);
        if (idx != -1) return idx;
        else
        {
            cache.Add(s);
            return cache.Count - 1;
        }
    }

    flyweightsNames = fullname.Split(' ')
        .Select(s => getOrAdd(s, _cachedNames)).ToArray();

    flyweightsTypeDeal = typedeal.Split(' ')
        .Select(s => getOrAdd(s, _cachedTypeDeal)).ToArray();
}

W trakcie tworzenia naszego kontraktu będziemy umieszczać wydzielone imiona i nazwiska do naszej listy statycznej.

Nasze poprzednie właściwości będą teraz wyciągać imiona i nazwiska oraz typy umów z tych statycznych list.

public string CustomerFullName => string.Join(" ",
    flyweightsNames.Select(i =>_cachedNames[i]));

public string TypeDeal => string.Join(" ",
flyweightsTypeDeal.Select(i => _cachedTypeDeal[i]));

To wszystko. Rodzi się oczywiście pytanie, czy to rzeczywiście zajmuje mniej pamięci.

Próbowałem paru metod mierzenia pamięci, ale ostatecznie musiałem skorzystać z płatnego narzędzia dotMemory w wersji Trial.

Napisałem taki kod, aby sprawdzić, która z wersji będzie zajmować mniej pamięci. 

List<Contract> list;
{
    List<string> firstNames = new List<string>();

    List<string> surNames = new List<string>();

    List<string> typeDealPart1 = new List<string>();

    List<string> typeDealPart2 = new List<string>();

    list = new List<Contract>();

    for (int i = 0; i < 10; i++)
    {
        var a1 = RandomString();
        var a2 = RandomString();
        var a3 = RandomString();
        var a4 = RandomString();

        for (int j = 0; j < 10; i++)
        {
            list.Add(new Contract
                ($"{a1} {a2}"
                , $"{a3} {a4}"));
        }
        Console.WriteLine(i);
    }

    Console.WriteLine();
}
Console.WriteLine("Done");

Każdy napis będzie składać się z 10 losowych znaków. Dla imion i nazwisk oraz typów kontraktów będziemy mieć przynajmniej 10 powtórzeń.

string RandomString()
{
    Random rand = new Random();
    return new string(
    Enumerable.Range(0, 10)
    .Select(i => (char)('a' + rand.
    Next(26))).ToArray());
}

Pozostało uruchomić ten program w wersji Trial i zobaczyć, jakie będą wyniki.

Parametry testu są takie : mamy pół miliona kontraktów i mamy 10 powtórzeń wartości.Czyli co 50.000 kontrakt ma podobne parametry.

Dla tradycyjnego kontraktu wynik wygląda tak.

Natomiast wynik dla wzorca FlyWeight wygląda tak.

Jak widać nas wzorzec dla takich parametrów zajął tyle samo pamięci.

Ten niby zysk pamięci wynikający z ilość powtórzeń jakoś został odjęty od ilość pamięci, która jest potrzebna do stworzenia tablicy liczb całkowitych, które referują się do przetrzymywanych powtarzających się wartości.

Co trzeba zrobić , aby zobaczyć pozytywny rezultat tego wzorca ? Trzeba zrobić więcej potworzeń wartości.

Warto zaznaczyć, że kod ze wzorcem FlyWeight jest dużo wolniejszy od tradycyjnego podejścia. Śmiałoby powiedział, że ten kod jest 5 razy wolniejszy od tradycyjnego podejścia, chociaż nie mierzyłem tego ze stoperem.

Jak widać użycie tego wzorca musi być przemyślane.

List<Contract2> list;
{
    List<string> firstNames = new List<string>();

    List<string> surNames = new List<string>();

    List<string> typeDealPart1 = new List<string>();

    List<string> typeDealPart2 = new List<string>();

    list = new List<Contract2>();

    for (int i = 0; i < 50; i++)
    {
        var a1 = RandomString();
        var a2 = RandomString();
        var a3 = RandomString();
        var a4 = RandomString();

        for (int j = 0; j < 100; j++)
        {
            list.Add(new Contract2
                ($"{a1} {a2}"
                , $"{a3} {a4}"));
        }
        Console.WriteLine(i);
    }

    Console.WriteLine("Done");
    Console.Read();
}

Patrząc na poprzedni przykład możemy zauważyć, że wyniki w Megabajtach  nam dużo nie mówią dlatego zmniejszy rozmiar generowanej kolekcji, abyśmy mogli zobaczyć różnice wyników na podstawie poszczególnych bajtów.

Poza tym testowanie pół milionowej kolekcji dla wzorca FlyWeight trwało dobre 45 minut. Taka informacja dla Ciebie, gdybyś chciał testować podobny kod.

Parametry testu są takie : mamy 5000 kontraktów i mamy 100 powtórzeń wartości. Czyli co 50 kontrakt ma podobne parametry.

Teraz taki wynik mamy dla kontraktu.

A taki dla naszego wzorca FlyWeight

Czego się więc nauczyliśmy? Faktu, że trzeba używać tego wzorca z głową, gdy masz pewność, że liczba powtarzających się wartości w całym systemie przekroczy przynajmniej liczbę 10.

Dodatkowo wzorzec FlyWeight mógłby zajmować jeszcze więcej pamięci niż tradycyjne podejście, jeślibyśmy nie mielibyśmy potworzeń.

FlyWeight ma sens na pewno, gdy wiesz, że twój wskaźnik zajmuje mniej pamięci niż cały obiekt, do którego on się referuje.

Wzorzec FlyWeight też ma inne zastosowanie.

FlyWeight jako token modyfikujący : Przykład z formatowaniem tekstu

Wzorzec FlyWeight wymaga często głębokiej analizy, jakie wartości możemy ztokenizować tak, aby nie tworzyć kolejnych instancji pewnego obiektu, aby osiągnąć trochę inny cel przy niewielkiej modyfikacji parametrów.

Wyobraź sobie obiekt, który przechowuje tekst, który ma z milion znaków. W nim także mamy meta informację :

• O wielkości znaków w danym obszarze napisu. Przykładowo określamy, że znaki od 15 do 20 w napisie mają być pisane wielką literą.
• O kolorze napisu w danym obszarze tego napisu. Przykładowo określamy, że znaki od 15 do 20 w napisie mają być pisane na czerwono.

W czym jest problem? Spójrz na tą klasę, która reprezentuje taki obiekt.

public class FormattedText
{
    private string plainText;

    public FormattedText(string plainText)
    {
        this.plainText = plainText;
        _capitalize = new bool[plainText.Length];
        _colorize = new bool[plainText.Length];
    }
    public void Capitalize(int start, int end)
    {
        for (int i = start; i <= end; ++i)
            _capitalize[i] = true;
    }

    public void Colorize(int start, int end)
    {
        for (int i = start; i <= end; ++i)
            _colorize[i] = true;
    }

    public void SetColor(string c)
    {
        _color = c;
    }

    private bool[] _capitalize;
    private bool[] _colorize;
    private string _color;

Tak będziemy generować napis.

public void Write()
{
    for (var i = 0; i < plainText.Length; i++)
    {
        var c = plainText[i];

        if (_capitalize[i])
        {
            c = char.ToUpper(c);
        }
        if (_colorize[i])
        {
            if (_color == "Red")
                Console.ForegroundColor = ConsoleColor.Red;
            if (_color == "Green")
                Console.ForegroundColor = ConsoleColor.Green;     
        }

        Console.Write(c);
        Console.ResetColor();
    }
}

Teraz chce zmienić identyczny napis na dwa różne sposoby. Niestety z tego powodu muszę stworzyć dwie instancje swojej klasy. Co oczywiście zajmuje więcej pamięci.

var ft = new FormattedText
    ("In the land of the blind, the one-eyed man is king\n");
ft.Capitalize(19, 24);
ft.Colorize(19, 24);
ft.SetColor("Red");
ft.Write();

var ft2 = new FormattedText
    ("In the land of the blind, the one-eyed man is king\n");
ft2.Colorize(19, 24);
ft2.SetColor("Green");
ft2.Write();

Co możemy z tym zrobić?

Tablica znaków, czyli string wypadałoby wydzielić od informacji o tym, jak tekst powinien być w modyfikowany w danych obszarach.

To dam możliwość wielokrotnej modyfikacji tego samego napisu bez tworzenia kolejny instancji podobnych obiektów.

FlyWeight daje nam moc takich tokenów, które modyfikują część mechanizmu bez tworzenia go całkowicie od nowa jeszcze raz.

Oto nasz obiekt, który da nam możliwość modyfikacji formatowania.

public class TextRange
{
    public int Start, End;
    public bool Capitalize;
    public bool Colorize;
    public string Color;
    public bool ChooseRange(int position)
    {
        return position >= Start && position <= End;
    }
}

Nasza klasa też się zmieniła. Mamy teraz możliwość dodania wielu takich modyfikacji obszarowych na raz dla jednego napisu.

public class BetterFormattedText
{
    private readonly string plainText;
    private readonly List<TextRange> formatting
    = new List<TextRange>();

    public BetterFormattedText(string plainText)
    {
        this.plainText = plainText;
    }
    public TextRange GetRange(int start, int end)
    {
        var range = new TextRange { Start = start, End = end };
        formatting.Add(range);
        return range;
    }

Tak teraz wygląda metoda Write().

public void Write()
{
    for (var i = 0; i < plainText.Length; i++)
    {
        var c = plainText[i];
        foreach (var range in formatting)
        {
            
            if (range.ChooseRange(i) && range.Capitalize)
            {
                c = char.ToUpper(c);
            }
            if (range.ChooseRange(i) && range.Colorize)
            {
                if (range.Color == "Red")
                    Console.ForegroundColor = ConsoleColor.Red;
                if (range.Color == "Green")
                    Console.ForegroundColor = ConsoleColor.Green;        
            }

            Console.Write(c);
            Console.ResetColor();
        }
    }
}

A tak wygląda użycie naszej klasy. Jak widzisz dla drugiej modyfikacji nie muszę tworzy od nowa całego obiektu, czyli tworzyć napisu dwa razy. Co jest istotne, gdybyśmy mówili o tekście, który ma milion znaków.

var bft = new BetterFormattedText
    ("In the land of the blind, the one-eyed man is king\n");
var range = bft.GetRange(19, 24);
range.Color = "Green";
range.Capitalize = true;
range.Colorize = true;

bft.Write();
range.Color = "Red";
range.Capitalize = false;
range.Colorize = true;
bft.Write();

Przykład może nie jest idealny, ale chciałem Ci zobrazować jak tokenizacja pewnych mechanizmów może Ci oszczędzić miejsce w pamięci.

Podsumowanie:

Flyweight jest to technika, której celem jest oszczędność pamięci komputera. Czasem jego użycie jest jawne. Przykładowo aplikacja zwraca Ci token, który później pozwoli ci modyfikować cokolwiek jest do tego tokenu podpięte. Zrobiliśmy taki trik z naszym edytorem tekstowym.

Gdy Flyweight jest niejawne to wtedy klient nawet nie wie, że taki wzorzec jest użyty. Ten trik zobaczyłeś, gdy tworzyliśmy Kontrakty.

W frameworku .NET taki wzorzec już istnieje i jest nim typ generyczny Span<T>. Span<T> przechowuje w sobie informacje o punkcie początkowym, jak i długość pewnych tablic.

Jest to bardzo zaawansowana technika, ale rzeczywiście, jeśli myślisz o optymalizacji swojego programu gdzie krążą napisy lub inne duże obiekty to warto poczytać o Span<T>.