Add EULA to ClickOnce Installation using Visual Studio 2015


ClickOnce technology is very smart and useful when you want simple, small and smart piece of software for deploying your Windows Forms or WFP application. This is specially useful if you deliver application which doesn’t require administrator rights during installation. ClickOnce is very powerful if you wants automatic update of your product, you can decide whenever the update appears before or after app is run. Also by using certificate you can deliver reliable and secure product to your customers. Long time ago I wrote detailed blog post  how to make ClickOnce deployment.

But one big thing is missing in ClickOnce deployment and for most of dev community is the feature which should be included by default. The feature which missing is “End User License Agreement” (EULA).  There is no simple way to implement it. Searching the internet I have found one forum post on Microsoft site describing how to implement it. Only way you can get ELUA at the beginning of the ClickOnce installation proces is by using it as prererquested component. Actually you build a redistributable component which would be seen as prerequsites dialog box under the publish window. To build custom prerequisites component you need a three files:

  1. Product.xml. – which is the file for bootstrapper and Visual Studio to show  a component in prerequisites dialog,
  2. Package.xml – which is the file containing all information about the component to be installed,
  3. EULA.txt – your ELUA text for user to accept.

Those three files must be installed in the location where all components are registered: C:\Program Files (x86)\Microsoft Visual Studio 14.0\SDK\Bootstrapper\Packages

For this blog post I have prepare demo sample which look like the following picture:

clickoncelicsl015

As can be seen, there is a two folders and one xml file. Each folder contains two files described earlier. Folders “en” and “de” means we are going to have EULA translated on two languages.

In order to successfully registered perquisites to be visible by Visual Studio we need to define proper content of the product.xml. The following xml code show content of our demo sample:

<?xml version="1.0" encoding="utf-8" ?>

<Product xmlns="http://schemas.microsoft.com/developer/2004/01/bootstrapper" ProductCode="EULA.Bootstrap.Component">
  <!-- Defines list of files to be copied on build -->
  <PackageFiles>
    <PackageFile Name="en/eula.txt"/>
  </PackageFiles>
  <Commands>
    <!-- Open eula.txt without any parameters -->
    <Command PackageFile="en/eula.txt" Arguments='' >
	
	  <!-- These checks determine whether the package is to be installed -->
	  <!-- No install conditions -->
      <InstallConditions>
        
      </InstallConditions>
	  
	   <!-- Exit codes -->
	   <ExitCodes>
        <ExitCode Value="0" Result="Success" />
        <DefaultExitCode Result="Fail" FormatMessageFromSystem="false" String="GeneralFailure" />
      </ExitCodes>

    </Command>
  </Commands>
</Product>

As we can see xml content is self-described, it contains product information, files to be installed, installation conditions and exit codes.

Each folder (en, de, …) contains package.xml file which holds localized messages and list of files to copied on build. The following xml content shows content of our en demo sample:

<?xml version="1.0" encoding="utf-8" ?>
<Package xmlns="http://schemas.microsoft.com/developer/2004/01/bootstrapper" Name="ClickOnceWithLicenseAgreement" Culture="Culture" LicenseAgreement="eula.txt">
  <!-- Defines list of files to be copied on build -->
    <PackageFiles>
        <PackageFile Name="eula.txt"/>
    </PackageFiles>

  <!-- Defines a localizable string table for error messages and url's -->
  <Strings>
    <String Name="DisplayName">ClickOnceWithLicenseAgreement 1.0 (x86 and x64)</String>
    <String Name="Culture">en</String>

    <String Name="CancelFailure">User Refuse to Accept to ClickOnceWithLicenseAgreement End User License Agreement.</String>
    <String Name="GeneralFailure">A fatal error occurred during the installation of ELUA Component Execution</String>
    <String Name="AdminRequired">You do not have the permissions required to install this application.  Please contact your administrator.</String>
  </Strings>    
</Package>

The EULA.txt file contains the text user need to accept in order to install the product.

For this demo we created folder EULAPackage, put product.xml and two folders en and de because we are going to support two installation languages (see picture above).

Copy the EULAPackage folder in to : C:\Program Files (x86)\Microsoft Visual Studio 14.0\SDK\Bootstrapper\Packages

Now we have set all necessary information about ELUA component and can be included in our demo sample.

  1. Open Visual Studio 2015 and create new WFP application.Name it as “ClickOnceWithLicenseAgreement

