Jirka Pénzeš Blog

Semestrální práce – Síťové kreslení

Fri, 20 Aug 2010 23:05:02 GMT

Na univerzitě nás učí programovat v jazyku Java - snaží se tento jazyk aplikovat do všech předmětů, které souvisí s programováním. Samozřejmě v předmětu „Úvod do jazyka C“ se Java neučí. Nicméně ve druhém ročníku je mezi povinně volitelnými předmět Programovací techniky jazyka Java. Tento předmět je určen pro studenty, kteří mají zájem o hlubší poznání tohoto jazyka a se základy programování nemají problém.

Zápočet z tohoto předmětu se skládal z vypracovaní semestrální práce (program) a následné obhájení této práce.

Zadání bylo prosté – mělo se jednat buď o síťovou aplikaci, aplikaci pracující s vlákny nebo aplikaci, které zpracovává a nějak vyhodnocuje XML dokument. Já jsem zvolil síťovou aplikaci. Mnou zadaný projekt nese název Síťové kreslení. Jedná se o jednoduchou aplikaci, která umožňuje kreslení základních geometrických tvarů po síti.

Popis funkčnosti

Aplikace je triviální – funguje na principu klient/server, tj. pouze dva účastníci. Komunikace probíhá pomocí příkazů, které určují, co se má nakreslit
obecný parametr:
TYP_OBRAZCE BARVA TLOUSTKA_STETCE PARAMETRY_KRESLENI[]

Aplikace umí posílat i obrázky, i když vykreslení trochu trvá – vykresluje po řádcích. Většina operací (kreslení, komunikace a posluchači) běží ve vláknech, samotná aplikace ale není na procesor moc náročná.

Jednotlivé třídy (architektura)

DemoApp – inicializuje panel a spouští celou aplikaci
DemoFrame – samotné okno aplikace obsahující menu a instanci plátna
Platno – kreslící plátno
Client – obstarává klientskou komunikaci (poslouchací vlákno)
Server – obstarává serverou část (poslouchací vlákno)
ConnectStatus - třida, která ví, zda se komunikuje, nekomunikuje nebo jestli se náhodou nedokomunikovalo :-)
CommandsCollection – Datová struktura, která přijímá a odebírá příkazy (synchronizovaná)
Algorithm – Obsahuje pomocné algoritmy kreslení (výpočet Lagrangeho polynomu, semínkové vyplňování a XOR režim kreslení)
DrawGeometry – statická třída, která umí kreslit jednotlivé útvary

V neposlední řadě tu je pak samotný balíček obsahující třídy jako Rect, Polygon, Line a další útvary. Tyto třídy ví, jaké parametry očekávat a jak z nich cílený útvar vytvořit.

Kódu je to kupa a divím se, že to vůbec funguje, nicméně započet i zkoušku mám.

Práce s šablony ve WPF

Dat, 07 Aug 2010 17:18:56 GMT

Krátké seznámení s vytvářením šablon (template) ve Windows Presentation Foundation. V ukázce je vysvětlena aplikace šablony na tlačítko, vytvoření reakce na myš, následné zanimovaní a odsunutí šablony do statických zdrojů, pro případné další použití.

Odkazy: zdrojové kódy, video na mstv.cz

Návrhový vzor Prototyp (Prototype)

Fri, 30 Jul 2010 20:48:25 GMT

Dalším návrhovým vzorem, po boku vzoru Singleton, je Prototyp, který také spadá do kategorie vytvářejících vzorů, tedy creational design patterns.

Pokud máme složitou inicializaci objektů, tedy dlouhý strojový čas provedení inicializace - vyplatí se objekty od sebe navzájem kopírovat, tedy vytvářet klony. Právě na této myšlence je postaven Prototyp. Mějme například nějaký vytvořený objekt, a pokud chceme vytvořit další instanci stejné typu => první si naklonujeme. Tím obejdeme další inicializaci. Výhody klonování jsou nesčetné, můžeme například vytáhnout data z kolekce jako kopii a dále s touto kopií pracovat a měnit ji, aniž bychom měnili hodnoty v jiné části programu.

