Z taką sytuacją można się spotkać, kiedy ściągamy z internetu np. cały sezon jakiegoś serialu w wydaniu tzw. scenowym Wtedy mamy do czynienia z każdym odcinkiem w osobnym katalogu, w którym znajdują się podzielone na części archiwa RAR, przeważnie ok. 14 MB. Często wypakowywanie takiego czegoś bywa monotonne i irytujące Z pomocą przychodzi nam wspomniany PowerShell. Poniżej prezentuję krótki skrypt, który wykona za nas tą pracę:

$env:Path = "C:\Program Files\WinRAR\"
$loc = Get-Location
$folders = ls | Where-Object { $_.PSIsContainer };
foreach ($folder in $folders)
{
   $arr = $folder.FullName, "\*.rar"
   $txt = $arr -join ""
   $arrargs = "x", $txt, $loc
   $args = $arrargs -join " "
   $app =  Start-Process WinRAR $args -passthru
   do
   {
   }
   while (Get-Process -Id $app.Id -ea SilentlyContinue)
}

Pokrótce jak to działa. Na początku dodajemy ścieżkę, do aplikacji WinRar. W drugiej linii dodajemy zmienną, przechowującą, gdzie został uruchomiony skrypt.
Linia

$folders = ls | Where-Object { $_.PSIsContainer };

tworzy tablicę katalogów po której będzie poruszał się skrypt. Ta linia zwraca nam tylko katalogi. Następnie zostaje tworzona pętla, która porusza się po wcześniej zadeklarowanej tablicy. W pętli zostają utworzone wszystkie potrzebne parametry wywołania dla WinRar’a. Linia

 $app =  Start-Process WinRAR $args -passthru

wypakowuje poszczególne pliki. Pętla do…while, została tutaj zastosowana, aby wszystkie archiwa wypakowywały się kolejno, w przeciwnym razie wszystkie archiwa wypakowywałyby się jednocześnie.

Jak to wykorzystać?

W PowerShell, każdy skrypt musi być podpisany. Dlatego aby uruchomić ten skrypt trzeba go albo podpisać, albo zezwolić na uruchamiania wszystkich skryptów. Na czas wykonywania takiego skryptu w konsoli PowerShell można wydać polecenie:

Set-ExecutionPolicy unrestricted -confirm

, które po zaakceptowaniu pozwoli na uruchamianie takiego skryptu.
Kiedy już umożliwimy uruchomienie takiego skryptu, kopiujemy go do katalogu, gdzie mamy to co chcemy wypakować. Następnie po naciśnięciu prawego przycisku myszy uruchamiamy skrypt poleceniem „Run with PowerShell”. Po tym następuje wypakowywanie plików, w miejsce, gdzie został wklejony skrypt.

Po tej operacji należy powrócić do pierwotnych ustawień:

Set-ExecutionPolicy AllSigned

, aby zabezpieczyć się przed przypadkowym uruchomieniem szkodliwego skryptu.
Aby ściągnąć skrypt kliknij TUTAJ!

Co nam będzie potrzebne?

Aby rozpocząć zabawę z paskiem zadań musimy ściągnąć paczkę Windows API Code Pack.
Po stworzeniu nowego projektu w Visual Studio musimy podpiąć następujące odwołania:

• Microsoft.WindowsAPICodePack
• Microsoft.WindowsAPICodePack.Shell
• PrezentationCore
• WindowsBase

Pierwsze dwa musimy dodać z paczki, którą przed chwilą ściągnęliśmy. Ostatnie dwa są w odwołaniach .NET.

Potrzebna nam będzie również ikonka, która będzie nam służyła jako przycisk w naszej aplikacji. Stworzoną przez nas ikonę wrzucamy do zasobów naszego rozwiązania.

Jak to zakodować?

Pierwszą rzeczą jaką musimy zrobić (dla ułatwienia kodowania) jest dodanie przestrzeni nazw

using Microsoft.WindowsAPICodePack.Taskbar;

Następnie dodajemy pole prywatne do naszego formularza:

private ThumbnailToolBarButton btn;

Następnie w konstruktorze formularza dodajemy kod:

            btn = new ThumbnailToolBarButton(Properties.Resources.tbb, "Kliknij");
            btn.Click+=new EventHandler(button1_Click);
            TaskbarManager.Instance.ThumbnailToolBars.AddButtons(this.Handle, btn);

Pierwsza linijka, jest to utworzenie obiektu naszego przycisku. Jako parametry podajemy wcześniej dodaną do zasobów ikonkę, drugi parametr jest to tooltip przycisku. W drugiej linijce, dodajemy zdarzenie, co ma się dziać po naciśnięciu przycisku. W tym przypadku jest to metoda przycisku, który jest już na formularzu. W linijce trzeciej, dodajmy nasz przycisk do kolekcji. Jako pierwszy argument jest tutaj uchwyt do formularza, drugi to przycisk.
Teraz już wystarczy tylko uruchomić nasz program i powinniśmy ujrzeć taki efekt:

Po naciśnięciu przycisku wywoła się metoda, która jest podpięta do Button1, w moim przypadku jest to po prostu wyświetlenie okienka dialogowego.

Cała klasa prezentuje się następująco:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.WindowsAPICodePack;
using Microsoft.WindowsAPICodePack.Shell;
using Microsoft.WindowsAPICodePack.Taskbar;
namespace tbb
{
    public partial class Form1 : Form
    {
        private ThumbnailToolBarButton btn;
        public Form1()
        {
            InitializeComponent();
            btn = new ThumbnailToolBarButton(Properties.Resources.tbb, "Kliknij");
            btn.Click+=new EventHandler(button1_Click);
            TaskbarManager.Instance.ThumbnailToolBars.AddButtons(this.Handle, btn);

        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Komunikat");
        }
    }
}

        public static string GenerujLosowaNazwe(int iloscZnakow, bool maleZnaki = false)
        {
            StringBuilder lancuch = new StringBuilder();
            Random rnd = new Random();
            char znak;

            for (int i = 0; i < iloscZnakow; i++)
            {
                znak = Convert.ToChar(Convert.ToInt32((Math.Floor(26 * rnd.NextDouble() + 65))));
                lancuch.Append(znak);
            }
            if (maleZnaki)
            {
                return lancuch.ToString().ToLower();
            }
            else
            {
                return lancuch.ToString();
            }
        }

Jak widzimy jest to prosta metoda, korzystająca z klasy Random do wygenerowania odpowiedniego kodu ASCII. Metoda generuje tylko litery od A do Z, dlatego możemy jeszcze przekazać, aby został zwrócony łańcuch z małych liter.
Oczywiście metoda ta nie jest za doskonała, ponieważ dostaniemy tylko same litery od A do Z, i to tylko w postaci małych lub tylko wielkich liter. Rozwiązaniem jest druga metoda, którą przedstawiam poniżej:

        private static readonly string _znaki = "ABCDEFGHIJKLMNPQRSTWXYZabcdefghijkmnopqrstwxyz0123456789";

        public static string GenereujLosowaNazwe2(int iloscZnakow)
        {
            Random rnd = new Random();
            StringBuilder lancuch = new StringBuilder();
            char[] tablica = _znaki.ToCharArray();
            for (int i = 0; i < iloscZnakow; i++)
            {
                int numer = rnd.Next(0, tablica.Length);
                lancuch.Append(tablica[numer]);
            }
            return lancuch.ToString();
        }

Widać, że ta metoda jest odrobinę prostsza od poprzedniej. Tutaj bazujemy na tablicy znaków z jakich możemy budować nasz łańcuch. Wystarczy w polu prywatnym

_znaki

dodać lub usunąć określony znak.

Jak widać wyżej, napisanie metody, która generuje ciąg znaków, nie jest trudny, ale po co wywarzać już otwarte drzwi? Platforma .NET za nas dostarcza już gotowe metody, które za nas wygenerują nasz losowy ciąg znaków.

Pierwszym z takich losowych ciągów znaków jest GUID (ang. Globally Unique Identifier). Jeden taki klucz przechowuje 32 znaki. Całkowita liczba kluczy jakich może wygenerować GUID to 2¹²⁸ czyli 340 282 366 920 938 463 463 374 607 431 768 211 456 czyli całkiem dużo.
Sposób wygenerowania GUID'u pod .NET jest bardzo prosty:

string g = Guid.NewGuid().ToString();

Wygenerowany GIUD jest postaci:

030B4A82-1B7C-11CF-9D53-00AA003C9CB6

Czasami znaki myślnika nie są nam potrzebne, dlatego możemy je łatwo usunąć:

 string g = Guid.NewGuid().ToString().Replace("-", "");

Jednak nie zawsze potrzebna jest nam tak długa nazwa pliku. Dlatego platforma dostarcza nam jeszcze jedną metodę, przeznaczoną specjalnie do generowania nazw plików. Metoda ta znajduje się w przestrzeni nazw System.IO. W klasie Path mamy do dyspozycji metodę GetRandomFileName. Generuje ona 8 znakową przypadkową nazwę pliku z 3 literowym przypadkowym rozszerzeniem. Przykład wykorzystania poniżej:

string f = Path.GetRandomFileName();

Wynikiem może być:

2cual2s2.zpm

W klasie Path jest jeszcze jedna metoda, bardzo przydatna do tworzenia plików tymczasowych:

string t = Path.GetTempFileName();

Wynikiem metody jest:

C:\Users\NazwaUżytkownika\AppData\Local\Temp\tmpC7F0.tmp

Metoda ta służy do tworzenia nazwy pliku tymczasowego w katalogu tymczasowym aplikacji systemu. Metoda ta tworzy samą nazwę, nie tworzy pliku na dysku.

4. LINQ to XML (XLINQ)

LINQ to XML jest nowym podejściem pracy z dokumentami XML. Dzięki LINQ to XML można łatwo załadować dokument XML do pamięci i równie łatwo można poprzez zapytania odczytywać dokument oraz go modyfikować. Po przetworzeniu można łatwo dokument zapisać z pamięci na dysk.
Ogromną zaletą LINQ to XML jest to, że można przetwarzać dokumenty XML-owe o wiele łatwiej niż to miało miejsce poprzednio czyli na przykład przy pomocy .NET-owej przestrzeni nazw System.Xml. Dzięki LINQ obsługa tych dokumentów stała się o wiele prostsza, przetwarzanie pojedynczych węzłów stało się o wiele bardziej łatwiejsze, a kod stał się o wiele bardziej czytelniejszy i krótszy.
LINQ to XML jest dostępne w przestrzeni nazw System.Xml.Linq, która to przestrzeń dostarcza wszystkie potrzebne klasy do pracy z dokumentem XML. Poniżej przedstawiam diagram klas tej przestrzeni nazw:

Jak widać powyżej przestrzeń nazw XLINQ jest dość złożona. Jednak aby sprawnie posługiwać się dokumentami XML za pomocą LINQ to XML trzeba poznać trzy najważniejsze klasy: XElement, XAttribute oraz XDocument. Klasa XElement reprezentuje element XML. Jak widać z diagramu powyżej pochodzi ona z abstrakcyjnej klasy XContainer, która to pochodzi z klasy XNode. Hierarchia tych klas jest taka, ponieważ każdy element w XML jest węzłem. Klasa XElement jest jedną z najważniejszych klas, ponieważ z jej pomocą można tworzyć i manipulować elementami XML tzn. można tworzyć elementy, dodawać i modyfikować atrybuty elementów oraz manipulować zawartością elementów tj. dodawać, usuwać oraz modyfikować elementy potomne.
Klasa XAttribute służy do manipulowania atrybutami elementów dokumentu XML. Jak wiadomo atrybut w XML jest to para nazwa/wartość przypisana konkretnemu elementowi. Praca z atrybutami w LINQ to XML jest bardzo podobna do pracy z elementami XML. Jednak należy pamiętać, że atrybut nie jest węzłem XML co doskonale widać z diagramu wyżej. Ponadto każdy atrybut musi posiadać nazwę, która jest unikatowa dla danego elementu.
Klasa XDocument umożliwia prace z poprawnymi dokumentami XML włączając w to deklaracje i komentarze. Klasa ta dziedziczy z klasy XContainer, czyli może posiadać elementy i węzły lecz może posiadać tylko jeden główny obiekt XElement, który jest węzłem głównym (ang. Root Element).

5. Programowanie w LINQ to XML (XLINQ)

5.1. Tworzenie drzew

Jedną z podstawowych rzeczy przy obsłudze dokumentów XML jest ich tworzenie. W XLINQ tworzenie drzew XML jest bardzo proste. Poniżej przedstawiam prosty pseudo-kod do tworzenia drzew XML:

XElement employee = new XElement(XName,
    new XElement(XName,
        new XElement(XName name),
        new XElement(XName name),
        new XElement(XName name),
        new XElement(XName name)
    );

Jak widać z powyższego kodu, za pomocą klasy XElement tworzymy nowe elementy drzewa XML. Deklaracja nagłówka klasy prezentuje się następująco:

XElement(XName name, params object[] content)

Z powyższej definicji widać, że konstruktor klasy przyjmuje dwa parametry: pierwszy, jest to nazwa elementu tworzonego, a drugim parametrem jest tablica obiektów, które mają się znaleźć w klasie. Obiektem tym może być zarówno atrybut jak i nowy element potomny.

5.2. Wczytywanie drzew XML

Wczytywanie drzewa XML możemy zrealizować z różnych źródeł. Podstawowa składnia wczytywania drzewa wygląda następująco:

XElement employees = XElement.Load(object);

Metoda ta jako parametr przyjmuje obiekty typu Stream, String (ścieżka do pliku), XmlReader, TextReader.

5.3. Serializacja dokumentów XML

Proces serializacji polega na zapisaniu obiektu na dysk twardy lub do pamięci. Kiedy proces przetwarzania dokumentu XML zostanie zakończony, wyniki pracy można zapisać do pliku. Proces ten uzyskuje się dzięki metodzie Save() klasy XDocument lub XElement. Do metody tej możemy przekazać albo ścieżkę do fizycznego miejsca na dysku, gdzie ma być zapisany dokument, obiekt XmlWriter lub TextWriter. Poniżej krótki przykład:

XElement employees = XElement.Parse(@"
            
                
                    Scott
                    
                    Gaming
                    04/17/92
                    M
                    M
                
            ");
using (StringWriter sw = new StringWriter())
{
    employees.Save(sw, true);
}

5.4. Wykonywanie zapytań LINQ w dokumentach XML

Kiedy dokument XML zostanie już wczytany można wykonywać zapytania XLINQ. Najlepszym sposobem do wyciągnięcia wszystkich elementów jest odwołanie się do głównego elementu dokumentu Root. Następnie należy się odwołać do interesującego nas elementu i wybrać elementy które nas interesują. Poniżej przedstawiam przykład:

            var doc =  XDocument.Load("planety.xml");

            var q = from p in doc.Root.Elements("Planet")
                    select p.Element("Name").Value;

            foreach (var s in q)
            {
                rtbXml.Text += s.ToString()+"\n"; //RichTextBox

            }

Taka składnia wyrażenia jest dobra, kiedy nie musimy zbyt głęboko wchodzić w strukturę dokumentu. Natomiast kiedy musimy przejść przez wiele poziomów dokumentu z pomocą przychodzi metoda Descendats(). Poniżej krótki kod, przedstawiający użycia tej metody. Kod ten wyświetla wszystkie elementy które są zagnieżdżone drugim lub większym poziomie dokumentu względem elementu głównego:

            var doc = XDocument.Load("planety.xml");

            var q = from p in doc.Descendants("Moon")
                    select p.Element("Name");

            foreach (var s in q)
            {
                rtbXml.Text += s.ToString() + "\n";
            }

Dla porównania ten sam efekt możemy uzyskać za pomocą takiego wyrażenia:

            var doc = XDocument.Load("planety.xml");

            var q = from p in doc.Root.Elements("Planet").Elements("Moons").Elements("Moon")
                       select p.Element("Name");

            foreach (var s in q)
            {
                rtbXml.Text += s.ToString() + "\n";
            }

Oczywiście z kodu XML można wyciągać również konkretne, interesujące się dane. Poniżej krótki przykład wyszukiwania elementu:

            var doc = XDocument.Load("planety.xml");

            var q = from XText t in doc.DescendantNodes().OfType()
                    where t.Value == "Moon"
                    select t;

            rtbXml.Text = q.First().ToString();

Kiedy elementy w dokumencie zawierają charakterystyczną, unikalną cechę w dokumencie, odnalezienie takiego węzła nie stanowi problemu:

            var doc = XDocument.Load("planety.xml");

            var q = from p in doc.Root.Elements("Planet")
                    where p.Attribute("id").Value == "3"
                    select p;

            rtbXml.Text = q.First().ToString();

5.5. Edytowanie dokumentu XML

Jedną z podstawowych operacji na dokumencie jest usuwanie węzłów. Wykonanie tego zadania realizuje się za pomocą metody Remove(). Metoda ta nie przyjmuje żadnych parametrów. Jest to metoda wywołana z wyniku zapytania. Po zakończeniu edycji należy zapisać plik:

            var doc = XDocument.Load("planety2.xml");

            var q = from p in doc.Root.Elements("Planet")
                    where p.Attribute("id").Value == "2"
                    select p;

            q.Remove();

            doc.Save("planety2.xml");

            rtbXml.Text = "Element został usunięty";

Edycja węzłów jest bardzo podobna. Wybieramy interesujący nas węzeł do edycji i za pomocą metody SetValue() . Metoda ta, podobnie jak przy usuwaniu, jest wywołana ze zmiennej przechowującej wynik zapytania:

            var doc = XDocument.Load("planety2.xml");

            var q = (from p in doc.Descendants("Planet")
                     where p.Element("Name").Value == "Mercury"
                     select p).Single();

            q.Element("Name").SetValue("Mercury po zmianie");

            doc.Save("planety2.xml");

            rtbXml.Text = "Element został zmieniony";

W powyższym kodzie przy zapytaniu została użyta metoda Single(), która gwarantuje zwrócenie tylko jednego rezultatu. Zabezpiecza to nas przed przypadkowym zmienieniem większej ilości danych w dokumencie.
Ostatnią czynnością przy edycji dokumentów jest dodawanie nowych elementów. Operację tę realizujemy za pomocą metody Add() obiektu XDocument. Nowy element możemy dodać w dowolnym stopniu zagnieżdżenia. W poniższym przykładzie, nowy element jest dodawany jest w węźle głównym dokumentu Root:

            var doc = XDocument.Load("planety2.xml");

doc.Root.Add(new XElement("Planet", new XAttribute("id", "5"), new XElement("Name", "Jupiter")));

            doc.Save("planety2.xml");

            rtbXml.Text = "Element został dodany";

Nowy element dodawany jest przez new XElement, nowy atrybut przez new XAttribute. XElement jako parametry przyjmuje nazwę elementu i jego wartość, lub nowe zagnieżdżone elementy. XAttribute przyjmuje nazwę atrybutu i jego wartość.

5.6. Walidacja dokumentu XML

Ostatnią czynnością dla upewnienia się, czy w dokumencie zostały wprowadzone dobre zmiany jest walidacja dokumentu. Walidacja polega na sprawdzenie dokumentu czy jest zgodny ze schematem. Dzięki wbudowanemu mechanizmowi w VS za pomocą paru linijek kodu, można sprawdzić poprawność dokumentu XML. Do walidacji dokumentu wymagane jest użycia klasy XmlSchemaSet z przestrzeni nazw System.Xml.Schema oraz użycia metody Validate() obiektu XDocument.

Do wpisu dołączam przykładowy projekt wykonany w Visual Studio 2010 prezentujący wymienione powyżej przykłady. Aby pobrać plik z solucją kliknij TUTAJ!

1. Standard XML

XML (Extensible Markup Language) jest standardem przetwarzania danych zalecanym przez konsorcjum W3C. XML jest spokrewniony z SGML (Standard Generalization Markup Language), ale w stosunku do niego jest o wiele bardziej uproszczony i pozbawionych wielu trudnych, rzadko używanych elementów.
XML tak samo jak język HTML jest językiem znaczników. Jednak w przeciwieństwie do HTML, XML pozwala na tworzenie własnych znaczników i ich atrybutów, gdzie w HTML ich struktura i nazwy są ściśle określone w standardzie HTML (np. <body>, <head>). W XML natomiast możemy tworzyć własne znacznik. Każdy taki element może być definiowany przez jego własny DTP (Document Type Definition) oraz arkusze stylów, które mogą być stosowane do jednego lub wielu dokumentów XML.
Mimo, że w XML można tworzyć własne znaczniki ich odpowiednie oznakowanie i położenie musi być ściśle zgodne ze standardami konsorcjum W3C. Podstawowym elementem w dokumencie XML-owym jest znacznik, który może posiadać dowolne atrybuty. Bardzo ważnym aspektem jest, że każdy znacznik musi być zamknięty. Jest to jeden z warunków koniecznych, aby dokument był zgodny ze standardami. Poniżej przedstawiam trzy przykłady znaczników w dokumencie:

• znacznik otwierający i zamykający z zawartością

  Henryk Sienkiewicz

• znacznik otwierający i zamykający z atrybutem i zawartością

  2,75

• znacznik otwierający i zamykający z atrybutem bez zawartości

  lub:

Jak wspomniałem wcześniej, dokument XML musi być ściśle zgodny ze standardami. Poniżej przedstawiam listę zagadnień, których znajomość jest nieodzowna przy tworzeniu własnego dokumentu:

• XML jest wrażliwy na wielkość znaków, dlatego znaczniki otwierające muszą być zapisane dokładnie w taki sam sposób jak zamykające,
• wartości atrybutów muszą być zapisane w cudzysłowach,
• niepusty element musi mieć znacznik otwierający i zamykający
• znaczniki muszą być zagnieżdżane w odpowiedniej kolejności. Zamykanie znaczników musi odbywać się w kierunku od ostatniego do pierwszego w stosunku do znaczników otwierających.

Do poprawnego zbudowania dokumentu jednak potrzebna jest odpowiednia budowa samego pliku lub plików. Do budowy poprawnego dokumentu XML zazwyczaj potrzebne są dwa pliki, lecz nie jest to wymagane. Pierwszym z nich jest to dokument XML, zawierający konkretne dane. Drugim plikiem jest plik DTD (Document Type Definition), który zawiera reguły, jak elementy XML, atrybuty i inne dane, które są definiowane i logicznie połączone w dokumencie.
Poniżej przedstawiam przykładowy, poprawny dokument XML (bez DTD):

    
        John
        Doe
        
        624253468
        2546885
        254842546
    
    
        Jane
        Doe
        
        
        54575485
        
    

Jak widać z przykładu powyżej dokument XML to hierarchiczny zbiór znaczników, gdzie na najwyższym poziomie może wystąpić tylko jeden znacznik, który jest elementem głównym dokumentu (ang. root).
Jak wspomniałem wcześniej dokument XML musi być ściśle związany ze standardami. Aby sprawdzić czy dany dokument XML jest prawidłowy pod względem składniowym i logicznym wykorzystuje się wspomniane wcześniej pliki DTD. Mechanizm ten jest odziedziczony po SGML-u i jest stosunkowo stary. Obecnie powszechnie wykorzystuje się również schematy XML (ang. XML Schema), który jest mechanizmem nowszym od DTD. Istnieje również trzeci mechanizm, który jest specyficzny dla firmy Microsoft o nazwie XDR (ang. XML Data Reduced), jednak wszędzie gdzie jest to możliwe powinno stosować się XSD (ang. XML Schema Definition) zalecany przez W3C. Wszystkie trzy mechanizmy pozwalają definiować ograniczenia co do zawartości dokumentu XML po przez określenie znaczników, które mogą wystąpić w dokumencie, znaczników opcjonalnych itd.
Dokument XML można również przedstawić jako drzewo DOM (ang. Document Object Model – Obiektowy model dokumentu), który reprezentuje wszystkie węzły i atrybuty w postaci drzewa. Poniżej przykład takiego drzewa:

Na koniec wprowadzenia do XML wymienię kilka obecnie szeroko stosowanych zastosowań standardu XML:

• zapis dokumentów przy pomocy zbioru znaczników zamiast stosowania skomercjalizowanych technologii (Word, PDF),
• wymiana danych, zarówno do wymiany danych między aplikacjami jak i całymi systemami,
• przechowywanie danych,
• realizacja operacji bazodanowych (np. w Microsoft Access czy SQL Server, wynikiem zapytania SQL może być dokument XML).

2. Klasyczne przetwarzanie XML (przestrzeń nazw System.Xml)

Większość funkcji związanych z przetwarzaniem dokumentów XML znajduje się w przestrzeni nazw System.Xml, która to realizuje przetwarzanie dokumentów XML w obowiązujących standardach (wersja 1.0) m.in.: przestrzenie nazw XML, schematy XML do sprawdzania poprawności dokumentów XML, DOM poziom 2 i inne.
Podstawową klasą do odczytu dokumentów XML jest XmlTextReader, która to zapewnia szybki, nie buforowany dostęp do strumienia danych XML, w którym poruszać się można tylko do przodu. Oznacza to, że cały dokument nie musi być ładowany do pamięci, a jedynie jest odczytywany jeden węzeł. Przy odczytywaniu kolejnych węzłów właściwości obiektu XmlTextReader odpowiadają aktualnie przetwarzanemu węzłowi.
Poniżej przedstawiam przykład użycia obiektu klasy XmlTextReader:

XmlTextReader rdr = new XmlTextReader("C:\Employees.Xml");
while (rdr.Read())
{
    XmlNodeType nt = rdr.NodeType;
    switch (nt)
    {
        case XmlNodeType.Element:
        break;
        case XmlNodeType.Attribute:
        break;
        case XmlNodeType.Comment:
        break;
        case XmlNodeType.Whitespace:
        break;
    }
}

Przestrzeń System.Xml pozwala nam również na zapis dokumentów XML. Służy do tego klasa XmlTextWriter, która zapewnia szybki, nie buforowany zapis danych XML w strumieniu lub pliku, w którym poruszać się można tylko do przodu. Korzystanie z tej klasy polega na wywołaniu metod, które wyprowadzają dane XML. W ten sposób decydujemy dokładnie w którym momencie co ma być wyprowadzone do strumienia lub pliku.
Poniżej przedstawiam przykład użycia klasy XmlTextWriter:

XmlTextWriter wrt = new XmlTextWriter(@"C:\Employees.Xml", Encoding.UTF8);
wrt.WriteStartDocument();
wrt.WriteComment("This is an example");
wrt.WriteStartElement("Employees");
wrt.WriteStartElement("Employee");
wrt.WriteStartElement("FirstName");
wrt.WriteString("Scott");
wrt.WriteEndElement();
wrt.WriteEndElement();
wrt.WriteEndElement();

Jak widzimy w powyższym przykładzie, zapis danych do pliku XML, zwłaszcza przy większej ilości danych może sprawiać problemy, zwłaszcza kiedy mamy do czynienia z wielopoziomowymi dokumentami, gdzie poziom zagłębienia jest duży.
Oczywiście przestrzeń nazw System.Xml zawiera o wiele więcej klas i metod do obsługi dokumentów XML, sprawdzania poprawności dokumentów oraz wiele więcej.

3. Projekt LINQ

LINQ (Language Integrated Query) jest to część platformy .NET i jest to zestaw standardowych operatorów zapytań które dostarczają bazową architekturę zapytań do nawigowania, filtrowania i wykonywania zapytań praktycznie z każdym źródłem danych. Takim źródłem danych może być relacyjna baza danych (LINQ to SQL), obiekt DataSet (LINQ to DataSet), dokument XML (LINQ to XML) lub kolekcja danych przechowywana w pamięci.
Jak wspomniałem wcześniej LINQ to zestaw operatorów zapytania, które wprowadzają udogodnienia wprost do języka programowania (Visual Basic, C#), dlatego dzięki LINQ nie trzeba już zapisywać zapytań SQL jako ciąg znaków nic nie znaczących dla kompilatora. Dzięki temu mamy kontrolę nad poprawnością zapisu zapytania już na etapie kodowania aplikacji.
Bardzo ważnym aspektem wyników zwracanych przez zapytanie LINQ jest to, że odpytywane źródło danych musi implementować generyczną wersję interfejsu IEnumerable, który znajduje się w przestrzeni nazw System.Collections.Generic.
Poniżej przedstawiam przykład zapytania LINQ. Pierwsze jest to tzw. Query Syntax. Jest to forma bardziej czytelna, która ma wiele wspólnego z zapytaniami SQL:

var query =
                    from c in contact
                    where c.FirstName.StartsWith("S")
                    && c.LastName.StartsWith("K")
                    orderby c.LastName
                    select new { c.FirstName, c.LastName, c.EmailAddress };

Drugą formą tego zapytania jest tzw. Method Syntax. Każde zapytanie zapisane w formie Query Syntax, przy uruchamianiu w środowisku .NET jest zawsze tłumaczone na Method Syntax. Do zapisu zapytań w tej postaci korzysta się z wyrażeń Lambda:

IEnumerable query = contact.Where(a => a.FirstName.StartsWith("S") &&
a.LastName.StartsWith("K")).OrderBy(a => a.LastName);

Na początku chciałbym przedstawić Combobox’a. Ciekawa kontrolka imitująca comboboxa. Piszę imitująca, ponieważ „programowo” nie ma nic wspólnego z systemową listą rozwijaną, ale zachowuje się oczywiście tak samo. Kontrolka ta oprócz oczywistych funkcji posiada również wyświetlanie ikonki obok każdej pozycji, animowanie otwierania listy, lista wielokolumnowa i wiele innych.
Osobiście jakoś wolę używać standardowych kontrolek tego typu, ale na pewno zdarzą się sytuacje kiedy taka „bajerancka” kontrolka się przyda. Pod tym adresem można się przekonać jak ten komponent sprawuje się w życiu.

Kolejny element to Editor służący do ułatwienia wprowadzania przez użytkownika tekstu. Jest to kontrolka przypominająca wstążkę z MS Office 2007. Jest to dość rozbudowany edytor z wieloma opcjami. Pod tym adresem można zobaczyć jak działa ten komponent.

Kolejnym, jak dla mnie chyba najbardziej użytecznym jest Menu. Dzięki temu narzędziu możemy stworzyć bardzo dobre zaawansowane menu na naszą stronę. Może ono występować w pozycji pionowej i poziomej, posiadać podmenu, ikonki przy poszczególnych pozycjach i wiele więcej opcji. Niestety niektóre motywy mają błędy i nie wyświetlają się poprawnie. Pod tym adresem można zobaczyć menu w akcji.

Kolejnym bardzo przydatnym narzędziem na naszą stronę może być ToolTip. ToolTip jest to podpowiedź wyskakująca obok danego obiektu po najechaniu na niego lub kliknięciu. Podpowiedź taka znika zaraz po opuszczeniu kursorem obszaru obiektu. Narzędzie takie jest bardzo przydatne na stronach web na przykład przy wypełnianiu przez użytkownika formularza, kiedy to po najechaniu na odpowiednie pole wyświetla się podpowiedź co ma do tego pola wpisać, albo jak wygląda maska dla takiego pola. Pod tym adresem jest prosty przykład prezentujący tą kontrolkę.

Jak pisałem kontrolek tych jest kilkanaście, dlatego nie będę opisywał tutaj wszystkich. Pełny spis można znaleźć pod tym adresem
Jest to bardzo ciekawy produkt, niestety zbyt drogi i wydaję mi się, że jak za taką cenę oferujący trochę zbyt mało. Mi pozostaje się tylko cieszyć roczną licencją tego produktu a innych zachęcam do przetestowania wersji trial.

Obudowa

Na pierwszy rzut oka całość się prezentuje bardzo dobrze i na szczęście tak zostaje przy bliższym przyjrzeniu. Całość jest wyposażona w klawiaturę, przy której się na chwilę zatrzymam, łącznie z klawiaturą numeryczną. Przy pierwszym kontakcie nie mogłem się do niej przyzwyczaić. Klawisze są zupełnie płaskie z odstępami pomiędzy nimi. Jednak po chwili oswojenia, klawiatura stała się całkiem wygodna. Rozmieszczenie klawiszy bardzo wygodne. Jedyny mankament, to źle wciskająca się literka „i” w moim egzemplarzu. Ponad klawiaturą a wyświetlaczem znajduje się znaczna przerwa, na której są głośniki i 7 przycisków dodatkowych (zasilanie, WiFi, Bluetooth, Backup Manager, 2 przyciski głośności i Lunch Manager). Przyciski rozmieszczone są w ergonomiczny sposób. Jedyna rzecz, która kuje mnie w oczy, to przycisk Bluetooth, w modelu który tego modułu nie posiada! Ostatnia sprawa to Touchpad. Jest on zlokalizowany w idealnym miejscu, przynajmniej dla mnie. Przyciski chodzą dość ciężko. Sam touchpad nie jest tak czuły jak być powinien. Czasami chwilę trzeba pojeździć po nim palcem żeby zareagował. Bardzo fajna jest funkcja multidotyku, której jednak na co dzień nie używam. Obok samego Touchpada znajduje się również przycisk do jego wyłączenia.

Co do portów, wszystkie są zlokalizowane bardzo dobrze. Po dwa porty USB z prawej i lewej strony, port LAN, HDMI, D-Sub oraz audio znajdują się po lewej stronie, po prawej natomiast port modemu analogowego i Keningston Lock. po tej stronie znajduje się również tacka z napędem DVD. Od przodu laptopa oprócz przycisku przesuwnego od klapy wyświetlacza znajduje się czytnik kart pamięci.
Ogólnie rzecz biorąc, muszę zaliczyć obudowę tego notebooka za udaną. Jest dobrze wykonana, sztywna i stabilna. Jedyna rzecz, która może irytować to pokrywa wyświetlacza, która jest tzw. „palcująca”, czyli najmniejszy dotyk i zostają widoczne ślady.

Wyświetlacz

Wyświetlacz w moim odczuciu jest wykonany bardzo dobrze. Ma duże kąty widzenia i jest bardzo wyraźny. Podświetlanie diodami LED jest bardzo dobre. Na początku ciężko się przestawić na tryb panoramiczny.

Środek

W samym środku dostajemy całkiem niezły sprzęt jak za tą cenę. Dobra i wydajna grafika, duża pamięć ulotna, dość duży dysk oraz wydajny procesor powinny zadowolić większość graczy.
Nie będę tutaj przeprowadzał żadnych testów, ponieważ są od tego lepsze portale i ludzie, którzy się na tym znają. Mogę jedynie przedstawić indeks wydajności systemu Windows.

Na koniec omawiania sprzętu chciał bym jeszcze zwrócić na technologię jaka została wykorzystana w zamontowanym procesorze. Mowa tutaj o technologii TurboBoost. Polega ona na podniesieniu taktowania na jednym rdzeniu procesora dla aplikacji, która może wykorzystywać tylko jeden rdzeń lub jeden wątek. Oczywiście jest to technologia bardziej zaawansowana, która mogła by zająć cały wpis. Poniżej jeszcze dla zainteresowanych sposób działania tej technologii:

A poniżej TurboBoost w akcji, czyli gadżet pulpitu systemu Windows do obrazowania tej technologii:

Słowem zakończenia

Podsumowując, na razie nie żałuję tego zakupu. Na początku miałem obawy przed marką Acer, jednak po zakupie i tym krótkim okresie użytkowania moje obawy trochę zmalały. Mam nadzieję, że z biegiem czasu znikną całkowicie.

1. Co to jest AJAX i z czym to się je…

Na początek może przytoczę co to właściwie jest AJAX:
AJAX jest to akronim od Asynchronous JavaScript and XML czyli mówiąc po polsku asynchroniczny JavaScript i XML. AJAX jest nowym podejściem do tworzenia stron internetowych. W tradycyjnym podejściu, użytkownik (a dokładniej przeglądarka) wysyła zapytanie do serwera, a serwer w odpowiedzi zwrotnej wysyła stronę do przeglądarki gdzie jest interpretowana. W technologii AJAX jest wysyłane zapytanie, ale serwer nie musi zwracać całej strony, tylko jej część, dzięki czemu strona nie musi być w całości przeładowywana. Zaletą tej technologi jest m.in. szybkość działania, zwłaszcza przy dużych stronach, gdzie tylko mały fragment strony jest aktualizowany.
Jednak, jak to w większości przypadków bywa, są pewne wady, które w AJAX’e niestety występują, a są to:

• jest to język skryptowy, a jak wiemy niektórzy użytkownicy blokują skrypty wykonywane po stronie klienta. Wtedy taka strona staje się bezużyteczna. Jest to znikoma część użytkowników, jednak taka sytuacja występuje;
• brak tradycyjnej nawigacji – ze względu, że nie jest to normalne zapytanie, nie możemy się poruszać w przód i w tył. Dla przeglądarki cały czas przeglądamy jedną stronę;
• utrudnienie indeksowania stron.

2. Visual Studio + ASP.NET + AJAX

Doszliśmy do sedna sprawy, czyli do biblioteki AJAX napisanej przez Microsoft dla potrzeb swojej technologii ASP.NET. Napisanie prostej asynchronicznej aplikacji w środowisku Visual Studio jest dziecinie proste, głównie za sprawą technologi Drag-and-Drop czyli Przeciągnij i Upuść.

Podstawowym komponentem jaki musi się znaleźć na każdej stronie, aby mógł być zastosowany AJAX jest ScriptManager służącym do zarządzania skryptami i bibliotekami AJAX’a oraz do zarządzania częściową aktualizacją strony.
Oczywiście, jeśli ktoś chce sam się zajmować i samodzielnie pisać skrypty, nic nie stoi na przeszkodzie, jednakże ja w tym artykule zajmuje się tylko narzędziami dostarczanymi prze MS.
Drugim komponentem jest UpdatePanel, który jest kontenerem na którym znajdują się kontrolki ASP.NET i HTML, które mają być uaktualniane bez pełnego przeładowywania strony.
Praktycznie te dwa komponenty wystarczą aby zbudować aplikację korzystającą z technologii AJAX.

3. Jak to wszytko połączyć?

W tym podpunkcie pokażę jak to wszytko razem ze sobą połączyć aby zbudować prostą aplikację.

1. Uruchamiamy Visual Studio lub Visual Web Developer i tworzymy nową stronę, wybieramy język C# i nadajemy odpowiednią nazwę.
2. Na obszar roboczy wrzucamy kontrolkę ScriptManager znajdującą się w Przyborniku w zakładce AJAX Extensions.
3. Na obszar wrzucamy Label i Button. Następnie z kontrolek AJAX Extensions dodajemy UpdatePanel i do wnętrza UpdatePanel wrzucamy Label i Button. Całość wygląda mniej więcej tak:

4. Klikamy dwa razy na przycisk z normalnym Postbackiem i przechodzimy do pliku kodu. Zdarzenie uzupełniamy następująco (drugi przycisk analogicznie):

    protected void Button1_Click(object sender, EventArgs e)
    {
        Label1.Text = DateTime.Now.ToString();
    }
    protected void Button2_Click(object sender, EventArgs e)
    {
        Label2.Text = DateTime.Now.ToString();
    }

5. W tym punkcie możemy już uruchomić nasza aplikację i cieszyć się użyciem AJAX’a.
Jak widzimy kiedy klikniemy na przycisk „Aktualizuj (Normalny Postback)” strona cała się przeładuje i na etykiecie pokaże się aktualna data. Kiedy natomiast klikniemy na przycisk „Aktualizuj (AJAX Postback)” zaktualizuje się tylko część strony w której znajduje się druga etykieta.

Jak widzimy z przykładu powyżej, wystarczy kilka kliknięć myszą i możemy cieszyć się aplikacją z użyciem technologii AJAX.

4. Tradycyjny model przeglądania stron czyli AJAX History

Na samym początku pisałem, że AJAX ma pewną wadę, mianowicie uniemożliwia standardowe przeglądanie stron z możliwością nawigacji wstecz i w przód. Programiści Microsoftu rozwiązali jednak ten problem i w wersji ASP.NET 3.5 z ServicePack 1 dodali AJAX History czyli możliwość aby użytkownik mógł nawigować pomiędzy stronami nawet jeśli to były zapytania AJAX.
Poniżej prezentuję prosty przykład użycia historii:
1. Tworzymy nową stronę internetową i nadajemy jej odpowiednią nazwę.
2. Na obszar roboczy wrzucamy ScriptManager. We właściwościach zaznaczamy właściwość EnableHistory na True
3. Teraz wrzucamy UpdatePanel, a w jego wnętrz dodajemy RadioButtonList z 4 opcjami do wyboru, Label oraz Button.
W kodzie wygląda to mniej więcej tak:

        
        
        
            
                
                    Opcja1
                    Opcja2
                    Opcja3
                    Opcja4
                
                
                
                
                
            
        

4. Dla RadioButtonList generujemy zdarzenie SelectedIndexChanged i uzupełniamy je następująco (Upewniamy się, że RadioButtonList ma zaznaczoną właściwość AutoPostback na True):

    protected void RadioButtonList1_SelectedIndexChanged(object sender, EventArgs e)
    {
        Label1.Text = RadioButtonList1.SelectedValue;
    }

5. Dla przycisku generujemy zdarzenie:

    protected void Button1_Click(object sender, EventArgs e)
    {
        string historia = "Zaznaczony element to " + RadioButtonList1.SelectedValue;
        ScriptManager1.AddHistoryPoint("rb", RadioButtonList1.SelectedValue, historia);
    }

Warto przyjrzeć się tutaj metodzie AddHistoryPoint() obiektu ScriptManager. Przyjmuje ona 3 argumenty: pierwszy, jest to unikatowy klucz dla danego punktu historii, drugi jest to wartość jaka ma być przechowana w danym punkcie historii, a 3 jest to tytuł jaki będzie widoczny w przeglądarce pod danym punktem historii. Metoda ta występuję w kilku przeciążeniach.
6. Ostatnim krokiem będzie kontrolowanie historii. Niestety środowisko nie zrobi wszystkiego za nas, dlatego dodanie nowego punktu historii musi być odpowiednio obsłużone, dlatego dodajemy zdarzenie Navigate obiektu ScriptManager. Zdarzenie to jest wykonywane w czasie asynchronicznego Postbacku, kiedy historia po stronie serwera zostaje zmieniona.
A tak wygląda jego obsługa:

    protected void ScriptManager1_Navigate(object sender, HistoryEventArgs e)
    {
        string str = String.Empty;
        if (e.State["rb"] != null)
        {
            str = e.State["rb"];
        }
        if (str.Length > 0)
        {
            RadioButtonList1.SelectedValue = str;
        }
        else
        {
            RadioButtonList1.SelectedIndex = -1;
        }
        Label1.Text = str;
    }

W tym przypadku właściwość State klasy HistoryEventArgs służy do wyciągania informacji/danych dla określonego stanu aplikacji, czyli w naszym przypadku dla określonego stanu w historii przeglądania. Jak widzimy w powyższym kodzie, stan aplikacji w danym punkcie musi być dokładnie obsłużony!

5. Słowem zakończenia…

Jak widzimy obsługa technologii AJAX w ASP.NET nie jest trudna i nie powinna przysporzyć problemów w prostych aplikacjach. Istnieje jeszcze dużo bibliotek rozszerzających możliwości tych standardowych kontrolek do obsługi AJAX’a dostarczonych nie dostarczonych przez Microsoft. Z tego co się zdążyłem zorientować godna uwagi jest paczka Ajax Control Toolkit, która rozszerza znacznie te możliwości.
Jednak cała ta technologia ma jedną poważną wadę: hosting aplikacji napisanych w ASP.NET jest drogi, dość trudno znaleźć odpowiedni hosting. Co ważniejsze na danym hostingu musi być zainstalowana biblioteka do obsługi AJAX, ponieważ inaczej nasze aplikacje napisane z użyciem tej technologii nie będą po prostu działać.

Projekty do artykułu (wykonane w Visual Studio 2010): KLIK!

Może krótko co to jest Windows PowerShell:

Windows PowerShell to interpreter poleceń opracowany przez firmę Microsoft. Jest znacznie rozbudowanym następcą dotychczasowych interpreterów command.com i cmd.exe, stosowanych w systemach operacyjnych MS-DOS i MS Windows. [...] PowerShell jest zintegrowany z .NET Framework i dostarcza środowisko do wykonywania zadań administracyjnych wykonywanych poleceniami cmdlets.
[za Wikipedia]

Jest to bardzo przydatne narzędzie dla administratorów systemów, serwerów, serwerów bazodanowych i wielu innych zastosowań. Bez problemu możemy zarządzać systemem zdalnie właśnie przez WPS. Jest to również bardzo dobre narzędzie do automatyzacji pracy przez zastosowanie skryptów. Twórcy chcieli zrobić coś na wzór konsoli pod systemy Uniksowe dla Windows i moim zdaniem im się to bardzo dobrze udało. Wreszcie jest coś co nie jest tak toporne jak standardowy cmd czy command. Na dodatek możemy korzystać z całego bogactwa platformy .NET, WMI czy ActiveX. Zapraszam do ściągnięcia mojej prezentacji „Wprowadzenie do Windows PowerShell”.

Link: WindowsPowerShell.zip