Tenho usado o Event Aggregator em UI para sincronização e comunicação indirecta entre user controls/views e entre controllers/presenters. Mas pode ser usado em variadas situações.

Ao introduzir um agregador de eventos entre publishers e subscribers, consegue-se baixo acoplamento. O subscriber observa o agregador de eventos em vez do publisher e o publisher por sua vez apenas sabe acerca do agregador de eventos e não sabe nada sobre os subscribers.



Um agregador simples

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);
                }
            }
        }
        
    }

A subscrição

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
    }

Wrapper do agregador

public static class Messages
    {

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

        }

    }

Exemplo de Invocação

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);

Implementações de Event Aggregator:

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

Referências: Simple message-based Event Aggregator, Implementing the Singleton Pattern in C#, Why Use an Event Aggregator?

Azure Functions é uma solução "das nuvens" para processamento de dados, integração de sistemas, IoT, APIs e microserviços.

O Portal Azure tem um conjunto de ferramentas para desenvolvimento e testes de Azure Functions, mas as funções podem ser desenvolvidas localmente no Visual Studio 2017.

Instalação das Azure Functions Core Tools

Azure Functions Core Tools é a versão local do runtime da cloud para Azure Functions e equipa o Visual Studio 2017 desde a versão 15.3.

Verificar a extensão:

O caminho para a func.exe da CLI Command Line Interface das Azure Functions é idêntico a este

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

Instalação do Azure Storage Emulator

O emulador pode ser instalado a partir daqui. Para instalar o emulador são necessários privilégios de administração.

Instalação do Azure Storage Explorer

O Azure Storage Explorer pode ser usado para trabalhar com os recursos do emulador. Depois de iniciado o emulador, a árvore do Storage Explorer apresenta "(Development)" na ramificação de "Storage Accounts".

Criação da Queue myqueue-items

Criação do projecto local

Configuração do ambiente local

No PowerShell mudar para o directório do projecto e executar o comando

func settings add AzureWebJobsStorage UseDevelopmentStorage=true

ou juntar ao local.settings.json a seguinte parametrização

"AzureWebJobsStorage": "UseDevelopmentStorage=true"

O aspecto final da configuração local será idêntico ao seguinte:

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

Execução local das Azure Functions

Iniciar a depuração carregando F5.

Azure Functions em acção

Video YouTube, Azure Functions Visual Studio Tooling






Referências: Getting Started With Azure Functions, Visual Studio 2017 Tools for Azure Functions, Setting up Azure Storage for local develop of timer or queue triggered Azure Functions, Publishing a .NET class library as a Function App

Video YouTube, Como Funciona a DreamShaper

Foi a partir do Brasil, de onde comanda a equipa em Portugal, que a Dreamshaper foi crescendo. Em Portugal, trabalha a equipa de produto e conteúdos pedagógicos, bem como os responsáveis tecnológicos. No Brasil, opera a equipa comercial. Hoje, é uma plataforma virtual utilizada nas salas de aulas, adaptada ao professor e ao aluno, que orienta e educa, com pequenos vídeos, a estruturação de uma ideia para o mercado real.

É possível desenvolver toda a estratégia de lançamento do negócio do início ao fim. A cada erro, a aplicação sugere uma mudança de estratégia, a cada sucesso, propõe uma estratégia melhor. No fim, há um plano de negócios, um modelo padronizado, "que eles podem pegar e levar para uma reunião, para um pitch, e é uma coisa respeitada", disse Miguel Queimado. A aplicação não se limita a ajudar na elaboração do plano de negócio. Não descura o foco inicial da casa mãe, e concentra-se na tal vertente socioemocional: saber acreditar e não perder o ritmo.



Para saber mais informações, consultar https://dreamshaper.com/









fonte: Observador

Trata-se da aplicação da separação de conceitos às ASP.NET Web forms de forma simples, rápida e com a aplicação das boas práticas com a framework Web Forms MVP.

É usado aqui um HelloWorld para prova de conceito básica.

Codificação da solução

Criar uma solução Web do tipo Web Forms, neste exemplo tem o nome ASPNET.WebForms.MVP.

Na Consola de Gestão de Pacotes NuGet procede-se à instalação da Framework WebFormsMVP, tendo este projecto como padrão

PM> Install-Package WebFormsMVP -Version 1.4.5

Adicionar à solução um projecto do tipo biblioteca que comporta a lógica com as pastas

• Model
• Presenter
• View

Novamente na Consola de Gestão de Pacotes NuGet procede-se à instalação da Framework WebFormsMVP, tendo este projecto como padrão

PM> Install-Package WebFormsMVP -Version 1.4.5

Ao Model adiciona-se a classe HelloWorldModel.cs

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

Ao Presenter adiciona-se a classe HelloWorldPresenter.cs

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 :)";
        }

    }

A aplicação Web referencia a biblioteca core preparada anteriormente e faz uso dos seus elementos no code behind da página HelloWorld.aspx adicionada:

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

HelloWorld.aspx

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

HelloWorl.aspx.cs

[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

É mais fácil usar os built-in routings, é no entanto, uma boa prática customizar o routing, nomeadamente para mais facilmente ser promovido junto dos motores de pesquisa como o google.com.

Métodos de customização de routings

• RouteConfig.cs
• AttributeRouting

Adição ao App_Start\RouteConfig.cs

Exemplo:

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

Esta é a melhor abordagem.

Pré-condição
Adição ao RouteConfig.cs da instrução para activação do route por atributo

routes.MapMvcAttributeRoutes();

Route aplicado como atributo
Adição da template ao atributo Route da action ByReleaseDate do controller MovieController.cs

[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