[ServiceContract]
public interface IService1                       
{
    [OperationContract]                                 
    string GetData(int value);
    [OperationContract]
    CompositeType GetDataUsingDataContract(CompositeType composite);
}
...
public class Service1 : IService1                         
{
    public string GetData(int value)
    {
        return string.Format("You entered: {0}", value);
    }

    public CompositeType GetDataUsingDataContract(CompositeType composite)
    {
        if (composite == null)
        {
            throw new ArgumentNullException("composite");
        }
        if (composite.BoolValue)
        {
            composite.StringValue += "Suffix";
        }
        return composite;
    }
}

1- Inline Constraints

app.UseMvc(routes =>
{
    routes.MapRoute("Values",
        "api/values/{id:int}",
        new { controller = "Values", action = "Get" });
});

[Route("api/[controller]")]
public class ValuesController : ControllerBase
{
    [HttpGet("{name:minlength(2):maxlength(10):alpha}")]
    public IActionResult Get(string name)
    {
        return Ok(name);
    }
}

2- MapRoute's Constraints Argument

app.UseMvc(routes =>
{
    routes.MapRoute(
        name: "Values",
        template: "api/values/{name}",
        defaults: new { controller = "Values", action = "Get" },
        constraints: new
        {
            name = new CompositeRouteConstraint(new List<IRouteConstraint>
            {
                new AlphaRouteConstraint(),
                new MinLengthRouteConstraint(2),
                new MaxLengthRouteConstraint(10)
            })
        });
});

public class StartsWithConstraint : IRouteConstraint
{
    public StartsWithConstraint(string startsWith)
    {
        if (string.IsNullOrWhiteSpace(startsWith))
            throw new ArgumentNullException(nameof(StartsWith));
        StartsWith = startsWith;
    }

    private string StartsWith { get; }

    public bool Match(HttpContext httpContext,
        IRouter route,
        string parameterName,
        RouteValueDictionary values,
        RouteDirection routeDirection)
    {
        if (parameterName == null)
            throw new ArgumentNullException(nameof(parameterName));

        if (values == null)
            throw new ArgumentNullException(nameof(values));

        if (!values.TryGetValue(parameterName, out var value) || value == null) 
            return false;

        string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
        return valueString.StartsWith(StartsWith);
    }
}

services.Configure<RouteOptions>(opt =>
opt.ConstraintMap.Add("startsWith", typeof(StartsWithConstraint)));

[Route("api/[controller]")]
public class ValuesController : ControllerBase
{
    [HttpGet("{name:minlength(2):maxlength(10):alpha:startsWith(Mo)}")]
    public IActionResult Get(string name)
    {
        return Ok(name);
    }
}

• Which API are you using? – Google+ API
• Where will you be calling the API from? – Web server (e.g. node.js, Tomcat)
• What data will you be accessing? – User data

https://localhost:6001/signin-google

{
  "Authentication": {
    "Google": {
      "ClientId": "xxxx",
      "ClientSecret": "xxxx"
    }
  }
}

namespace DNT.IDP
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
   // ... 

            services.AddAuthentication()
                .AddGoogle(authenticationScheme: "Google", configureOptions: options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                    options.ClientId = Configuration["Authentication:Google:ClientId"];
                    options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
                });
        }

 public const string ExternalCookieAuthenticationScheme = "idsrv.external";

