var claims = new[]
            {
                new Claim(ClaimTypes.Name, customer.Username, ClaimValueTypes.String, "Issuer"),
                new Claim(ClaimTypes.Email, customer.Email, ClaimValueTypes.Email, "Issuer")
            };
            
            var userIdentity = new ClaimsIdentity(claims, "AuthenticationScheme");
            var userPrincipal = new ClaimsPrincipal(userIdentity);

            var authenticationProperties = new AuthenticationProperties
            {
                IsPersistent = isPersistent,
                IssuedUtc = DateTime.UtcNow
            };

            //sign in
            await HttpContext.SignInAsync("AuthenticationScheme", userPrincipal,   authenticationProperties);

public class AuthenticationMiddleware
    {
        private readonly RequestDelegate _next;

        public IAuthenticationSchemeProvider Schemes { get; set; }

        public AuthenticationMiddleware(RequestDelegate next, IAuthenticationSchemeProvider schemes)
        {
            _next = next ?? throw new ArgumentNullException(nameof(next));
            Schemes = schemes ?? throw new ArgumentNullException(nameof(schemes));
        }


        public async Task Invoke(HttpContext context)
        {
            context.Features.Set<IAuthenticationFeature>(new AuthenticationFeature
            {
                OriginalPath = context.Request.Path,
                OriginalPathBase = context.Request.PathBase
            });

            // Give any IAuthenticationRequestHandler schemes a chance to handle the request
            var handlers = context.RequestServices.GetRequiredService<IAuthenticationHandlerProvider>();
            foreach (var scheme in await Schemes.GetRequestHandlerSchemesAsync())
            {
                try
                {
                    if (await handlers.GetHandlerAsync(context, scheme.Name) is IAuthenticationRequestHandler handler && await handler.HandleRequestAsync())
                        return;
                }
                catch { continue; }
            }

            var defaultAuthenticate = await Schemes.GetDefaultAuthenticateSchemeAsync();
            if (defaultAuthenticate != null)
            {
                var result = await context.AuthenticateAsync(defaultAuthenticate.Name);
                if (result?.Principal != null)
                {
                    context.User = result.Principal;
                }
            }

            await _next(context);
        }
    }

var authenticationBuilder = services.AddAuthentication(options =>
            {
                options.DefaultSignInScheme = "AuthenticationScheme";
            });

            authenticationBuilder.AddCookie("AuthenticationScheme", options =>
            {
                options.Cookie.Name = "lalala";
                options.Cookie.HttpOnly = true;
                options.LoginPath = "LoginPath";
                options.AccessDeniedPath = "AccessDeniedPath";
            });

...........
             application.UseMiddleware<AuthenticationMiddleware>();

            app.UseMiddleware<AuthenticationMiddleware>();

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });