TLA311 The Future of C#
Hlavním tématem nové verze C# je DLR (Dynamic Language Runtime):
- DLR je nadstavba (library) nad CLR, není to náhrada CLR, ani snad jeho přímá součást,
- myšlenka je mít společné jádro pro dynamické features všech jazyků, klasická myšlenka .NET o language nezávislosti,
- do C# se dynamičnost projeví zejména v podobě nového compile-time typu dynamic, ten se v praxi projeví tím, že při použití tohoto typu se veškerá typová vyhodnocení, lookupy odpovídajících memberů a všeho souvisejícího odloží až do run-time, kde následně proběhnou úplně stejně, jako by tomu bylo u nedynamického typu v compile-time fázi.
- použití může vypadat třeba takto:
dynamic Add(dynamic a, dynamic b)
{
return a + b;
}
void Main()
{
string x = Add("Ahoj", "Nazdar");
int sum = Add(10, 15);
DateTime day = Add(DateTime.Today, TimeSpan.FromDays(5));
}
...prostě až za běhu se řeší, jestli existuje operátor + mezi parametry metody Add a operace se provede. Návratovým typem je výstup operátoru +, nicméně ten v compile-time neznáme, takže dynamic.
- jsou scénáře, kde se to může hodit (a musím i přes svou značnou skepsi k dynamickým jazykům uznat, že tam, kde dosud stejně člověk statické typování neměl, tak je to příjemná syntaxe), např. interakce Silverlightu s JScriptem stránky
// dosud
myHtmlWindow.Invoke("myJavaScriptFunction", param1, param2);
myHtmlDocument.SetProperty("Title", "Titulek");
// C# 4.0
myHtmlWindow.myJavaScriptFunction(param1, param2);
myHtmlDocument.Title = "Titulek";
...hodí se to prostě tam, kde se stejně musela použít reflexe, nebo jiná podobná netypovaná obstrukce.
- jsou scénáře, kde čistá podobnost interface nabádá k dynamickému použití a těchto scénářů se popravdě řečeno v praxi docela bojím. Kolikrát jste třeba přemýšleli nad tím, že SqlDataReader a DataRow mají oba string-indexer s návratovým typem object, ale nemají žádný společný interface, který by umožňoval vytahovat data z obou stejným způsobem?
void PopData(dynamic readerOrRow)
{
this.ID = Convert.ToInt32(readerOrRow["ID"]);
this.FirstName = readerOrRow["FirstName"].ToString();
}
// ono se v podstatě můžeme dočkat i podoby (viz níže o rozhraní IDynamicObject)
void PopData(dynamic readerOrRow)
{
this.ID = readerOrRow.ID;
this.FirstName = readerOrRow.FirstName;
}
- dokonce i "signatura" (spíš vnější interpretace) objektu samotného může být dynamická, pomocí implementace rozhraní IDynamicObject, popř. děděním z abstraktního předka DynamicObject můžeme pomocí definice několika metod (ála SetMember, GetMember, atp., přesná jména si už nepamatuji) zajistit zcela dynamické chování objektu (např. ála expando)
Další novinkou C# 4.0 budou optional parameters u metod:
void DoSomething(string path, bool createIfNotExist = true, MyMode mode = MyMode.Super)
{
...
}
void Main()
{
DoSomething("C:\\test");
DoSomething("C:\\test", false);
DoSomething("C:\\test", mode: MyMode.FailProof); // named parameters!!
DoSomething(mode: MyMode.Xy, path: "D:\\", createIfNotExist: false); // na pořadí nezáleží
}
Společně s optional parameters přichází i named parameters, které mohou v mnoha případech výrazně zpřehlednit kód (např. metodu Cache.Add() a podobné už nebudu muset popisovat komentáři, co který null/true vůbec znamená). Na pořadí named parameters nezáleží, nicméně vyhodnocují se v pořadí jejich zápisu (to kdyby je nedejbože někdo ještě během předávání i modifikoval).
Pro C# vývojáře API, kteří byli dosud naivně přesvědčeni, že na názvu parametrů zas tak moc nezáleží, a mohou si je přejmenovat, to znamená, že už konečně i oni si uvědomí, že by neměli (a neměli ani dosud, protože jiné jazyky named parameters už znají).
Dynamické fetures, optional/named parameters jsou obzvláště užitečné při COM Interop, kde výrazně vyčistí dosavadní mess-kód plný Type.Missing, atp. COM Interop ale není naštěstí moje běžná potřeba a mohu jen litovat ty, kdo se tím musí zabývat.
Další novinkou C# 4.0 bude generická variance - covariance nebo contravariance.
Ve zkratce jde o možnost použít instanci MyClassOrInterface<DerivedClass> tam, kde se očekává MyClassOrInterface<BaseClass>, tj. covariance a opačným směrem, tj. contravariance. Dosud to nešlo (invariance), protože třeba do List<string> nemůžete přidávat metodou Add() hodnoty typu object, tam, kde se pracuje s List<object>. C# 4.0 to řeší striktním určením kontraktu na invariantní/covariantní/contravariantní, např. interface IEnumerable<T> bude v C# 4.0 definováno covariantně (protože IEnumerable neumožňuje přidávat prvky):
public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
...podstatné je klíčové slovo out pro covarianci, popř. in pro contravarianci. Contravariance je použitelná třeba u rozhraní IComparer<in T>, pokud mám totiž IComparer<object>, mohu ho použít i tam, kde se očekává IComparer<string>.
Poslední prezentovanou novinkou bylo Compiler Services API. V podstatě jde o to, že compiler C# (i VB.NET) budou mít klasické .NET API, pomocí kterého bude možné dělat spoustu věcí, namátkou:
- dělat si třeba custom-highlighting,
- pracovat s metadaty a objektovou reprezentací kódu a dělat tak snadno např. vlastní refactoring,
- možno snadné práce s procesem kompilace, např. rozšíření o Aspect-Oriented Programming, atp.
- no a asi hlavní a dnes prezentovanou možností byla kompilace a vyhodnocování kódu za běhu programu, což může být například využitelné v aplikacích přímo pro zadávání výrazů v C#, pro LINQ dotazování, apod. Bohužel byla tato věc i takto předváděna (zhruba něco jako myCompilerHelper.Eval(MyTextBox.Text)), což pokud s tím bude Microsoft tímto stylem prezentace pokračovat, bez jediné zmínky o security, brzy přejdeme z SQL-injection epochy do věku C#-injection... :-(((
Každopádně se máme v C# 4.0 na co těšit. Přináší nové možnosti, které v dobrých rukou mohou dobře sloužit, bohužel však očekávám, že se v praxi budeme častěji setkávat ještě s mnohem většími prasárnami v kódu, než bylo možné dosud vůbec realizovat. Hodně teď bude záležet na tom, jak Microsoft pojme své prezentace novinek a jestli do nich konečně zapojí i best-practices, nebo zůstane jen u svého osvědčeného wow-efektu.
TLA05-IS Debugging Performance Issues, Memory Issues and Crashes in .net Applications
Interactive-session pokračování středeční breakout session WUX405.
- nové Visual Studio bude umožňovat "dump debugging" (úplnou analýzu memory dumpů, nyní se dělá ve windbg)
- základními nástroji produkčního ladění jsou nyní adplus (konfiguračními soubory řízená utilita pro získání dumpu) a windbg (Windows GUI Symbolic Debugger), lze použít nadstavby pro lepší GUI (Debug Diag, SOS Assist, atp.)
- získání memory dumpu:
adplus -hang -pn w3wp.exe
adplus -crash -pn w3wp.exe
adplus -pn w3wp.exe -c configFile.cfg (ukázky configů jsou na http://blogs.msdn.com/tess)
.cmdtree C:\sos-cmdtree.txt (načtení command-tree pro lepší ovládání)
.loadby sos mscorwks (načtení sos.dll pro podporu .NET; sos.dll se liší dle verze .NET, je i verze pro Silverlight)
~* e !clrstack (zobrazí call-stack všech threadů)
!ip2md <ip> (převod z instruction pointeru na "md")
!dumpil <md> (disassembly kódu z <md> do MSIL)
!u
!syncblk
~<thread_id> S (přepnutí do kontextu threadu X, po crashi je context v dumpu přednastavený na thread, který crash způsobil)
!dso (Dump Stack Objects - všechny objekty v paměti)
!do <addr> (Dump Object - watch objektu)
- nejdůležitější performance countery pro běžné ladění
- # Loaded Asemblies
- # Bytes in all heaps
- # Gen 0, 1, 2 Collections
- % Time in GC
- Allocated Bytes/s
- Large Object Heap Size
- # Exceptions Thrown
- % Process Time
- Virtual Bytes ~ memory reservation
- Private Bytes ~ skutečně použitá paměť
- unhandled exception v jiném, než request-threadu ASP.NET nám kompletně shodí aplikaci, request-thread má výchozí handling (žluitá page, popř. customErrors)
- exception code z eventu id 1000 (Application Error) je googlovatelný, obvykle něco jako Stack Overflow
WUX03-IS Microsoft Visual Studio 10: Easing ASP.NET Web Deployment
Interactive-session podrobněji o nových možnostech Web Deploymentu ve Visual Studiu 2010 - zejména o transformacích web.configů a o MSDeploy packagingu.
Nebudu podrobně rozvádět, ale protože jsem se na přípravě této funkcionality svou troškou do mlýna prostřednictvím Web Deployment Advisory Councilu taky zapojil (a zejména k web.config transformacím mám velmi kladný vztah, protože se tam hodně mých myšlenek opravdu projevilo), pokusím se uspořádat na toto téma přednášku.
TLA324 The Joy of Writing Code in Visual Studio 2010
Wrap-up session, kde už byly jenom shrnuty novinky source-code-editove VS2010, které už jsem převážně jinde popisoval. Tedy jen v bodech:
- Quick-Search (inteligentní vyhledávání v názvech tříd, metod, souborů, atp.)
- Highlight References (zvyraznění všech použití jednoho symbolu)
- podpora Consume-First kódování (TDD) - zejména speciální režim Intelli-Sense, vylepšené generátory kódu (Generate Stub), ato.
- zvýrazňování compile-time chyb už během psaní kódu (červené podtržení, nyní známo již ve VB, v C# se objevuje až po kompilaci),
- Call Hiearchy - analýza vzájemných volání metod ála Reflector,
- Debug History - rozšířený debuging s historií ála tracing, zaznamenávání událostí, průběhu hodnot v minulosti, atp. (+ možnost uložení na disk třeba pro nahlášení bugu do issue-management systému)
- editor bude vytvořen ve WPF - což umožní snadnou rozšiřitelnost a určité nové grafické možnosti (plynulé zoomování, atp.)
- ...a další
Závěr
TechEd Barcelona 2008 dnes skončil a osobně ho hodnotím jako poměrně zdařilou akci. Zejména díky období mnoha novinek Microsoftu pro vývojáře bylo co prezentovat a na co koukat. Klasicky se projevilo, že nemá smysl chodit na sessions, kde o tématu člověk předem víceméně něco zná (byť by byly session označeny deep-dive, level 400, hardcore, či jakkoliv jinak), ale naopak jsou užitečné session, kde dají člověku první rychlou představu o něčem novém a pomůžou mu se zorientovat, co má smysl dále studovat, a co nestojí za námahu. Ne vždy se mi podařilo takové session trefit a někdy jsem naopak litoval překryvu, každopádně se těším na videa ze všech session a podívám ještě na pár věcí, které jsem minul.