C#: usando Skip e Take com Entity Framework Core e SQL Server 2005 ou 2008

Requisitos

.NET Core Runtime 2.2.8 e SDK 2.2.207
SQL Server 2008 Express

Simulando o problema

Abra o Visual Studio Code,
Crie e abra a pasta C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008,
Execute os comandos a seguir:

dotnet new globaljson --sdk-version 2.2.207
dotnet new sln
mkdir src
dotnet new console --output .\src\CSharpEFSkipTakeSql2005e2008.Prompt
dotnet sln add .\src\CSharpEFSkipTakeSql2005e2008.Prompt\
dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.SqlServer" --version 2.2.6
dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.Design" --version 2.2.6
dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.Tools" --version 2.2.6
dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.Extensions.Configuration.FileExtensions" --version 2.2.6
dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.Extensions.Configuration.Json" --version 2.2.6

dotnet new globaljson --sdk-version 2.2.207

dotnet new sln

mkdir src

dotnet new console --output .\src\CSharpEFSkipTakeSql2005e2008.Prompt

dotnet sln add .\src\CSharpEFSkipTakeSql2005e2008.Prompt\

dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.SqlServer" --version 2.2.6

dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.Design" --version 2.2.6

dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.EntityFrameworkCore.Tools" --version 2.2.6

dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.Extensions.Configuration.FileExtensions" --version 2.2.6

dotnet add ".\src\CSharpEFSkipTakeSql2005e2008.Prompt\CSharpEFSkipTakeSql2005e2008.Prompt.csproj" package "Microsoft.Extensions.Configuration.Json" --version 2.2.6

Na pasta C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008\src\CSharpEFSkipTakeSql2005e2008.Prompt adicione o arquivo appsettings.json,

{
    "Logging": {
        "LogLevel": {
            "Default": "Debug",
            "System": "Information",
            "Microsoft": "Information"
        }
    },
    "AllowedHosts": "*",
    "ConnectionStrings": {
        "SkipTakeConnection": "Server=.\\SQLExpress;Integrated Security=true;Initial Catalog=SkipTakeDb"
    }
}

{

"Logging": {

"LogLevel": {

"Default": "Debug",

"System": "Information",

"Microsoft": "Information"

}

"AllowedHosts": "*",

"ConnectionStrings": {

"SkipTakeConnection": "Server=.\\SQLExpress;Integrated Security=true;Initial Catalog=SkipTakeDb"

}

Edite o arquivo de projeto CSharpEFSkipTakeSql2005e2008.Prompt.csproj, incluindo a referência ao arquivo appsettings.json,

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="3.1.0" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="3.1.0" />
  </ItemGroup>

  <ItemGroup>
    <EmbeddedResource Include="appsettings.json">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </EmbeddedResource>
  </ItemGroup>

</Project>

<TargetFramework>netcoreapp3.0</TargetFramework>

</PropertyGroup>

<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

</PackageReference>

<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

</PackageReference>

</ItemGroup>

<CopyToOutputDirectory>Always</CopyToOutputDirectory>

</EmbeddedResource>

</ItemGroup>

</Project>

Na pasta C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008\src\CSharpEFSkipTakeSql2005e2008.Prompt adicione o arquivo Person.cs,

using System;

namespace CSharpEFSkipTakeSql2005e2008.Prompt
{
    public class Person
    {
        public Guid Id { get; private set; }
        public string Name { get; private set; }
        public int Age { get; private set; }
    }    
}

using System;

namespace CSharpEFSkipTakeSql2005e2008.Prompt

{

public class Person

{

public Guid Id { get; private set; }

public string Name { get; private set; }

public int Age { get; private set; }

}

Na pasta C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008\src\CSharpEFSkipTakeSql2005e2008.Prompt adicione o arquivo SkipTakeContext.cs,

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
 
namespace CSharpEFSkipTakeSql2005e2008.Prompt
{ 
    public class SkipTakeContext : DbContext
    {
        private readonly string _connectionString;
 
        public SkipTakeContext()
        {
            var configurationFile = new ConfigurationBuilder()
                .SetBasePath(AppContext.BaseDirectory)
                .AddJsonFile($"appsettings.json")
                .Build();
 
            _connectionString = configurationFile
                                    .GetConnectionString("SkipTakeConnection");
 
        }
 
        public DbSet<Person> People { get; set; }
 
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(_connectionString);
            base.OnConfiguring(optionsBuilder);
        }
    }
}

using System;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Configuration;

namespace CSharpEFSkipTakeSql2005e2008.Prompt

{

public class SkipTakeContext : DbContext

{

private readonly string _connectionString;

public SkipTakeContext()

{

var configurationFile = new ConfigurationBuilder()

.SetBasePath(AppContext.BaseDirectory)

.AddJsonFile($"appsettings.json")

.Build();

_connectionString = configurationFile

.GetConnectionString("SkipTakeConnection");

}

public DbSet<Person> People { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

{

optionsBuilder.UseSqlServer(_connectionString);

base.OnConfiguring(optionsBuilder);

}

Abra o terminal e digite os comandos a seguir para criar o banco,

dotnet ef migrations add InitialCreate --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt
dotnet ef database update --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt --verbose

1 2	dotnet ef migrations add InitialCreate --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt dotnet ef database update --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt --verbose

Inclua umas 20 linhas de dados,

USE [SkipTakeDb]
GO

INSERT INTO [dbo].[People]
           ([Id]
           ,[Name]
           ,[Age])
     VALUES 
		('6bb58044-f817-4729-b03d-b71b7f9001c8','João', 18),
		('bcb719f4-6374-4352-8f1e-4a3699eac4fe','Maria', 32),
		('bfa3cc30-acab-4570-ba47-3dc1d2027309','José', 45),
		('85a8fdd2-6211-4308-8a36-6323a8330114','Rodrigo', 8),
		('04ae1a1f-6fc7-41f7-aac5-37cad718156b','André', 20),
		('cc8efb11-5d0a-4f23-83c5-66a28feebd50','Letícia', 50),
		('5f9c8f34-815e-44e2-974c-4746a5b14583','Antônia', 22),
		('814d5bf3-a520-4e16-8103-67e226274344','Mia', 16),
		('437121bb-131c-4967-a365-998878a1c4d8','John', 39),
		('0c75b32d-a9f6-4856-ab9e-1ccd98cd50a0','Snake', 45),
		('94f7f221-f974-4538-a213-87c69c63fa43','Clarissa', 61),
		('627d15d1-8d0e-4dfb-a18c-bef33ae95542','Ziraldo', 28),
		('1a5772ca-6e27-4d0f-8d1d-043129466ba8','Cebolinha', 6),
		('76b5a2f6-b23a-4a02-9617-73086db2dbb2','Bianca', 18),
		('10f9c766-cf05-4902-9e0f-dc4fbbff1aec','Sindy', 32),
		('3e2a0bd2-211f-4e83-83d5-8f5f75361b62','Andrei', 18),
		('eb8ab1a6-2513-438d-b7cb-a106d233f533','Fabiano', 18),
		('7a42c0e9-49d2-46b8-ad71-0ce7124c94d7','Daniel', 18),
		('508e095c-7437-471c-8b67-198e43bd38b6','Falcão', 18),
		('d439c17f-f708-44a9-9c0e-8bce5ff7e0c0','Claudia', 18)
GO

USE [SkipTakeDb]

INSERT INTO [dbo].[People]

([Id]

,[Name]

,[Age])

VALUES

('6bb58044-f817-4729-b03d-b71b7f9001c8','João', 18),

('bcb719f4-6374-4352-8f1e-4a3699eac4fe','Maria', 32),

('bfa3cc30-acab-4570-ba47-3dc1d2027309','José', 45),

('85a8fdd2-6211-4308-8a36-6323a8330114','Rodrigo', 8),

('04ae1a1f-6fc7-41f7-aac5-37cad718156b','André', 20),

('cc8efb11-5d0a-4f23-83c5-66a28feebd50','Letícia', 50),

('5f9c8f34-815e-44e2-974c-4746a5b14583','Antônia', 22),

('814d5bf3-a520-4e16-8103-67e226274344','Mia', 16),

('437121bb-131c-4967-a365-998878a1c4d8','John', 39),

('0c75b32d-a9f6-4856-ab9e-1ccd98cd50a0','Snake', 45),

('94f7f221-f974-4538-a213-87c69c63fa43','Clarissa', 61),

('627d15d1-8d0e-4dfb-a18c-bef33ae95542','Ziraldo', 28),

('1a5772ca-6e27-4d0f-8d1d-043129466ba8','Cebolinha', 6),

('76b5a2f6-b23a-4a02-9617-73086db2dbb2','Bianca', 18),

('10f9c766-cf05-4902-9e0f-dc4fbbff1aec','Sindy', 32),

('3e2a0bd2-211f-4e83-83d5-8f5f75361b62','Andrei', 18),

('eb8ab1a6-2513-438d-b7cb-a106d233f533','Fabiano', 18),

('7a42c0e9-49d2-46b8-ad71-0ce7124c94d7','Daniel', 18),

('508e095c-7437-471c-8b67-198e43bd38b6','Falcão', 18),

('d439c17f-f708-44a9-9c0e-8bce5ff7e0c0','Claudia', 18)

Altere a classe Program.cs, ordenando por nome listando os primeiros 10 registros (Take(10)) e pulando os dois primeiros (Skip(2)),

using System;
using System.Linq;

namespace CSharpEFSkipTakeSql2005e2008.Prompt
{
    class Program
    {
        static void Main(string[] args)
        {
            var dbContext = new SkipTakeContext();
            var people = dbContext.People
                                    .OrderBy(x => x.Name)
                                    .Take(10)
                                    .Skip(2);

            foreach (var person in people)
            {
                Console.WriteLine($"Name: {person.Name}\t | Age: {person.Age}\t | Id: {person.Id}");
            }            
        }
    }
}

using System;

using System.Linq;

namespace CSharpEFSkipTakeSql2005e2008.Prompt

{

class Program

{

static void Main(string[] args)

{

var dbContext = new SkipTakeContext();

var people = dbContext.People

.OrderBy(x => x.Name)

.Take(10)

.Skip(2);

foreach (var person in people)

{

Console.WriteLine($"Name: {person.Name}\t | Age: {person.Age}\t | Id: {person.Id}");

}

Execute o projeto com o comando a seguir,

dotnet run --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt\

1	dotnet run --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt\

A seguinte mensagem de erro será exibida:

Unhandled exception. Microsoft.Data.SqlClient.SqlException (0x80131904): Incorrect syntax near 'OFFSET'.
   at Microsoft.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)
   at Microsoft.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)
   at Microsoft.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj, Boolean callerHasConnectionLock, Boolean asyncClose)
   at Microsoft.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj, Boolean& dataReady)
   at Microsoft.Data.SqlClient.SqlDataReader.TryConsumeMetaData()
   at Microsoft.Data.SqlClient.SqlDataReader.get_MetaData()
   at Microsoft.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString, Boolean isInternal, Boolean forDescribeParameterEncryption, Boolean shouldCacheForAlwaysEncrypted)
   at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean isAsync, Int32 timeout, Task& task, Boolean asyncWrite, Boolean inRetry, SqlDataReader ds, Boolean describeParameterEncryptionRequest)
   at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry, String method)
   at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method)
   at Microsoft.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior)
   at Microsoft.Data.SqlClient.SqlCommand.ExecuteDbDataReader(CommandBehavior behavior)
   at System.Data.Common.DbCommand.ExecuteReader()
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReader(RelationalCommandParameterObject parameterObject)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryingEnumerable`1.Enumerator.InitializeReader(DbContext _, Boolean result)
   at Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal.SqlServerExecutionStrategy.Execute[TState,TResult](TState state, Func`3 operation, Func`3 verifySucceeded)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryingEnumerable`1.Enumerator.MoveNext()
   at CSharpEFSkipTakeSql2005e2008.Prompt.Program.Main(String[] args) in C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008\src\CSharpEFSkipTakeSql2005e2008.Prompt\Program.cs:line 16
