Cum se face paginare pe tabelele din Windows Azure

Daca lucram cu tabelele din Windows Azure o sa avem nevoie sa facem paginare. Default nu avem nici un mecanism de paginare, dar acesta este usor de implementat.
In postul anterior am descris modul prin care se pot obtine mai mult de 1000 de entitati dintr-un tabel. Pe baza mecanismului prezentat anterior putem sa parcurgem datele din tabel in format paginat.
Trebuie sa ne folosim de metoda Take din LINQ, care din fericire este suportata si de LINQ folosit pentru tabelele din Windows Azure( nu trebuie sa uitam ca doar o parte din LINQ este implementat pentru Windows Azure in acest moment). Apeland metoda Take putem sa obtinem doar o parte din entitati care ne sunt returnate de catre query.
Folosindu-ne de token-urile nextPartitionToken si nextRowToken putem sa luam urmatoarele x elemente incepand de pe o anumita pozitie.
Mai jos gasiti o implementare minimala a unui mecanism de paginare.

    public class Pagination<TItem>
        where TItem : class
    {
        private const string NoValue = "novalue";

        private string _nextPartitionToken;
        private string _nextRowToken;
        private DataServiceQuery<TItem> _dataServiceQuery;
        private List<TItem> _items;
        private int _pageSize;

        /// <summary>
        /// TRUE when another page exist.
        /// </summary>
        public bool HasNextPage { get { return _nextPartitionToken != NoValue && !string.IsNullOrEmpty(_nextPartitionToken); } }

        /// <summary>
        /// Gets all the items of the current page.
        /// </summary>
        public List<TItem> Items { get { return _items; } }

        /// <summary>
        /// The base contructor.
        /// </summary>
        /// <param name="dataServiceQuery">The query that is executed on Azure tables.</param>
        /// <param name="pageSize">The size of the page.</param>
        public Pagination(DataServiceQuery<TItem> dataServiceQuery, int pageSize)
        {
            _nextPartitionToken = NoValue;
            _pageSize = pageSize;
            _dataServiceQuery = dataServiceQuery.Take(_pageSize);
        }

        /// <summary>
        /// Load the next page.
        /// </summary>
        public void NextPage()
        {
            if(string.IsNullOrEmpty(_nextPartitionToken))
            {
                return;
            }

            if (_nextPartitionToken!=NoValue)
            {
                _dataServiceQuery.AddQueryOption("NextPartitionKey", _nextPartitionToken);
                _dataServiceQuery.AddQueryOption("NextRowKey", _nextRowToken);
            }

            //Get the result.
            var result = _dataServiceQuery.Execute();
            _items = result.ToList();

            //Get tokens for the next page.
            QueryOperationResponse queryOperationResponse = (QueryOperationResponse)result;
            queryOperationResponse.Headers.TryGetValue("x-ms-continuation-NextPartitionKey", out _nextPartitionToken);
            queryOperationResponse.Headers.TryGetValue("x-ms-continuation-NextRowKey", out _nextRowToken);
        }
    }

Ceea ce lipseste este calcularea numarului total de pagini. Pentru a putea face acest lucru este nevoie sa executam un query care sa returneze numarul total de entitati de pe un anumit tabel.
Pentru ca utilizatorul sa aiba optiunea de a putea accesa orice pagina este nevoie ca in constructor sa executam cate un query pentru fiecare pagina in parte si sa salvam token-urile.

Read More

Convert a collection of items to a string

Sunt cazuri cand avem liste pe care dorim sa le convertim intr-un string folosind un anumit delimitator.

List<string> lista=new List<string>(){ "A" , "B" , "C" };
//Output: A, B, C,

LINQ nu contine o solutie directa, putem incerca sa interam cu un foreach toate elementele din lista si sa le adaugam la un StringBuilder

StringBuilder sb=new StringBuilder();
string format = "{0}, ";
lista.ForEach(item => sb.AppendFormat(format, item));

Dar din pacate codul scris mai sus este echivalent cu un foreach clasic, doar ca iteram folosind LINQ. O solutie este sa folosim metoda String.Join, care primeste doi parametrii:
-delimitatorul;
-un array care contine lista de string-uri;
Aceasta metoda functioneaza fara probleme, singura problema care o are este ca nu functioneaza pe obiecte generice de tip IEnumerable. Pentru a rezolva acest neajuns este sa apelam la extension method si sa ne scriem propria noastra metoda pentru IEnumerable.

 /// <summary>
        /// For generic IEnumerable.
        /// </summary>
        /// <typeparam name="T">The generic type of IEnumerable.</typeparam>
        /// <param name="source">The IEnumerable object.</param>
        /// <param name="separator">The string separator.</param>
        /// <returns>The string formed from the of each item of list.</returns>
        public static string ToString<T>(this IEnumerable<T> source, string separator)
        {
            if (separator == null)
            {
                throw new ArgumentNullException("Parameter separator can not be null.");
            }

            return string.Join(
                separator,
                source
                    .Where(item => item != null)
                    .Select(item => item.ToString())
                    .ToArray());
        }

        /// <summary>
        /// For generic IEnumerable.
        /// </summary>
        /// <param name="source">The IEnumerable object.</param>
        /// <param name="separator">The string separator.</param>
        /// <returns>The string formed from the of each item of list.</returns>
        public static string ToString(this IEnumerable source, string separator)
        {
            if (separator == null)
            {
                throw new ArgumentNullException("Parameter separator can not be null.");
            }

            string[] array = source.Cast<object>().Where(n => n != null).Select(n => n.ToString()).ToArray();

            return string.Join(
                separator,
                source
                    .Cast<object>()
                    .Where(item => item != null)
                    .Select(item => item.ToString())
                    .ToArray());
        }

