// Set up a timer to trigger every minute.  
System.Timers.Timer timer = new System.Timers.Timer();  
timer.Interval = 60000; // 60 seconds  
timer.Elapsed += new System.Timers.ElapsedEventHandler(this.OnTimer);  
timer.Start();

public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)  
{  
    // TODO: Insert activities here.  
}

using Unity;
using Unity.Lifetime;

private static Lazy container;

private static void RegisterTypes(UnityContainer container)
        {
            //Using Lifetime Managers: https://docs.microsoft.com/en-us/previous-versions/msp-n-p/ff647854(v%3dpandp.10)
container.RegisterType<IRepositoryAsync<Author>, AuthorRepository>(new PerRequestLifetimeManager());
container.RegisterType<IService<Author>, Service<Author>> (new PerRequestLifetimeManager());
container.RegisterType<IAuthorService, AuthorService>(new PerRequestLifetimeManager());
   }

        /// 
        /// Configured Unity Container.
        /// 
        public static IUnityContainer Unitycontainer => container.Value;

public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)  
{  
               container =
                  new Lazy<iunitycontainer>(() =>
                  {
                      var container = new UnityContainer();
                      RegisterTypes(container);
                      return container;
                  });
   
            #region Unit of Work pattern with Unity DI
            var _dataContext = new PlutoContext();
            var _unitOfWork = new UnitOfWork(_dataContext);

            Unitycontainer.RegisterInstance<Idatacontext>(_dataContext, new ContainerControlledLifetimeManager());
            Unitycontainer.RegisterInstance<Idatacontextasync>(_dataContext, new ContainerControlledLifetimeManager());

            Unitycontainer.RegisterInstance<Iunitofwork>(_unitOfWork, new ContainerControlledLifetimeManager());
            Unitycontainer.RegisterInstance<Iunitofworkasync>(_unitOfWork, new ContainerControlledLifetimeManager());

            Unitycontainer.Resolve<Idatacontext>();
            Unitycontainer.Resolve<Idatacontextasync>();
            #endregion
   
   
     //Using Unity DI with a Console Application: https://stackoverflow.com/questions/29103508/using-unity-di-with-a-console-application
     //Dependency Injection with Unity: https://msdn.microsoft.com/en-us/library/dn178463(v=pandp.30).aspx#_Lifetime_Management
     ////https://www.tutorialspoint.com/design_pattern/command_pattern.htm
     Unitycontainer.Resolve<Program>().Run();
   
     _unitOfWork.Dispose();
   
     Unitycontainer.Dispose();
   
}

Exemplo de tipos para mapeamento

public partial class GamaO
    {
        public int Id { get; set; } // id (Primary key)
        public string Ab { get; set; } // ab (length: 2)
        public int IdMarca { get; set; } // idMarca
        public string Nome { get; set; } // Nome (length: 45)
        public string NomeTipo { get; set; } // NomeTipo (length: 20)
        public int? IdEixo { get; set; } // IdEixo

    }

 public class GamaD
    {
        public string Nome { get; set; }
        public string Abreviatura { get; set; }
        public string Tipo { get; set; }
        public virtual Marca Marca { get; set; }
    }

 public class Marca
    {
        public string IdERP { get; set; }
        public string Nome { get; set; }
    }

Instalação do AutoMapper no VS

PM> Install-Package AutoMapper

Configuração do AutoMapper

 public MapperConfiguration Config { get; set; }
Config = new MapperConfiguration(cfg =>
            {
                // Configure AutoMapper
                cfg.CreateMap<GamaO, GamaD>()
                    .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.GuidCrm))
                    .ForMember(dest => dest.IdERP, opt => opt.MapFrom(src => src.Id))
                    .ForMember(dest => dest.Nome, opt => opt.MapFrom(src => src.Nome))
                    .ForMember(dest => dest.Abreviatura, opt => opt.MapFrom(src => src.Ab))
                    .ForMember(dest => dest.Tipo, opt => opt.MapFrom(src => src.NomeTipo))
                    .ForPath(dest => dest.Marca.IdERP, opt => opt.MapFrom(src => src.IdMarca))
                    .ForPath(dest => dest.Marca.Nome, opt => opt.Ignore())
                    .ReverseMap();

            });

Mapear com AutoMapper

 // Perform mapping
            var mapper = Config.CreateMapper();
            GamaD entityD = mapper.Map(entityGamaO);

Reverter mapeamento com AutoMapper

 // Perform reverse mapping
            GamaD entityD = new GamaD();
            mapper.Map(entityGamaO, entityGamaD);

Diagrama UML desenhado com a app web draw.io

Feature: Addition
In order to calculate totals
As a user
I want to calculate the sum of multiple numbers