Implementace Prototypu v jazyce C#.NET

Klování se provádí za pomoci implementace rozhraní ICloneable, které nám implementuje jednu metodu - Clone(), která je bezparametrická a vrací nám obecný objekt (nejedná se tedy o generické rozhraní). Metoda je typu public a může být volána jen v rámci třídy nebo z modulu, který danou třídu obsahuje.

Možností implementace metody Clone() je více. My si zde ukážeme dva způsoby.

První způsob využívá systémového klonování, které je přebrané ze třídy Object, neboť každý objekt je děděn od této třídy - můžeme toho tedy šikovně využít a použít již hotovou dobrou implementaci.

class Prototype : ICloneable
{
    // Název objektu
    private String _nazev;

    // Veřejný kontruktor pro vytvoření třídy
    public Prototype(String nazev)
    {
        // Nastavení stavu
        this._nazev = nazev;
    }

    // Getter a setter
    public String Nazev
    {
        get { return _nazev; }
        set { _nazev = value; }
    }

    // Rozhraní ICloneable
    #region ICloneable Members

    // Klonovací metoda Clone()
    public object Clone()
    {
        // Vytvoření objektu 
        Object c = null;
            
        // Test implementace metody
        try
        {
            // Vytvoření kopie pomocí děděné metody
            c = base.MemberwiseClone();
        }
        catch (NotImplementedException e)
        {
            // Pokud není implementována metoda Clone - vyjímka
            Console.WriteLine(e.Message);
        }

        // Návrat kopie
        return c;
    }

    #endregion
}

Dalším způsobem je vytvoření nové instance za pomoci privátního kontruktoru, který je přizpůsobený požadavkům klonování. Této možnosti je dobré využít tehdy, chceme-li mít klonování více pod kontrolou nebo pokud chceme s klonovaným objektem ještě něco provést.

// Rozhraní ICloneable
#region ICloneable Members

// Privátní kontruktor pro vytvoření kopie
private Prototype(Prototype o)
{
    // Kopie stavů objektu
    this._nazev = o.Nazev;
}

// Klonovací metoda Clone()
public object Clone()
{
    // Vytvoření nové instance (kopie)
    return new Prototype(this);
}

#endregion

Návrhový vzor jedináček (Singleton)

Sun, 25 Jul 2010 01:20:34 GMT

Pokud chceme psát pěkné aplikace, tedy z pohledu kódu, je dobré dodržovat jakési standardy. V dnešní době celkem hýbe světem pojem OOP, neboli objektově orientované programování. Do tohoto odvětví spadá spousty různých praktik a pravidel, které zlepšují čitelnost kódu a zvyšují větší abstrakci aplikace. Mimo jiné sem patří takzvané „návrhové vzory“ (ang. design patterns). Jedná se o jakési obecné řešení problému. Nejedná se o žádné hotové útržky kódů či hotové knihovny, které by se přímo vložili do naší aplikace. Jedná se jakousi architekturu, nebo spíše lépe řečeno – popis řešení problému nebo šablonu. Není zde žádná konkrétní implementace, proto můžou být návrhové vzory použity v libovolných situacích.

Mezi nejznámější a asi nejpoužívanější (možná pro svou jednoduchost) patří návrhový vzor Jedináček (angl. Singleton). Jedná se o návrhový vzor spadající do kategorie Creational patterns, tedy vzory týkající se tvorby objektů.

Návrhový vzor Jedináček je typický tím, že instance nějaké třídy může být v celém programu právě a jen jednou. Této výhody, že v celé aplikaci funguje pouze 1 objekt dané třídy se může velmi dobře využít, například při získávání informací mezi objekty. Typickým příkladem dobré implementace Jedináčka je schránka ve Windows, kde se data mohou přesouvat mezi aplikacemi, přičemž schránka může existovat jen jedna.