clickoncelicsl011

2. Right-Click on the Project and select Property menu option, then select Publish tab item of the Project Property window.

clickoncelicsl016

3. Click on Prerequisites Button, then you will see your prerequisite component in the standard prerequisites lists.

clickoncelicsl013

4. Select ClickOnceWithLicenseAgreement component and click Ok button. Afterwards click Publish button to build installation package.

5. Open publish folder from the disk. DoubleClick Setup.exe and the ELUA window should be appeared:

clickoncelicsl014

6. Now user has two choises to accept or Refuse the EULA, which means install or not install the app.

Prerequested demo sample component for EULA can be downloaded from here.

Happy programming.

 

Advertisements

Where is Debug – Exception menu option in Visual Studio 2015


Few days ago Microsoft launched Visual Studio 2015, the  long waited release with tons of great features. In the last three years I held several sessions on Microsoft and Community conferences about some of the new feature in Visual Studio 2015, like new C# and VB compiler so called Roslyn, new JIT 64 compiler, Framework 4.6 , native Compiler, as well as great new Debugging and Profiling tools.

During daily development I am using Debug features a lot. First time I have opened Visual Studio 2015, I could not find Debug Exception option. Usually the option is under Debug menu.

Visual Studio 2015

Visual Studio 2013

Visual Studio 2015

Visual Studio 2015

After some researching I have found the option in Debug->Window->Exception Settings. Now the Exception Setting window is modless dialog, so you can set the option without interrupting debug process. Also there are powerfull filter to quickly find right exception you want to throw.

debug_exception2

There is a great video about this feature which you can see here and see why Visual Studio team moved this option to Debug-Windows menu option.

https://channel9.msdn.com/Events/Visual-Studio/Visual-Studio-2015-Final-Release-Event/Revamped-Exception-Settings-Experience-in-Visual-Studio-2015/player

error CS0433 for ‘System.Windows.Automation’ type


vsissu2e

Few days ago I had a strange issue in one of my Visual Studio 2013 solution. The Test project required functionality of System.Windows.Automation, and I have added assembly UIAutomationClient. When tried to run tests I got the folowing compiler error:

error CS0433: The type ‘System.Windows.Automation.AutomationElement’ exists in both ‘c:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\UIAComWrapper.dll’ and ‘c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\UIAutomationClient.dll’

It was strange issue, because I didn’t add UiaComWrapper assembly. Tried to remove the assembly, but as soon I run test the previous error appeared.

vsissue

 

Fixing the issue

To fix this issue we have to use “Reference Alias” which is specified here. So for our assembly UIAutomatisationClient change the Alias from “global” to  “UIAutomationClientAlias”. See picture below.

vsissuesl2

Now that we defined new alias, in the following text it is shown how to use it in your cs file. Open the cs file we have error.

1. At the top opf the file put the folowing line:

extern alias UIAutomationClientAlias;

2. Define using namespace from the new alias:

using Autom = UIAutomationClientAlias::System.Windows.Automation;

3. Now we can use all members from Automation class safely, and the compiler error is despaired.

vsissuesl3

Azure DevCamp @ HUB387 Sarajevo


azure_dev_Camp_sarajevo2014

Nakon decembarskog AzureDevCampa u Banjaluci, Microsoft BiH organizira jos jedan AzureDev Camp. Naime, u subotu 21. marta u tehnološkom parku HUB387, održat će se cjelodnevni trening o Microsoft Azure za developere, softverske arhitekte te IT profesionalce.

Kao i prethodni ut meni je pripala čast da vodim ovaj trening i nadam se da ću zahtjevnoj publici uspjeti prezentirati očekivano.

Koncept Azure DevCampa sastoji se od 6 predavanja koja uključuju osnovne cjeline koje Microsoft Azure nudi.

Polaznici će na radionici imati priliku vidjeti osnovne konceptima razvoja rješenja u cloud-u, prvenstveno paradigmama kao što su to SaaS, PaaS i IaaS. U nastavku, kroz različite Azure servise, biće demonstrirani različiti scenariji počevši od hostiranja web aplikacija baziranih na različitim tehnologijama (.NET, PHP, Java, Node.js, …) , skladištenja i upravljanja podacima (SQL, NoSQL, BLOB, …), podizanja infrastrukture (Win/Linux virtuelne mašine, virtuelne mreže,…) pa do integracije sa mobilnim uređajima.

 