Scenario: Add two numbers
Given I have entered 10 into the calculator
And I have entered 50 into the calculator
When I press add
Then the result should be 60 on the screen

[Given("I have entered (.*) into the calculator")]
public void GivenIHaveEnteredSomethingIntoTheCalculator(int number)
{
    calculator = new Calculator();
    calculator.Enter(number);
}

Instalação dos clientes da cache

PM> Install-Package StackExchange.Redis

PM> Install-Package StackExchange.Redis.StrongName

Ligação à cache

using StackExchange.Redis;

ConnectionMultiplexer connection = ConnectionMultiplexer.Connect(<connectionstring>);

<azure redis cache id>.redis.cache.windows.net:6380,password=<pwd>,ssl=True,abortConnect=False

private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect(ConfigurationManager.ConnectionStrings["RedisCache"].ConnectionString);
        });

        public static ConnectionMultiplexer Connection
        {
            get
            {
                return lazyConnection.Value;
            }
        }

PM> Install-Package Newtonsoft.Json

using Newtonsoft.Json;

Exemplo de Utilização

<connectionStrings>
    <add name="RedisCache" connectionString="<azure redis cache id>.redis.cache.windows.net:6380,password=<pwd>,ssl=True,abortConnect=False"/>
  </connectionStrings>

System.Configuration.ConfigurationManager.ConnectionStrings["RedisCache"].ConnectionString);

 public class Author
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public virtual ICollection<Course> Courses { get; set; }
    }

    public class Course
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public int Level { get; set; }
        public float FullPrice { get; set; }
        public int AuthorId { get; set; }
        public bool IsBeginnerCourse
        {
            get { return Level == 1; }
        }
        public virtual Author Author { get; set; }
    }

 static Author AddAuthor()
        {

            return new Author
            {
                Id = 1,
                Name = "Silvia Pinhao Lopes",
                Courses = new List<Course>
  {
   new Course
   {
    AuthorId = 1,
    Description = "First Course",
    FullPrice = 12,
    Id = 1,
    Level = 1,
    Name = "1st Course"
   }
  }
            };
        }

static void Main(string[] args)
        {
            IDatabase cache = Connection.GetDatabase();
            IEnumerable authors;

            var cAuthorKey = "authors";

            RedisValue lstAuthors = cache.StringGet(cAuthorKey);

            if (!lstAuthors.HasValue)
            {
                authors = new List<Author> { AddAuthor() };

                cache.StringSet(cAuthorKey, value: JsonConvert.SerializeObject(authors, Formatting.Indented), expiry: TimeSpan.FromMinutes(2));
            }
            else
            {
                Console.WriteLine("Cache hit");
                authors = JsonConvert.DeserializeObject<IEnumerable<Author>>(lstAuthors);
            }

            foreach (var author in authors)
            {
                Console.WriteLine(author.Name);
            }

            Console.Read();

        }

Criação da solução

• Pasta Application
• Pasta Domain
• Pasta Infrastructure

Criação dos projectos Domain-Driven

Geração de POCO e DbContext

PM> install-package EntityFramework

  <connectionStrings>
    <add name="PlutoContext" connectionString="data source=(localdb)\MSSQLLocalDB;initial catalog=Pluto_Queries;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>

using UnitOfWorkRepository.Framework.Core.Model;

Integração com a URF Framework

Integração do DbContext

namespace UnitOfWorkRepository.Framework.EntityFramework
{
    using System.Linq;
    using UnitOfWorkRepository.Framework.Core.Model;
    using Repository.Pattern.Ef6;

    [System.CodeDom.Compiler.GeneratedCode("EF.Reverse.POCO.Generator", "2.32.0.0")]
    public partial class PlutoContext : DataContext, IPlutoContext
    {
        public System.Data.Entity.DbSet<Author> Authors { get; set; } // Authors
        public System.Data.Entity.DbSet<Course> Courses { get; set; } // Courses

        static PlutoContext()
        {
            System.Data.Entity.Database.SetInitializer<PlutoContext>(null);
        }

        public PlutoContext()
            : base("Name=PlutoContext")
        {
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

       [...]

     }
}

Integração do Model

namespace UnitOfWorkRepository.Framework.Core.Model
{     
  using Repository.Pattern.Ef6;     