Pojďme se podívat na implementaci Jedináčka v jazyce C#.NET. Předvedeme si tři způsoby, kde každý způsob je něčím speciální.

Singleton

První implementace je typická tím, že se inicializace statického objektu vně třídy provádí až při prvním volání této instance.

class Singleton
{
    // statický objekt
    private static Singleton instance;

    // privátní konstruktor
    // nelze z venku zavolat vytvoření objektu
    // to nám zaručí jedinečnost instance v programu
    private Singleton() { }

    // metoda, která nám vrátí instanci třídy
    public static Singleton Instance
    {
        get
        {
            // kontrola, zda instance byla již vytvořena
            if (instance == default(Singleton))
            {
                // pokud instance není, vytvoří se
                instance = new Singleton();
            }
            // vrátí instanci
            return instance;
        }
    }

}

Statická inicializace

V prvním příkladu se instance vytvoří až při prvním volání. Pokud ale chceme vytvořit instanci již při startu aplikace – musíme kód lehce pozměnit tak, aby byla statická inicializace objektu. Zde se o vše postará o CLR. Kromě toho je proměnná označena klíčovým slovíčkem Readonly, to nám zaručuje, že je určena pouze ke čtení a lze jí přiřadit pouze při statické inicializaci nebo v kontruktoru. Nevýhodou zde možná je jen to, že nad vytvářením nemáme takovou kontrolu. Tato implementace je doporučována při vytváření implementace Jedináčka.

class Singleton
{
    // vytvoření statické instance
    private static readonly Singleton instance = new Singleton();

    private Singleton() { }

    // metoda vracející instanci třídy
    public static Singleton Instance
    {
        get
        {
            // nyní se již nemusíme ptát, zda instance již byla vytvořena
            // je zde statická inicializace
            return instance;
        }
    }

}

Vícevláknový přístup

Pokud se podíváme na předchozí implementace Singletona a budeme jej chtít nasadit ve vícevláknové aplikaci – může nastat problém. Podívejme se na první implementaci. Pakliže zavolá vytváření instance Jedináčka jedno vlákno, které po chvilce přepne (aniž by dokončilo svůj proces) na vlákno druhé, které také požádá o instanci jedináčka. Mohou vzniknout dvojčata a to je již proti pravidlům tohoto návrhového vzoru a také je to pro nás nežádoucí. Jak se tomuto problému tedy vyhnout? Musíme zde navrhnout nějakou synchronizaci - nabízí se zde řešiní pomocí komplexní synchronizace tovární třídy, nicméně můžeme využít moderních nástrojů, které synchronizaci vyřeší za nás – tedy použití klíčového slůvka volatile. Značně nám to ušetří práci.

class Singleton
{
    // tentokrát dopňíme klíčové slůvko volatile
    // volatile nám zaručí synchronizaci
    private static volatile Singleton instance;

    // připravení zámku
    private static object zamek = new Object();

    // opět privátní konstruktor
    private Singleton() { }

    public static Singleton Instace
    {
        get
        {
            // kontrola vytvoření instance
            if (instance == null)
            {
                // použití zámku, aby ke bloku kódu přistupovalo
                // pouze jedno vlákno
                lock (zamek)
                {
                    // opětovná kontrola instance
                    if (instance == null)
                        instance = new Singleton();
                }
            }

            // návrat instance
            return instance;
        }
    }
}
}

Vytváření hashů SHA-1 a MD5 v jazyce C#.NET

Wed, 21 Jul 2010 18:51:16 GMT

Pokud vytváříte aplikace, ve které chcete některá data hashovat (zpravidla přihlašovací údaje uživatelů). Musíte sáhnout po některém šifrovacím algoritmu nebo si vytvořit šifrovací algoritmus vlastní.