Vidimo se na Azure DevCampu.

Treća MSCommunityBH Konferencija, Hotel Sarajevo, 19/09/2014


badge-predavac

Treća po redu MSCommunityBH konferencija održava se ove godine u Hotelu Sarajevo,  19. septembra sa početkom u 9:00 sati. Iz godine u godinu konferencija sve više dobija na polularnosti ne samo u Bosni i Hercegovini nego i regionu. Organizirana od strane MSCommunit zajednice u Bosni i Hercegovini, lokalnog ureda Microsofta te sponzora koji od samog početka financiraju MSCommunity događaje zaista je svijetli primjer uspješne organizacije, uz pomoć lokalnih snaga i sponzora.

Pored izuzetno kvalitetnih predavača, kao i tema koja spadaju u sami vrh IC tehnologija sa akcentom na microsoftove tehnologije, konferencija daje priliku maldim ljudima da se upoznaju sa najnovijim tehnologijama iz područja razvoja softvera, Cloud Computinga (računanja u oblaku) ,  IT Pro tema, a  kroz networking razmjene iskustava i dobro se provedu.

Po treći put mi se ukazala mogućnost da na konferenciji održim predavanja iz oblasti razvojnih alata na .NET platformi. Predavanja počinje nakon otvaranje konferencije u 10:00 sati.

Tema: Visual Studio 14: Šta dolazi?
Nivo: 300
Opis:
Microsoft je još sa VS 2012 promijenio strategiju razvoja i objavljivanja Visual Studia koncepcijom kontinuiranog objavljivanja novih verzija svaka 4 mjeseca. Polazeći od Update 2 za Visual Studio 2013 preko Visual Studio 14 Microsoft je lansirao i najavio nekoliko vrlo važnih proširenja na .NET Frameworku odnosno na samom Visual Studiu. Ove promjene odnose se na sve četiri aktivne Microsoft platforme: Mobile, Desktop, Web i Cloud. Nova proširenja na mobilnoj platformi dolaze kako za nativni razvoj mobilnih rješenja preko integracije XAMARINa u Visual Studio, tako i miltiplatformski razvoj preko Multi-Device Hybrid proširenja za Visual Studio. Desktop platforma doživaljava veliki preobražaj pojavom nove .NET kompajlerske plaftorme „Roslyn“, novog 64 bitnog .NET kompajlera „RyuJIT“ i novog .NET Nativnog kompajlera „.NET Native“. Web platforma odnosno ASP.NET vNext dolazi u open source verziji sa podrškom za Mono odnosno podrškom za Linux i Mac. Novi razvojni alati donosi i unapređenja u razvoju cloud baziranih rješenja, a sa kombinacijom za Visual Studio Online i integracijom Visual Studia u Microsoft Azure daje nove koncepcije razvoja i održavanja sistema. Pored toga nadolazeća verzija Visual Studio 14 donosi mnoštvo alata za uređivanje koda, debuggiranja, memory profiling alate i drugo.

Vidimo se na konferenciji.

Visual Studio 2010 i C# 4.0 IV DIO: Parallelfx i rješavanje sistema linearnih jednačina


Najznačajnija novina u VS 2010 po mom mišljenju je ParallelFx biblioteka za paralelno programiranje koja iskorištava višejezgrene procesore. O ovoj novini pisao sam na nekoliko postova:
  1. ParallelFx nova generacija konkurentnog programiranja
  2. ParallelFx II dio-PLINQ
  3. Izračunavanje broja PI i implementacija prekoParallelFx
U ovom dijelu biće prezentirana primjena ParallelFx na rješavanje sistema linearnih jednačina. Više detalja oko same biblioteke možete pronaći na gornjim linkovima.
Uvod

Jako puno inženjerskih problema pri procesu rješavanja svodimo na rješavanje sistema linearnih jednačina, koje onda rješavamo jednom od standardnih matematičkih metoda. Rješavanje sistema linearnih jednačina zahtjeva znatno procesorsko vrijeme kao i znatnu količinu memorije za pohranjivanje. Kada rješavamo sisteme sa većim brojem nepoznatih 100, 1000, 10000 i više, vrijeme izvršavanja klasičnim metodama i algoritmima se smanjivalo se kako su se procesori razvijal. Obzirom da se takt procesora više ne može povećavati, a daljnje proširenje svodi se na višejezgrene procesore, naši algoritmi za rješavanje ostali su na istom nivou. Naime, svi ti algoritmi bazirani su na sekvencijalno načinu izvršavanja koda pa višejezgreni procesori nemaju efekta u rješavanju. Pojavom više jezgrenih procesora šire su se počeli razvijati algoritmi za paralelno procesuiranje, a tako i paralelni algoritmi za rješavanje sistema jednačina kao i drugih algoritama koji zahtjevaju značajno procesorsko vrijeme. Paralelni algoritmi za rješavanje određenih inženjerskih procesa pojavili su se početkom 90-tih godina i s njima su se koristile samo velike kompanije poput NASA-e i sličnih, a koji su imali znatne materijalne i financijske resurse. U tu svrhu povezivali su se hiljade procesora koji su onda paralelno izvršavali dijelove koda, a na kraju su se sublimirali i davali rješenja. Tada još nisu bili poznati višejezgreni procesori poput današnjih pa su se procesori povezivali klasično gdje su zauzimali znatno prostora.

servers

Slika 1. 1000-Pentium Beowulf-Style Cluster Computer (www.genetic-programming.org/)

Npr. John Koza tvorac genetskog programiranja, povezao je 1000 procesora gdje je vršio svoja ispitivanja i proračune sa paralelnim algoritmom genetskog programiranja (O genetskom programiranju već sam pisao ). Pojavom višejezgrenih procesora paralelno programiranje postalo je dostupno i običnim „smrtnicima“ a samim tim i šira upotreba paralelnog načina programiranja.

Gaussova metoda eliminacije

Jedna od najpopularnijih metoda rješavanja sistema linearnih jednačina je Gaussova metoda koja koristi princip eliminacije kojom se u konačnom broju iteracija na kraju dobija jedno rješenje, od kojeg se u povratnom smjeru dolazi do drugih rješenja. Linearni sistema od clip_image006 jednačina sa clip_image006[1] nepoznatih clip_image008 je skup jednačina clip_image010 slijedeće matrične forme:

clip_image012

clip_image014

clip_image016

Gdje su clip_image018i clip_image020 realni brojevi članovi matrice. Sistem zovemo homogenim ako su svi članovi matrice kolone slobodnih članova clip_image020[1] jednaki nuli; inače sistema zovemo nehomogeni. Korištenjem matrica i njihovih operacija, jednačine clip_image010[1] možemo posmatrati kao matrični jednačinu:

clip_image022

Gdje je matrica clip_image024 clip_image026 matrica

clip_image028,

dok su matrice kolona nepoznatih označavamo sa clip_image030 , a matricu kolona slobodnih članova označavamo sa clip_image032. Formalni zapisi ovih matrica dati su sljedećim izrazima respektivno:

clip_image034 ,

clip_image036.

Proširena matrica sistema clip_image038 je matrica reda clip_image040 koju definišemo kao:

clip_image042

Rješenje sistema linearnih jednačina je skup brojeva clip_image044 koji zadovoljavaju svih clip_image006[2] jednačina, a vektor rješenja sistema linearnih jednačina clip_image046 je vektor koji zadovoljava matričnu jednačinu. Način na koji se rješavaju sistemi linearnih jednačina Gaussovim sistemom eliminacije možete pogledati iz referenci koje su stavljene na kraju ovog članka. Da bi implementirali algoritma za rješavanje sistema linearnih jednačina potrebno je poznavati ovu metodu, te imati na umu procesorsko vrijeme i memoriju koju će algoritam zauzimati.

Algoritam Gausove metode eliminacije

Način na koji rješavamo sisteme jednačina „pješice“ najbolji je način kako da započnemo implementaciju algoritma. Za informaciju, na internetu postoje hiljade stranica na kojima se mogu naći algoritmi za rješavanje sistema linearnih jednačina u raznim programskim jezicima. S toga ova implementacija koja je data nije ništa revolucionarno.

Algoritam Gauss clip_image048 – proširena matrica sistema

ULAZ : Proširena matrica sistema koja definiše clip_image050 članova clip_image052, gdje je clip_image054, a clip_image056– predstavlja broj nepoznati. 1.