  // Authors
  [System.CodeDom.Compiler.GeneratedCode("EF.Reverse.POCO.Generator", "2.32.0.0")]
  public partial class Author: Entity
  {
   [...]
  }
}

Integração das Interfaces

using UnitOfWorkRepository.Framework.Core.Model;
using Repository.Pattern.Repositories;

namespace UnitOfWorkRepository.Framework.Core.Interfaces
{
   public interface IAuthorRepository: IRepositoryAsync<Author>
   {
     Author GetAuthorWithCourses(int id);
   }
}

Integração dos Repositórios

using Repository.Pattern.DataContext;
using Repository.Pattern.Ef6;
using Repository.Pattern.UnitOfWork;
using System.Linq;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using UnitOfWorkRepository.Framework.Core.Model;

namespace UnitOfWorkRepository.Framework.EntityFramework.Repositories
{
  public class AuthorRepository: Repository <Author>, IAuthorRepository 
  {
    public AuthorRepository(IDataContextAsync dataContext, IUnitOfWorkAsync unitOfWork)
 : base(dataContext, unitOfWork){}
 
    public Author GetAuthorWithCourses(int id) 
    {
      var authorWithCourses = base.Query().Include(a => a.Course).Select().AsQueryable();
   
      return authorWithCourses.FirstOrDefault();
    }
  }
}

Introdução da lógica de negócio

using System.Collections.Generic;
using UnitOfWorkRepository.Framework.Core.Model;
using Service.Pattern;

namespace UnitOfWorkRepository.Framework.Core.Interfaces
{
  public interface IAuthorService: IService<Author>
  {
    IEnumerable<Author> GetAllAuthors();
    Author GetAuthor(int Id);
    Author GetAuthorWithCourses(int id);
  }
}

using System.Collections.Generic;
using UnitOfWorkRepository.Framework.Core.Model;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using Service.Pattern;
using Repository.Pattern.Repositories;

namespace UnitOfWorkRepository.Framework.Application
{
    public class AuthorService : Service<Author>, IAuthorService
    {
        private IAuthorRepository _repository;

        public AuthorService(IRepositoryAsync<Author> repository)
            :base(repository)
        {
            _repository = repository as IAuthorRepository;
        }

        public IEnumerable<Author> GetAllAuthors()
        {
            return base.Query().Select();
        }

        public Author GetAuthor(int Id)
        {
            return base.Find(Id);
        }

        public Author GetAuthorWithCourses(int id)
        {
            return _repository.GetAuthorWithCourses(id);
        }

        public override void Insert(Author author)
        {
            // TODO: lógica de negócio
            base.Insert(author);
        }

        public override void Delete(Author author)
        {
            // TODO: lógica de negócio
            base.Delete(author);
        }

        public override void Update(Author author)
        {
            // TODO: lógica de negócio
            base.Update(author);
        }
    }
}

Consumo por framework de apresentação

using UnitOfWorkRepository.Framework.Application;
using Repository.Pattern.Repositories;
using UnitOfWorkRepository.Framework.Core.Model;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using Repository.Pattern.UnitOfWork;
using Repository.Pattern.Ef6;
using Repository.Pattern.DataContext;
using UnitOfWorkRepository.Framework.EntityFramework;
using UnitOfWorkRepository.Framework.EntityFramework.Repositories;
using Service.Pattern;

container.RegisterType<IUnitOfWork, UnitOfWork>(new PerRequestLifetimeManager());
container.RegisterType<IUnitOfWorkAsync, UnitOfWork>(new PerRequestLifetimeManager());
container.RegisterType<IDataContext, PlutoContext>(new PerRequestLifetimeManager());
container.RegisterType<IDataContextAsync, PlutoContext>(new PerRequestLifetimeManager());
container.RegisterType<IRepositoryAsync<Author>, AuthorRepository>(new PerRequestLifetimeManager());
container.RegisterType<IService<Author>, Service<Author >> (new PerRequestLifetimeManager());
container.RegisterType<IAuthorService, AuthorService>(new PerRequestLifetimeManager());

Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));

using Repository.Pattern.Infrastructure;
using Repository.Pattern.UnitOfWork;
using System.Web.Mvc;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using UnitOfWorkRepository.Framework.Core.Model;

namespace UnitOfWorkRepository.Framework.WebApplication.MVC.Controllers
{
    public class AuthorsController : Controller
    {
        private IAuthorService _authorService;
        private IUnitOfWork _unitOfWork;

        public AuthorsController(IAuthorService authorService, IUnitOfWork unitOfWork)
        {
            _authorService = authorService;
            _unitOfWork = unitOfWork;
        }

        // GET: Authors
        public ActionResult Index()
        {
            return View(_authorService.GetAllAuthors());
        }

        // GET: Authors/Details/5
        public ActionResult Details(int id)
        {
            Author author = _authorService.GetAuthor(id);
            if (author == null)
            {
                return HttpNotFound();
            }

            return View(author);
        }

        // GET: Authors/Create
        public ActionResult Create()
        {
            return View();
        }