namespace DNT.IDP.Controllers.Account
{
    [SecurityHeaders]
    [AllowAnonymous]
    public class ExternalController : Controller
    {
        public async Task<IActionResult> Callback()
        {
            var result = await HttpContext.AuthenticateAsync(IdentityServer4.IdentityServerConstants.ExternalCookieAuthenticationScheme);
            var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

            var (user, provider, providerUserId, claims) = await FindUserFromExternalProvider(result);
            if (user == null)
            {
                // user = AutoProvisionUser(provider, providerUserId, claims);
                
                var returnUrlAfterRegistration = Url.Action("Callback", new { returnUrl = returnUrl });
                var continueWithUrl = Url.Action("RegisterUser", "UserRegistration" ,
                    new { returnUrl = returnUrlAfterRegistration, provider = provider, providerUserId = providerUserId });
                return Redirect(continueWithUrl);
            }

var (user, provider, providerUserId, claims) = await FindUserFromExternalProvider(result);  
foreach (var claim in claims)
{
   _logger.LogInformation($"External provider[{provider}] info-> claim:{claim.Type}, value:{claim.Value}");
}

External provider[Google] info-> claim:http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name, value:Vahid N.
External provider[Google] info-> claim:http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname, value:Vahid
External provider[Google] info-> claim:http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname, value:N.
External provider[Google] info-> claim:urn:google:profile, value:https://plus.google.com/105013528531611201860
External provider[Google] info-> claim:http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress, value:my.name@gmail.com

        [HttpGet]
        public async Task<IActionResult> Callback()
        {
            // ...

            var (user, provider, providerUserId, claims) = await FindUserFromExternalProvider(result);
            if (user == null)
            {
                // user wasn't found by provider, but maybe one exists with the same email address?  
                if (provider == "Google")
                {
                    // email claim from Google
                    var email = claims.FirstOrDefault(c =>
                        c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress");
                    if (email != null)
                    {
                        var userByEmail = await _usersService.GetUserByEmailAsync(email.Value);
                        if (userByEmail != null)
                        {
                            // add Google as a provider for this user
                            await _usersService.AddUserLoginAsync(userByEmail.SubjectId, provider, providerUserId);

                            // redirect to ExternalLoginCallback
                            var continueWithUrlAfterAddingUserLogin =
                                Url.Action("Callback", new {returnUrl = returnUrl});
                            return Redirect(continueWithUrlAfterAddingUserLogin);
                        }
                    }
                }


                var returnUrlAfterRegistration = Url.Action("Callback", new {returnUrl = returnUrl});
                var continueWithUrl = Url.Action("RegisterUser", "UserRegistration",
                    new {returnUrl = returnUrlAfterRegistration, provider = provider, providerUserId = providerUserId});
                return Redirect(continueWithUrl);
            }

<meta name="fragment" content="!">
<base href="/">

http://www.example.com/user/123?_escaped_fragment_=

DynamicModuleUtility.RegisterModule(typeof(Prerender.io.PrerenderModule));

public static string TruncateAtWord(this string input, int length)
{
    if (input == null || input.Length < length)
        return input;
    int iNextSpace = input.LastIndexOf(" ", length);
    return string.Format("{0}...", input.Substring(0, (iNextSpace > 0) ? iNextSpace : length).Trim());
}

public IPdfReportData CreatePdfReport(int type,int RequestId)
        {
            return new PdfReport().DocumentPreferences(doc =>
            {
                doc.RunDirection(PdfRunDirection.RightToLeft);
                doc.Orientation(PageOrientation.Portrait);
                doc.PageSize(PdfPageSize.A4);
               
            })
            .DefaultFonts(fonts =>
            {
                fonts.Path(AppPath.ApplicationPath + "\\Fonts\\BNAZANIN.TTF",
                                  AppPath.ApplicationPath + "\\Fonts\\TIMES.TTF");
                fonts.Size(20);
            })
            .PagesFooter(footer =>
            {
                footer.DefaultFooter("");
                footer.PdfFont.Size = 8;

            })
            .PagesHeader(header =>
            {
                if (type == 1)
                {
                    header.CustomHeader(_customHeader);
                }
                else
                {
                    header.DefaultHeader(h => h.Message("mohsen"));
                }

            })
             .MainTableTemplate(template =>
             {
                 template.BasicTemplate(BasicTemplate.SilverTemplate);
             })
            .MainTablePreferences(table =>
            {
                table.ColumnsWidthsType(TableColumnWidthType.Relative);


            })
            .MainTableDataSource(dataSource =>
            {
               
                
                var ctx = new ClearanceEntities();




                var list = (from c in ctx.CLEARANCE_ITEMS
                            where c.CLEARANCE_REQUEST.REQUEST_ID == RequestId
                            select new
                            {
                                c.TARIFF_NO,
                                c.GOODS_DESCRIPTION,
                                vahed = c.QUANTITY,
                                c.PACKING_TYPES.PACKING_NAME,
                                c.GROSS_WEIGHT,
                                arzesh = (c.GOODS_PRICE * c.GOODS_CURRENCY_RATE) + (c.FREIGHT_PRICE * c.FREIGHT_CURRENCY_RATE),
                                hoghogh = " ",
                                sood = " "

                            }).ToList();
               



                dataSource.AnonymousTypeList(list );
            })

            .MainTableColumns(columns =>
            {
                columns.AddColumn(column =>
                {
                    column.PropertyName("TARIFF_NO");

                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(0);
                    column.Width(3);
                    column.HeaderCell("تعرفه");
                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("GOODS_DESCRIPTION");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);

                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(5);
                    column.HeaderCell("نام کالا");
                    column.ColumnItemsTemplate(template =>
                        {
                            new CellBasicProperties
                                {
                                  
                                    //PdfFontStyle = DocumentFontStyle.Bold | DocumentFontStyle.Underline,
                                    //FontColor = new BaseColor(System.Drawing.Color.Brown),
                                    //BackgroundColor = new BaseColor(System.Drawing.Color.Yellow)
                                };
                            return;
                        });

                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("vahed");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(5);
                    column.HeaderCell("واحد");

                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("GROSS_WEIGHT");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(5);
                    column.HeaderCell("وزن ناخالص");

                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("arzesh");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(5);
                    column.HeaderCell("ارزش دلاری");

                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("hoghogh");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(3);
                    column.HeaderCell("حقوق گمرکی");

                });
                columns.AddColumn(column =>
                {
                    column.PropertyName("sood");
                    column.CellsHorizontalAlignment(HorizontalAlignment.Center);
                    column.IsVisible(true);
                    column.Order(1);
                    column.Width(3);
                    column.HeaderCell("سود بازرگانی");

                });


            })
            .MainTableEvents(events =>
            {
                events.DataSourceIsEmpty(message: "There is no data available to display.");

}

                 events.DocumentClosing(args =>
            {
                if (HttpContext.Current == null || HttpContext.Current.Response == null) return;

                // close the document without closing the underlying stream
                args.PdfWriter.CloseStream = false;
                args.PdfDoc.Close();
                args.PdfStreamOutput.Position = 0;

                // write pdf bytes to output stream
                var pdf = ((MemoryStream)args.PdfStreamOutput).ToArray();
                string str = Guid.NewGuid().ToString();
                HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.NoCache);
                HttpContext.Current.Response.ContentType = MediaTypeNames.Application.Pdf;
                HttpContext.Current.Response.AddHeader("Content-Length", pdf.Length.ToString());
                HttpContext.Current.Response.AddHeader("content-disposition", "attachment;filename=" + str + ".pdf");
                HttpContext.Current.Response.Buffer = true;
                HttpContext.Current.Response.Clear();
                HttpContext.Current.Response.OutputStream.Write(pdf, 0, pdf.Length);
                HttpContext.Current.Response.OutputStream.Flush();
                HttpContext.Current.Response.OutputStream.Close();
                HttpContext.Current.Response.End();
            });
        })

           .Generate(data => data.AsPdfStream(new MemoryStream()));