Read More

Cum sa obtii mai mult de 1000 de entitati dintr-un query pe tabelele din Windows Azure

Pentru a putea obtine date din tabelele din Windows Azure putem sa folosim DataServiceQuery. Acesta suporta LINQ, astfel ne va fi foarte usor sa filtram continutul.

DataServiceQuery<Person> queryPersons =
     ApplicationServiceContext
     .PersonEntryTable
     .Where( p => p.Age >= 18 );
var result = queryPersons.Execute();

In variabila result o sa avem toate persoanele care au varsta mai mare sau egala cu 18.
Problema apare cand rezultatul contine mai mult de 1000 de entitati. Un query pe tabele din cloud va returna maxim 1000 de rezultate. In cazul in care acest numar este depasit acesta va contine doua token-uri pe baza carora se pot obtine si celelate entitati din query.
Cele doua token-uri reprezinta token-ul pentru Partition Key si Row Key. Se pot obtine din heather-ul rezultatului:

var resultQOR = (QueryOperationResponse)result;
string nextPartitionToken = null;
string nextRowToken = null;
resultQOR.Headers.TryGetValue("x-ms-continuation-NextPartitionKey", out nextPartitionToken);
resultQOR.Headers.TryGetValue("x-ms-continuation-NextRowKey", out nextRowToken);

Cele doua token-uri se pot trasmite mai departe la query pentru a obtine urmatorul set de rezultate.

queryPersons = queryPersons
            .AddQueryOption("NextPartitionKey", nextPartitionToken)
            .AddQueryOption("NextRowKey", nextRowToken);
var rezult2 = queryPersons.Execute();

In result2 am obtinut urmatoarele 1000 entitati din tabel.
Folosind acest mecanism putem sa implementam si un mecanism de paginare.

Read More

Tool-uri pentru Windows Azure

Total Cost Calculator
http://www.microsoft.com/windowsazure/economics/
O aplicatie oferita de catre Microsoft pentru a ne ajuta sa estimam preturiile unei aplicatii in loud. Estimariile nu sunt foarte exacte, dar ne pot oferii o idee asupra preturiilor in prima faza. As fi vrut sa fie mai exacta si sa ne permita sa introduce in calculul final mai multe variabile, dar in versiunea actuala trebuie sa ne multumim doar cu atat.
Nota 8.

Azure Storage Explorer
http://azurestorageexplorer.codeplex.com/
O alta aplicatie foarte utila poate sa fie Azure Storage Explorer. Prin intermediul ei putem sa interogam si sa executam operatii CRUD pe table, blob si queues aflate in cloud sau de pe masina de test. Poate sa ne fie de foarte ajutor, mai ales in faza de debug sau de testare.
Nota 10.

Windows Azure Service Management CmdLets
http://archive.msdn.microsoft.com/azurecmdlets
Ne permite sa facem deploy si sa controlam o aplicatie din cloud din linia de comanda. Putem sa scriem scripturi pe care apoi sa le rulam automat. Tot procesul de deploy poate sa fie automatizat si din cate am observat putem sa automatizam si modul in care scalam aplicatie. CmdLets ne permite sa cream( sau distruge) instante in cloud. Daca stim Power Shell putem sa generam scripturi care sa faca minuni.
Nota 10.

Read More

VM role - o noua dimensiune pentru Windows Azure

Windows Azure permite pana in acest moment doua tipuri de instance:

• web role - similar cu 'Web Application', in principiu orice ce merge pe http si https;
  
• worker role - similar cu un 'Windows Service', ruleaza neincetat prelucrand date;

Nu vreau sa intru in amanunte pe aceasta tema. Pe langa aceste doua, Microsoft ne pregateste un nou rol, denumit VM role. In momentul de fata este in ultima faza de testare, urmand sa apara pe piata cat de curand.
VM role-ul o sa ne permita sa controlam in intregime masina. Este nevoie sa cream local local un VM role pe care apoi sa il copiem in cloud. Pe el o sa putem pune de exemplu Windows Server 2003, putem sa controlam tot ce este instalat pe el. Singurul dezavantaj este partea de administrate care o sa fie facuta in totalitate de utilizator. O parte din pachete de update de exemplu nu o sa mai fie facute automat sau configurarea nivelului de securitate. Iar cloud-ul NU ne ofera back-up la aceasta instanta in mod automat. In cazul in care instanta moare, imaginea care o sa fie folosita este cea pe care am trimis-o ultima data spre cloud. Imaginea care este pusa pe cloud si care este folosita de catre instance pentru a initializa un VM role se numeste "golden image".
Putem sa controlam totul pe aceste intante, de la sistemul de operare la ce aplicatii ruleaza si in ce fel. Dar acest lucru se poate intoarce impotriva noastra, trebuie sa facem si partea de administrare, care poate sa fie uneori costisitoare, nu doar din punct de vedere a timpului cat si financiara.
Se recomanda folosirea acestor tipuri de instante in cazul in care configurarea unui web/worker role ia mai mult de 5 minute. Aici nu stiu ce sa zic, s-ar putea ca noi sa nu fi gandit corespunzator modul in care noi facem deploy.
Chiar daca VM role poate sa para pentru unii un vis devenit realitate, eu il vad mai mult ca in compromis. Trebuie din nou sa facem partea de administrare, licentiere si alte lucruri care cresc pretul final si complexitatea proiectului. Trebuie sa avem un motiv intemeiat cand dorim sa alegem aceasta optiune( poate se preteaza pentru aplicatiile deja scrise, in cazul carora costul portarii pe cloud ar fi destul de mic).