ClientConnectionId:a199f978-2f56-458e-83fb-71502c001368
Error Number:102,State:1,Class:15

Unhandled exception. Microsoft.Data.SqlClient.SqlException (0x80131904): Incorrect syntax near 'OFFSET'.

at Microsoft.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)

at Microsoft.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)

at Microsoft.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj, Boolean callerHasConnectionLock, Boolean asyncClose)

at Microsoft.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj, Boolean& dataReady)

at Microsoft.Data.SqlClient.SqlDataReader.TryConsumeMetaData()

at Microsoft.Data.SqlClient.SqlDataReader.get_MetaData()

at Microsoft.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString, Boolean isInternal, Boolean forDescribeParameterEncryption, Boolean shouldCacheForAlwaysEncrypted)

at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean isAsync, Int32 timeout, Task& task, Boolean asyncWrite, Boolean inRetry, SqlDataReader ds, Boolean describeParameterEncryptionRequest)

at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry, String method)

at Microsoft.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method)

at Microsoft.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior)

at Microsoft.Data.SqlClient.SqlCommand.ExecuteDbDataReader(CommandBehavior behavior)

at System.Data.Common.DbCommand.ExecuteReader()

at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReader(RelationalCommandParameterObject parameterObject)

at Microsoft.EntityFrameworkCore.Query.Internal.QueryingEnumerable`1.Enumerator.InitializeReader(DbContext _, Boolean result)

at Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal.SqlServerExecutionStrategy.Execute[TState,TResult](TState state, Func`3 operation, Func`3 verifySucceeded)

at Microsoft.EntityFrameworkCore.Query.Internal.QueryingEnumerable`1.Enumerator.MoveNext()

at CSharpEFSkipTakeSql2005e2008.Prompt.Program.Main(String[] args) in C:\GitHub\tiagopariz\CSharpEFSkipTakeSql2005e2008\src\CSharpEFSkipTakeSql2005e2008.Prompt\Program.cs:line 16

ClientConnectionId:a199f978-2f56-458e-83fb-71502c001368

Error Number:102,State:1,Class:15

O erro ocorre quando o Entity Framework Core tenta executar a seguinte consulta:

exec sp_executesql N'SELECT [t].*
FROM (
    SELECT TOP(@__p_0) [x].[Id], [x].[Age], [x].[Name]
    FROM [People] AS [x]
    ORDER BY [x].[Name]
) AS [t]
ORDER BY [t].[Name]
OFFSET @__p_1 ROWS',N'@__p_0 int,@__p_1 int',@__p_0=10,@__p_1=2

exec sp_executesql N'SELECT [t].*

FROM (

SELECT TOP(@__p_0) [x].[Id], [x].[Age], [x].[Name]

FROM [People] AS [x]

ORDER BY [x].[Name]

) AS [t]

ORDER BY [t].[Name]

OFFSET @__p_1 ROWS',N'@__p_0 int,@__p_1 int',@__p_0=10,@__p_1=2

A clausula OFFSET é um recurso do SQL Server 2012 e que é a forma padrão do .NET Core criar consultas usando Take e Skip.

No SQL Server 2008 temos a função Row_Number() que atende o Take e Skip. Então, para que o EF Core use esta função, precisamos fazer um ajuste mínimo na classe de contexto.

Ajustando o DbContext

Edite o arquivo SkipTakeContext.cs, e no método OnConfiguring() edite a linha optionsBuilder.UseSqlServer(_connectionString) para que o Entity Framework Core use a função Row_Number() no lugar da claúsula OFFSET,

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
 
namespace CSharpEFSkipTakeSql2005e2008.Prompt
{ 
    public class SkipTakeContext : DbContext
    {
        private readonly string _connectionString;
 
        public SkipTakeContext()
        {
            var configurationFile = new ConfigurationBuilder()
                .SetBasePath(AppContext.BaseDirectory)
                .AddJsonFile($"appsettings.json")
                .Build();
 
            _connectionString = configurationFile
                                    .GetConnectionString("SkipTakeConnection");
 
        }
 
        public DbSet<Person> People { get; set; }
 
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            <strong>optionsBuilder.UseSqlServer(_connectionString, builder => builder.UseRowNumberForPaging());</strong>            
            base.OnConfiguring(optionsBuilder);
        }
    }
}

using System;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Configuration;

namespace CSharpEFSkipTakeSql2005e2008.Prompt