Zaměřme se například na zmiňované uživatelské údaje a výhody použití hashů na tyto informace. Pokud máte internetovou aplikaci, kde hesla ukládáte do databáze přímo – máte nebezpečnou aplikaci. Kdyby přišel nějaký zákeřný útočník a například pomocí techniky SQL-Injection by napadl vaši databázi a získal tato data. Mohl by ovládnout všechny uživatelské účty. Tento černý scénář je hrůzou každého tvůrce internetových aplikací. Lze mu ale předejít, resp. útočníkovi velmi znepříjemnit práci pomoci hashování hesel. Při přihlašování se pak porovnávají zmiňované hashe a nikdo skutečná hesla nezná.

V dnešní době se nejvíce používá šifrovací algoritmus SHA-1 a starší MD5. Na tyto dva algoritmy se podíváme.

SHA-1 (Secure Hash Algorithm -1)

Jedná o algoritmus z kolekce Secure Hash Algorithm (odtud název SHA). Vytváří se 160 bitový obraz s maximální délkou 2^64 - 1 bitů. Tento algoritmus je založený na poznatcích z algoritmů MD4 a MD5. Algoritmus byl sice již prolomen, nicméně na prolomení hashe potřebujete takový stroj, který by se popral se složitostí 2^64. Tato výpočtová náročnost algoritmu na prolomení je ale mimo současnou techniku, takže se není třeba bát. Nástupce SHA-2 není zatím moc zastoupen, pravděpodobně za to může slabší podpora na operačních systémech.

MD5 (Message-Digest algorithm 5)

Algoritmus MD5 je dnes asi nejrozšířenější šifrovacím algoritmem, i když byl již prolomen a složitost prolomení je znatelně menší než u SHA-1 – jedná se zde o složitost výpočtu 2^33.

Vytváří se zde otisk fixní délky (128 bitů) a velkou výhodou MD5 je, že malá změna na vstupu provede velkou změnu na výstupu. Algoritmu vdechl život Ronald Rivest v roce 1991. V moderních bezpečnost aplikací se od tohoto algoritmu opouští a bývá nahrazen některým algoritmem z kolekce SHA.

Velké zvýšení bezpečnosti lze dosáhnout pomocí kombinace obou algoritmů.

SHA1(MD5("login").MD5("heslo"))

Pokud budeme chtít šifrovací algoritmy použít, nemusí se již zabývat jejich implementací, jelikož jsou už oba skvěle naprogramované a jsou i součástí .NET Frameworku, konkrétně ve jmenném prostoru System.Security.Cryptography – proto je důležitý tento prostor do aplikace přidat, pokud nechceme používat tečkovou notaci pro kompletní zápis objektů.
V následujícím kódu je ukázka vytvoření šifry SHA-1 a MD5 v jazyce C#.NET.

class SifrovaciProgram
{
    static void Main(string[] args)
    {
        // načteme řětězec, který chceme hashovat
        Console.Write("Zadej text: ");
        string text = Console.ReadLine();

        // připravíme si encoder
        ASCIIEncoding encoder = new ASCIIEncoding();
            
        // vstupni text prevedeme pomoci encoderu na pole bytů
        byte[] c = encoder.GetBytes(text);
            
        // vytvoření hashe SHA-1
        SHA1 sha1 = SHA1.Create();

        // metoda ComputeHash vratí pole bytů
        // toto pole pomocí statické třídy Convert převedeme na řetězec
        string hashSHA1 = Convert.ToBase64String(sha1.ComputeHash(c));

        // vytvoření hashe MD5
        MD5 md5 = MD5.Create();
             
        // stejně jako u SHA-1 převedeme na byte[]
        string hashMD5 = Convert.ToBase64String(md5.ComputeHash(c));

        // vypís jednotlivých hashů
        Console.WriteLine("\nSHA-1:\t" + hashSHA1);
        Console.WriteLine("MD5:\t" + hashMD5);
            
        // konec
        Console.ReadKey();
    }
}