Nakon učitavanja matrice sistema potrebno je izvršiti triangulaciju matrice, gdje je po definiciji zadnjih član takve matrice rješenje clip_image058. 2. Obrnutim postupkom uz poznavanje rješenja clip_image058[1] dolazimo do rješenje clip_image060, i tako do rješenja clip_image062

IZLAZ : Vektor rješenja  clip_image064.gif. Izvorni kod ovog algoritma dat je u nastavku:

//Gaussova metoda eliminacije
for (int k = 0; k <= brKol - 2; k++)
 {
  // Prvo potrazimo najveci koeficijent u kolonama kao Pivot, zbog preciznosti rezultata
  double pivot = matSistema[k][k];
  for (int i = k + 1; i <= brVrsta - 1; i++)
   {
    if (pivot < Math.Abs(matSistema[i][k]))
    {
      double[] temp = matSistema[k];
      matSistema[k] = matSistema[i];
      matSistema[i] = temp;
    }
  }
 // Triangulacija
 for (int j = k + 1; j <= brVrsta - 1; j++)
  {
    m[j][k] = matSistema[j][k] / matSistema[k][k];
    for (int p = k; p <= brKol - 1; p++)
    {
      matSistema[j][p] = matSistema[j][p] - m[j][k] * matSistema[k][p];
    }
  }
 }
//
double[] rjesenje = new double[brKol - 1];
rjesenje[brKol - 2] = matSistema[brVrsta - 1][brKol - 1] / matSistema[brVrsta - 1][brKol - 2];
 for (int i = brVrsta - 2; i >= 0; i--)
 {
   double sum = 0.0;
   for (int j = brKol - 2; j >= i + 1; j--)
    {
      sum = sum + matSistema[i][j] * rjesenje[j];
    }
   rjesenje[i] = (1 / matSistema[i][i]) * (matSistema[i][brKol - 1] - sum);
 }
return rjesenje;

Kada smo implementirali algoritam za rješavanje sistema linearnih jednačina potrebno je sada analizirati kod i vidjeti gdje bi se mogla izvršiti paralelizacija da bi naš algoritam bio brzi od konvencionalnog odnosno da bi mogao iskorištavati današnja višejezgrene procesore. Prije nego se upustimo u analizu koda potrebno je pretpostaviti da će naš algoritam rješavati više od 500 jednačina odnosno tražiti više od 500 nepoznati. Ako bi algoritam rješavao manje jednačina paralelizacija ne bi imala smisla jer se vrijeme izvršavanja sekvencijalnog koda bilo brže od paralelnog. Ako pogledamo gornju implementaciju mjesta gdje bi paralelizirali kod je samo na dijelovima pri triangulaciji matrice i izračunavanju rješenja. Na ova dva mjesta imamo ugnježdene petlje, a one u algoritmu troše najviše procesorskog vremena.

Kako algoritam počinje…

On uzima prvu kolonu i provjerava da li u danoj koloni prvi član po apsolutnoj vrijednosti je najveći član od svih desnih kolona. Ako to slučaj nije tada se traži kolona u kojoj je prvi član najveći i te dvije kolone zamjenjuju mjesta. To možemo slobodno uraditi zbog osobina matrica. Kada se normalizira kolona tada se vrši triangulacija odnosno za svaku vrstu ispod posmatrane elementi kolone moraju biti nule (Gaussov postupak eliminacije). U ovom koraku se koriste dvije ugnježdene petlje (crveno obojen kod) kojim se ovo ostvaruje. Ovaj dio kod je najpogodniji za paralelnu implementaciju. Razlog zašto se ne ide na paralelnu implementacije prve petlje je taj što se mora ispoštovati poredak kolona, a u paralelnoj implementaciji to ne možemo postići jednostavno. Drugi dio koda pri kojem se na osnovu triangulacije matrice izračunavaju rješenja također koristi dvije ugnježdene petlje, a samim tim i dio koda koji bi mogao biti kandidat za paralelnu implementaciju. Ovaj dio koda također se mora izvršavati u striktno definisanom redu tj. prvo se izračunava zadnja vrsta, pa predzadnja i td. do prve vrste. Kada bi ovaj dio koda bio implementiran paralelno narušili bi poredak, a tako i rješenja ne bi bila izračunata tačno. Na osnovu analize paralelna implementacija kod izgleda na sljedeći način:

//Gaussova metoda eliminacije
for (int k = 0; k <= brKol - 2; k++)
{
  // Prvo potrazimo najveci koeficijent u kolonama kao Pivot, zbog preciznosti rezultata
  double pivot = matSistema[k][k];
  for (int i = k + 1; i <= brVrsta - 1; i++)
  {
    if (pivot < Math.Abs(matSistema[i][k]))
     {   double[] temp = matSistema[k];
       matSistema[k] = matSistema[i];
       matSistema[i] = temp;
     }
  }
 // Triangulacija
 Parallel.For(k + 1, brVrsta, j =>
 {
   m[j][k] = matSistema[j][k] / matSistema[k][k];
   for (int p = k; p <= brKol - 1; p++)
   {
     matSistema[j][p] = matSistema[j][p] - m[j][k] * matSistema[k][p];
   }
 }
             );
}
//
double[] rjesenje = new double[brKol - 1];
rjesenje[brKol - 2] = matSistema[brVrsta - 1][brKol - 1] / matSistema[brVrsta - 1][brKol - 2];
for (int i = brVrsta - 2; i >= 0; i--)
 {
   double sum = 0.0;
   for (int j = brKol - 2; j >= i + 1; j--)
    {
      sum = sum + matSistema[i][j] * rjesenje[j];
    }
   rjesenje[i] = (1 / matSistema[i][i]) * (matSistema[i][brKol - 1] - sum);
 }
 return rjesenje;

Vidimo da paralelna verzija algoritma se nije puno promijenila a što Parallelfx čini vrlo efikasnom bibliotekom.

Testiranje sekvencijalnog i paralelnog algoritma

Sada kada smo implementirali algoritam potrebno ga je i testirati na višejezgrenim PC mašinama da bi smo se uvjerili da naš paralelni algoritam brže radi od sekvencijalog. U tu svrhu generirano je 5 csv datoteka u kojim stoje proširene matrice sistema od 10, 50, 100, 500 i 1000 nepoznatih, kojim ćemo izvršiti testiranje algoritma. Sistemi su jednostavni čija su rješenja sve jedinice. Test aplikacija je koncipirana tako da učitava sisteme jednačina iz csv datoteka rješava sisteme koristeći sekvencijalni i paralelni algoritam te na konzolu izbacuje vremena koja su potrošena pri rješavanju. Test koji je prezentiran ovdje rađen je na Intel Core 2 Quad CPU Q6600 2,4 GZ:

CoreQuad

Rezultat testa je sljedeći:

restest

Iz testa možemo primijetiti da sistemi preko 100 nepoznati daju bolje rezultate kod paralelne implementacije i možemo smatrati okvirno da je to neka granica preko koje bi trebali koristiti paralelnu implementaciju algoritma. Kako broj nepoznatih raste tako raste razlika između paralelne i sekvencijalne implementacije algoritma. Kompletan izvorni kod algoritma i testa može se skinuti sa ovog linka. Projekt je rađen u Visual Studiu 2010 beta 1koji se može skinuti sa ovog linka.

Reference

  1. http://blogs.msdn.com/pfxteam/
  2. Ćamila Ljubović, Matematika, IPSvjetlost Sarajevo 1997
  3. http://geeks.netindonesia.net/blogs/norman

Visual Studio 2010 i C# 4.0 III DIO – Dinamički tipovi podataka


DLR nova komponenta .NET frameworka

U prethodna dva dijela obradili smo neke novine koje dolaze sa novom verzijom C# 4.0, gdje smo se upoznali sa opcionim i imenskim parametrima, kao i ko i kontra varijncama novim svojstvima programskog jezika. U ovom postu govori ćemo o novom svojstvu C# odnosno dinamičkim tipovima podataka u jeziku. Novom verzijom kompletnog .NET 4.0 frameworka microsoft uvodi novu tehnologiju poznatu pod imenom DLR – Dynamic Language Runtime.

DLR implementirana je nad CLR (Common Language Runtime) i nadopunjava je sa skupom tehnologija i alata pomoću kojih se može izvršavati interne operacije u .NET frameworku, te u vrijeme izvršavanja koda pretvarati dinamicke tipove u statičke.

