{"id":41,"date":"2022-10-18T14:19:00","date_gmt":"2022-10-18T12:19:00","guid":{"rendered":"http:\/\/217.182.75.69\/blog-content\/?p=41"},"modified":"2022-10-19T15:54:02","modified_gmt":"2022-10-19T13:54:02","slug":"jak-uzyc-asp-net-identity-i-nie-zrobic-sobie-smietnika-w-bazie-danych","status":"publish","type":"post","link":"https:\/\/blog.michalch.pl\/index.php\/2022\/10\/18\/jak-uzyc-asp-net-identity-i-nie-zrobic-sobie-smietnika-w-bazie-danych\/","title":{"rendered":"Jak u\u017cy\u0107 ASP.NET Identity i nie zrobi\u0107 sobie \u015bmietnika w bazie danych?"},"content":{"rendered":"

Mo\u017cesz skomentowa\u0107 ten wpis w serwisach spo\u0142eczno\u015bciowych: Linkedin (przejd\u017a<\/a>) lub Facebook (przejd\u017a<\/a>).<\/em><\/p>\n

Witam,<\/p>\n

w tym wpisie chcia\u0142em opisa\u0107 histori\u0119 swoich „zmaga\u0144” z ASP.NET Identity. My\u015bl\u0119 \u017ce niekt\u00f3rzy programi\u015bci mog\u0105 z tych zmaga\u0144 skorzysta\u0107 i u\u017cy\u0107 ich efekt\u00f3w we w\u0142asnych aplikacjach. Jest to tak\u017ce historyjka ciekawa, bo jest to jeden z epizod\u00f3w – wprawdzie nie najistotniejszy – ale jeden z powod\u00f3w, dla kt\u00f3rych moja \u015bcie\u017cka programistyczna potoczy\u0142a si\u0119 tak a nie inaczej.<\/p>\n

Wszystko zaczyna si\u0119 wiosn\u0105 2016 r. Moja wiedza o „du\u017cych” bibliotekach czy te\u017c frameworkach s\u0142u\u017c\u0105cych do budowy aplikacji by\u0142a w\u00f3wczas bardzo niewielka. W\u0142a\u015bnie planowa\u0142em sobie aplikacj\u0119 do mojej in\u017cynierki, a jedn\u0105 z decyzji jakie mia\u0142em podj\u0105\u0107, dotyczy\u0142a technologii z kt\u00f3rej skorzystam przy budowie tej aplikacji. W gr\u0119 wchodzi\u0142a w\u00f3wczas Java – a dok\u0142adniej zbudowany na jej bazie Spring Framework – oraz \u015brodowisko ASP.NET na bazie j\u0119zyka C#.<\/p>\n

Obie decyzje by\u0142y na tamten moment ryzykowne. Poniewa\u017c chcia\u0142em, aby moja aplikacja – a dok\u0142adniej strona internetowa – nie wymaga\u0142a prze\u0142adowywania strony za ka\u017cdym razem kiedy u\u017cytkownik co\u015b zmienia (tzw.\u00a0single-page application<\/em>), potrzebowa\u0142em jakiego\u015b mechanizmu logowania i obs\u0142ugi kont u\u017cytkownik\u00f3w, kt\u00f3ry zadzia\u0142a w warunkach REST API (a zatem standardowy formularz logowania nie wchodzi\u0142 w gr\u0119).\u00a0Pocz\u0105tkowo pr\u00f3bowa\u0142em wst\u0119pnie „okie\u0142zna\u0107” oba frameworki. O ile si\u0119 nie myl\u0119, na bardzo wczesnym etapie rozwa\u017ca\u0142em nawet jednoczesne tworzenie API w obydwu technologiach. Inn\u0105 mo\u017cliwo\u015bci\u0105 by\u0142 wyb\u00f3r tej biblioteki, kt\u00f3r\u0105 \u0142atwiej dopasuj\u0119 do swoich oczekiwa\u0144.<\/p>\n

W przypadku Springa, przez d\u0142ugi czas barier\u0105 nie do pokonania by\u0142o skonfigurowanie oAuth’a, kt\u00f3ry mia\u0142 mi pos\u0142u\u017cy\u0107 do obs\u0142ugi logowania u\u017cytkownik\u00f3w. Z kolei w przypadku ASP.NET problematycznym okaza\u0142 si\u0119 modu\u0142 ASP.NET Identity.<\/p>\n

W wielkim skr\u00f3cie, ASP.NET Identity – wraz z innymi komponentami ASP.NET – pozwala do\u015b\u0107 szybko zaprogramowa\u0107 i skonfigurowa\u0107 ca\u0142\u0105 obs\u0142ug\u0119 kont u\u017cytkownik\u00f3w, wraz z mo\u017cliwo\u015bci\u0105 wyboru czy chcemy korzysta\u0107 ze standardowych formularzy logowania, z lokalnego oAuth’a czy te\u017c mo\u017ce z zewn\u0119trznego podmiotu uwierzytelniaj\u0105cego takiego jak np. Google czy Facebook. Niemal\u017ce automatycznie pozwala te\u017c zapisa\u0107 wszystkie informacje o u\u017cytkownikach do bazy danych. Potrzebne do tego jest jedynie skonfigurowanie klasy DbContext<\/a>, a nast\u0119pnie wykonanie tzw. migracji, kt\u00f3ra zapisze nasz\u0105 struktur\u0119 danych w rzeczywistej bazie.<\/p>\n

Okaza\u0142o si\u0119 jednak \u017ce tak zbudowana biblioteka wymusza pewn\u0105 struktur\u0119 klasy odzwierciedlaj\u0105cej dane u\u017cytkownika systemu. Co gorsza, ta struktura jest zapisywana w bazie danych. Przyczyn\u0105 tego stanu rzeczy jest fakt, i\u017c domy\u015blny spos\u00f3b wykorzystania ASP.NET Identity zak\u0142ada \u017ce klasa reprezentuj\u0105ca u\u017cytkownika b\u0119dzie dziedziczy\u0107 po klasie IdentityUser<\/a>\u00a0–\u00a0na co wskazuje nag\u0142\u00f3wek klasy IdentityDbContext<\/a>, b\u0119d\u0105cej bazow\u0105 konfiguracja bazy danych:<\/p>\n

public<\/span> class<\/span> IdentityDbContext<\/span><TUser<\/span>> : IdentityDbContext<\/span><TUser<\/span>, IdentityRole<\/span>, string<\/span>> where<\/span> TUser<\/span> : IdentityUser<\/span><\/pre>\n
\u0179r\u00f3d\u0142o: repozytorium ASP.NET Core w serwisie github.com<\/a><\/small><\/small><\/p>\n
Z kolei klasa IdentityUser ju\u017c na samym starcie zawiera ca\u0142kiem sporo p\u00f3l. Na ka\u017cde z nich musi zosta\u0107 zarezerwowane miejsce w bazie danych.<\/p>\n
W efekcie, tabela u\u017cytkownik\u00f3w w naszej bazie danych b\u0119dzie wygl\u0105da\u0142a mniej wi\u0119cej tak:<\/p>\n
1> SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'AspNetUsers';\n2> GO\nCOLUMN_NAME\n--------------------\nId\nAccessFailedCount\nConcurrencyStamp\nEmail\nEmailConfirmed\nLockoutEnabled\nLockoutEnd\nNormalizedEmail\nNormalizedUserName\nPasswordHash\nPhoneNumber\nPhoneNumberConfirmed\nSecurityStamp\nTwoFactorEnabled\nUserName\n\n(15 rows affected)<\/pre>\n
Powy\u017cszy kod jest zrzutem z konsoli SQL Server w mojej przyk\u0142adowej bazie danych, kt\u00f3ra zosta\u0142a przygotowana na bazie instancji klasy IdentityUser. Wykona\u0142em tutaj polecenie odczytu nazw wszystkich kolumn w tabeli u\u017cytkownik\u00f3w.<\/p>\n
I teraz pytanie do Czytelnik\u00f3w:<\/p>\n
Czy naprawd\u0119 ka\u017cdy z Was w swojej aplikacji potrzebuje p\u00f3l takich jak: LockoutEnabled, LockoutEnd? A SecurityStamp?\u00a0ConcurrencyStamp? S\u0105 to kwestie dotycz\u0105ce aktywowania lub dezaktywowania konta u\u017cytkownik\u00f3w oraz znaczniki zwi\u0105zane z dodawaniem nowego konta u\u017cytkownika lub zmian\u0105 jego has\u0142a. Je\u015bli kto\u015b chce korzysta\u0107 – droga wolna, ale dla mnie to kompletny bullshit.<\/p>\n
AccessFailedCount? Liczba b\u0142\u0119dnych logowa\u0144 na konto danego u\u017cytkownika. TwoFactorEnabled? Logowanie dwusk\u0142adnikowe. Te rzeczy mog\u0105 si\u0119 przyda\u0107 przy systemach szczeg\u00f3lnie wra\u017cliwych na bezpiecze\u0144stwo, ale ma\u0142o prawdopodobne by interesowa\u0142y tw\u00f3rc\u0119 przeci\u0119tnej strony internetowej.<\/p>\n
Podobnie EmailConfirmed czy te\u017c\u00a0NormalizedEmail i\u00a0NormalizedUserName.<\/p>\n
Nawet pola dotycz\u0105ce numeru telefonu (PhoneNumber i\u00a0PhoneNumberConfirmed) nie musz\u0105 by\u0107 konieczne w ka\u017cdej aplikacji. Nie mam problemu wyobrazi\u0107 sobie prostej aplikacji, kt\u00f3ra nie potrzebuje zbiera\u0107 takich danych. Zw\u0142aszcza po wprowadzeniu RODO m\u00f3wi\u0142o si\u0119 wiele o tym, by nie zbiera\u0107 danych kt\u00f3rych nie musimy u\u017cywa\u0107.<\/p>\n
A wi\u0119c kiedy wspomnian\u0105 wiosn\u0105 2016 r. zorientowa\u0142em si\u0119 \u017ce te wszystkie pola musia\u0142yby siedzie\u0107 w bazie danych, zacz\u0105\u0142em si\u0119 zastanawia\u0107, co by tu zrobi\u0107 \u017ceby si\u0119 ich pozby\u0107 i korzysta\u0107 wy\u0142\u0105cznie z tych, kt\u00f3re s\u0105 mi rzeczywi\u015bcie potrzebne.<\/p>\n
W tamtym okresie mia\u0142em kontakt ze znajomym, kt\u00f3ry ko\u0144czy\u0142 studia i zaczyna\u0142 si\u0119 zajmowa\u0107 zawodowo programowaniem w .NET.\u00a0 Jednak na pytanie co zrobi\u0107 aby pozby\u0107 si\u0119 niechcianych p\u00f3l, stwierdzi\u0142: co mi te pola przeszkadzaj\u0105, \u017ce nie musz\u0119 ich wype\u0142nia\u0107 danymi, \u017ce to nie zajmuje zbyt wiele miejsca w bazie danych, \u017ce musia\u0142bym nadpisa\u0107 kilka komponent\u00f3w w Identity i w og\u00f3le tak si\u0119 nie powinno robi\u0107. Mo\u017cna powiedzie\u0107 i\u017c da\u0142 mi do zrozumienia \u017ce mi nijak nie pomo\u017ce.<\/p>\n
C\u00f3\u017c pocz\u0105\u0107… Nie umia\u0142em sobie jeszcze poradzi\u0107 z tym samodzielnie. Szczeg\u00f3lnie \u017ce w owym okresie open-source’owy .NET Core by\u0142 w powijakach. Kojarz\u0119 \u017ce nawet nie mia\u0142 jeszcze pierwszej wersji stabilnej, a jedynie testow\u0105. Moje \u00f3wczesne pr\u00f3by napisania aplikacji do in\u017cynierki dotyczy\u0142y jeszcze poprzedniego, Windowsowego \u015brodowiska ASP.NET, kt\u00f3ry nie mia\u0142 otwartego kodu. Nie mog\u0142em sobie podejrze\u0107 \u017ar\u00f3d\u0142a klas, kt\u00f3re powinienem nadpisa\u0107 aby pozby\u0107 si\u0119 niechcianych p\u00f3l IdentityUser’a. Mog\u0142em znale\u017a\u0107 jedynie ich nag\u0142\u00f3wki, a tak\u017ce dokumentacj\u0119 opisuj\u0105c\u0105 wprawdzie zastosowanie tych klas, ale bez dok\u0142adnej implementacji.<\/p>\n
Jaki\u015b czas p\u00f3\u017aniej uda\u0142o mi si\u0119 upora\u0107 z problemami kt\u00f3re uniemo\u017cliwia\u0142y mi prawid\u0142owe skonfigurowanie uwierzytelniania w aplikacji Springowej i finalnie aplikacja do pracy in\u017cynierskiej powsta\u0142a w tym w\u0142a\u015bnie frameworku – w j\u0119zyku Java. Kwestia „okie\u0142znania” ASP.NET Identity zosta\u0142a za\u015b od\u0142o\u017cona\u00a0ad acta<\/em>.<\/p>\n
Kr\u00f3tko po obronieniu mojej pracy in\u017cynierskiej napisa\u0142em nawet dosy\u0107 prost\u0105 aplikacj\u0119 REST API w \u015brodowisku ASP.NET Core. Jednak pomny przykrych do\u015bwiadcze\u0144 z ASP.NET Identity, tamtym razem nie skorzysta\u0142em w og\u00f3le z Identity, decyduj\u0105c si\u0119 w tym wzgl\u0119dzie na jedno z alternatywnych rozwi\u0105za\u0144.<\/p>\n
…<\/p>\n
Od czasu nieudanej pr\u00f3by u\u017cycia ASP.NET Identity min\u0119\u0142o ju\u017c kilka lat. Oczywi\u015bcie przez ten czas wiele si\u0119 zmieni\u0142o. Sp\u0119dzi\u0142em wiele czasu, pracuj\u0105c nad swoj\u0105 prac\u0105 magistersk\u0105, kt\u00f3ra dotyczy por\u00f3wnania Spring Framework i ASP.NET Core w zakresie mo\u017cliwo\u015bci jakie ka\u017cdy z nich daje programi\u015bcie przy tworzeniu aplikacji sieciowej, g\u0142\u00f3wnie REST API. Przy tworzeniu tej\u017ce pracy niejednokrotnie analizowa\u0142em dokumentacj\u0119, a nawet kod \u017ar\u00f3d\u0142owy ka\u017cdego z omawianych framework\u00f3w. (Na szcz\u0119\u015bcie, dzisiaj ASP.NET w opensource’owym wydaniu Core ma si\u0119 o wiele lepiej. Nie ma problemu z dotarciem do kodu \u017ar\u00f3d\u0142owego, a i jako\u015b\u0107 dokumentacji czy literatury jemu po\u015bwi\u0119conej jest znacznie lepsza – cho\u0107 moim zdaniem ASP.NET nadal ust\u0119puje w tym wzgl\u0119dzie Springowi.)<\/p>\n
Ju\u017c od jakiego\u015b czasu dochodzi\u0142em do wniosku \u017ce tym razem sta\u0107 b\u0119dzie mnie na samodzielne zmierzenie si\u0119 z wyzwaniem dokonania drobnych modyfikacji dzi\u0119ki kt\u00f3rym b\u0119d\u0119 m\u00f3g\u0142 wykorzysta\u0107 mo\u017cliwo\u015bci ASP.NET Identity, ale moja klasa (a zarazem tabela bazodanowa) u\u017cytkownika b\u0119dzie zawiera\u0142a te i tylko te pola, kt\u00f3re uznam za potrzebne.<\/p>\n
Poni\u017cej opisz\u0119, jak te zmagania wygl\u0105da\u0142y i co nale\u017cy wykona\u0107 aby za\u0142o\u017cony cel osi\u0105gn\u0105\u0107.<\/p>\n
Przyjrzyjmy si\u0119 najpierw, jak wygl\u0105da proces w\u0142\u0105czania modu\u0142u Identity do naszego projektu. Zajrzyjmy do \u017ar\u00f3d\u0142a (https:\/\/github.com\/aspnet\/Identity\/):<\/p>\n
Je\u015bli zajrzymy do kodu typowej aplikacji sieciowej wykorzystuj\u0105cej Identity, np. jednego z szablon\u00f3w generowanych w Visual Studio, w metodzie ConfigureServices klasy Startup pojawia si\u0119 co\u015b w tym stylu:<\/p>\n
services.AddIdentity<ApplicationUser, IdentityRole>().AddEntityFrameworkStores<ApplicationDbContext>().AddDefaultTokenProviders();\n<\/pre>\n
albo takim:<\/p>\n
services.AddDefaultIdentity<IdentityUser>().AddDefaultUI(UIFramework.Bootstrap4).AddEntityFrameworkStores<ApplicationDbContext>();\n<\/pre>\n
Metod\u0119 .AddIdentity<>() mo\u017cemy odnale\u017a\u0107 w klasie IdentityServiceCollectionExtensions<\/a>. Nag\u0142\u00f3wek tej metody wygl\u0105da nast\u0119puj\u0105co:<\/p>\n
public static IdentityBuilder AddIdentity(this IServiceCollection services) where TUser : class where TRole : class => services.AddIdentity(setupAction: null);\n[\u2026]\npublic static IdentityBuilder AddIdentity(this IServiceCollection services, Action setupAction) where TUser : class where TRole : class\n{\n[\u2026]\n}\n<\/pre>\n
W tej klasie nie pojawia si\u0119 odwo\u0142anie do klasy IdentityUser, kt\u00f3rej instancj\u0119 chcemy usun\u0105\u0107. Klasa u\u017cytkownika i jego roli mo\u017ce by\u0107 dowoln\u0105 klas\u0105. A zatem tej metody nie musimy rusza\u0107.<\/p>\n
Podobnie jest z alternatywn\u0105 metod\u0105 AddDefaultIdentity<>()<\/em>, kt\u00f3rej definicj\u0119 znajdziemy w klasie IdentityServiceCollectionUIExtensions<\/a>:<\/p>\n\n\n
\npublic static IdentityBuilder AddDefaultIdentity(this IServiceCollection services, Action configureOptions) where TUser : class\n{\n[\u2026]\n}\n<\/code><\/pre>\n\n\n
Wewn\u0105trz tej metody znajdziemy odwo\u0142anie do metody AddIdentityCore<>()<\/em>, wi\u0119c pozwol\u0119 sobie na pokazanie nag\u0142\u00f3wka r\u00f3wnie\u017c tej metody (klasa IdentityServiceCollectionExtensions><\/a> \/znajduje si\u0119 w innym pakiecie nazw ni\u017c pierwsza wymieniona klasa o tej nazwie – to nie jest to samo!\/:)<\/p>\n\n\n
\npublic static IdentityBuilder AddIdentityCore(this IServiceCollection services) where TUser : class => services.AddIdentityCore(o => { });\n[...]\npublic static IdentityBuilder AddIdentityCore(this IServiceCollection services, Action setupAction) where TUser : class\n{\n[...]\n}\n<\/code><\/pre>\n\n\n
Metody AddDefaultTokenProviders() (klasa IdentityBuilderExtensions<\/a>) oraz AddDefaultUI() (klasa IdentityBuilderUIExtensions<\/a>) tak\u017ce nie maj\u0105 nic wsp\u00f3lnego z klas\u0105 IdentityUser.<\/p>\n
Najwi\u0119cej do zrobienia b\u0119dzie z metod\u0105 AddEntityFrameworkStores<>()<\/em> – klasa IdentityEntityFrameworkBuilderExtensions<\/a>. Wygl\u0105da ona tak:<\/p>\n\n\n
\npublic static IdentityBuilder AddEntityFrameworkStores(this IdentityBuilder builder)\n    where TContext : DbContext\n{\n    AddStores(builder.Services, builder.UserType, builder.RoleType, typeof(TContext));\n    return builder;\n}\nprivate static void AddStores(IServiceCollection services, Type userType, Type roleType, Type contextType)\n{\n    var identityUserType = FindGenericBaseType(userType, typeof(IdentityUser<>));\n    if (identityUserType == null)\n    {\n        throw new InvalidOperationException(Resources.NotIdentityUser);\n    }\n    var keyType = identityUserType.GenericTypeArguments[0];\n    if (roleType != null)\n    {\n        var identityRoleType = FindGenericBaseType(roleType, typeof(IdentityRole<>));\n        if (identityRoleType == null)\n        {\n            throw new InvalidOperationException(Resources.NotIdentityRole);\n        }\n        Type userStoreType = null;\n        Type roleStoreType = null;\n        var identityContext = FindGenericBaseType(contextType, typeof(IdentityDbContext<,,,,,,,>));\n        if (identityContext == null)\n        {\n            \/\/ If its a custom DbContext, we can only add the default POCOs\n            userStoreType = typeof(UserStore<,,,>).MakeGenericType(userType, roleType, contextType, keyType);\n            roleStoreType = typeof(RoleStore<,,>).MakeGenericType(roleType, contextType, keyType);\n        }\n        else\n        {\n            userStoreType = typeof(UserStore<,,,,,,,,>).MakeGenericType(userType, roleType, contextType,\n                identityContext.GenericTypeArguments[2],\n                identityContext.GenericTypeArguments[3],\n                identityContext.GenericTypeArguments[4],\n                identityContext.GenericTypeArguments[5],\n                identityContext.GenericTypeArguments[7],\n                identityContext.GenericTypeArguments[6]);\n            roleStoreType = typeof(RoleStore<,,,,>).MakeGenericType(roleType, contextType,\n                identityContext.GenericTypeArguments[2],\n                identityContext.GenericTypeArguments[4],\n                identityContext.GenericTypeArguments[6]);\n        }\n        services.TryAddScoped(typeof(IUserStore<>).MakeGenericType(userType), userStoreType);\n        services.TryAddScoped(typeof(IRoleStore<>).MakeGenericType(roleType), roleStoreType);\n    }\n    else\n    {   \/\/ No Roles\n        Type userStoreType = null;\n        var identityContext = FindGenericBaseType(contextType, typeof(IdentityUserContext<,,,,>));\n        if (identityContext == null)\n        {\n            \/\/ If its a custom DbContext, we can only add the default POCOs\n            userStoreType = typeof(UserOnlyStore<,,>).MakeGenericType(userType, contextType, keyType);\n        }\n        else\n        {\n            userStoreType = typeof(UserOnlyStore<,,,,,>).MakeGenericType(userType, contextType,\n                identityContext.GenericTypeArguments[1],\n                identityContext.GenericTypeArguments[2],\n                identityContext.GenericTypeArguments[3],\n                identityContext.GenericTypeArguments[4]);\n        }\n        services.TryAddScoped(typeof(IUserStore<>).MakeGenericType(userType), userStoreType);\n    }\n}\n<\/code><\/pre>\n\n\n
Metoda AddEntityFrameworkStores<>()<\/em> przekierowuje ruch do kolejnej metody, o nazwie AddStores()<\/em>. Tam natomiast ju\u017c na samym pocz\u0105tku nast\u0119puje poszukiwanie typu generycznego na kt\u00f3ry zapisano klas\u0119 typu IdentityUser. Je\u015bli kompilator nie znajdzie takiej instancji w naszym projekcie, zwr\u00f3ci wyj\u0105tek i aplikacja si\u0119 nie skompiluje.<\/p>\n
Zatem, ca\u0142\u0105 t\u0119 metod\u0119 musimy napisa\u0107 na nowo, je\u015bli chcemy pozby\u0107 si\u0119 konieczno\u015bci odwo\u0142ania do klasy IdentityUser.<\/p>\n
Co jednak robi ta nieszcz\u0119sna metoda AddStores()<\/em>?<\/p>\n
Na pocz\u0105tku, jak ju\u017c pisa\u0142em, pr\u00f3buje ona odszuka\u0107 typ generyczny przypisany do instancji IdentityUser w naszej aplikacji. Upraszczaj\u0105c, chodzi o typ wpisany w nawiasach tr\u00f3jk\u0105tnych obok typu klasy, np. IdentityUser<int>, IdentityUser<string> itp. Jest to typ klucza g\u0142\u00f3wnego b\u0119d\u0105cego identyfikatorem danego u\u017cytkownika. Mo\u017ce to by\u0107 warto\u015b\u0107 liczbowa, albo np. nazwa u\u017cytkownika czy te\u017c tzw. globally unique identifier, w skr\u00f3cie GUID.<\/a><\/p>\n
Nast\u0119pnym etapem wykonywania metody AddStores()<\/em> jest pr\u00f3ba odszukania – w analogiczny spos\u00f3b – typu identyfikatora w roli u\u017cytkownika. Tu r\u00f3wnie\u017c wymusza si\u0119 na programi\u015bcie, aby skorzysta\u0142 z narzuconej przez ASP.NET klasy IdentityRole<\/a>. Podobnie jak IdentityUser, mamy tutaj kilka nadmiarowych p\u00f3l, kt\u00f3re tw\u00f3rcy frameworka pr\u00f3buj\u0105 „na si\u0142\u0119” wcisn\u0105\u0107 do naszej bazy danych, nie pytaj\u0105c si\u0119 programisty czy tych danych potrzebuje czy nie. Obok oczywistej informacji, jak nazwa roli u\u017cytkownika czy te\u017c identyfikatora roli (chocia\u017c niekt\u00f3rzy tw\u00f3rcy aplikacji mogliby przyj\u0105\u0107 \u017ce nazwa roli wystarczy jako jej identyfikator), wymusza si\u0119 na programi\u015bcie zapewnienie miejsca w bazie danych na pola takie jak: nazwa znormalizowana roli czy „concurrency stamp” (tego zwrotu nawet nie uda\u0142o mi si\u0119 przet\u0142umaczy\u0107 na j\u0119zyk polski), wed\u0142ug opisu ma to by\u0107 jaka\u015b losowa warto\u015b\u0107 zmieniana za ka\u017cdym razem kiedy umieszcza si\u0119 now\u0105 rol\u0119 u\u017cytkownika w zbiorze wszystkich r\u00f3l.<\/p>\n
<\/p>\n
Jednak po kolejnym przyjrzeniu si\u0119<\/strong> temu, co dzieje si\u0119 wewn\u0105trz metody AddStores(), <\/em>zwr\u00f3ci\u0142em uwag\u0119 na zupe\u0142nie inny element<\/strong>, kt\u00f3ry okaza\u0142 si\u0119 by\u0107 KLUCZOWYM<\/strong>.<\/p>\n
Zauwa\u017cmy \u017ce pr\u00f3buj\u0105c odnale\u017a\u0107 te typy generyczne, odwo\u0142ano si\u0119 do klas o nazwie UserStore<\/em> i RoleStore<\/em>:<\/p>\n\n\n
\nuserStoreType = typeof(UserStore<...>).MakeGenericType(...)\nroleStoreType = typeof(RoleStore<...>).MakeGenericType(...)\n<\/code><\/pre>\n\n\n\n
Warto tak\u017ce zwr\u00f3ci\u0107 uwag\u0119 na dodanie serwis\u00f3w do mechanizmu dependency injection<\/em>, gdzie ma miejsce  odwo\u0142anie do interfejs\u00f3w o nazwach IUserStore<><\/em> i IRoleStore<><\/em>:<\/p>\n\n\n\n
services.TryAddScoped(typeof(IUserStore<>).MakeGenericType(userType), userStoreType);\nservices.TryAddScoped(typeof(IRoleStore<>).MakeGenericType(roleType), roleStoreType);<\/code><\/pre>\n\n\n\n
Wspomniane klasy UserStore<\/a><><\/em> i RoleStore<\/a><><\/em> nadal zale\u017c\u0105 od nieszcz\u0119snego IdentityUser<\/em> (i analogicznie od IdentityRole<\/em>), jednak ogl\u0105daj\u0105c ich kod \u017ar\u00f3d\u0142owy znacznie bardziej zbli\u017camy si\u0119 do rozwi\u0105zania naszego problemu.<\/p>\n\n\n\n
Sp\u00f3jrzmy najpierw na nag\u0142\u00f3wki wspomnianych klas:<\/p>\n\n\n\n
public class UserStore<TUser, TRole, TContext, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken, TRoleClaim> :\n        UserStoreBase<TUser, TRole, TKey, TUserClaim, TUserRole, TUserLogin, TUserToken, TRoleClaim>,\n        IProtectedUserStore<TUser>\n        where TUser : IdentityUser<TKey>\n        where TRole : IdentityRole<TKey>\n        where TContext : DbContext\n        where TKey : IEquatable<TKey>\n        where TUserClaim : IdentityUserClaim<TKey>, new()\n        where TUserRole : IdentityUserRole<TKey>, new()\n        where TUserLogin : IdentityUserLogin<TKey>, new()\n        where TUserToken : IdentityUserToken<TKey>, new()\n        where TRoleClaim : IdentityRoleClaim<TKey>, new()\n...\n\npublic class RoleStore<TRole, TContext, TKey, TUserRole, TRoleClaim> :\n        IQueryableRoleStore<TRole>,\n        IRoleClaimStore<TRole>\n        where TRole : IdentityRole<TKey>\n        where TKey : IEquatable<TKey>\n        where TContext : DbContext\n        where TUserRole : IdentityUserRole<TKey>, new()\n        where TRoleClaim : IdentityRoleClaim<TKey>, new()\n...<\/code><\/pre>\n\n\n\n
Dodatkowo, zaprezentuj\u0119 nag\u0142\u00f3wek klasy UserStoreBase<><\/em>, kt\u00f3r\u0105 rozszerza wymieniona przed chwil\u0105 klasa UserStore<><\/em>:<\/p>\n\n\n\n
public abstract class UserStoreBase<TUser, TKey, TUserClaim, TUserLogin, TUserToken> :\n        IUserLoginStore<TUser>,\n        IUserClaimStore<TUser>,\n        IUserPasswordStore<TUser>,\n        IUserSecurityStampStore<TUser>,\n        IUserEmailStore<TUser>,\n        IUserLockoutStore<TUser>,\n        IUserPhoneNumberStore<TUser>,\n        IQueryableUserStore<TUser>,\n        IUserTwoFactorStore<TUser>,\n        IUserAuthenticationTokenStore<TUser>,\n        IUserAuthenticatorKeyStore<TUser>,\n        IUserTwoFactorRecoveryCodeStore<TUser>\n        where TUser : IdentityUser<TKey>\n        where TKey : IEquatable<TKey>\n        where TUserClaim : IdentityUserClaim<TKey>, new()\n        where TUserLogin : IdentityUserLogin<TKey>, new()\n        where TUserToken : IdentityUserToken<TKey>, new()\n...<\/code><\/pre>\n\n\n\n
Zwr\u00f3\u0107my teraz uwag\u0119 na fakt, i\u017c zacytowane klasy: UserStore<><\/em>, UserStoreBase<><\/em> i RoleStore<><\/em> implementuj\u0105 interfejsy odpowiadaj\u0105ce za przechowywanie r\u00f3\u017cnych informacji na temat u\u017cytkownika lub jego roli w systemie. Wszystkie one dziedzicz\u0105 odpowiednio po IUserStore<><\/em> lub IRoleStore<><\/em>.<\/p>\n\n\n\n
Przypomn\u0119, i\u017c istot\u0105 tych poszukiwa\u0144 by\u0142o zdobycie wiedzy o tym, co nale\u017cy zrobi\u0107, aby skonfigurowa\u0107 ASP.NET Identity przy u\u017cyciu w\u0142asnego formatu bazy danych, z u\u017cyciem tylko tych p\u00f3l kt\u00f3re s\u0105 nam rzeczywi\u015bcie potrzebne.<\/p>\n\n\n\n
Rozwi\u0105zaniem<\/strong> problemu jest samodzielna implementacja<\/strong> interfejs\u00f3w IUserStore<><\/em>, IRoleStore<><\/em> lub, w razie potrzeby innego, bardziej szczeg\u00f3\u0142owego interfejsu dziedzicz\u0105cego po IUserStore<><\/em>, a nast\u0119pnie  u\u017cycie tej implementacji w konfiguracji naszej aplikacji.<\/p>\n\n\n\n
Niestety, rozwi\u0105zanie to okaza\u0142o si\u0119 by\u0107 obarczone pewn\u0105 wad\u0105, kt\u00f3ra wywodzi si\u0119 z samej konstrukcji ASP.NET Identity i wed\u0142ug mojej wiedzy, nie ma mo\u017cliwo\u015bci jej idealnego „omini\u0119cia”.<\/p>\n\n\n\n
W\u015br\u00f3d metod znajduj\u0105cych si\u0119 w najbardziej podstawowych interfejsach IUserStore<> i IRoleStore<> znalaz\u0142o si\u0119 odniesienie do tzw. „znormalizowanej nazwy” u\u017cytkownika lub roli, w postaci metod GetNormalizedUserNameAsync<\/em>() i SetNormalizedUserNameAsync()<\/em> dla IUserStore<><\/em> i analogicznych dla IRoleStore<><\/em>. Jedynym wyj\u015bciem z tej sytuacji – je\u017celi nie chcemy zamie\u015bci\u0107 w bazie osobnego pola dla nazwy znormalizowanej – jest kreatywne „obej\u015bcie” tej kwestii w kodzie. Mo\u017cemy tu skorzysta\u0107 z podpowiedzi zamieszczonej przez jednego z u\u017cytkownik\u00f3w portalu Stackoverflow.com<\/a> – zwracanie w metodzie „Get…” naszej nazwy zapisanej wielkimi literami, oraz ignorowanie operacji „Set…” poprzez pozostawienie tej metody pustej (implementacja nie wykonuj\u0105ca \u017cadnej akcji).<\/p>\n\n\n\n
Mo\u017cesz skomentowa\u0107 ten wpis w serwisach spo\u0142eczno\u015bciowych: Linkedin (przejd\u017a<\/a>) lub Facebook (przejd\u017a<\/a>).<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
Mo\u017cesz skomentowa\u0107 ten wpis w serwisach spo\u0142eczno\u015bciowych: Linkedin (przejd\u017a) lub Facebook (przejd\u017a). Witam, w tym wpisie chcia\u0142em opisa\u0107 histori\u0119 swoich „zmaga\u0144” z ASP.NET Identity. My\u015bl\u0119 \u017ce niekt\u00f3rzy programi\u015bci mog\u0105 z tych zmaga\u0144 skorzysta\u0107 i u\u017cy\u0107 ich efekt\u00f3w we w\u0142asnych aplikacjach. Jest to tak\u017ce historyjka ciekawa, bo jest to jeden z epizod\u00f3w – wprawdzie nie najistotniejszy […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[4],"tags":[],"_links":{"self":[{"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/posts\/41"}],"collection":[{"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/comments?post=41"}],"version-history":[{"count":41,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/posts\/41\/revisions"}],"predecessor-version":[{"id":134,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/posts\/41\/revisions\/134"}],"wp:attachment":[{"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/media?parent=41"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/categories?post=41"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.michalch.pl\/index.php\/wp-json\/wp\/v2\/tags?post=41"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}