        // POST: Authors/Create
        // Para se proteger de mais ataques, ative as propriedades específicas a que você quer se conectar. Para 
        // obter mais detalhes, consulte https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create([Bind(Include = "Id,Name")] Author author)
        {
            if (ModelState.IsValid)
            {
                _authorService.Insert(author);
                _unitOfWork.SaveChanges();
                
                return RedirectToAction("Index");
            }

            return View(author);
        }

        // GET: Authors/Edit/5
        public ActionResult Edit(int id)
        {
            Author author = _authorService.GetAuthor(id);

            if (author == null)
            {
                return HttpNotFound();
            }
            return View(author);
        }

        // POST: Authors/Edit/5
        // Para se proteger de mais ataques, ative as propriedades específicas a que você quer se conectar. Para 
        // obter mais detalhes, consulte https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "Id,Name")] Author author)
        {
            if (ModelState.IsValid)
            {
                author.ObjectState = ObjectState.Modified;
                _authorService.Update(author);
                _unitOfWork.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(author);
        }

        // GET: Authors/Delete/5
        public ActionResult Delete(int id)
        {
            Author author = _authorService.GetAuthor(id);
            if (author == null)
            {
                return HttpNotFound();
            }
            return View(author);
        }

        // POST: Authors/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            Author author = _authorService.GetAuthor(id);
            _authorService.Delete(author);
            _unitOfWork.SaveChanges();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _unitOfWork.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}

<url base>/Authors

Pressupostos

Adição de documentação XML ao controller

private string[] lista
        {
            get
            {
                if (System.Web.HttpContext.Current.Application["lista"] == null)
                {
                    System.Web.HttpContext.Current.Application["lista"] = new string[] { "value1", "value2" };
                }
                return
                    (string[])System.Web.HttpContext.Current.Application["lista"];
            }
        }

        /// <summary>
        /// Retrieves the list of values
        /// </summary>
        /// <returns></returns>
        public IEnumerable<string> Get()
        {
            return lista;
        }
        /// <summary>
        /// Retrieves one value from the list of values
        /// </summary>
        /// <param name="id">The id of the item to be retrieved</param>
        /// <returns></returns>
        public string Get(int id)
        {
            return lista[id];
        }
        /// <summary>
        /// Insert a new value in the list
        /// </summary>
        /// <param name="value">New value to be inserted</param>
        public void Post([FromBody]string value)
        {
        }
        /// <summary>
        /// Change a single value in the list
        /// </summary>
        /// <param name="id">The id of the value to be changed</param>
        /// <param name="value">The new value</param>
        public void Put(int id, [FromBody]string value)
        {
            lista[id] = value;
        }
        /// <summary>
        /// Delete an item from the list
        /// </summary>
        /// <param name="id">id of the item to be deleted</param>
        public void Delete(int id)
        {

        }

<url base>/api/values

["value1","value2"]

Integração do Swagger no projecto

PM> Install-Package Swashbuckle.Net45 -Version 5.2.1

Configuração da documentação XML

Configuração do SwashBuckle

c.IncludeXmlComments(GetXmlCommentsPath());

protected static string GetXmlCommentsPath()
          {
              return System.String.Format(@"{0}\bin\myWebApi.xml", 
                  System.AppDomain.CurrentDomain.BaseDirectory);
          }

Visualização da página de documentação Swagger

<url base>/Swagger/ui/index

Lista de operações da classe ValueController.cs

Especificação da interface da acção Get da API REST

Bootstrap Slider

Pressupostos

No portal Azure

No Visual Studio 2017

Preparação da execução

Execução

Inserção de documento

1. Inserção de documento

Depuração da function app remota

2. Depuração da function app remota

Log do Azure da função

3. Log do Azure da função

Bootstrap Slider

public sealed class EventAggregator : IEventAggregator
    {
        private readonly IDictionary<Type, IList> _subscriptions = new Dictionary<Type, IList>();

        #region Singleton - not quite as lazy, but thread-safe without using locks

        private static readonly EventAggregator instance = new EventAggregator();

        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static EventAggregator()
        {
        }

        private EventAggregator()
        {
        }

        public static EventAggregator Instance
        {
            get
            {
                return instance;
            }
        }

        #endregion

        public void Publish<TMessage>(TMessage message) where TMessage : IMessage
        {
            if (message == null) throw new ArgumentNullException("no message");

            Type messageType = typeof(TMessage);

            if (_subscriptions.ContainsKey(messageType))
            {
                var subscriptionList = new List<ISubscription<TMessage>>(
                    _subscriptions[messageType].Cast<ISubscription<TMessage>>());

                foreach (var subscription in subscriptionList)
                {
                    subscription.Action(message);
                }
            }
        }