Čeština pro Visual Studio 2010 Professional

Fri, 09 Jul 2010 13:49:29 GMT

Byl uvolněn český jazykový balíček pro Visual Studio 2010. Tuto jazykovou sadu lze nainstalovat do VS2010, ovšem do verze Professional, popř. vyšší. Do edice express zatím není možné tuto sadu nainstalovat, pravděpodobně je to dáno tím, že express edice nepodporuje zásuvné moduly.
Pokud si češtinu nainstalujete, nemusíte se bát, že přijdete o anglickou lokalizaci – je možno mezi oběma jazyky velmi snadno přepínat, bez nutnosti restartovat celý program.

Přepínání jazyků:
Tools (Nástroje) -> Options (Možnosti) -> Environment (Prostředí) -> International Settings (Mezinárodní nastavení) -> nabídka Language (Jazyk)

Stahovat češtinu, popřípadě získat více informací, můžete na tomto linku.

C#.NET 4.0 datový typ Dynamic - nové klíčové slovo

Thu, 08 Jul 2010 18:53:06 GMT

Jednou z novinek C#.Net 4.0 je klíčové slovo Dynamic. Jedná se o statický typ, jehož vlastnosti a obecně implementace tohoto objektu v naší aplikaci je zkoumána až za chodu programu. Použijeme-li tedy například neexistující metody – kompilátor vše překousne a výjimka nastane až v samotném chodu aplikace. Datový typ je automaticky odvozen.

Jakýkoliv objekt může být převeden na dynamický typ implicitně.

static void Main(string[] args) {
        dynamic d1 = 7;
        dynamic d2 = "string";
        dynamic d3 = System.DateTime.Today;
        dynamic d4 = System.Diagnostics.Process.GetProcesses();

        int i = d1;
        string str = d2;
        DateTime dt = d3;
        System.Diagnostics.Process[] procs = d4;
}

Chování nového datového typu je obdobné, jako u objektu typu Object. Nicméně dynamic není kontrolován kompilátorem, což přináší řadu výhod i nevýhod. Pro porovnání těchto objektů se podívejme na následující příklad.

static void Main(string[] args) {
        dynamic dyn = 1;
        object obj = 1;

        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
}

Výpis by měl být v obou případech stajný - System.Int32. Pokud ale přidáme následující dva řádky, program již nespustíme. Zde zareaguje kompilátor – nelze „spojit“ object a integer. Všimněte si ale, že u dynamického typu žádné problémy nemá a pokud druhý řádek zakomentujeme - chyba nenastane a program se spustí.

        dyn = dyn + 3;
        obj = obj + 3; //toto kompilátor již nevezme

Podívejme se, jak lze vytvářet instanci od třídy, kde zvolíme při instanci datový typ dynamic. Vytvořme si pro tento příklad jednoduchou třídu Pocitadlo, která umí pouze inkrementaci a dekrementaci čísla, které v sobě uchovává.

    class Program {
        static void Main(string[] args) {
            //deklarace dynamického typu
            dynamic c = new Pocitadlo();

            for (int i = 0; i < 10; i++) {
                 c.increment();
            }
            c.decrement();

            // c.cislo = 10; - zde by za chodu programu nastala chyby
            // setter je privátní
           

            //vypíše hodnotu 9
            Console.WriteLine("Hodnota počítadla: " + c.cislo);
        }
    }

    class Pocitadlo {
        public int cislo { get; private set; }

        public Pocitadlo() 
        {
            cislo = 0;
        }

        public void increment() { cislo++; }

        public void decrement() { cislo--; }
    }

Jak je vidět z ukázky kódu - nad tímto typem můžeme dělat všechny klasické operace – volání metod, přístup k prvkům i vlastnostem a další. Pokud budete kód psát, možná si povšimnete, že nefunguje IntelliSense. To je dobře, neboť Visual Studio neví, o jaký datový typ se jedná – vše se dozví až za běhu programu a přetypování provede implicitně za běhu programu.

