Vítejte na blog.vyvojar.cz Přihlásit | Registrovat | Pomoc
Titulní Blogy Fotky Soubory

2P.Knowledge.Blog.API

  • Visual Studio 2010 RTM na MSDN

    Finální verze dlouho očekávaného vývojové prostředi Visual Studio 2010 a s tím související .NET 4.0 je konečně tady! Majitelé MSDN Subscription ji mohou již dnes stahovat. Tak s chutí do toho!

    Visual Studio 2010

    V případě, že nejste MSDN předplatiteli, můžete si stáhnout Trial verzi nebo "odlehčenou" verzi Express, která je zcela zdarma.

    Trial verze:
    http://www.microsoft.com/visualstudio/en-us/download

    Free Express verze :
    http://www.microsoft.com/express/Downloads/

    Dále přikládám odkazy na stránky, které se novinkám ve VS 2010 a .NET 4.0 věnují:

    Enjoy!

    Petr Puš

  • Materiály z DevDays2009

    Pokud jste z nějakého důvodu nebyli na letošních Microsoft Developer Days 2009, anebo jste tam byli a chcete si je ještě připomenout, potěší Vás zpráva o tom, že již jsou on-line k dispozici materiály ve formě webcastů, screencastů a prezentací. Všechny materiály jsou dostupné na www.devdays.cz .

    Developer Days 2009 

  • Visual Studio 2010 Beta 2

    Tento týden se objevila ke stažení již v pořadí druhá beta verze Visual Studio 2010 a .NET framework 4.0. Kromě předplatitelů MSDN si ji mohou stáhnout všichni ostatní zde.

    Visual Studio 2010 Logo

    Kromě drobně inovovaného vzhledu, který napovídá výše zobrazené nové logo VS 2010 se můžete mimo jiné těšit na opravu chyb/nedodělků, podporu ASP .NET MVC 2, Silverlight 3, Dynamic Languge Runtime (DLR). Za zmínku také určitě stojí podpora nového systému plug-inů do Visual Studia, které je nyní možné tvořit v technologii WPF. Narozdíl od minulé beta verze již beta 2 VS 2010 a .NET 4.0 umožňuje běh zároveň se staršími verzemi .NET frameworku a Visual studia. Novinek v této verzi je opravdu hodně.

    Pokud se

    vrhnete do zkoušení, dovolím si doporučit pár linků, které se k danému tématu vztahují.

     

    Přeji příjemnou zábavu při zkoušení.

  • Prezentace z přednášky Design patterns a .NET

    Jelikož si celkem dost lidí napsalo mailem o poskytnutí prezentace k přednášce Design patterns a .NET, kterou jsem (mimo jiné) dělal v Microsoftu, jal jsem se konečně umístit tuto prezentaci do veřejného prostoru. Prezentaci je tedy možné stáhnout zde.
  • Prezentace o Entity Frameworku

    ADO .NET Entity Framework je technologií, na kterou jsem byl velice zvědav. Když jsem se dostal k tomu, si ji vyzkoušet, rovnou jsem udělal pár přednášek, abych se o své znalosti a pocity podělil v rámci WUG a taky v rámci MSP na MFF UK. Pro ty, kteří se chtějí podívat na prezentaci, kterou jsem za tímto účelem vytvořil, mohou si ji stáhnout zde.

     Když velice rychle shrnu svůj pohled na tuto technologii, tak mohu říci, že se jedná o dobře použitelný O-R mapper, který se narozdíl od mého favorita nHibernate, dá velice jednoduše a rychle použít (integrovaný designer, LINQ, ..), není narozdíl od LINQ to SQL závislý pouze na SQL serveru (používá ADO .NET provider model), ale co tuto technologii z mého pohledu dost degradovalo je naprostá absence lazy-loading (což, dle mých informací z TechEd má být vyřešeno v další verzi).

  • Visual Studio 2010 a .NET 4.0 CTP

    Není to zase tak dlouho, co vyšlo Visual Studio 2008 a už je na světě CTP (Community Technology Preview) další verze, kterou je Visual Studio 2010 (VS10). CTP je dodáváno formou Virtual PC image, jehož HW nároky nejsou zrovna malé (75 GB HDD, 2 GB RAM, Dual Core, ...). Pokud tedy disponujete strojem splňujícím tyto požadavky, můžete poprvé vyzkoušet .NET 4.0, který je, jakožto nezbytná součást VS 2010, taktéž součástí Virtual PC. CTP je ke stažení zde.
  • Materiály z WUG (C# 3.0 a LINQ) v Hradci Králové

    V Hradci Králové jsem měl 10.1. 2008 pro sdružení WUG přednášku o C# 3.0 a LINQ, která vznikla rozšířením přednášky o C# 3.0, kterou jsem vytvořil v rámci programu MSP. Slidy i ukázkové příklady jsou k dispozici ke stažení zde. Mimochodem ukázky na novinky v C# 3.0 byly použity i v mém článku, který zde nedávno vyšel.
  • Ukládání ViewState do Session

    View-state patří k vrozeným vlastnostem ASP .NET již od jeho počátku a některými lidmi je milován a jinými zase zatracován. Podle mě je pravda někde mezi a při jeho správném použití může přinést spoustu užitku. Standardně je view-state stránky ukládán ve skrytém políčku formuláře (hidden field), což v případě stránek z mnoha ASP .NET prvky vede ke značné velikosti obsahu tohoto políčka a tím pádem i celé stránky. Nebo může být s touto reprezentací viewstate problém v případě mobilních zařízení.V těchto situacích je vhodné view-state uložit do alternativního úložiště, kterým často bývá session, která jak známo čerpá prostředky serveru.

    Již od své první verze ASP .NET disponuje možností definovat vlastní mechanismus persistence view-state stránky pomocí překrytí metod LoadPageStateFromPersistenceMedium a SavePageStateToPersistenceMedium. V takovémto případě implementace persistence view-state je dobré myslet mimo jiné na to, že klient může mít otevřeno více oken prohlížeče a tím pádem není vhodné ukládat view-state všech stránek do session pod stejným klíčem. Řešením může být GUID ve skrytém poli stránky. Také je při překrývání těchto metod dobré myslet na to, kdy data z alternativního uložiště odstranit, aby nedocházelo ke zbytečnému plýtvání zdroji. Problém také vidím v tom, že metoda SavePageStateToPersistenceMedium se nezavolá v případě vyhození výjimky, což je problém při použití AJAX, kdy není přesměrováno na chybovou stránku, ale po zobrazení chyby pomocí javascriptu (což je v ASP .NET AJAX frameworku výchozí) je klientovi umožněn další požadavek, u jehož zpracování ovšem nebude k dispozici view-state.

    Na tyto problémy ovšem existuje poměrně jednoduchý lék, který je v ASP .NET, již od zaběhlé verze 2.0, k dispozici. Od ASP .NET 2.0 je možnost persistence view-state v session implementována, avšak je ve výchozím nastavení vypnuta. ASP .NET pro uložení view-state využívá služeb typů odvozených od třídy PageStatePersister, které jsou standardně dva a to HiddenFieldPageStatePersister, který ukládá view-state standardně do skrytého pole a druhým typem je SessionPageStatePersister, jež ukládá viewstate do session. Konkrétní PageStatePersister je pro konkrétní stránku získán přečtením vlastnosti PageStatePersister. Takže uložení viewstate do session se provede jednoduchým překrytím této vlastnosti na stránce a navrácení instance typu SessionPageStatePersister. Pozor na to, že je třeba vracet v rámci stránky stejnou instanci typu PageStatePersister, jinak se mohou vyskytnout problémy (špatné uchovávání hodnot mezi post-backy).

    protected override PageStatePersister PageStatePersister
    {
      if (statePersister == null)
      {
          statePersister = new SessionPageStatePersister(this);
      }
      return statePersister;
    }

    V případě, že se nechcete vydat cestou použití dědičnosti stránek, můžete využít podpory adaptivního renderingu, která je k dispozici od ASP .NET 2.0 a vytvořit PageAdapter u něhož je možné překrýt metodu GetStatePersister. Tímto způsobem lze v kombinaci s konfigurací v browser souboru zajistit, že view-state bude v session pouze pro specifická zařízení.

    public class MyPageAdapter : PageAdapter
    {
        public override PageStatePersister GetStatePersister()
        {
            return new SessionPageStatePersister(this.Page);
        }
    }

    Použití SessionStatePagePersisteru zařídí uložení view-state do session a do skrytého pole jsou uloženy pouze informace nutné k možné rekonstrukci viewstate ze session. Pro případné otevření více oken ukládá data několika posledních stránek. Výchozím nastavením je hodnota 9, takže když klient otevře desáté okno v tom prvním otevřeném při post-backu nedojde k načtení viewstate. Tuto hodnotu je ovšem možno konfiguračně nastavit v sekci system.web souboru web.config.

    <system.web>
        <sessionPageState historySize="10"/>
    </system.web>

    V mnoha případech ovšem zjistíte, že i přestože je použit SessionPageStatePersister, tak je view-state pořád poměrně velký. Je tomu z důvodu, že control-state, který je od ASP .NET 2.0 přítomen pro zachování fukčnosti ASP .NET prvků i v případě vypnutého view-state je stále ukládán do skrytého pole a to i v případě, že standardní viewstate je v session. V případě řešení, které bylo zmíněno výše, tedy pomocí překrytí metod LoadPageStateFromPersistenceMedium a SavePageStateToPersistenceMedium tento problém nenastává, protože je ukládán view-state i control-state dohromady. Naštěstí je k dispozici řešení i v případě použití elegantějšího SessionPageStatePersisteru a to opět pomocí konfigurace v sekci browserCaps (která je již označena za deprecated, ale jiné řešení jsem nenašel).

    <browserCaps>
          <case>RequiresControlStateInSession=true</case>
    </browserCaps>

    Udělal jsem si malý test s jednoduchou stránkou s prvkem GridView, ve kterém bylo zobrazeno 10 záznamů se 3 sloupci a nastavenou vlastností DataKeyNames na hodnotu ID (hodnoty ID se ukládají do view-state) a tady jsou výsledky velikosti skrytého pole s ID __VIEWSTATE ve stránce :

    View-state i Control-state ve skrytém poli - 1440 bajtů
    View-state v session a Control-state ve skrytém poli - 352 bajtů
    View-state i Control-state v session - 56 bajtů

  • Zdržení uvolnění zdrojových kódů .NET

    Když Scott Guthrie na svém blogu vydal příspěvek o plánovaném uvolnění zdrojových kódů .NET frameworku byl jsem velmi nadšen a dokonce jsem o tomto skvělém plánu na studentském komunitním serveru netstudent.cz naším rodným jazykem informoval. Zdrojové kódy měly být uvolněny spolu s oficiálním vydáním Visual Studia 2008.

    Visual Studio 2008 bylo vydáno už 19.11. minulého roku avšak, když jsem si dnes řekl, že bych mohl konečně, po zvládnutých zápočtech a "proflákaných" svátcích (.. a nadšení ze C# 3.0 a LINQ :-) ), zkusit debugování .NETu, nadšení vystřídalo zklamání, protože zdrojové kódy a server, který je má spolu s PDB symboly hostovat ještě není přístupný. V blog postu Shawna Burkeho je vysvětlení, kde uvádí, že je mimo jiné performance bug ve VS 2008, na jehož opravě usilovně pracují.

    Dobrá zpráva je, že Shawn ve svém příspěvku uvádí zpřístupnění zdrojových kódů a debug symbolů v rámci několika týdnů (od konce listopadu, kdy příspěvek vydal), takže to snad bude co nevidět. Než na to zase zapomenu :)

  • Video o Parallel FX

    Hlavní architekt jazyku C# a projektu LINQ Anders Hejlsberg a Joe Duffy z parallel computing platform teamu Microsoftu spolu na půlhodinovém videu na Channel 9 představují základní koncepty frameworku pro paralelní zpracování operací, kde již nebudeme "bojovat" s vlákny, jejich synchronizací či optimalizací pro vícejaderné procesory - Parallel FX. Diskuze je nejen o základním použití API tohoto frameworku, ale i pojednání o vnitřní architektuře PFX a zapomenut není ani projekt PLINQ (paralelní spouštění LINQ dotazů).
    Mě osobně to velmi zaujalo a myslím, že nebudu sám. Video je ke shlédnutí i stažení zde.
  • Jak "zkamarádit" assembly

    Objektově orientovaný přístup nám definuje několik modifikátorů viditelnosti typů či jejich členů (public, protected, private). V jazyku C# existuje jeden specifický modifikátor přístupu, který je na rozdíl od dříve zmíňených vázaný na konkrétní umístění kódu typu. Nemám na mysli nic jiného, než specifikátor přístupu internal, který daný typ či člen učiní viditelný pouze pro typy v rámci assembly, ve které je definován.

    Od .NET frameworku verze 2.0 existuje způsob, který nám umožní na úrovni assembly definovat, že některé vybrané assembly budou mít přístup k interním typům či členům, označených specifikátorem přístupu internal. K takovémuto rozhodnutí můžou být různé důvody - zviditelnění nějakého API vybraným částem aplikace, unit testy atd. Tento způsob je představován použitím speciálního atributu InternalsVisibleTo.

    Pojďme se podívat na jednoduchý příklad použití.

    Mějme dvě assembly - LibraryA a LibraryB.
    Na úrovni assembly s názvem LibraryB je definován interní typ obsahující interní člen.

    namespace LibraryB
    {
      internal class ClassFromLibraryB
      {
        internal void SomeMethod()
        { 
          //implementace metody..
        }
      }
    }

    Pokud bychom tento typ a jeho metodu chtěli použít z typu, který je obsažen v assembly s názvem LibraryA, tak by kompilace našeho projektu zcela logicky skončila chybou (LibraryB.ClassFromLibraryB' is inaccessible due to its protection level). Pokud ovšem na úrovni assmbly LibraryB aplikujeme atribut InternalsVisibleTo, kompilace po této změně proběhne bez problémů, protože jsme tímto assembly LibraryA prohlásili za assembly přátelskou (Friendly assembly).

    //assembly s nazvem LibraryA oznacime za pratelskou
    [
    assembly: System.Runtime.CompilerServices.InternalsVisibleTo("LibraryA")]
    namespace LibraryB
    {
      internal class ClassFromLibraryB
      {
        ...
      }
    }

    Níže uvedený kód již tedy bude zkompilovatelný.

    /// <summary>
    /// Trida, ktera vyuziva sluzeb internich typu z assembly LibraryB.
    /// </summary>
    public class ClassFromLibraryA
    {
      public void DoSomething()
      {
      //je mozne vytvorit instanci interniho typu pratelske assembly
      ClassFromLibraryB friendlyType = new ClassFromLibraryB();
      //je mozne zavolat interni metodu na typu z pratelske assembly
      friendlyType.SomeMethod();
      }
    }

    Pokud by assembly s názvem LibraryA měla silné jméno, situace se nám trochu zkomplikuje, protože v takovémto případě je nutné při použití atributu InternalsVisibleTo specifikovat kromě názvu assembly i hodnotu veřejného klíče (pozor, opravdu ne token veřejného klíče, jak by někteří mohli očekávat). Hodnotu veřejného klíče z podepsané assembly je možné získat pomocí utility sn.exe například s přepínačem -Tp. V kontextu našeho příkladu by tedy použití atributu InternalsVisibleTo vypadalo nějak takto (veřejný klíč není z důvodu jeho délky uveden celý):

    [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("LibraryA, PublicKey=0024000004 ... 4dd65a3085dd5")]

    Samozřejmě je dobré této vlastnosti používat z rozmyslem a pouze v opodstatněných a dobře promyšlených případech.

    P.S. I přesto, že jsem v .NET "čístý" C#ista, zmíním, že pro přátelské assembly je nyní s příchodem .NET 3.5 podpora už i v novém Visual Basicu 9. Viz tento link.

  • Přednáška o .NET 3.5 a C# 3.0

    Dne 19.11. 2007 jsem na půdě Fakulty informatiky a managementu Univerzity Hradec Králové přednášel o novinkách v .NET 3.5 a C# 3.0. Shodou okolností ten den oficiálně vyšlo očekáváné Visual Studio 2008 spolu s .NET 3.5 o čemž jsem v době přednášky nevěděl a tak jsem tam ještě mluvil v budoucím čase Smile. Pro zájemce jsem na portál www.netstudent.cz umístil svou prezentaci ke stažení, takže koho to zajímá, nechť se na tomto portálu zaregistruje, pokud ještě tak neučinil, a zmiňovanou prezentaci si zde stáhne.

  • Power Collections

    Základní knihovna tříd .NET frameworku obsahuje ve jmenných prostorech System.Collections a System.Collections.Generic implementaci základních netypových respektive (mých oblíbených) typových kolekcí. Nicméně pokud jste například někdy pracovali v Javě a používali kolekce z JCF (Java Collection Framework) jistě jste při používání kolekcí v .NET poznali, že to není to na co jste zvyklí. Ale i pokud jste Javou nedotknutí, možná mi dáte za pravdu, že základní podpora kolekcí v .NET není na všechny situace adekvátně připravena.

    Pokud máte občas výše zmiňované pocity vyzkoušejte Wintellect's Power Collections for .NET. Tento zajímavý open source projekt si klade za hlavní cíl implementovat kolekce, které nejsou v BCL k dispozici. Všechny implementované kolekce jsou silně typované díky použití generik. Implementované kolekce jsou jak takové, které nemají, co se funkcionality týče, protějška v BCL (Set, Bag, Deque..), ale i takové, které mají funkcionality stejnou, nicméně efektivněji implementovanou (BigList například). Dále v této knihovně najdete velkou množinu různých utilit pro práci s kolekcemi. Tyto utility nejsou vázány na použití kolekcí z Power Collections, ale používají standardních rozhraní .NETu (IEnumerable...), takže je můžete použít i pro standardní kolekce z BCL.

    Pro inspiraci zde uvedu pár ukázek použití. Tak například je zde implementována kolekce Set, kterou dobře znají "Javisti". Jedná se o nesetříděnou kolekci, která neobsahuje duplikátní prvky.

    //vytvoreni instanci
    Set<int> firstSet = new Set<int>();
    Set<int> secondSet = new Set<int>();
    //naplneni prvky
    firstSet.Add(1);
    firstSet.Add(2);
    secondSet.Add(2);
    secondSet.Add(3);
    secondSet.Add(4);
    //ziskani prvku, ktere jsou v jinem setu jine
    Set<int> differences = secondSet.Difference(firstSet);
    Console.WriteLine("Different items in second set : ");
    foreach (int item in differences)
    {
     
    Console.WriteLine(item);
    }

    Další zajímavou implementovanou kolekcí v Power Collections je MultiDictionary. Tato implementace slovníku je rozdílná od standardní v tom, že může pod jedním klíčem uchovávat více hodnot.

     MultiDictionary<int, string> dict = new MultiDictionary<int, string>(true);
    //naplneni daty
    dict.Add(1, "First item for '1'");
    dict.Add(1,
    "Second item for '1'");
    dict.Add(2,
    "First item for '2'");
    dict.Add(2,
    "Second item for '2'");
    //pro kazdy klic je vypsana mnozina hodnot
    foreach (KeyValuePair<int, ICollection<string>> pair in dict)
    {
     
    Console.WriteLine("VALUES FOR KEY '{0}' : ", pair.Key);
     
    foreach (string value in pair.Value)
      {
        
    Console.WriteLine(value);
      }
      Console.WriteLine();
    }

    Užitečná může být i struktura Pair pro pohodlnou práci s dvojicí hodnot.

    Dictionary<Pair<int, string>, string> dict = new Dictionary<Pair<int, string>, string>();
    dict.Add(
    new Pair<int, string>(1, "Hello"), "First item");
    dict.Add(
    new Pair<int, string>(2, "World"), "Second item");
    string itemFromDict = dict[new Pair<int, string>(1, "Hello")];

    Statická třída Algorithms obsahuje implementace spousty algoritmů, které při práci s kolekcemi nezřídka přijdou vhod. Například můžete spočítat kolik prvků v kolekci splňuje nějakou podmínku, kterou definujete implementací delegáta Predicate<T>. V ukázce je použita kolekce Bag, která je podobná kolekci Set, s tím rozdílem, že může obsahovat duplikátní prvky.

    Bag<int> bagOfInts = new Bag<int>();
    bagOfInts.Add(1);
    bagOfInts.Add(2);
    bagOfInts.Add(3);
    Predicate<int> predicate = delegate(int item)
    {
     
    return item > 1;
    };
    int count = Algorithms.CountWhere<int>(bagOfInts, predicate);
    Console.WriteLine(count);

    Na třídě Algorithms jsou dále implementovány metody pro Binární prohledávání, řazení, kartézský součin, naplňování kolekcí atd.

    Pokud tedy patříte mezi ty, kterým ne vždy stačí standardní možnosti kolekcí v .NET neváhejte sáhnout pro tuto knihovnu, která je hostována na CodePlex (Microsoft repository pro open source projekty), přesně zde http://www.codeplex.com/PowerCollections .

  • Centralizace nastavení assembly

    Práce na větších aplikacích s sebou nese řadu menších či větších problémů. Takovéto aplikace je totiž obvykle dobré rozdělit na několik assembly, což znamená mít několik projektů v solution Visual Studia. Jedním z možných problémů je zajištění společných vlastností těchto assembly, které tvoří naši aplikaci.  Atributy definující vlastnosti assembly jakými jsou mimo jiné verze assembly či název výrobce, jsou standardně umísťovány v souboru AssemblyInfo.cs ve složce Properties daného VS projektu. Vážou se tedy pouze k assembly vyprodukované kompilací zdrojových kódů VS projektu .

    Často ovšem chceme, aby všechny assembly měli po kompilaci například stejnou verzi či zmiňovaného výrobce nebo jakékoliv jiné společné vlastnosti. V případě, že je naše solution tvořena dvěma projekty, tak to zase takový problém není, ovšem problém nastává v případě, kdy je potřeba sjednotit některé vlastnosti pro 20 projektů, což u solution větších aplikací není zase tak nezvyklé. V tom případě se udržování těchto společných vlastností pomocí souborů AssemblyInfo.cs stává jaksi nepohodlné dalo by se označit za takovou "opičí" práci.

    Existuje ovšem poměrně jednoduchý způsob, jak mít všechny společné vlastnosti na jednom místě a opici si tedy nechat akorát tak na rána po předchozích hospodských večerech. Tomuto způsobu se někdy říká SolutionInfo pattern a spočívá v tom, že se vytvoří jeden soubor obsahující atributy pro společné vlastnosti všech assembly aplikace a tento soubor je následně nalinkován do všech projektů v solution.

    Postup je tedy následující:

    1. Vytvořte soubor SolutionInfo.cs (název může samozřejmě být i jiný), do kterého pomocí atributů nadefinujte společné vlastnosti pro celou aplikaci.
      Příklad souboru SolutionInfo.cs :

      using System.Reflection;

      [assembly: AssemblyVersion("2.0.0.0")]
      [assembly:
      AssemblyFileVersion("2.0.0.0")]
      [assembly:
      AssemblyCompany("Petr Pus Comany")]
      [assembly:
      AssemblyProduct("Muj velky projekt")]

    2. Ze souborů AssemblyInfo.cs smažte všechny atributy, které jsou centralizovány v souboru SolutionInfo.cs
    3. Do jednotlivých projektů v solution nalinkujte soubor SolutionInfo.cs (Kontextová nabídka na VS projektu>Add>ExistingItem..>Add as link)

    Pak by měla vaše solution vypadat nějak takto..

    Můžete jít v aplikaci tohoto postupu ještě dále a vytvořit jeden soubor pouze na určení společné verze všech assembly (např. SolutionVersion.cs) a v souboru SolutionInfo.cs uvést ostatní společné vlastnosti, ale to už nechám na vás. Doufám, že tímto postupem ušetříte svůj, jistě drahý, čas Wink

  • Shawn Burke o vydání zdrojových kódu

    Na Channel 9 je zajímavé video, kde Shawn Burke z .NET Developer Platform group hovoří o vydání zdrojových kódu k .NET frameworku a ukazuje jak je možné při ladění ve VS 2008 krokovat v interní implementaci .NET frameworku. Doporučuji shlédnout.

    Link zde :http://channel9.msdn.com/Showpost.aspx?postid=345805

Více článků Další stránka »
Powered by Community Server (Personal Edition), by Telligent Systems