Read More

Code Contracts

Este un tool pentru definirea specificatiilor si pentru validarea acestora in cod.
Are la baza conceptul definit de Vienna Development Method( VDM) care defineste o metoda formala pentru definirea specificatiilor unui soft si definirea integritatii acestuia.
VDM defineste trei elemente:

• invariantii - un set de conditii ce trebuie sa fie adevarate in orice moment pe durata de viata a instantei;
• preconditii - un grup de conditii folosite pentru validarea datelor de intrare;
• postconditii - una sau mai multe conditii care valideaza rezultatul;

Code Contracts nu ne asigura ca programul este corect, doar ne asigura ca un set de reguli sunt indeplinite( iar o parte din specificatii sunt respectate).
La baza Code Contracts sta Spec# care apare in 2007.Aceasta librarie este integrata cu Visual Studio 2010 in 2009. Echivalentrul in Java este Eiffel, care apare cu mult inainte de Spec#.
Mai jos o sa dau un exemplu de cod scris fara Code Contracts care concateneaza o lista de cuvinte:

public string Stick(string[] args)
{
if(args == null)
{
throw new ArgumentNullException();
}
if(args.Lenght < 1 || args[0] == null) { throw new ArgumentException(); } return args.Agregate(string.Empty, (current, r) => current + r);
}

Exista doua IF-uri, care reprezinta preconditiile, iar daca am avea nevoie sa validam rezultatul ar fi nevoie sa salvam rezultatul intr-o variabila, iar apoi sa facem validarea acestuia. Cu Code Contracts totul este mult mai simplu. Orice dezvoltator care o sa vina dupa noi o sa inteleaga cu usurinta care parte din cod reprezinta validarea specificatiilor(pre/post-conditii) si care partea de cod care prelucreaza informatia.

public string Stick(string[] args)
{
Contract.Requires(args != null);
Contract.Requires(args.Lenght < 1); Contract.Requires(args[0] == null);

Contract.Ensures(String.IsNullOrWhiteSpace(Contract.Result()));

return args.Agregate(string.Empty, (current, r) => current + r);
}

La inceput verificam preconditiile ca sa fie valide. In cazul in care una din ele nu este valida aruncam o exceptia pe care o trimitem prin "<..>". Folosind Contract.Ensures putem sa verificam postconditia. Pentru a putea accesa valoarea pe care o returneaza metoda este nevoie sa apelam Contract.Result. Nu are importanta unde plasam Contract.Ensures in interiorul metodei, acesta va fi apelat mereu in momentul in care rezultatul este returnat.
Pentru a putea definii invariantii avem nevoie sa scriem o metoda in interiorul clasei care sa nu primeasca nici un parametru si sa returneze void. Aceasta trebuie sa fie decorata cu atributul ContractInvariantMethod.

[ContractInvariantMethod]
void CustomQueueInvariant()
{
Contract.Invariant(_list != null && _list.Count >0);
}

In exemplul dat mai sus, se va verifica mereu daca _list este diferit de null si contine cel putin un element. Trimiterea unui mesaj custom se face exact la fel cum se face pentru Assert, se poate trimite prin al doilea parametru la fiecare metoda un string care sa reprezinta mesajul custom pe care noi vrem sa il trimitem.
Urmatoarea intrebare este cand se face aceasta validare?
In functie se setariile sistemului, aceasta validare se face la compilare, iar dezvoltatorul o sa fie notificat printr-un warning sau o eroare( depinde de setari). O alta optiune este ca aceasta validare sa se faca in momentul in care cineva foloseste assembly-ul pe care noi l-am oferit. De exemplu daca se apeleaza Stick fara a se face o validare ca args sa fie diferit de null, in cazul acesta un warning poate sa apara. Nu este nevoie sa se faca inainte de apel "If (args !=null) ... ", compilatorul verifica automat daca se poate ajunge la acest apel iar parametrul sa fie null. Daca exista aceasta posibilitate el ne va notifica.
Cel mai tare lucru care mi s-a parut este posibilitatea de a definii invariantii pentru o interfata, iar orice alta clasa care va implementa interfata data va fi nevoita sa respecte invarianti definiti. De exemplu vrem ca orice dezvoltator care implementeata interfata IIdentifiable sa aibe Id-ul diferit de valoarea default. Pentru acest lucru putem sa avem:

public interface IIdentifiable
{
Guid Id{get;set;}
}

public class IdentifiableValidator : IIdentifiable
{
public Guid Id{get;set;}

[ContractInvariantMethod]
void CustomInvariant()
{
Contract.Invariant(Id != Guid.Empty);
}
}

Orice clasa care va implementa interfata definita de noi va fi obligata sa respecte conditia pe care noi am definito. Iata un exemplu umpic mai complicat:

public interface IIdentifiable
where TType : class
{
TType Id { get; set; }
}

public class IdentifiableValidator : IIdentifiable
where TType : class
{
public TType Id { get; set; }

[ContractInvariantMethod]
void CustomInvariant()
{
Contract.Invariant(Id != default(TType));
}
}

Exista cateva metode de baza pe care o sa le enumar mai jos:

• Contract.Requires() - definire preconditii;
• Contract.Ensures() - definire postconditii;
• Contract.Invariant() - definire invarianti;
• Contract.Result() - se obtine rezultatul returnat de metoda;
• Contract.OldValue(T) - se obtine valoarea vechie a unui field, propietati a clasei, inainte de apelul metodei curente( se poate folosii pentru a ne asigura va valoarea unei propietati s-a modificat - valoarea unui contor de exemplu s-a schimbat);
• Contract.Assert() - assert definit prin intermediul Code Contracts;
• Contract.ForAll() - iterarea unei liste pentru verificare unei pre/post-conditii;

Nu o sa intru in detalii despre modul in care se poate configura Code Contracts pentru fiecare proiect in parte, va las pe voi sa descoperiti.
Code Contracts nu a fost creat pentru a inlocuii testele, nu renuntati niciodata la ele. Code Contracts poate sa ajute la definirea specificatiilor in cod si pentru a ne asigura ca acestea sunt mereu indeplinite.
Puteti sa gasiti un mic demo aici:
http://ronua.ro/CS/groups/ronua-cluj-napoca/media/p/217648.aspx

Read More

Intalnire RONUA: 2 martie 2011

Comunitatea RONUA din Cluj-Napoca a ajuns la a doua intalnire in acest format. Cei care doresc sa participle ii rog sa imi dea un reply la acest email pentru a putea sa stim la cate personae sa ne asteptam. Va asteptam.

Oricine e interesat in a afla si discuta subiecte interesante din lumea .NET si nu numai, e asteptat in data de 02 martie (miercuri), de la orele 19:00, la urmatoarea intalnire RONUA Cluj.

In urma votului, au ramas doua subiecte:
• ESB (enterprise service buss) - un mecanism prin care mai multe module (aplicatii) pot comunica intre ele, trimitand un fel de notificari http://en.wikipedia.org/wiki/Enterprise_service_bus (Radu Vunvulea)
• Customizable (desktop) applications design (Dragoș Andronic)
* se da un produs (desktop, windows, .net)
* 80% din functionalitate este ok pentru toti clientii insa fiecare client vrea altceva de la restul de 20% (adica doreste ca aplicatia sa ii fie customizata conform propriilor nevoi)
* ca sa realizam asta va voi prezenta 2 idei arhitecturale (exemplificate cu cod) prin care:
o deschidem spre customizare "main application workflow-ul" prin "pre action hooks" si "post action hooks". Tot legat de acest subiect voi prezenta si un model de organizare a codului (layere si assembliuri) pentru a usura astfel de customizari
o permitem clientului sa customizeze structura de meniuri a aplicatiei (main menu, toolbar menus. context menus): componenta meniurilor, aspectul lor, functionalitatea lor
(durata: ~ 1h)
Fiecare prezentare va fi urmata (daca se doreste) de discutii libere pe marginea subiectului.
Locatia: Evoline, Sigma Tower (fostul IEIA), Strada Republicii, nr. 109, etaj 3.
Cart. Zorilor, intersectia dintre Republicii si Observatorului; acess cu autobuzele 35, 46, 50, 43.
Map: http://www.wikimapia.org/#lat=46.7562728&lon=23.5945129&z=17&l=0&m=b&v=8
(Va trebui sa rugati jos la receptie sa va "trimita" cu liftul la 3 deoarece lifturile merg doar cu cheie.
In caz ca nu va descurcati, gasiti "suport tehnic" la 0751569435 :) - Dragos Andronic (ando)).

Sursa: http://ronua.ro/CS/groups/ronua-cluj-napoca/forum/t/8067.aspx

Read More

SOLID - Design patterns

SOLID este un acronim de la:
SRP - The Single Responsibility Principle: o clasa ar trebui sa aibe o singura responsabilitate;
OCP - The Open Closed Principle: o clasa trebuie sa fie deschisa la extindere fara a necesita modificarea ei;
LSP - The Liskov Substitution Principle: clasele derivate pot sa fi inlocuite de clasele de baza;
ISP - The Interface Segregation Principle: interfete cu granulatie fina, specifice unei anumite responsabilitati, specifice unui anumit client;
DIP - The Dependency Inversion Principle: dependintele trebuie sa fie definite prin interfete si clase abstracte si nu prin clase concrete;

The Single Responsibility Principle( SRP)

"There should never be more than one reason for a class to change." — Robert Martin

O clasa trebuie sa faca doar in singur lucru si nimic mai mult. Fiecare clasa in parte trebuie sa aiba o singura responsabilitate. O clasa care are o singura responsabilitate este mai usor de modificat, mult mai usor de inteles si mai usor de testat. Totodata daca o clasa are mai multe responsabilitati avem mai mari sanse ca acelasi cod sa apara si in alte clase.
O clasa care are mai multe functionalitati este prea mare, face prea multe si este mult prea complicata. Cel mai usor lucru pentru a rezolva aceasta problema este sa facem split la clasa.

Open Closed Principle( OCP)

"Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification." — Robert Martin

O clasa trebuie sa fie deschisa spre extindere si inchisa spre modificare. Comportamentul unei clase ar trebui sa fie modificat prin mostenire si prin compozitie. Principala idee este ca functionalitatile logice sa fie cat mai bine definite, iar daca este cazul acestea sa fie mutate in alte clase si referite prin intermediul interfetelor.
De exemplu daca avem o clasa ce face validarea unui obiect, aceasta nu trebuie sa contina si regulile de validare. Acestea pot sa fie referite prin intermediul unei interfete si transmise prin constructor. In felul acesta daca regulile se modifica, nu o sa fie necesar sa modificam clasa care face validarea. Astfel regulile de validare o sa poata fi schimbate mult mai usor.