Co jsem se dočetl, tak tento datový typ je směřován především pro zjednodušení přístupu k COM API, jako je Office Automation API, IronPython knihovny nebo HTML Document Object Model.

Největší nevýhodu vidím v nepřítomnosti extensit metod. Uvidíme, jak se tento typ vyvine v dalších verzích jazyka.

Generický vzor Singleton

Dat, 03 Jul 2010 11:28:03 GMT

Byl mi položen dotaz, zda lze vytvořit takový model vzoru Singleton, který půjde použít i jinde, resp. pro jiný typ. Singleton je ale takový vzor, který může mít právě jednu instanci pro celý program – obecně by měl figurovat pouze jednou. Jak tady udělat nějaký znovupoužitelný Singleton v jednom programu? Na tuto otázku si lze odpověď celkem jednoduše – použijeme generické typy jazyka C#.NET.

class Singleton where T : new()
{
    private Singleton() { }

    static class vytvoreniJedinacka
    {
        internal static readonly T instance = new T();
    }

    public static T Instance
    {
        get
        {
            return vytvoreniJedinacka.instance;
        }
    }
}

Na ověření, zda všechno funguje tak jak má, je zde přirpravena krátká testovací metoda. Zkusíme udělat více instancí a pak dva stejné typy porovnat. Pokud se budou rovnat - můžeme říct, že to šlape dobře.

class Program
{
    class Osoba { }

    static void Main(string[] args)
    {
        Double d1 = Singleton<Double>.Instance;
        Int16 i = Singleton<Int16>.Instance;
        Double d2 = Singleton<Double>.Instance;
        Osoba o = Singleton<Osoba>.Instance;

        if (d1 == d2)
        {
            Console.WriteLine("Jsou to stejné instance");
        }

        Console.ReadKey();

    }
}

Z výsledku vidíme, že lze vytvořit i generický Singleton, který umí vytvářet unikátní instanci vždy pro zadaný typ.

Dva nové přírůstky do knihovny - Mistrovství ve Windows Presentation Foundation a Microsoft LINQ

Mon, 28 Jun 2010 15:29:42 GMT

Nedávno byla na internetovém knihkupectví Computer Press akce na knihy, s tématikou programování. Některé tituly dostali slevu až ve výši 50%, a to je u některých dražších kousků na ceně velmi znát. Proto jsem neváhal a hned dvě knihy, na které jsem měl již delší dobu spadeno, objednal.

Jedná se o tituly Mistrovství ve Windows Presentation Foundation a Microsoft LINQ. Knihy mají pevnou vazbu a nejedná se o žádné slabé kousky.

Mistrovství ve Windows Presentation Foundation

Už jen myšlenka, že kniha spadá do edice „Mistrovství“, představuje knihu, která vás uvede do kompletní problematiky WPF (Windows Presentation Foundation).

Kniha je rozdělena do dvou základní části, jak již napovídá obálka – kód a markup. V první části knihy se autor věnuje kódu jazyka C#.NET. Představí většinu komponent, vysvětlí použití a vše demonstruje na spousty praktických příkladech. V druhé části knihy, zhruba v polovině, se autor věnuje části markup, tedy jazyku XAML. V obou částech je vše pěkně vysvětlené a díky doprovodu spousty zdrojových kódu a předvedené. Každá část této knihy je dále rozdělena na několik tematických kapitol. Celkově na mě kniha působí zatím kladně a především hodně detailně obsáhle, nicméně jeden zápor by tu byl. Chybí mi, především v markup části, screeny aplikací, které autor vytváří. Přeci jen je WPF určeno na tvorbu grafických aplikací a proto mi absence ukázky hotových výtvorů trochu chybí.

Microsoft LINQ - Kompletní průvodce programátora