        public void UnSubscribe<TMessage>(ISubscription<TMessage> subscription) where TMessage : IMessage
        {
            Type messageType = typeof(TMessage);

            if (_subscriptions.ContainsKey(messageType))
            {
                _subscriptions[messageType].Remove(subscription);
            }
        }

        public ISubscription<TMessage> Subscribe<TMessage>(Action<TMessage> action) where TMessage : IMessage
        {
            Type messageType = typeof(TMessage);
            var subscription = new Subscription<TMessage>(this, action);

            if (_subscriptions.ContainsKey(messageType))
            {
                _subscriptions[messageType].Add(subscription);
            }
            else
            {
                _subscriptions.Add(messageType, new List<ISubscription<TMessage>> { subscription });
            }

            return subscription;
        }

        public void ClearAllSubscriptions()
        {
            ClearAllSubscriptions(null);
        }

        public void ClearAllSubscriptions(Type[] exceptMessages)
        {
            foreach (var messageSubscriptions in new Dictionary<Type, IList>(_subscriptions))
            {
                bool canDelete = true;
                if (exceptMessages != null)
                {
                    canDelete = !exceptMessages.Contains(messageSubscriptions.Key);
                }

                if (canDelete)
                {
                    _subscriptions.Remove(messageSubscriptions);
                }
            }
        }
        
    }

public class Subscription<TMessage> : ISubscription<TMessage> where TMessage : IMessage
    {
        public Action<TMessage> Action { get; private set; }
        public IEventAggregator EventAggregator { get; private set; }

        public Subscription(IEventAggregator eventAggregator, Action<TMessage> action)
        {
            if (eventAggregator == null) throw new ArgumentNullException("no eventAggregator");
            if (action == null) throw new ArgumentNullException("no action");

            EventAggregator = eventAggregator;
            Action = action;
        }


        #region IDisposable Support
        private bool disposedValue = false; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    EventAggregator.UnSubscribe(this);
                }

                disposedValue = true;
            }
                
        }

        // This code added to correctly implement the disposable pattern.
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }

public static class Messages
    {

        public static IEventAggregator Hub
        {
            get
            {
                return Service.EventAggregator.Instance;
            }

        }

    }

private void ShowItemName(IEventAggregator messageHub)
        {
            messageHub.Subscribe<Item>(item => { /* ... */; });
        }

private static void SetItemName(IEventAggregator messageHub, TextBox textBox)
        {
           messageHub.Publish(new Item { /* ... */ });
        }

[...]

ShowItemName(Messages.Hub);

SetItemName(Messages.Hub, (TextBox)sender);

• Easy Event Aggregator por Nima Ara
• Asynchronous Event Aggregator por Timothy Makarov

Instalação das Azure Functions Core Tools

C:\Users\<username>\AppData\Local\Azure.Functions.Cli\1.0.0\func.exe

Instalação do Azure Storage Emulator

Instalação do Azure Storage Explorer

Criação da Queue myqueue-items

Criação do projecto local

Configuração do ambiente local

func settings add AzureWebJobsStorage UseDevelopmentStorage=true

"AzureWebJobsStorage": "UseDevelopmentStorage=true"

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "AzureWebJobsDashboard": ""
  },
  "ConnectionStrings": {},
  "Host": {
    "LocalHttpPort": 7071,
    "CORS": "*"
  }
}

Execução local das Azure Functions

Azure Functions em acção

Video YouTube, Azure Functions Visual Studio Tooling

Codificação da solução

PM> Install-Package WebFormsMVP -Version 1.4.5

• Model
• Presenter
• View

PM> Install-Package WebFormsMVP -Version 1.4.5

public class HelloWorldModel
    {
        public string HelloWorld { get; set; }
    }

using WebFormsMvp;
[...]
public class HelloWorldPresenter : Presenter<IView<HelloWorldModel>>
    {
        public HelloWorldPresenter(IView<HelloWorldModel> view) : base(view)
        {

            View.Load += View_Load;
        }

        private void View_Load(object sender, EventArgs e)
        {
            View.Model.HelloWorld = "Olá Mundo :)";
        }

    }

using WebFormsMvp;
using WebFormsMvp.Web;
using ASPNET.WebForms.MVP.Logic.Model;
using ASPNET.WebForms.MVP.Logic.Presenter;

<br />
    <h3><%= Model.HelloWorld %></h3>
    <br />

[PresenterBinding(typeof(HelloWorldPresenter), ViewType = typeof(IView<HelloWorldModel>))]
    public partial class HelloWorld : MvpPage<HelloWorldModel>
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            
        }
    }