{

public class SkipTakeContext : DbContext

{

private readonly string _connectionString;

public SkipTakeContext()

{

var configurationFile = new ConfigurationBuilder()

.SetBasePath(AppContext.BaseDirectory)

.AddJsonFile($"appsettings.json")

.Build();

_connectionString = configurationFile

.GetConnectionString("SkipTakeConnection");

}

public DbSet<Person> People { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

{

<strong>optionsBuilder.UseSqlServer(_connectionString, builder => builder.UseRowNumberForPaging());</strong>

base.OnConfiguring(optionsBuilder);

}

Execute novamente a aplicação:

dotnet run --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt\

1	dotnet run --project .\src\CSharpEFSkipTakeSql2005e2008.Prompt\

Agora os resultados serão exibidos corretamente,

Name: Antônia    | Age: 22       | Id: 5f9c8f34-815e-44e2-974c-4746a5b14583
Name: Bianca     | Age: 18       | Id: 76b5a2f6-b23a-4a02-9617-73086db2dbb2
Name: Cebolinha  | Age: 6        | Id: 1a5772ca-6e27-4d0f-8d1d-043129466ba8
Name: Clarissa   | Age: 61       | Id: 94f7f221-f974-4538-a213-87c69c63fa43
Name: Claudia    | Age: 18       | Id: d439c17f-f708-44a9-9c0e-8bce5ff7e0c0
Name: Daniel     | Age: 18       | Id: 7a42c0e9-49d2-46b8-ad71-0ce7124c94d7
Name: Fabiano    | Age: 18       | Id: eb8ab1a6-2513-438d-b7cb-a106d233f533
Name: Falcão     | Age: 18       | Id: 508e095c-7437-471c-8b67-198e43bd38b6

Name: Antônia | Age: 22 | Id: 5f9c8f34-815e-44e2-974c-4746a5b14583

Name: Bianca | Age: 18 | Id: 76b5a2f6-b23a-4a02-9617-73086db2dbb2

Name: Cebolinha | Age: 6 | Id: 1a5772ca-6e27-4d0f-8d1d-043129466ba8

Name: Clarissa | Age: 61 | Id: 94f7f221-f974-4538-a213-87c69c63fa43

Name: Claudia | Age: 18 | Id: d439c17f-f708-44a9-9c0e-8bce5ff7e0c0

Name: Daniel | Age: 18 | Id: 7a42c0e9-49d2-46b8-ad71-0ce7124c94d7

Name: Fabiano | Age: 18 | Id: eb8ab1a6-2513-438d-b7cb-a106d233f533

Name: Falcão | Age: 18 | Id: 508e095c-7437-471c-8b67-198e43bd38b6

.NET Core 3.0 ou superior

Não há suporte para SQL Server 2005 e 2008 a partir do .NET Core 3.0.

Repositório no GitHub

https://github.com/tiagopariz/CSharpEFSkipTakeSql2005e2008

C#: PostgreSQL e .NET Core 2.1

Certas vezes é inviável contar com um banco de dados pago quando o projeto está iniciando. Mas nem por isso não será preciso que seja um repositório de dados profissional. Portanto, neste artigo ensino como usar o banco de dados relacional PostgresSQL com o .NET Core 2.1, ainda usando Entity Framework Core e Migrations.

Antes de começar você vai precisar:

Ter o PostgreSQL instalado, com a senha do localhost como 123456,
Ter o Visual Studio Code intalado,
Ter o .NET Core 2.1 SDK instalado.

Criando o projeto

Crie uma pasta vazia chamada PostgreSqlNetCore e dentro dela crie uma outra chamada src. E na pasta raíz, crie o arquivo da solução, usando o comando:

dotnet new sln

1	dotnet new sln

Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Domain, e neste diretório execute o comando abaixo para criar o projeto do domínio:

dotnet new classlib

1	dotnet new classlib

Crie uma pasta chamada Entities, e adicione duas classes, uma de pessoa e outra de categoria.

using System;

namespace PostgreSqlNetCore.Domain.Entities
{
    public class Person
    {
        public Person(Guid id, 
                      string name,
                      Guid categoryId)
        {
            Id = id;
            Name = name;
            CategoryId = categoryId;
        }

        public Guid Id { get; private set; }
        public string Name { get; private set; }
        public Guid CategoryId { get; private set; }
    }
}

using System;

namespace PostgreSqlNetCore.Domain.Entities

{

public class Person

{

public Person(Guid id,

string name,

Guid categoryId)

{

Id = id;

Name = name;

CategoryId = categoryId;

}

public Guid Id { get; private set; }

public string Name { get; private set; }

public Guid CategoryId { get; private set; }

}

using System;

namespace PostgreSqlNetCore.Domain.Entities
{
    public class Category
    {
        public Category(Guid id, 
                        string description)
        {
            Id = id;
            Description = description;
        }

        public Guid Id { get; private set; }
        public string Description { get; private set; }
    }
}

using System;

namespace PostgreSqlNetCore.Domain.Entities

{

public class Category

{

public Category(Guid id,

string description)

{

Id = id;

Description = description;

}

public Guid Id { get; private set; }

public string Description { get; private set; }

}

Agora vamos criar o projeto que conterá nossa camada de acesso a dados, migrations e CRUD. Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Infra.Data, e neste diretório execute o comando abaixo para criar o projeto de domínio:

dotnet new classlib

1	dotnet new classlib

Instale os pacotes conforme a seguir:

Npgsql.EntityFrameworkCore.PostgreSQL

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

1	dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

Microsoft.Extensions.Configuration.FileExtensions

dotnet add package Microsoft.Extensions.Configuration.FileExtensions

1	dotnet add package Microsoft.Extensions.Configuration.FileExtensions

Microsoft.Extensions.Configuration.Json

dotnet add package Microsoft.Extensions.Configuration.Json

1	dotnet add package Microsoft.Extensions.Configuration.Json

Adicione a referência ao projeto de domínio, com o comando:

dotnet add reference ..\PostgreSqlNetCore.Domain\

1	dotnet add reference ..\PostgreSqlNetCore.Domain\

Crie uma pasta chamada Context, e adicione uma classe chamada PostgreSqlContext.

using System;
using Microsoft.EntityFrameworkCore;
using PostgreSqlNetCore.Domain.Entities;
using Microsoft.Extensions.Configuration;
using System.IO;

namespace PostgreSqlNetCore.Infra.Data.Context
{
    public class PostgreSqlContext : DbContext
    {
        private readonly IConfigurationRoot _configurationFile;
        private readonly string _connectionString;

        public PostgreSqlContext(DbContextOptions<PostgreSqlContext> options) :
            base(options)
        {
            _configurationFile = new ConfigurationBuilder()
                                    .SetBasePath(Directory.GetCurrentDirectory())
                                    .AddJsonFile("appsettings.json")
                                    .Build();

            _connectionString = _configurationFile
                                    .GetConnectionString("PostgreSqlNetCoreConnection");

        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseNpgsql(_connectionString);
            base.OnConfiguring(optionsBuilder);
        }

        public DbSet<Person> People { get; set; }
        public DbSet<Category> Categories { get; set; }
    }
}

using System;

using Microsoft.EntityFrameworkCore;

using PostgreSqlNetCore.Domain.Entities;

using Microsoft.Extensions.Configuration;

using System.IO;

namespace PostgreSqlNetCore.Infra.Data.Context

{

public class PostgreSqlContext : DbContext

{

private readonly IConfigurationRoot _configurationFile;

private readonly string _connectionString;

public PostgreSqlContext(DbContextOptions<PostgreSqlContext> options) :

base(options)

{

_configurationFile = new ConfigurationBuilder()

.SetBasePath(Directory.GetCurrentDirectory())

.AddJsonFile("appsettings.json")

.Build();

_connectionString = _configurationFile

.GetConnectionString("PostgreSqlNetCoreConnection");

}

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

{

optionsBuilder.UseNpgsql(_connectionString);

base.OnConfiguring(optionsBuilder);

}

public DbSet<Person> People { get; set; }

public DbSet<Category> Categories { get; set; }

}

Abra a a pasta src e crie dentro dela a pasta PostgreSqlNetCore.Prompt, e neste diretório execute o comando abaixo para criar o projeto de domínio:

dotnet new console

1	dotnet new console

Instale o pacote Microsoft.EntityFrameworkCore.Design.

dotnet add package Microsoft.EntityFrameworkCore.Design

1	dotnet add package Microsoft.EntityFrameworkCore.Design

Adicione referência ao projeto de Dados.

dotnet add reference ..\PostgreSqlNetCore.Infra.Data\

1	dotnet add reference ..\PostgreSqlNetCore.Infra.Data\

Na raiz do projeto, adicione um arquivo chamado appsettings.json, e altere conforme a seguir:

{ 
    "ConnectionStrings": 
    { 
        "PostgreSqlNetCoreConnection": "Host=localhost;Port=5432;Username=postgres;Password=123456;Database=PostgreSqlNetCoreDb;" 
    } 
}

{

"ConnectionStrings":

{

"PostgreSqlNetCoreConnection": "Host=localhost;Port=5432;Username=postgres;Password=123456;Database=PostgreSqlNetCoreDb;"

}

Adicione ainda na raiz do projeto a classe DesignTimeDbContextFactory.

using System.IO;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;
using PostgreSqlNetCore.Infra.Data.Context;

namespace PostgreSqlNetCore.Prompt
{
    public class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<PostgreSqlContext>
    {
        public PostgreSqlContext CreateDbContext(string[] args)
        {
            IConfigurationRoot configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build();
            var builder = new DbContextOptionsBuilder<PostgreSqlContext>();
            var connectionString = configuration.GetConnectionString("PostgreSqlNetCoreConnection");
            builder.UseNpgsql(connectionString);
            return new PostgreSqlContext(builder.Options);
        }
    }
}

using System.IO;

using Microsoft.EntityFrameworkCore;

using Microsoft.EntityFrameworkCore.Design;

using Microsoft.Extensions.Configuration;

using PostgreSqlNetCore.Infra.Data.Context;

namespace PostgreSqlNetCore.Prompt

{

public class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<PostgreSqlContext>

{

public PostgreSqlContext CreateDbContext(string[] args)

{

IConfigurationRoot configuration = new ConfigurationBuilder()

.SetBasePath(Directory.GetCurrentDirectory())

.AddJsonFile("appsettings.json")

.Build();

var builder = new DbContextOptionsBuilder<PostgreSqlContext>();

var connectionString = configuration.GetConnectionString("PostgreSqlNetCoreConnection");

builder.UseNpgsql(connectionString);

return new PostgreSqlContext(builder.Options);

}

Agora é preciso associar todos os projetos na solução, e para isso, abra a pasta raiz no terminal, e execute os comando a seguir:

dotnet sln add .\src\PostgreSqlNetCore.Domain\
dotnet sln add .\src\PostgreSqlNetCore.Infra.Data\
dotnet sln add .\src\PostgreSqlNetCore.Prompt\

dotnet sln add .\src\PostgreSqlNetCore.Domain\

dotnet sln add .\src\PostgreSqlNetCore.Infra.Data\

dotnet sln add .\src\PostgreSqlNetCore.Prompt\

Agora é só executar o comando para criar a migração.

dotnet ef migrations add initial --project .\src\PostgreSqlNetCore.Infra.Data\PostgreSqlNetCore.Infra.Data.csproj --startup-project .\src\PostgreSqlNetCore.Prompt\

1	dotnet ef migrations add initial --project .\src\PostgreSqlNetCore.Infra.Data\PostgreSqlNetCore.Infra.Data.csproj --startup-project .\src\PostgreSqlNetCore.Prompt\

E então atualizar o banco de dados.

dotnet ef database update --project .\src\PostgreSqlNetCore.Infra.Data\ --startup-project .\src\PostgreSqlNetCore.Prompt\

1	dotnet ef database update --project .\src\PostgreSqlNetCore.Infra.Data\ --startup-project .\src\PostgreSqlNetCore.Prompt\

E enfim podemos ver o banco de dados com as nossas tabelas criadas e o versionamento das migrations.

Acesse o repositório no githus deste projeto no link a seguir:

https://github.com/tiagopariz/PostgreSqlNetCore

Obrigado, e até a próxima.

Arquitetura: camadas de serviços em Domain-Driven Design

Quando desenvolvemos usando a abordagem dirigida por modelos, é preciso entender as responsabilidades e local de cada camada, e entre todas as usadas, um tipo é responsável por chamar e expor de forma abstraída e funcional todas as regras de negócio do domínio, elas são chamadas de serviços.

Os serviços podem estar em alguns locais da arquitetura do software, conforme a necessidade e a função exercida para a solução. Segundo Eric Evans, em seu livro Domain-Driven Design, os serviços são divididos ao menos em três camadas:

Aplicativo – Serviço de mais externo

Digere as entradas, tais como requisições em txt, xml e Json,
Envia mensagens para o serviço de domínio para complementação
Espera a confirmação,
Decide enviar uma notificação através de um serviço de infraestrutura

Domínio – Regras de negócios

Interage com objetos necessários e dispara comportamentos
Fornece confirmações do resultado

Infraestrutura – Mensagens e outras comunicações externas

Envia mensagens
Recebe mensagens

Mas, sem mais delongas, montei uma aplicação bem simples para demonstrar a ideia. São três projetos: Domínio, aplicação e Infraestrutura de mensagens.

Primeiro, vamos criar, no projeto de domínio, uma entidade que representa uma pessoa.

using System;

namespace DDDServicesLayers.Domain.Entities
{
    public class Person
    {
        public Person(Guid id,
                      string name)
        {
            Id = id;
            Name = name;
        }

        public Guid Id { get; private set; }
        public string Name { get; private set; }
    }
}

using System;

namespace DDDServicesLayers.Domain.Entities

{

public class Person

{

public Person(Guid id,

string name)

{

Id = id;

Name = name;

}

public Guid Id { get; private set; }

public string Name { get; private set; }

}

Dentro do mesmo projeto de domínio, vamos adicionar o serviço que salva a pessoa.

using System;
using DDDServicesLayers.Domain.Entities;

namespace DDDServicesLayers.Domain.Services
{
    public class PersonService
    {
        public PersonService(Person person)
        {
            Person = person;
        }

        public Person Person { get; private set; }
        public bool Success { get; private set; }

        public void Save()
        {
            // Save person logic
            Success = true;
        }
    }
}

using System;

using DDDServicesLayers.Domain.Entities;

namespace DDDServicesLayers.Domain.Services

{

public class PersonService

{

public PersonService(Person person)

{

Person = person;

}

public Person Person { get; private set; }

public bool Success { get; private set; }

public void Save()

{

// Save person logic

Success = true;

}

No projeto de Infraestrutura, iremos adicionar o serviõ de envio de mensagens.

using System;

namespace DDDServicesLayers.Infra.Messages.MessageServices
{
    public class EmailService
    {
        public EmailService(string to,
                            string subject,
                            string body)
        {
            To = to;
            Subject = subject;
            Body = body;
        }

        public string To { get; private set; }
        public string Subject { get; private set; }
        public string Body { get; private set; }
        public bool Success { get; private set; }

        public void Send()
        {
            // Send e-mail
            Success = true;
        }
    }
}

using System;

namespace DDDServicesLayers.Infra.Messages.MessageServices

{

public class EmailService

{

public EmailService(string to,

string subject,

string body)

{

To = to;

Subject = subject;

Body = body;

}

public string To { get; private set; }

public string Subject { get; private set; }

public string Body { get; private set; }

public bool Success { get; private set; }

public void Send()

{

// Send e-mail

Success = true;

}

E por fim, vamos adicionar o serviço na camada de aplicação.

using System;
using DDDServicesLayers.Domain.Entities;
using DDDServicesLayers.Domain.Services;
using DDDServicesLayers.Infra.Messages.MessageServices;

namespace DDDServicesLayers.Application.AppServices
{
    public class PersonAppService
    {
        private readonly Person _person; 
        public PersonAppService(string name)
        {
            _person = new Person(Guid.NewGuid(), name);
        }

        public void Save()
        {
            var personServiceSave = new PersonService(_person);
            personServiceSave.Save();

            if (personServiceSave.Success)
            {
                var emailService = new EmailService("test@mail.com", "Confirm", "Register saved.");
                emailService.Send();
            }
        }
    }
}

using System;

using DDDServicesLayers.Domain.Entities;

using DDDServicesLayers.Domain.Services;

using DDDServicesLayers.Infra.Messages.MessageServices;

namespace DDDServicesLayers.Application.AppServices

{

public class PersonAppService

{

private readonly Person _person;

public PersonAppService(string name)

{

_person = new Person(Guid.NewGuid(), name);

}

public void Save()

{

var personServiceSave = new PersonService(_person);

personServiceSave.Save();

if (personServiceSave.Success)

{

var emailService = new EmailService("test@mail.com", "Confirm", "Register saved.");

emailService.Send();

}

Este projeto está disponível no meu GitHub no endereço a seguir:

https://github.com/tiagopariz/DDDServicesLayers

C# e Mvc: mapa do Google com marcadores

Você já precisou colocar um mapa em seu site ou aplicativo? E este mapa precisaria mostrar vários locais, como unidades comerciais de um empresa com filiais? Neste artigo eu mostro como exibir um mapa usando a API Google e adicionar os devidos marcadores em um site feito em C# e MVC.

Mas primeiro, você vai precisar de uma chave do Google API Maps, que pode ser adquirida no endereço:

https://developers.google.com/maps

Chave na mãe, vamos criar uma pasta chamada CSharpMvcGoogleMapWithMarkers e dentro dela incluir outra chamada src e então abrir no Visual Studio Code.

Se você ainda não usou o VS Code e/ou ainda usa apenas o Visual Studio convencional, eu fiz um artigo para quebrar o gelo com este editor opensource da Microsoft.

Dentro da pasta src, crie outra pasta chamada CSharpMvcGoogleMapWithMarkers.Mvc, volte na pasta raiz e abra esta pasta no terminal e vá digitando os comandos a seguir:

Crie uma solução, para que seja possível abrir no Visual Studio convencional:

dotnet new sln

1	dotnet new sln

Abra a pasta do projeto MVC:

cd .\src\CSharpMvcGoogleMapWithMarkers.Mvc\

1	cd .\src\CSharpMvcGoogleMapWithMarkers.Mvc\

Crie um projeto C# do tipo MVC:

dotnet new mvc

1	dotnet new mvc

Volte a pasta raiz:

cd ..\..\

cd ..\..\

Adicione o projeto MVC na solução:

dotnet sln add .\src\CSharpMvcGoogleMapWithMarkers.Mvc\

1	dotnet sln add .\src\CSharpMvcGoogleMapWithMarkers.Mvc\

Execute o site e veja no navegador:

dotnet run --project .\src\CSharpMvcGoogleMapWithMarkers.Mvc\CSharpMvcGoogleMapWithMarkers.Mvc.csproj

1	dotnet run --project .\src\CSharpMvcGoogleMapWithMarkers.Mvc\CSharpMvcGoogleMapWithMarkers.Mvc.csproj

A saída do terminal será esta, onde o VS Code vai informar a URL local para testar, normalmente https://localhost:5001 ou http://localhost:5000.

Copie e cole no navegador o endereço e confira a página:

Crie um novo controller, chamado StoreController, que será uma tela com um mapa e ponto onde há lojas de uma empresa. Para isso, clique o botão direito sobre a pasta Controllers, clique em New file e defina o nome como StoreController.cs.

using Microsoft.AspNetCore.Mvc;

namespace CSharpMvcGoogleMapWithMarkers.Mvc.Controllers
{
    public class StoreController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }

        public IActionResult Detail()
        {
            return View();
        }        
    }
}

using Microsoft.AspNetCore.Mvc;

namespace CSharpMvcGoogleMapWithMarkers.Mvc.Controllers

{

public class StoreController : Controller

{

public IActionResult Index()

{

return View();

}

public IActionResult Detail()

{

return View();

}

Clique o botão direito sobre a pasta Models, clique em New file e defina o nome como StoreViewModel.cs.

using System;

namespace CSharpMvcGoogleMapWithMarkers.Mvc.Models
{
    public class StoreViewModel
    {
        public Guid Id { get; set; }
        public String Name { get; set; }
        public String Address { get; set; }
        public String Phone { get; set; }
        public String Latitude { get; set; }
        public String Longitude { get; set; }
    }
}

using System;

namespace CSharpMvcGoogleMapWithMarkers.Mvc.Models

{

public class StoreViewModel

{

public Guid Id { get; set; }

public String Name { get; set; }

public String Address { get; set; }

public String Phone { get; set; }

public String Latitude { get; set; }

public String Longitude { get; set; }

}

Para facilitar, adicione um novo item de menu chamado Know our stores que abre a action Index do controller Store, para isto edite o arquivo Views/Share/_Layout.cshtml.

(...)

<div class="navbar-collapse collapse">
    <ul class="nav navbar-nav">
        <li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
        <li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
        <li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>
        <li><a asp-area="" asp-controller="Store" asp-action="Index">Know our stores</a></li>
    </ul>
</div>

(...)

(...)

<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>

<li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>

<li><a asp-area="" asp-controller="Store" asp-action="Index">Know our stores</a></li>

</ul>

</div>

(...)

Clique o botão direito sobre a pasta Views, clique em New folder e digite Store, em seguida clique o botão direito sobre Store e em New file e defina o nome como Index.cshtml.

@{
    ViewData["Title"] = "Map";
}
<h2>@ViewData["StoreName"]</h2>
<h3>@ViewData["Message"]</h3>

<style>
    #map {
    height: 600px;
    }
</style>

<h2>Stores</h2>

<div id="map"></div>
<script>
    var map;
    function initMap() {
    map = new google.maps.Map(document.getElementById('map'), {
        center: {lat: -30.060821, lng: -51.181687},
        zoom: 14
        });

        var marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.059737, -51.164658),
            title:"Store 1"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.064746, -51.157816),
            title:"Store 2"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.066648, -51.155412),
            title:"Store 3"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.051898, -51.194615),
            title:"Store 4"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.052617, -51.181038),
            title:"Store 5"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.071457, -51.191396),
            title:"Store 6"
        });
        marker.setMap(map);

        marker = new google.maps.Marker({
            position: new google.maps.LatLng(-30.059410, -51.207637),
            title:"Store 7"
        });
        marker.setMap(map);
    };
</script>
<script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&callback=initMap" async defer></script>

ViewData["Title"] = "Map";

}

<h2>@ViewData["StoreName"]</h2>

<h3>@ViewData["Message"]</h3>

<style>

#map {

height: 600px;

}

</style>

<h2>Stores</h2>

var map;

function initMap() {

map = new google.maps.Map(document.getElementById('map'), {

center: {lat: -30.060821, lng: -51.181687},

zoom: 14

});

var marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.059737, -51.164658),

title:"Store 1"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.064746, -51.157816),

title:"Store 2"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.066648, -51.155412),

title:"Store 3"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.051898, -51.194615),

title:"Store 4"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.052617, -51.181038),

title:"Store 5"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.071457, -51.191396),

title:"Store 6"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.059410, -51.207637),

title:"Store 7"

});