Tato knihy spadá do edice „Kompletní průvodce“. Je o něco málo slabší, nežli předchozí titul. Knihu napsali dva autoři – Paolo Pialorsi a Marco Russo. Kniha je velmi dobře čtivá a vše je dobře vysvětleno. LINQ je zde brán od samotného začátku, takže začátečníci s LINQ nebudou mít problém (i já s touto technologií začínám). Kód je zde prakticky předváděn v jazyce C#.NET a Visual Basic. Je to postavené na .NET Frameworku 3.5 – na konci knihy jsou popsaný novinky v .NET 3.5, které se nějak dotýkají právě technologie LINQ, jak pro jazyk C# tak VB. Kniha je zde rozdělena do šesti částí: Základy LINQ, LINQ pro relační data, LINQ pro XML, Pokročilé LINQ, LINQ v praxi a poslední kapitola jsou zmiňované Přílohy.

Můj verdikt pro tuto knihu je opět kladný. Je velmi dobře napsané a čtivá, což každá kniha není. Začátečníkům programátorům bych až zas tak tolik nedoporučoval, neboť se zde předpokládá alespoň základní znalost programování v .NET. Doporučil bych ji jinak každému vývojáři .NET aplikací.

Třídící algoritmus Merge Sort

Sun, 20 Jun 2010 13:50:34 GMT

Jako u algoritmu QuickSort se jedná algoritmus pracující se strategií „rozděl a panuj“, ovšem Merge Sort je postaven na odlišném principu. Logaritmická složitost algoritmu, by mohla napovídat o jeho velké rychlosti, ovšem oproti QuickSortu nebo HeapSortu je pomalejší. Nevýhodou může být potřeba dalšího pole o N prvků, které Merge Sort potřebuje. Tato nevýhoda lze obejít, nicméně se velmi zkomplikuje implementace a kvůli vysoké režii se algoritmus zpomalí.

Tento algoritmus spadá do kategorie „třídění spojováním“, někdy je proto Merge Sort nazýván jako algoritmus slévání.

Merge Sort je implicitním vyhledávacím algoritmem v mnoha implementacích programovacích jazyků – například JAVA, Perl, Python a GNU C Library. Častá implementace je dána tím, že se jedná o velmi stabilní algoritmus, který se lépe paralelizuje a má vyšší výkon na sekvenčních médiích s nižší přístupovou dobou.

Algoritmus Merge Sort vytvořil maďarský matematik John von Neumann, který mimo jiné vymyslel základní koncepci počítače, která je používána do dnes.

Princip algoritmu

Rozdělíme pole na dvě zhruba stejné částí (vzniknout nám dva problémy)
Jednotlivé podmnožiny seřadíme (vyřešíme problémy)
- Pokud je problému mnoho – vyřešíme je rekurzí (volání bodu 1)
- Vyřešíme přímo – dimenze podproblémů je malá
Postupně jednotlivé podmnožiny (podproblémy) spojíme (slijeme) do jedné výsledné množiny dat (původní problém)

Možná implementace algoritmu Merge Sort v jazyce C#.NET

class MergeSort
{
    public static void setrid<T>(T[] pole) where T : IComparable
    {
        mergeSort<T>(pole, 0, pole.Length - 1);
    }

    private static void mergeSort<T>(T[] pole, int start, int konec) where T : IComparable
    {
        int s = start;
        int k = konec;

        if (s >= k)
        {
            return;
        }

        int prostredek = (s + k) / 2;

        mergeSort(pole, s, prostredek);
        mergeSort(pole, prostredek + 1, k);

        int i = prostredek;
        int j = prostredek + 1;

        while ((start <= i) && (j <= k))
        {
            if (pole[s].CompareTo(pole[j]) < 0)
            {
                s++;
            }
            else
            {
                T Temp = pole[j];
                for (int p = j - 1;p >= s; p--)
                {
                    pole[p + 1] = pole[p];
                }
                pole[s] = Temp;
                s++;
                i++;
                j++;
            }
        }
    }
}