Liskov Substitution Principle( LSP)

"Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it." — Robert Martin

Ideea de baza este ca putem inlocui instanta unei clase cu subclasa fiu si totul sa functioneze normal. Nu este tocmai usor de facut acest lucru, deoarececlasa poate sa aibe un set de actiuni specifice care sa nu se mai regăsească in clasa fiu.
Un bun exemplu este exemplu clasic cu dreptunghiul si patratul, unde un patratul poate sa mosteneasca din dreptunghi dar laturiile deja difera ca denumire si logica.
Dar asta nu inseamna ca nu trebuie sa incercam sa respectam LSP. Trebuie sa incercam sa facem clasele de baza cat mai generice. Aceasta regula nu se aplica mereu, dar exista cazuri cand este foarte utila. De foarte multe ori nu putem modela obiectele exact la fel cum sunt in lumea reala prin mostenire, dar ne putem folosi de compozitie pentru acest lucru.

Interface Segregation Principle( ISP)

"Clients should not be forced to depend upon interfaces that they do not use." —Robert Martin

Fiecare interfata trebuie sa fie cat mai simpla si sa defineasca un singur lucru( sa fie specifice). In cazul in care avem o interfata foarte mare, cel mai bine este ca aceasta sa fie sparta in functie de ce responsabilitati are. In cazul in care avem mai multe functionalitati intr-o clasa, atunci in clasa respectiva va fi nevoie sa implementam toate interfetele de care avem nevoie. De multe ori daca avem o interfata foarte mare, clientul nu o sa aibe nevoie sa implementeze toate functiile, ci doar o parte din ele, a.i. se ajunge ca o mare parte din metode sa nu fie implementate.

Dependency Inversion Principle( DIP)

"A. High level modules should not depend upon low level modules. Both should depend upon abstractions.
B. Abstractions should not depend upon details. Details should depend upon abstractions." — Robert Martin

Daca o clasa are dependinte fata de alte clase, acestea ar trebui sa fie prin interfete si clase abstracte si nu prin clase concrete. Prin acest mod clasele se pot modifica mult mai usor, o sa fie mult mai decuplata si mult mai usor de testat.
Daca respectam acest principiu, putem folosi Dependency Injection fara nici o problema. Totodata putem mult mai usor sa separam nivelele unei aplicatii.

Read More

Metoda marcata cu abstract si override

O metoda sau o propietate poate sa fie marcata ca abstracta cand aceasta nu contine si implementarea.
O metoda sau o propietate poate sa fie marcata ca override cand vrem sa modificam implementarea si sa oferim o noua implementare pentru un menbru mostenit din clasa de baza.
Pana aici nimic deosebit, OOP pur. Oare putem sa avem o metoda care sa fie marcata atat abstracta cat si override? Raspunsul este DA. Desi pare ciudat, putem sa marcam o metoda cu aceste doua atribute:

public void abstract override DoWork();

Cand putem sa avem acest caz?
Cand avem o clasa abstracta care contine o metoda virtuala.

public abstract Actiune
{
   public virtual void DoWork()
   {  
       Console.Write("Actiune1.DoWork");
   }
}

Aceasta clasa poate sa fie mostenita de o alta clasa care sa ofere o alta implementare de baza la metoda DoWork.

public abstract Actiune2 : Actiune
{
   public abstract override void DoWork();
}

Orice clasa ce va implementa clasa abstracta Actiune2 o sa fie obligata sa ofere o implementare la metoda DoWork(), chiar daca Actiune2 mosteneste din clasa abstracta Actiune1 care ofera o implementare pentru metoda noastra.

Read More

IComparer generic - propietatea Default

De obicei cand dorim sa putem compara doua obiecte de acelasi tip folosim IComparar. Aceasta ne pune la dispozitie metoda

int Compare(T x, T y);

Valorea returnata de aceasta metoda poate sa fie:

• >0 - daca x este mai mare ca y;
• =0 - daca x este egal cu y;
• <0 - daca x este mai mic ca y;

In cazul in care una( sau amandoua) din valori, metoda poate sa returneze:

• >0 - daca y este null;
• =0 - daca x so y sunt null;
• <0 - daca x este mai mic ca y;

Dar pentru a putea face aceasta comparatie una din valori trebuie sa fie diferita de null, atlfel o sa avem parte de NullReferenceException. Pentru a putea rezolva aceasta problema putem sa avem ceva de genul:

var valoare = x == null ? ( y == null ? 0 : -1 ) : x.CompareTo(y);

Este necesar sa verificam daca una din valor este null. Valoarea lui y nu trebe sa o verificam obligatoriu, dar cea a lui x trebuie sa o verificam mereu.
Pentru a rezolva acest neajuns, avem la dispozitie propietatea Default pe IComparable. Aceasta va crea automat comparatorul default pentru tipul de data dat. De exemplu daca lucram cu un obiect de tip nullable, putem sa evitam sa facem verificarea descrisa mai sus folosind aceasta propietate:

int? x,y;
// ...
var valoare = Comparar<int?>.Default.Compare(x,y);

Acesta va crea instanta in regim de Singleton, o instanta a clasei Comparer. Tipul de data T pe care il folosim trebuie sa implementeze interfata IComparable.
Aceasta propietate ne poate scapa de grijile de a verifica fiecare element daca este null inainte de a face compararea.

Read More

AutoMapper - object to object mapper

Acest mic framework ne ajuta cand trebuie sa mapam doua entita cu aceleasi propietati. In mod traditional pentru a face acest lucru trebuie sa scriem ceva de genul:

CarDb carDb = LoadFromDb(id);
// ...
Car car = new Car()
     {
          Type = carDb.Type,
          Number = carDb.Number,
          Owner = varDb.Owner,
          RegFrom = carDb.RegFrom                            
     };

Acest caz apare mai ales cand avem o aplicatie pe mai multe nivele, iar modelul care persista in baza de baza de date si modelul care ajunge la client sunt diferite.
Ce poate sa faca AutoMapper, este sa faca automat copierea valorilor proprietarilor, fara sa mai scrim noi cod. In cazul in care propietatea primeste o alta valorea sau are un nume diferit, putem sa scriem o expresie lambda care sa faca conversia.
Mai jos o sa gasiti cateva exenple:
1. Mapare intre doua entitati Car si CarDb

// Creare mapare.
Mapper.CreateMap<CarDb,Car>() ;
// Conversia propriu-zisa.
Car car = Mapper.Map<CarDb,Car>(carDb) ;

In loc sa avem o lista de propietati la care sa facem atribuiire, a fost nevoie sa apelam doar metoda CreateMap.
2. Maparea a doua propietati de tipuri diferite.
Sa presupunem ca Car contine o propietate IsHit de tip bool, iar CarDb contine aceiasi propietate, dar este de tipul int.
Pentru acest lucru este nevoie sa cream un nou ValueResolver care sa stie sa convertească din int in bool. ValueResolver este un tip de data definit de AutoMapper, folosit pentru a face conversii intre date.

public class HitIntToBoolResolver : ValueResolver<int,bool>
{
     protected ovveride bool ResolveCore(int val)
     {
          return val==1;
     }
}

Iar pentru a face maparea trebuie pe CreateMap sa adaugăm resolver-ul custom:

Mapper
     .CreateMap<CarDb,Car>()
     .ForMember(
          car => car.IsHit,
          x => x.ResolveUsing<HitIntToBoolResolver>().FromMember( m => m.IsHit));

In acest moment, pentru propietatea IsHit, se va face o conversie automata din int in bool.
3. Cum sa atribuim o valoare custom la o propietate.
Sa presunem ca entitatea Car are o propietate FullNumber de tip string formata din RegDate+Number. Pentru a putea seta aceasta valoare in AutoMapper este nevoie sa scriem urmatorul cod:

Mapper
     .CreateMap<CarDb,Car>()
     .ForMember(
          car => car.FullNumber,
          x => x.MapFrom( e => e.RegDate.ToString() + e.Number ));

