Contents tagged with Desenvolvimento

  • What, Why and How About SignalR

    16/06/2016

    By Abhishek Goswamiwww.c-sharpcorner.com

    • December 1st, 2013

    What is SignalR

    We know very well how a client sends data to a server so now it's time to understand how a server pushes data to a client in a HTTP connection. SignalR is an open source library to add real-time web functionality in your ASP.Net web application. So what does real-time functionality mean? Just use as an example when more than 1 user is working on the same document in Google Documents When a user is making changes and at the same time another user can see the changes without reloading the page. So real-time web functionality is the ability to have server code to push content to connected clients. In the HTTP request response model we know each time we need to send a new request to communicate with the server but SignalR provides a persistent connection between the client and server.

    It can be easily scaled out via SQL Server, Redis or a service bus (scale out means adding more servers to handle the load). There is no need to worry about this scale out term, in my next article I will explain it in detail because SignalR provides good scale out features. SignalR uses Web socket technology to send data. WebSocket is a new HTML5 API that enables bidirectional communication between the browser and server but if it is not available then SignalR can use other technologies like long polling.

    SignalR transfers data in non-compressed JSON text or plain text so if you want to send data in compressed JSON then you need to write your own logic on the server side and the same logic on the client side also. SingnalR makes extensive use of asynchronous techniques to achieve immediate and maximum performance.

    Modes of communication

    SignalR provides two models for communicate between clients and severs.

    1. Persistent Connections

    Persistent Connections provide direct access to a low-level communication protocol that signalR provides. Each client connection to a server is identified by a connectionID. So in your application if you need more control over a connection, in SingnalR you can use this model. This midel can be used where you want to work with a messaging and dispatching model rather than remote invocation or in any existing application using a message model and you want to port to signalR.

    2. Hubs

    Hubs provide a High level API for the client and server to call each other's method. It will be very familiar to those developers who have worked on remote invocation APIs. If you have multiple types of messages that you want to send between a server and a client then it is recommended to use Hubs so you don't need to do your own dispatching. You can create an application either using Hubs or a Persistent connection; the only concern is, with Hubs it will be easy to implement.

    So now we have an idea of what SignalR is so now it's time to proceed to "why".

    WHY use SignalR

    Using SignalR we can create web applications that require high frequency updates from the server. For examle, a dashboard, games and chat applications. SignalR uses Web Sockets and the HTML5 API that helps in bidirectional communication. It also provides an API for server-to-client Remote Procedure Calls (RPC) call, it may be something new for you because most of the time we use a request and response model.

    SignalR includes automatic connection management, it provides the facility to broadcast messages to all connected clients or to a specific client. The connection between the client and server is persistent while in HTTP it isn't persistent.

    So now where to use SignalR:

    1. Notification: If you want to notify 1 client or all clients then we can use SignalR. Notification can be like some alerts, a reminder, feedback or comments and so on.
    2. Chat: It is very easy to implement a chat application using SignalR, either it could be one-to one or a group chat.
    3. Gaming: SignalR helps to create a Gaming application that requires frequently pushing from a server and so on.

    HOW use SignalR

    Here I am not going to directly jump into code. I will first explain how a Remote Procedure Call (RPC) happens.

    Let's assume that on the server side we have a method named MyServerFunction() so if we want to call that method from a client you can call it using "$.connection.myHub.server.MyServerFunction()" and suppose we have a JavaScript function named "myClientFunction()" and we want to call that method from the server so we can call that using "Client.Client(id). myClientFunction()".

    I know many of you are thinking, what are this connection, hub and server keywords. So please be patient, very shortly I will explain all these when I will explain both modes (persistent and hubs) in details.

    See the following diagram for a better understanding.

    As you can see, during the RPC using SignalR the hub will be at the server side and the client will have a hub proxy. When the proxy object wants to call a real method of the server, the object implements Ajax style calls to the real method. Whereas when the server wants to invoke the client method , it is resolved using dynamic types and a special protocol that packages these calls to the server.

    When an application has a SignalR connection and it wants to send some data to the server, the data is not sent in a raw form, SignalR wraps that data in JSON with other information and wraps it all on the JOSON payload before sending to the server.

    I think we have explained many concepts about SignalR. I know many of you are feeling bored but don't worry, in my next article I will have with all the coding and implementation about SignalR. I wrote this article because I didn't find any article on SignalR that can explain all concepts and how SignalR works. Thanks for reading and be ready for the next article.

    Ref.: http://www.c-sharpcorner.com/UploadFile/abhijmk/what-why-and-how-about-signalr/


  • NHibernate + Fluent :: Mapeamento de campo varchar com valor separado por caracter com conversão em propriedade de coleção no domínio automaticamente

    16/06/2016

    Trabalhando em um projeto recente esbarrei na seguinte necessidade, um campo "varchar" na tabela XPTO possuirá conteúdo no seguinte formato:
    
    

    65;78;21;6;98

    
    
    É um caso bem conhecido, algo que em um banco de dados normalizado se transformaria em uma agregação, mas que nesse específico o conteúdo são as chaves estrangeiras para uma tabela separadas por ; (ou qualquer outro separador de valor) gravado em um campo na tabela.
    
    
    A solução mais comum para esse tipo de caso seria tratar em um DTO, Model ou semelhante o retorno de uma propriedade com a coleção, um array por exemplo, após a leitura do campo que contém a lista concatenada. 
    
    
    Usando Fluent e NHibernate (não testei sem Fluent) temos uma maneira mais direta e elegante de fazer o mesmo.
    
    
    
    
    
    
    Na classe de mapeamento definimos a seguinte regra: 
    
    
    Map(x => x.PropriedadeDaColecao"CampoComAListaConcatenada").CustomType(typeof(string)).Access.CamelCaseField(Prefix.Underscore);
    
    
    
    
    
    
    
    Na classe de domínio a seguinte definição de propriedade:
    
    
            protected string _propriedadeDaColecao; 
            public virtual List<int> PropriedadeDaColecao
            {
                get
                {
                    if (string.IsNullOrEmpty(_propriedadeDaColecao))
                    { 
                        return new List<int>();
                    }
     
                    return _propriedadeDaColecao.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(n => int.Parse(n)).ToList();
                }
                set
                {
                    _propriedadeDaColecaostring.Join(";"value);
                }
            }
    
    
    
    
    Apesar de mapearmos o campo "varchar" CampoComAListaConcatenada para a propriedade PropriedadeDaColecao, que é do "tipo coleção" - ao invés do tipo string como seria o correto - a definição do CustomType faz o que é necessário para se adequar ao domínio.
    
    
    Uma explicação superficial é que através da definição ".Access.CamelCaseField(Prefix.Underscore)" o Fluent sabe que deve atribuir e recuperar o valor direto de _propriedadeDaColecao, que vemos que está declarada como "protected" ao invés de "private". A PropriedadeDaColecao será usada pelo programador de forma transparente como uma coleção.
    
    
    É até natural a leitura do código, estamos dizendo que o CustomType é do tipo string, acessado através do "field" que está definido em CamelCase com o prefixo _ (underscore), ou seja, para PropriedadeDaColecao ele encontrará por Reflection _propriedadeDaColecao.
    
    
    
    
    Uma outra possibilidade seria construirmos uma classe CustomType para o mapeamento, mas se temos essa possibilidade de conversão direta porque não usar?


  • Wijmo, muito bom, fácil de implantar e leve, mas peca em documentação

    15/06/2016

    O Wijmo, muito bom, fácil de implantar e leve, mas peca em documentação.

    Você rala para descobrir funções, pesquisa artigos e então descobrei que o problema é que as soluções em artigos estão obsoletas e que a documentação não explica o que deveria.

    Exemplo recente, precisa recuperar os eventos (appointments) do Event Calendar, segundo a documentação bastaria acessar à propriedade "appointments", mas esta sempre retorna vazio.

     appointments: /// <summary>  
         /// The event objects array. This option is deprecated:  
         ///     please, use eventsData option, instead.  
    

    Somente abrindo o código que agora a propriedade é "eventsData" na versão atual (desde quando?) que é a 2013.1.

    Então a linha de código correta é:

     var eventos = $("#eventscalendar").wijevcal("option", "eventsData");  
    

    É o velho problema dos manuais que não acompanham a evolução dos softwares produzidos.


  • Como fazer o deploy de WebParts desenvolvidas no Visual Studio 2010 no Sharepoint 2010

    15/06/2016

    Há alguns anos eu precisei desenvolver WebParts para Sharepoint 2010 e nas pesquisas sobre como implantar em produção resumi para os seguintes comandos:

     

    • Adicionar a solution da feature utilizando o stsadm:
      stsadm -o addsolution -filename MinhaSolution.wsp
       
    • Depois de adicionar a solution, você deve executar o deploy no seu site. Para isto você pode utilizar o stsadm:
      stsadm -o deploysolution -name MinhaSolution.wsp -immediate -allcontenturls -allowgacdeployment

      -allcontenturls : instalar em todos os sites, se você quiser especificar qual site instalar troque pelo parametro "-url http:\nomedoserver:porta"
      -allowgacdeployment : instalar dependências configuradas na GAC.       
       
    • Atualizar uma solution:
      stsadm -o upgradesolution -name MinhaSolution.wsp -filename MinhaSolution.wsp -immediate -allowgacdeployment


    Eu tinha feito um pequeno manual usando os comandos dentro do shell do Sharepoint ao invés do STSADM, mas não encontrei, caso o encontre atualizo este post.



    Origem: http://marcelocml.wordpress.com/2010/02/03/deploy-de-uma-solution-wsp-no-sharepoint/