Framework Web Forms MVP em acção

Métodos de customização de routings

• RouteConfig.cs
• AttributeRouting

Adição ao App_Start\RouteConfig.cs

routes.MapRoute(
                name: "MoviesReleaseByDate",
                url: "Movie/Released/{year}/{month}",
                defaults: new { controller = "Movie", action = "ByReleaseDate"},
                constraints: new { year = @"\d{4}", month = @"\d{2}"}
            );

Construção de AttributeRouting

routes.MapMvcAttributeRoutes();

[Route("Movie/Released/{year}/{month:regex(\\d{2}):range(1, 12)}")]
 public ActionResult ByReleaseDate(int year, int month)
 {
   return Content(string.Format("year={0}&month={1}", year, month));
 }  

Routing em acção

Criar a solução

1. Pasta Application
2. Pasta Domain
3. Pasta Infrastructure

Code-First Migrations

Modelo e BD Iniciais

• Pasta Repositories

PM> install-package EntityFramework

• Pasta Model

public class Author
    {
        public int Id { get; set; }
        public string  Name { get; set; }
        public virtual ICollection<Course> Courses { get; set; }
    }

public class Course
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public int Level { get; set; }
        public float FullPrice { get; set; }
        public bool IsBeginnerCourse
        {
            get { return Level == 1; }
        }
        public int AuthorId { get; set; }
        public virtual Author Author { get; set; }
    }

using System.Data.Entity;
using UnitOfWorkRepositoryPattern.PoC.Core.Model;

namespace UnitOfWorkRepositoryPattern.PoC.EntityFramework
{
    public class PlutoContext: DbContext
    {
        public PlutoContext()
            : base("name=PlutoContext")
        {
            this.Configuration.LazyLoadingEnabled = false;
        }

        public virtual DbSet<author> Authors { get; set; }
        public virtual DbSet<course> Courses { get; set; }
       
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }

    }
}

  <connectionStrings>
    <add name="PlutoContext" connectionString="data source=(localdb)\MSSQLLocalDB;initial catalog=Pluto_Queries;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>

Activação das Code-First Migrations

PM> enable-migrations

Geração e Execução das Code-First Migrations

PM> add-migration <designação>

PM> update-database –verbose

Repository Pattern

• Add(object)
• Remove(object)
• Get(id)
• GetAll()
• Find(predicate)

public interface IRepository<TEntity> where TEntity : class
    {
        void Add(TEntity entitity);
        void Remove(TEntity entity);
        TEntity Get(int id);
        IEnumerable<TEntity> GetAll();
        IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
    }

public interface IAuthorRepository: IRepository<Author>
    {
        Author GetAuthorWithCourses(int id);
    }

public interface ICourseRepository: IRepository<Course>
    {
        IEnumerable<Course> GetTopSellingCourses(int count);
        IEnumerable<Course> GetCoursesWithAuthors(int pageIndex, int pageSize);
    }

 public class RepositoryBase<TEntity> : IRepository<TEntity> where TEntity : class
    {
        protected readonly DbContext Context;

        public RepositoryBase(DbContext dbContext)
        {
            Context = dbContext;
        }

        public void Add(TEntity entitity)
        {
            Context.Set<TEntity>().Add(entitity);
        }

        public IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
        {
            return Context.Set<TEntity>().Where(predicate);
        }

        public TEntity Get(int id)
        {
            return Context.Set<TEntity>().Find(id);
        }

        public IEnumerable<TEntity> GetAll()
        {
            return Context.Set<TEntity>().ToList();
        }

        public void Remove(TEntity entity)
        {
            Context.Set<TEntity>().Remove(entity);
        }
    }

public class AuthorRepository : RepositoryBase<Author>, IAuthorRepository
    {
        public PlutoContext PlutoContext
        {
            get { return Context as PlutoContext; } 
        }

        public AuthorRepository(PlutoContext plutoContext) : base(plutoContext){ }

        public Author GetAuthorWithCourses(int id)
        {
            return PlutoContext.Authors.Include(a => a.Courses).SingleOrDefault(a => a.Id == id);
        }
    }

Unit Of Work

mantém uma lista de objectos afectados por uma transacção e coordena a escrita de mudanças e trata possíveis problemas de concorrência

A classe ObjectContext no Entity Framework é exemplo de uma Unidade de Trabalho

public interface IUnitOfWork: IDisposable
    {
        IAuthorRepository Authors { get; }
        ICourseRepository Courses { get; }
        int Complete();
    }