Podrška za DLR u .NET 4.0 sadrži novi prostor imena System.Dynamic. DLR sadrži 3 sloja prikazana na gornjoj slici i to:

  1. The .NET Language Integration Layer – (Integracijski sloj za .NET jezke)
  2. The Dynamic Language Runtime Code Components – (Komponente coda DLR)
  3. Language Binders – (Jezički povezivač)

DLR service sadrži:

  • Dynamic Method Dispatch – Prosljeđivač dinamičkih metoda
  • Dynamic Code Generation – Generator Dynamičkog koda
  • Hosting API – API za hostovanje [preuzeto sa 1]

Statički dinamički tipovi

Novom verzijom C# 4.0 kao i novom proširenju .NET frameworka DLR obezbjeđuje se mogućnost implementacije dinamičkih tipova podataka u C#. Kao što je poznato C# do sada je definisao statički određene tipove podataka. To jednostavno znači da u vrijeme kompajliranja koda poznati su svi tipovi podataka koji se nalaze. Svaka situacija u kojoj kompajler ne može izvršiti konverziju jednog tipa u drugi ili jednostavno deklarisani tip ne poznaje, pojavljivala se greška kompajlera.

Sa dynamic novom ključnom riječju u C#4.0 deklariše se dinamički tip podataka. Ovo znači da ovako deklarisani tip podata je nepoznat u vrijeme kompajliranja, te kompajler neće javiti nikakvu grešku. U vrijeme izvršavanja koda DLR obezbjeđuje da se ovaj dynamički tip deklariše i potpuno definiše u statički. Više informacija o statičkim odnosno dinamičkim tipovima podataka kao i načinu korištenja te tretiranja kompajlera možete naći na stranici wikipedie [2]. Nrp pogledajmo sljedeći dio koda:[primjer preuzet sa 3]


<pre>class Program
{
  static void Main(string[] args)
  {
    foreach (dynamic d in GetValues())
    Console.WriteLine("{0} ima {1} godina.", d.Ime, d.Godina);
  }
  static IEnumerable<dynamic> GetValues()
  {
    Dictionary<string, int> result = new Dictionary<string, int>();
      result["Šemso"] = 30;
      result["Elvis"] = 25;

    foreach (var item in result)
    yield return new { Ime = item.Key, Godina = item.Value };
  }
}

Ovakvu konstrukciju koda nismo mogli implementirati u prethodnim verzijama C# je se anonimne klase nisu mogle globalno prenositi, odnosno var ključna riječ mogla se samo lokalno upotrbljavati. Sada kada imamo dynamic ključnu riječ ovakvu konstrukciju odnosno anonimnu klasu možemo imati kao tip podataka koju vraća neka metoda. Na koji nači kompajler tretira ovaj kod. Naime u vrijeme kompajliranja anonimna klasa dobije svoju definicu koja u vrijeme izvršavanja posjeduje statički tip. DLR u vrijeme izvršavanja koda definisani tip koji je kompajler odredio anonimnoj klasu obezbjeđuje vraćanje podataka kroz foreach petlju.

Dinamički tipovi nisu TypeSafe to znači da ako u implementaciji foreach petlje napišemo npr.

<pre>foreach (dynamic d in GetValues())
   Console.WriteLine("{0} ima {1} godina.", d.Naziv, d.Godiste);

Kompajler neće pronaći ni upozoriti na bilo kakvu grešku ili upozorenje, a naš program će prilikom pokretanja izbaciti izuzetak da nešto ne štima sa članovima anonimne klase.

Razlika između var i dynamic

Primjetićemo da i u C# 3.0 postoji var ključna riječ koja ima istu funkciju kao dynamic, što je totalno pogrešno. var ključna riječ spoznaje svoj istinski tip podatke u vrijeme kompajliranja. U to se možemo uvjeriti ako na definisani var tip odnesemo miša a intellisence vam već daje informaciju o kojem tipu se podatka radi. To znači da var tip u vrijeme kompajliranja definiše svoj istinski tip podatka, što kod dynamicto nije slučaj.

Reference:

  • http://www.devx.com/dotnet/Article/42262/0/page/2
  • http://en.wikipedia.org/wiki/Type_system
  • http://blog.codinglight.com/2009/05/c-40-dynamic-type-something-useful.html