marker.setMap(map);

};

</script>

Explicando o código Javascript do mapa

Declaramos uma variável chamada map e criamos uma função initMap (), serão informadas as coordenadas inciais e logo após definido os marcadores.

var map;
function initMap()
{

};

var map;

function initMap()

{

};

Agora vamos definir a posição e o zoom do mapa, instanciando um novo objeto google.maps.Map, que recebe os parâmetros que informa qual a div que será renderizado o mapa, as coordenadas e o zoom.

var map;
function initMap() {
    map = new google.maps.Map(document.getElementById('map'), {
            center: {lat: -30.060821, lng: -51.181687},
            zoom: 14
        });
};

var map;

function initMap() {

map = new google.maps.Map(document.getElementById('map'), {

center: {lat: -30.060821, lng: -51.181687},

zoom: 14

});

};

Se você quiser entender melhor como funciona o Zoom e demais opções, clique no link abaixo para a documentação do google:

https://developers.google.com/maps/documentation/javascript/tutorial

Agora, com o mapa pronto, é adicionar os marcadores, para isso é só instanciar um objeto do tipo google.maps.Marker e usar a função setMap().

var map;
function initMap() {
    map = new google.maps.Map(document.getElementById('map'), {
            center: {lat: -30.060821, lng: -51.181687},
            zoom: 14
        });

    var marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.059737, -51.164658),
        title:"Store 1"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.064746, -51.157816),
        title:"Store 2"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.066648, -51.155412),
        title:"Store 3"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.051898, -51.194615),
        title:"Store 4"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.052617, -51.181038),
        title:"Store 5"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.071457, -51.191396),
        title:"Store 6"
    });
    marker.setMap(map);

    marker = new google.maps.Marker({
        position: new google.maps.LatLng(-30.059410, -51.207637),
        title:"Store 7"
    });
    marker.setMap(map);
};