public class UnitOfWork : IUnitOfWork
    {
        protected readonly PlutoContext _plutoContext;

        public UnitOfWork(PlutoContext plutoContext)
        {
            _plutoContext = plutoContext;

            Authors = new AuthorRepository(_plutoContext);
            Courses = new CourseRepository(_plutoContext);
        }

        public IAuthorRepository Authors { get; private set; }

        public ICourseRepository Courses { get; private set; }

        public int Complete()
        {
            return _plutoContext.SaveChanges();
        }

        public void Dispose()
        {
            _plutoContext.Dispose();
        }
    }

Utilização

PM> install-package EntityFramework

using UnitOfWorkRepositoryPattern.PoC.Core;
using UnitOfWorkRepositoryPattern.PoC.Core.Model;
using UnitOfWorkRepositoryPattern.PoC.EntityFramework;

IUnitOfWork unitOfWork = new UnitOfWork(new PlutoContext());

            unitOfWork.Authors.Add(
                new Author {
                    Id = 1,
                    Name = "Silvia Pinhao Lopes",
                    Courses = new List<Course>
                    {
                        new Course
                        {
                            AuthorId = 1,
                            Description = "First Course",
                            FullPrice = 12,
                            Id = 1,
                            Level = 1,
                            Name = "1st Course"
                        }
                    }
                });

            unitOfWork.Complete();

            var allAuthors = unitOfWork.Authors.GetAll();

            foreach (var author in allAuthors)
            {
                System.Console.WriteLine(author.Name);
                unitOfWork.Authors.Remove(author);
            }
            unitOfWork.Complete();

            unitOfWork.Dispose();

            System.Console.Read();

Pré-requisitos

• Projecto .NET do tipo biblioteca
• Selecção a opção "Make assembly COM-Visible" na "Assembly Information" da biblioteca
• Selecção da opção "Register for COM interop" para ambiente de desenvolvimento compatível com projectos COM
• Adição ao projecto da referência web (Web Reference) para geração de código baseado nos web services da .NET Framework 2.0

public class SGDDocument
{
  public SGDDocument() { }

  public SGDWebService.HeaderType headerType { get; set; }
  public SGDWebService.GetDocContentBody docContentBody { get; set; }

  public string Url { get; set; }

  public string Get()
  {

  SGDWebService.GetDocContent doc = new SGDWebService.GetDocContent();
  doc.Header = headerType;
  doc.Body = docContentBody;

  SGDWebService.SGDWebService_V3HttpService service = new SGDWebService.SGDWebService_V3HttpService();
  service.Url = Url;

  SGDWebService.GetDocContentResponse docContentResponse = service.GetDocContent(doc);

  SGDWebService.GetDocContentBodyResponse docContentBodyResponse = docContentResponse.Body;

  string type = docContentBodyResponse.Type;

  SGDWebService.DocContentType docContext = docContentBodyResponse.ContextData as SGDWebService.DocContentType;
  SGDWebService.SuccessDataType successData = docContentBodyResponse.Item as SGDWebService.SuccessDataType;

  if ("E".Equals(type))
  {
  SGDWebService.ErrorDataType errorData = docContentBodyResponse.Item as SGDWebService.ErrorDataType;
  return string.Format("Ocorreu um erro na obtenção do documento: {0} {1}.", 
      errorData.Title.GetValue(0).ToString(), errorData.Detail.GetValue(0).ToString());
  }

  string dirFicheiro = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, docContext.DocFileName);
  File.WriteAllBytes(dirFicheiro, docContext.DocContent);

  return dirFicheiro;
  }

}

Public Function GetDocContent(ByVal FileID As Double) As String
Dim SGDDocument As SGDService.SGDDocument
Dim headerType As SGDService.headerType
Dim getDocContentBody As SGDService.getDocContentBody

Dim docFullName, destFullName As String
Dim guid1, guid2 As String

On Error GoTo errHandler

guid1 = Trim$(GetGUID())
guid1 = Mid(guid1, 2, Len(guid1) - 3)

guid2 = Trim$(GetGUID())
guid2 = Mid(guid2, 2, Len(guid2) - 3)

Set headerType = New SGDService.headerType

headerType.Version = <version>
headerType.TimeStamp = DateTime.Now
headerType.MessageGuid = guid1
headerType.GeneratorEntity = <Entity>
headerType.GeneratorApplication = <Application>
headerType.ServiceId = "<webservice>/GetDocContent"
headerType.InternalId = guid2

''Operation Input Parameteres (in this example)
Set getDocContentBody = New SGDService.getDocContentBody

getDocContentBody.Conversion = 1
getDocContentBody.DocID = CStr(FileID)
getDocContentBody.docPage = 0
getDocContentBody.system_name = <Document Management System Name>