In acest fel putem genera valori custom orice propietati.
4. In cazul in care entitatea are propietati care la randul lor trebuie mapate, ajunge sa definim maparea tuturor tipurilor de date implicate, in ncazul nostru este nevoie sa definim o mapare in plus pentru tipul de data Builder( presupunem ca entitatea Car are o propietare cu numele BuildBy de tip Buildder.

Mapper.CreateMap<BuilderDb,Builder>

AutoMapper va detecta automat ca aceasta propietate este deja mapata si va folostii maparea definita deja.

Mapper.CreateMap<BuilderDb,Builder>();
Mapper .CreateMap<CarDb,Car>();
Car car = Mapper.Map<CarDb,Car>(carDb) ;

Din punct de vedere a vitezei, nu va asteptati sa fie la fel de rapid. In spate AutoMapper se bazeaza pe Reflection. Fata de o mapare manuala este undeva de 6-7 ori mai lent. In cazul in care nu aveti nevoie de mii de conversii pe secunta, cred ca AutoMapper este o solutie foarte buna. Obtinem un cod mai usor de intretinut si mult mai clar.
Link:

https://github.com/jbogard/AutoMapper

http://automapper.codeplex.com/

Read More

HTML: Cum sa facem disable un element din drop down.

Uneori avem nevoie pe UI sa facem un element dintr-un drop-down disable. Utilizatorul sa il poata vedea, dar sa nu il poata selecta. Aceasta varianta este foarte utila cand un update la o aplicatie deja existenta, unele optiuni dispar. Pana cand toti utilizatori o sa isi faca update la configuratie( backward compatibility).
Pe fiecare optine dintr-un select avem atributul disable ce care il putem seta. Pana aici totul pare in regula:

<select name="telefon">     <option value="1">Nokia</option>     <option value="2" disabled="disabled">LG</option>     <option value="3">Samsung</option></select>

Optiunea de LG nu o sa poata fi selectata, dar utilizatorul o poate vizualiza, iar din codul de java script se poate selecta aceasta valoare.
Ar aparea ceva de genul acesta:
Nokia LG Samsung
Singura problema este cu IE. Acesta nu suporta acest atribut. Pentru a rezolva acest neajuns putem sa folosim urmatorul cod javascript:

<script>
function AddOptionsDisabledSupport(){
    var allSelectItems = document.getElementsByTagName('select');
        for(var i=0; i < allSelectItems.length; i++){
            allSelectItems[i].onchange= function(){
            if(this.options[this.selectedIndex].disabled){
                if(this.options.length<=1){
                    this.selectedIndex = -1;
                }else
                if(this.selectedIndex < this.options.length - 1){
                    this.selectedIndex++;
                }else{
                    this.selectedIndex--;
                }
            }
        }
       
        //Change the color to gray.
        for(var j=0; j < allSelectItems[i].options.length; j++){
            if(allSelectItems[i].options[j].disabled){
                allSelectItems[i].options[j].style.color = '#CCC';
            }
        }
    }
}

//Run each time when page is loaded.
window.attachEvent("onload", AddOptionsDisabledSupport)
</script>

Iar de acuma acest atribut o sa poata fi folosit si pe IE.

Read More

Propietati de tip array in tabelele din Windows Azure (part 2)

Partea 1 http://vunvulearadu.blogspot.com/2011/02/propietati-de-tip-vector-in-tabele-din.html
Continuare:
In ultimul meu post am descris trei variante prin care se poate persista o entitate care contine o propietate de tip array( lista) intr-un tabel. Ultima varianta, care la prima vedere pare cea mai buna era folosind DataServiceContext.
Aceasta solutie este viabila, atata timp cat nu trebe sa facem un query direct pe tabel. In acest moment tabelel din Windows Azure nu suporta pe query expresii de genu:

• Contains
• Count
• Select

Din aceasta cauza, daca avem o propietate de tip lista nu o sa putem avea un query de genul:

(item => item.ListaElemente.Contains(id)

Din aceasta cauza, pentru a putea face un astfel de query ar fi nevoie sa incarcam toate elementele din tabel si sa le procesam din cod, cea ce nu tocmai optim.
Dar nici prima varianta nu se poate folosii din pacate( lista sa fie stocata ca si un string cu un caracter despartitor), din cauza ca urmatorul query nu este suportat:

(item => item.ListaElementeSz.Contains(id.ToString())

Nu putem sa avem un query care sa foloseasca metoda Contains() pe string.

Singura varianta ramasa este a 2-a, folosirea unei tabele intermediare .

Read More

Propietati de tip array in tabelele din Windows Azure( part 1)

Am inceput sa folosesc din plin tabelele din Windows Azure. Orice fel de date se pot salva acolo, atata timp cat sunt serializabile.
Cu ajutorul lor am facut maparea unor entitati fara probleme. Am ajuns in momentul in care intre doua entitati A si B aveam o relatie n la m, iar intre alte doua entitati 1 la n. Fara nici o problema am scris:

public List<Guid> ItemIds { get; set; }

Am continuat sa scriu codul in continuare fara nici o problema, iar intr-un final am ajuns la unit-teste unde am avut o surpriza nu tocmai placuta. Cea ce am ignorat de la bun inceput a fost faptul ca tabele din Windows Azure nu sunt O/R, ele nu stiu sa stocheze in mod default o lista.
Greseala mea, fapta fiind deja comisa a trebuit sa caut solutii la aceasta problema. Am gasit urmatoarele solutii:

• o propietate de tip string care sa stocheze id-urile despartite printr-un caracter special. Solutia destul de viabila, daca tinem cont de faptul ca obiectele care se stocheaza pe tabele nu ajung sa fie folosite pe partea logica si/sau client side;

• o tabela intermediara care sa stocheze relatiile intre cele doua obiecte. Pare o solutie bunicica, dar ma sperie putin ideea de a crea aceste tabele intermediare;

• ultima solutie gasita care m-a incantat cel mai mult este prin folosirea lui DataServiceContext. Acesta ne permite sa controlam momentul in care o entitate se salveaza sau se incarca dintr-un tabel si sa modificam continutul care se salveaza.

O sa detaliez mai jos aceasta varianta. Windows Azure salveaza toate aceste obiecte din tabele in format Atom Feed. Ce inseamna asta pentru noi? Pai, noi putem controla cea ce se salveaza si sa modificam continutul care ajunge sa fie salvat pe "tabele". Asa cum putem controla serializarea si deserializarea, cu ajutorul la DataServiceContext putem controla valoarea care se persista in tabele. Avem la dispozitie doua "metode":

• ReadingEntity: pentru citirea din tabel;
• WritingEntity: pentru scrierea in tabel;

Un exemplu de implementare puteti sa gasiti aici:
http://convective.wordpress.com/2009/12/30/entities-in-azure-tables/
In momentul acesta am de ales intre ultimele doua variante. Cred ca o sa aleg ultima varianta din cauza si altor neajunsuri pe care le are in momentul de fata Windows Azure la capitolul tabele( modul in care se genereaza un query).
Partea a 2-a: http://vunvulearadu.blogspot.com/2011/02/propietati-de-tip-array-in-tabelele-din.html

Read More

Cum sa "NU" rulezi mai mult de un serviciu windows din acelasi process.

Daca vrem sa pornim mai mult de un serviciu in acelasi proces avem nevoie sa apelam urmatorul cod:

services = new ServiceBase[]
                                              {
                                                  new DeleteService(),
                                                  new CopyService(),
                                                  new LoadService(),
                                              };
ServiceBase.Run(services );

Dupa ce o sa executam acest cod o sa avem surpiza sa observam ca doar primul serviciu din lista a ponit. In prima faza ne gandim ca avem acelasi nume, asa ca verificam la cele trei servicii numele. Totul pare in ordine.
Urmatorul pas este sa setam serviciul pe "Share" type. Pentru acest lucru trebuie facut:

sc config "NumeServiciu" type=share

Dar din pacate problema se manifesta in continuare. Doar primul serviciu din lista de servicii porneste.

Am renuntat la acesta idee si am facut cate in install pentru fiecare servciu in parte.

Read More

System.Web.Helpers.Json.Decode + dynamic = generic deserialization

Azi am făcut o mare descoperire. Prin helpe-ul de web am gasit metoda Json.Decode. Se poate folosii oriunde nu doar in aplicațiile web. Este nevoie doar sa referim System.Web.Helpers.
Cu ce ne ajuta, putem face decode la orice obiect serializat prin Json, iar in combinatie cu dynamic type obtinem urmatorul cod:

var webClient = new WebClient();
var jsonResult = webClient.DownloadString("URL");
var result = Json.Decode(jsonResult);
//result.response.sets.items - depinde de cea ce returneaza Json
var listItem = new List<dynamic>(result.response.sets.items);

In listItem avem deja o lista de obiecte de orice tip deserializate. Singurul lucru in minus este ca propietatiile care se acceseaza dintr-un obiect de tip dynamic nu sunt strong type. Doar la runtime o sa stim daca proprietatea exista sau nu - din cauza la DLR( Dynamic Language Runtime).

Read More

Operatii CRUD pe tables in Windows Azure

Se da obiectul de tip Point, cu doua propietati de tip int X si Y si un id tot de tip int, unde point implementeaza TableServiceEntity.

Initalizare:

//Initializare cont (se poate incarca din fisierul de configurare).
StorageAccountInfo account = ...
TableStorage tableStorage = TableStorage.Create(account);
//Creare tabel cu un anumit nume.
tableStorage.TryCreateTable("Point");

Salvare:

Point point = new Point();
...
TableStorageDataServiceContext context = table.GetDataServiceContext();
context.AddObject(point);
//Doar pe save se salveaza in tabel obiectul nostru.
context.Save();

Interogare:

TableStorageDataServiceContext context = table.GetDataServiceContext();
//Trebuie specificat numele tabelului. Un tabel poate sa contina orice tip de obiecte, chiar si de tipuri diferite.
var query = context .CreateQuery("Point").Where(item => item.Id == 10);
IEnumerable resultList = new TableStorageDataServiceQuery((DataServiceQuery)query).ExecuteAll();

Stergere:

//Dupa ce prin avem obiectul de tip Point( ajunge sa fie un obiect de tip Point care sa aibe partition key si row key corespunzator.
TableStorageDataServiceContext context = table.GetDataServiceContext();
context.DeleteObject(point);
context.SaveChanges()

Read More

Windows Azure - static properties & fields

Variabilele de tip static pe Azure nu sunt chiar statice. Din cauza ca nu stim intr-un anumit moment pe ce instanta putem sa ajunge printr-un call, nu trebuie sa presupunem ca intre doua call-uri consecutive o sa ajungem pe aceiasi masina.
Aceasta problema apare mai ales in cazul variabilelor care le initializam printr-o metoda publica intr-un anumit moment diferit de initializarea aplicatiei.
Din aceasta cauza cel mai bine este sa lucram cu propietati, nu cu field-uri si sa avem un cod asemanator cu cel pentru Singleton.

        private static ObjA _item;
        private static object _itemLock;
        public static ObjA Item
        {
            get;
            {
                if(_item == null)
                {     
                    InitItem ();
                }
                return _item;
            }          
        }

        private static InitItem()
        {
             lock(_itemLock)
             {
                if(_item == null)
                {
                    _item = Init;
                }
            }
        }

Read More

ConvertAll - Conversia unei liste mult mai usor

Avem urmatorul scenariu. O lista de elemente de tip A, pe care trebuie sa o convertim la o lista de tip B. Pentru a putea rezolva aceasta problema putem să implementam operatorul implicit sau explicit de conversie, iar apoi să iteram prin lista pentru a face conversia la tipul B.

List<A> listaA;
List<B> listaB;
...
foreach(A a in listaA)
{
    listaB.Add(a);
}

sau

listaB.foreach(item=>listaB.Add(item));

Ambele soluții sunt rezonabile, dar e puțin mai greu de înțeles ca in spate se face o conversie. Pentru a face codul mai clar putem să facem in felul următor:

listaB = listaA.ConvertAll<B>(item => item)

Ce am scris mai sus? Fiecare element din listaA convertestel in tipul B si adaug-al in colecția care rezulta. item => item am putut sa scrie deoarece am presupus ca un operator de conversie implicita sau explicita intre cele doua tipuri a fost deja implementat.
In cazul in care acesta nu ar fi implementat am avea ceva asemanator:
Din

private B ConvertAToB(A a) { return new B(); ... }
...
List<A> listaA;
List<B> listaB;
...
foreach(A a in listaA)
{
    listaB.Add(ConvertAToB(a));
}

Am avea:

private B ConvertAToB(A a) { return new B(); ... }
...
listaB = listaA.ConvertAll<B>(item => ConvertAToB(item));

Cea ce am scris mai sus se poate scrie si:

listaB = listaA.ConvertAll<B>(ConvertAToB);

Chiar daca folosim ConvertAll obtinem acelasi rezultat, doar ca folosind ConvertAll obtinem un cod mai clar. Urmatorul dezvoltator care o sa vina dupa noi o sa inteleaga ca aici facem oconversie.

Read More

Cum sa verificam daca un path este valid

Uneori avem nevoie să verificam dacă un path dat de utilizator este valid. Asa cum exista System.IO.File.Exist() exista pentru a face aceasta verificare si System.IO.Directory.Exist().
Iata mai jos si un exemplu:

string path = "d:/locatie";
if(System.IO.Directory.Exist(path))
{
     //path-ul este valid.
} else
{
     // path-ul nu este valid.
}

In cazul in care path-ul contine si numele unui fisier putem sa facem urmatorul artificiu:

string path = "d:/locatie/a.txt";
if(System.IO.Directory.Exist(GetDirectoryName(path)))
{
     //path-ul este valid.
} else
{
     // path-ul nu este valid.
}

Read More