var map;

function initMap() {

map = new google.maps.Map(document.getElementById('map'), {

center: {lat: -30.060821, lng: -51.181687},

zoom: 14

});

var marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.059737, -51.164658),

title:"Store 1"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.064746, -51.157816),

title:"Store 2"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.066648, -51.155412),

title:"Store 3"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.051898, -51.194615),

title:"Store 4"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.052617, -51.181038),

title:"Store 5"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.071457, -51.191396),

title:"Store 6"

});

marker.setMap(map);

marker = new google.maps.Marker({

position: new google.maps.LatLng(-30.059410, -51.207637),

title:"Store 7"

});

marker.setMap(map);

};

Segue a documentação do Google sobre marcadores:

https://developers.google.com/maps/documentation/javascript/markers

Ao carregar o mapa, todas as lojas serão exibidas como marcadores no mapa.

Pronto, agora temos uma mapa com marcadores de locais.

Este projeto pode ser conferido no meu repositório do GitHub:

https://github.com/tiagopariz/CSharpMvcGoogleMapWithMarkers

Git: Corrija o autor dos commits

O git tem uma característica que pode ser um problema se o programador não prestar atenção ao clonar e enviar seus primeiros commits para repositórios quando ele trabalha em projetos diferentes, que é esquecer de alterar o autor e e-mail usado no repositório.