''Prepare call to service proxy
Set SGDDocument = New SGDService.SGDDocument
Set SGDDocument.headerType = headerType
Set SGDDocument.docContentBody = getDocContentBody

SGDDocument.Url = <SGD_WEBSERVICE_URL>

''Get Document from service proxy
docFullName = SGDDocument.Get()

''Save document to working directory
destFullName = BuildPath(gsWorkDir, GetFileName(docFullName))

MoveFile docFullName, destFullName

GetDocContent = destFullName

Exit Function
errHandler:

''Error Handling TODO

  GetDocContent = vbNullString

End Function

Dim strFileC As String

''Get document using encapsulation
strFileC = GetDocContent(<FileDocID>)

Debug.Print strFileC

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:serv="http://www.dummyComp.pt/TargetWebService" xmlns:comp="http://www.dummyComp.pt/DummyCompService">
<soapenv:Header/>
<soapenv:Body>
<serv:GetDocContent>
<Header>
<acor:Version>1</acor:Version>
<acor:TimeStamp>2013-10-01T16:07:03.388Z</acor:TimeStamp>
<acor:MessageGuid>25892e17-80f6-415f-9c65-7395632f0223</acor:MessageGuid>
<acor:GeneratorEntity>MyEntity</acor:GeneratorEntity>
<acor:GeneratorApplication>MyApplication</acor:GeneratorApplication>
<acor:ServiceId>TargetWebService/GetDocContent</acor:ServiceId>
</Header>
<Body>
<system_name>DocumentManagementSystemName</system_name>
<docId>286284628</docId>
<docPage>0</docPage>
<conversion>0</conversion>
</Body>
</serv:GetDocContent>
</soapenv:Body>
</soapenv:Envelope>

C:\windows\Microsoft.NET\Framework\v2.0.50727\RegAsm.exe WebServiceProxy.dll /tlb:WebServiceProxy.tlb

C:\windows\Microsoft.NET\Framework\v2.0.50727\RegAsm.exe /unregister WebServiceProxy.dll

Modern web development in Visual Studio 2017

Principais novidades do Visual Studio 2017

• Mais simples e mais rápido de instalar
• Mais rápido a arrancar
• Várias melhorias ao nível da interface
• Melhorias ao nível do debug e diagnóstico do código
• Melhorias significativas ao nível das ferramentas colaborativas
• Integração com a cloud (Microsoft Azure)
• Todas as novidades estão disponíveis aqui

• Visual Studio Productivity Power Tools
• Web Essentials
• ReSharper (comercial)

O que é

Quando e como é usado

• estão em desenvolvimento aplicações complexas que requerem processos de instalação complexos
• é necessário dar suporte e garantir o trabalho de muitos computadores
• são necessárias releases frequentes
• é importante monitorizar a aplicação em produção e resolver os bugs rapidamente

Processos da ALM

• Planeamento em tempo eral
• Rastreabilidade do ciclo de desenvolvimento
• Colaboração in-context
• Sistema de Inteligência aplicada ao desenvolvimento
• Melhoria contínua dos processos

ALM pela Microsoft

Funcionalidades do Visual Studio para ALM

• Agile
• Backlogs
• Sprint backlogs
• Kanban boards
• Task boards

• Controlo de Versões
• Team Explorer (cliente TFS Team Foundation Server ou Git)

• Testes
• Testes unitários
• Testes de UI
• Testes de desempenho da web
• Testes de carga

Métricas em destaque

Do Desenvolvimento para as Operações

Microsoft Release Management

• Identificar os ambientes de teste pelos quais a aplicação vai passar (ex: Dev-> QA-> Produção)
• Definir a sequência de acções necessárias à instalação da release em cada um dos ambientes
• Identificar os membros da equipa responsáveis por cada passo da instalação

Das Operações para o Desenvolvimento

Microsoft System Center 2012 Operations Manager

Microsoft Monitoring Agent

Application Insights

Visual Studio Online

• Monitorizar a disponibilidade e o tempo de resposta das aplicações web.
• Basta para isso especificar a URL Uniform Resource Locator e o Visual Studio executa os testes.
• Monitorizar o desempenho e a ocorrência de erros.
• O Microsoft Monitoring Agent está instalado no computador em que a aplicação a monitorizar está instalada e é ligado ao Application Insights. Depois disto a informação recolhida fica disponível no Application Insights.
• Analisar as acções do utilizador.
• Esta ferramenta regista todos os eventos que ocorrem na aplicação (ex: carregamento de um ecrã). Esta opção está disponível para os seguintes tipos de aplicação:
• Windows Phone 8
• Windows Store
• Web services
• Web pages

Microsoft Feedback Client

Integração com outras ferramentas

Referências