Mas para entender o que ocorre e buscar uma solução, vamos simular uma situação a seguir:

Imagine que eu trabalho em mais de uma projeto, e que ao clonar o primeiro eu defini as configurações globais de nome do autor e e-mail corretas do primeiro projeto. Fiz algumas alteração, e envio meu commit. Até ai, tudo bem.

Se eu conferir meu log, vai estar lá o commit, com o nome de usuário e e-mail corretos.

Agora eu mudei de projeto, e estou trabalhando em outro código, onde meu e-mail mudou, eu clono o novo repositorio, usando o novo usuário e senha, e começo a trabalhar, enviando alguns commits, quando eu vou ver o log, percebo que dei push com o usuário global do outro repositório.

E agora? como consertar esta bagunça, pois meu e-mail neste projeto é tiago@timeq.me.

Acredite, tive este problema ao usar o comando amend, que inclui as alterações no último commit, só não havia percebido que o ultimo commit não era meu, passei mais de uma mês commitando no usuário do meu colega.

Vamos primeiro explicar qual foi o meu primeiro erro: eu devo configurar estes dados por repositório e não global, e admito que esqueço muitas vezes! Então vamos consertar isto primeiro, definindo o usuário e e-mail sem o parâmetro –global.

Vamos enviar um novo commit e conferir o log.

Finalmente! Nosso git está versionando com o usuário correto, mas ainda temos um problema, os dois commits enteriores não mudaram, ou seja, somente os commits futuros serão armazenados de forma correta. Mas sem pânico! temos a solução para isto, e ela vem em forma de uma comando complicado, mas milagroso! Digite no bash a instrução abaixo, informando o e-mail antigo em OLD_EMAIL e os novos usuários e e-mails em CORRECT_EMAIL:

git filter-branch --env-filter '
OLD_EMAIL="tiago@projetot.top"
CORRECT_NAME="Tiago Pariz"
CORRECT_EMAIL="tiago@timeq.me"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
export GIT_COMMITTER_NAME="$CORRECT_NAME"
export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
export GIT_AUTHOR_NAME="$CORRECT_NAME"
export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

git filter-branch --env-filter '

OLD_EMAIL="tiago@projetot.top"

CORRECT_NAME="Tiago Pariz"

CORRECT_EMAIL="tiago@timeq.me"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]

then

export GIT_COMMITTER_NAME="$CORRECT_NAME"

export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"

if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]

then

export GIT_AUTHOR_NAME="$CORRECT_NAME"

export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"

' --tag-name-filter cat -- --branches --tags

Após digitar ou copiar o comando, os commits serão reescritos, esta operação pode levar bastante tempo, dependendo do tamanho do repositório.

Ao conferir o log, veremos que os commits foram corrigidos.

Será preciso forçar forçar um push:

git push --force

1	git push --force

Algumas recomendações

Precisa ser em uma branch desprotegida,
Faça esta alterações depois que todos tenha enviado suas alterações, e em um horário onde ninguém esteja usando o repositório.
Se possível, faça um backup dos repositórios.

C#: evitando a Injeção de SQL

A Injeção de SQL, ou em inglês SQL Injection, é uma vulnerabilidade que permite que algum usuário malicioso possa executar uma instrução em SQL dentro da aplicação, aproveitando uma brecha em uma consulta que permita acesso ao banco de dados.

Para demonstrar um exemplo desta vulnerabilidade, vamos criar um banco de dados de vendas, onde temos nossa tabela de usuários com alguns informações.

USE [master];
GO

CREATE DATABASE [VendasDb];
GO

USE [VendasDb];
GO

CREATE TABLE [dbo].[Usuario]
	(
		[Id] INT IDENTITY(1,1) NOT NULL PRIMARY KEY, 
		[Usuario] VARCHAR(50) NOT NULL, 
		[Senha] VARCHAR(50) NOT NULL
	);
GO

INSERT 
	INTO [dbo].[Usuario]([Usuario], [Senha])
	VALUES ('tiagopariz', '123456'), 
		   ('jonatanvies', '789012'), 
		   ('alineloas', '345678');
GO

USE [master];

CREATE DATABASE [VendasDb];

USE [VendasDb];

CREATE TABLE [dbo].[Usuario]

(

[Id] INT IDENTITY(1,1) NOT NULL PRIMARY KEY,

[Usuario] VARCHAR(50) NOT NULL,

[Senha] VARCHAR(50) NOT NULL

);

INSERT

INTO [dbo].[Usuario]([Usuario], [Senha])

VALUES ('tiagopariz', '123456'),

('jonatanvies', '789012'),

('alineloas', '345678');

Abra o Visual Studio Code, e crie uma pasta chamada EvitandoAInjecaoDeSQL, e dentro dela outra chamada src. Em EvitandoAInjecaoDeSQL crie uma solução usando o comando dotnet new sln e logo em seguida abra a pasta src, adicione e logo abra um nova pasta chamada EvitandoAInjecaoDeSQL.Web e adicione um projeto do tipo MVC usando o comando dotnet new mvc, volte até a pasta EvitandoAInjecaoDeSQL e adicone o projeto na solução usando o comando dotnet sln add .\src\EvitandoAInjecaoDeSQL.Web\EvitandoAInjecaoDeSQL.Web.csproj.

Adicione um controller na pasta Controllers do projeto de MVC chamado ContaController.cs e uma view chamada Login.cshtml na pasta Views/Conta.

using System;
using Microsoft.AspNetCore.Mvc;
using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers
{
    public class ContaController : Controller
    {
        [HttpGet]
        public ActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Login(string usuario, string senha)
        {
            var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
            var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

            try
            {
                using (var conexao = new SqlConnection(connectionString))
                {
                    conexao.Open();

                    using (SqlCommand comando = new SqlCommand(consulta, conexao))
                    {
                        var resultado = (int)comando.ExecuteScalar();
                        if (resultado > 0)
                            ViewBag.Mensagem = "Login efetuado com sucesso";
                        else
                            ViewBag.Mensagem = "Falha no login";
                    }
                }
            }
            catch (Exception e)
            {
                ViewBag.Mensagem = "Erro: " + e.Message;
            }

            return View();
        }
    }
}

using System;

using Microsoft.AspNetCore.Mvc;

using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers

{

public class ContaController : Controller

{

[HttpGet]

public ActionResult Login()

{

return View();

}

[HttpPost]

public ActionResult Login(string usuario, string senha)

{

var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";

var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

try

{

using (var conexao = new SqlConnection(connectionString))

{

conexao.Open();

using (SqlCommand comando = new SqlCommand(consulta, conexao))

{

var resultado = (int)comando.ExecuteScalar();

if (resultado > 0)

ViewBag.Mensagem = "Login efetuado com sucesso";

else

ViewBag.Mensagem = "Falha no login";

}

catch (Exception e)

{

ViewBag.Mensagem = "Erro: " + e.Message;

}

return View();

}

<h2>Login</h2>

@using (Html.BeginForm("Login", "conta", FormMethod.Post, new { enctype = "multipart/form-data" }))
{
    <label>Usuario: </label>
    <input type="text" id="usuario" name="usuario" /><br />

    <label>Senha: </label>
    <input type="text" id="senha" name="senha" /><br />

    <input type="submit" value="Login" /><br />

    <label>@ViewBag.Mensagem</label>
}

<h2>Login</h2>

@using (Html.BeginForm("Login", "conta", FormMethod.Post, new { enctype = "multipart/form-data" }))

{

<label>Usuario: </label>

<label>Senha: </label>

<label>@ViewBag.Mensagem</label>

}

A tela de login deve ser semelhante a esta, após abrir o site e digitar uma senha válida:

O nosso site está funcionando, então agora vamos aplicar o SQL Injection para verificar a vulnerabilidade. Como vimos, o campo usuário e senha só efetua login se for digitado um nome de usuário e uma senha correta. Mas vamos tentar burlar isto.

Para entdenr o que acontece no lado do banco de dados ao digitar o usuário e senha da captura de tela, vamos analisar a intrução SQL montada pelo aplicativo:

SELECT COUNT(*)
    FROM Usuario 
    WHERE Usuario = 'tiagopariz' AND Senha = '123456'

SELECT COUNT(*)

FROM Usuario

WHERE Usuario = 'tiagopariz' AND Senha = '123456'

Se executarmos a instrução acima no SQL Server, temos o resultado 1, que é a informação que permite que o sistema permita o acesso.

Mas esta instrução é facilmente alterada usando alguns caracteres de ‘ (apóstrofo), fazendo a consulta ficar assim:

SELECT COUNT(*)
    FROM Usuario 
    WHERE Usuario = 'tiagopariz' AND Senha = '' OR '1' = '1'

SELECT COUNT(*)

FROM Usuario

WHERE Usuario = 'tiagopariz' AND Senha = '' OR '1' = '1'

Que retorna um valor positivo, mesmo sem informar a senha.

Mas como isto é possível sem editar o SQL que está no código? Simples, pois a forma a instrução foi montada, permite que seja alterada, pois o SELECT é uma concatenação dos campos que são enviados no post e a o corpo da instrução, o C# não sabe o que é filtro e o que é comando de banco, ele monta primeiro uma string e depois executa no banco. Sendo assim, vamos recriar esta consulta direto no campo de senha.

Antes, tente digitar uma senha errada, para conferir se formulário está funcionando e acessando os dados corretamente.

Agora vamos explorar a vulnerabilidades, digitando no campo de senha ‘ OR ‘1’ = ‘1 e clique em login.

E acabamos de ser invadidos por uma falha bem simples no site, pois é possivel “editar” a instrução SQL antes de enviar. Este tipo de falha, pode ser tão grave que é até pode permitir acessar e alterar informações do próprio sistema operacional, dependendo da configuração do banco de dados.

Mas como consertamos este caso específico? A solução a seguir vai resolver este tipo de abertura, mas há outros tipos de falahas que podem precisar uma solução mais avançada. O que vamos fazer é passar parâmetros para o banco de dados em vez de montar todo o sql de uma vez, para isso, em vez de usar uma concatenação, mas nomer estes dados usando um @ (arroba antes) antes, então, para isto, vou comentar o código vulnerável do arquivo ContaController.cs e adicionar a forma mais segura, como segue:

using System;
using Microsoft.AspNetCore.Mvc;
using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers
{
    public class ContaController : Controller
    {
        [HttpGet]
        public ActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Login(string usuario, string senha)
        {
            var connectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=VendasDb;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
            
            // Código com a vunerabilidade devido a concatenação
            //var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

            // Forma mais segura, montando o SELECT que espera os parâmetros @usuario e @senha
            var consulta = "SELECT COUNT(*) " +
                                "FROM Usuario " +
                                "WHERE " +
                                    "Usuario = @usuario AND " +
                                    "Senha = @senha;";

            try
            {
                using (var conexao = new SqlConnection(connectionString))
                {
                    conexao.Open();

                    using (SqlCommand comando = new SqlCommand(consulta, conexao))
                    {
                        // Passando os parâmetros de SQL sem a necessidade de concatenar
                        comando.Parameters.Add(new SqlParameter("@usuario", usuario));
                        comando.Parameters.Add(new SqlParameter("@senha", senha));

                        var resultado = (int)comando.ExecuteScalar();
                        if (resultado > 0)
                            ViewBag.Mensagem = "Login efetuado com sucesso";
                        else
                            ViewBag.Mensagem = "Falha no login";
                    }
                }
            }
            catch (Exception e)
            {
                ViewBag.Mensagem = "Erro: " + e.Message;
            }

            return View();
        }
    }
}

using System;

using Microsoft.AspNetCore.Mvc;

using System.Data.SqlClient;

namespace EvitandoAInjecaoDeSQL.Web.Controllers

{

public class ContaController : Controller

{

[HttpGet]

public ActionResult Login()

{

return View();

}

[HttpPost]

public ActionResult Login(string usuario, string senha)

{

// Código com a vunerabilidade devido a concatenação

//var consulta = "SELECT COUNT(*) FROM Usuario WHERE Usuario = '" + usuario + "' AND Senha = '" + senha + "'";

// Forma mais segura, montando o SELECT que espera os parâmetros @usuario e @senha

var consulta = "SELECT COUNT(*) " +

"FROM Usuario " +

"WHERE " +

"Usuario = @usuario AND " +

"Senha = @senha;";

try

{

using (var conexao = new SqlConnection(connectionString))

{

conexao.Open();

using (SqlCommand comando = new SqlCommand(consulta, conexao))

{

// Passando os parâmetros de SQL sem a necessidade de concatenar

comando.Parameters.Add(new SqlParameter("@usuario", usuario));

comando.Parameters.Add(new SqlParameter("@senha", senha));

var resultado = (int)comando.ExecuteScalar();

if (resultado > 0)

ViewBag.Mensagem = "Login efetuado com sucesso";

else

ViewBag.Mensagem = "Falha no login";

}

catch (Exception e)

{

ViewBag.Mensagem = "Erro: " + e.Message;

}

return View();

}

Com isto, temos um código mais seguro. Outra solução, seria usar frameworks ORM, como Entity Framework ou NHibernate.

O projeto completo está disponível no meu GitHub:

https://github.com/tiagopariz/EvitandoAInjecaoDeSQL

Obrigado e um bom dia a todos.

GitHub: criando um Fork e enviando um Pull Request

Já pensou em contribuir com aquele projeto bacana opensource e deixar sua marca, mostrando que você é uma pessoa aberta a interagir com a comunidade de desenvolvimento? Pois bem, neste artigo vou mostrar como criar um fork de um repositório do GitHub, e depois enviar a contribuição para o autor aprovar. Para nosso exemplo vou usar o projeto Flunt do André Baltieri para sugerir uma alteração.

Primeiro, vamos no repositório do Flunt, no perfil do André, acessando https://github.com/andrebaltieri/Flunt, e então vamos clicar em fork, que irá criar uma cópia de todo o projeto em um repositório na minha conta.

Aguarde o processo terminar.

Agora eu tenho um cópia do projeto em um repositório próprio, onde posso fazer todas as alterações na branch master que eu quiser.

Antes de prosseguir, é preciso criar clone local, clicando em Clone or download, e copiando a URL.

Agora vamos criar um clone no meu computador, usando o comando do Git e para isso abra o Git Bash e cole o endereço, como o exemplo a seguir.

git clone https://github.com/tiagopariz/flunt.git

1	git clone https://github.com/tiagopariz/flunt.git

Obs.: Se você for repetir o tutorial, use seus dados de usuário do seu repositório.

Acesse a pasta e abra no Visual Studio o projeto, e abra a classe Notifiable.cs, e nela vamos alterar o trecho de código destacado da linha 12.

Onde temos a variável somente leitura de notifications:

public IReadOnlyCollection<Notification> Notifications { get { return _notifications; } }

1	public IReadOnlyCollection<Notification> Notifications { get { return _notifications; } }

Vamos alterar a declaração usando a sintaxe chamada expression-bodied property, como segue:

public IReadOnlyCollection<Notification> Notifications => _notifications;

1	public IReadOnlyCollection<Notification> Notifications => _notifications;

Agora vamos fazer upload da alteração via comando do Git, usando a sequência que segue.

$ git add --all $ git commit --message "Expression-bodied property in Notifications" $ git push

1	$ git add --all $ git commit --message "Expression-bodied property in Notifications" $ git push

Na tela a seguir é mostrado todos os comandos, desde o acesso à pasta até o envio do código.

Abra o o seu repositório pelo site do GitHub, no meu caso, acessando https://github.com/tiagopariz/flunt e clique em Pull requests, em seguida em create a pull request.

Em Comparing changes, clique em compare across forks e por fim clique em Create pull request.

Em Open a pull request, confira a descrição e adicione informações adicionais se assim for necessário, e finalmente clique em Create a pull request.

A alteração será enviado ao dono do repositório, com os detalhes do que irá mudar.

Pronto, agora é só esperar a aprovação.

IIS: efetuando deploy no Windows 10 e IIS 10

Não é mais recomendado usar o protocolo FTP para transferência de arquivos por conta de suas vulnerabilidades, tão pouco para publicar aplicações que carregam consigo códígos e senhas altamente sensíveis. Então, a plataforma do Visual Studio e o IIS fornecem um meio muito mais rápido e seguro de subir publicações para aos ambientes de testes e produção chamado Web Deploy, neste artigo vou mostrar como configurar e publicar a um site a partir do Visual Studio 2017.

Web Platform Installer

Para facilitar a Instaleinstalação de ferramentas no IIS é preciso instalar a Web Platform Installer, para isso acesse o site https://www.microsoft.com/web/downloads/platform.aspx.

Clique em Install this extension e faça download do pacote para IIS.

Excute o instalador, e clique em I accept the terms in the License Agreement e em seguida em Install. Se o instalador pedir para executar como administrador, clique em Sim.

Aguarde o término da instalação e clique em Finish.

Agora no IIS, em gerenciamento, teremos a opção do Web Platform Installer.

Instale Web Deploy 3.6

Abra o IIS, e clique duas vezes em Web Platform Installer e pesquise por Web Deploy 3.6. Clique em Adicionar e então em Instalar.

Em Pré-Requisitos, clique em Aceito.

Aguarde o download e instalação.

Ao terminar a instalação, clique em Concluir.

Obs.: Talvez seja preciso verificar algumas coisas antes de publicar uma aplicação, segue uma lista de procedimentos que talvez sejam necessários:

Reiniciar os serviços do IIS,
Reiniciar o Site,
Reiniciar o Serviço de Gerenciamento da Web (wmsvc),
Desativar o Firewall ou liberar a porta 8172,
Fechar e abrir novamente a aba de Profile de publicação no Visual Studio.

Adicione o host deploy.sitelocal.com

Para facilitar o trabalho de depuração com a aplicação e simular um acesso direto pela internet, configure o host e adicione o site no IIS com a URL deploy.sitelocal.com seguindo este artigo.

Crie uma aplicação ASP.NET MVC

No Visual Studio, crie uma solução chamada DeploySite, e adicione um projeto do tipo ASP.NET Web Application chamado Deploy.Site. O nível de detalhes e complexidade não importa, pois só será preciso para publicação, eu criei um aplicação MVC e deixei pronta no GitHub, caso não queira nem se dar ao trabalho e só fazer um clone.

https://github.com/tiagopariz/DeploySite

Crie o perfil de publicação

Após criar e carregar a aplicação, vamos usar nosso servidor de deploy para subir nosso site. Para isso, clique com o botão direito sobre o projeto e clique com o esquerdo em Publish.

Em Pick a publish target, clique em IIS, FTP, etc e em seguida em Create Profile.

Preencha os campos de conexão, com os dados:

Server: O endereço do servidor de deploy, que pode não ser o mesmo do host, pois um servidor com IIS pode ter vários hosts, no nosso caso, é http://localhost.
Site name: o nome do site configurado no IIS, no caso deploy.sitelocal.com.
Destination URL: o endereço da Internet da aplicação que está sendo publicada, no nosso caso http://deploy.sitelocal.com, este endereço será aberto ao final da publicação.

Clique em Validate Connection para testar a configuração e se estiver tudo ok, clique em Next >.

Em Settings, selecione Release em Configuration e clique em Save.

Ao abrir a aba de publicação, clique em Rename Profile.

Digite o novo nome como DeployReleaseProfile e clique em Save.

Clique em Publish e visualize na janela Output os resultados.

Após a publicação, o site será aberto no navegador.

Dica: instale apenas o Web Deploy

É possível instalar no windows apenas o Web Deploy sem o Web Platform Installer, então para isso, entre no site https://www.iis.net/downloads/microsoft/web-deploy e faça o download do Web Deploy Installer.

IIS: adicionar endereços válidos locais para depuração

Muitas vezes, ao trabalhar com aplicações Web e/ou WebAPI, deparamos com limitações e dispositivos de segurança nos navegadores, pois eles exigem um endereço válido para comunicação, tanto entre APIs quanto para requisições Ajax. Geralmente, quando configuramos nosso IIS, o endereço default costuma ser:

http://localhost/nomeapp

Mas, este endereço é inválido para a segurança de uma aplicação web, principalmente para algumas chamadas AJAX, que procuram algo no padrão:

http://nomeapp.com ou http://nomeapp.dominio

Para contornar este problema é preciso editar o arquivo hosts (sem extensão mesmo) em C:\Windows\System32\drivers\etc, abrindo em um editor de texto. Inclua um formato de endereço válido seguindo o padrão nomedoapplocal.com, para todos os aplicativos necessários.

# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost
127.0.0.1       nomedoapp1local.com
127.0.0.1       nomedoapp2local.com

# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.

# This file contains the mappings of IP addresses to host names. Each

# entry should be kept on an individual line. The IP address should

# be placed in the first column followed by the corresponding host name.

# The IP address and the host name should be separated by at least one

# space.

# Additionally, comments (such as these) may be inserted on individual

# lines or following the machine name denoted by a '#' symbol.

# For example:

# 102.54.94.97 rhino.acme.com # source server

# 38.25.63.10 x.acme.com # x client host

# localhost name resolution is handled within DNS itself.

# 127.0.0.1 localhost

# ::1 localhost

127.0.0.1 nomedoapp1local.com

127.0.0.1 nomedoapp2local.com

Obs.: Talvez seja preciso alterar as configurações de segurança da pasta C:\Windows\System32\drivers\etc, fornecendo acesso completo ao seu usuário.

Agora, é só usar estes endereços no seu IIS.

Jenkins: Instalar no Windows

Integração continua é uma necessidade neste novo mundo de mudanças constantes e metodologias ágeis com entregas constantes, e para isso temos muitas ferramentas, mas uma das mais populares é o Jenkins, que funciona para inúmeras plataformas e sistemas operacionais. Neste artigo vou ensinar como fazer uma instalação básica do Jenkins em um servidor Windows e deixá-lo pronto para publicar a partir de repositórios Git.

Baixe o Jenkins para Windows

Entre no site do Jenkins em jenkins.io, clique em Download.

E clique na versão para o Windows.

Descompacte o arquivo jenkins-(versão).zip e execute o instalador jenkins.msi e ao abrir a tela de bem-vindo, clique em Next.

Mantenha a pasta padrão de destino da instalação e clique em Next.

Em Ready to install, clique em Install.

Aguarde o processo de instalação, se for solicitado pelo Windows para executar como administrador, clique em Sim.

Após a conclusão, clique em Finish.

Configuração inicial do Jenkins

Após o térmno da instação, o endereço http://localhost:8080/ vai abrir no browser e então uma tela de desbloqueio do Jenkins será exibida, com o caminho da senha inicial.

Abra o arquivo initialAdminPassword no Bloco de Notas e copie a senha.

Digite a senha no campo Administrator password e clique em Continue. Em Customize Jenkins clique em Install suggested plugins, para que o Jenkins instale o plugins mais usados.

Aguarde o término das configurações iniciais e a instalação dos plugins.

Após a instalação dos plugins, será preciso criar o primeiro usuário administrador, para isso preencha o formulário em Create First Admin User e por fim clique em Save an Finish.

Após a conclusão, em Jenkins is ready!, clique em Start usign Jenkins.

Agora o jenkins está pronto para uso! O próximo passo é criar os Jobs e instalar os plugins adicionais.