Category Archives: .NET Core

Azure Static Web Apps [Lukáš Rada, Vzdělávací okénko, 22.7.2020]

Záznam ze Vzdělávacího okénka HAVIT, kde Lukáš Rada mluvil o Azure Static Web Apps (aktuálně v Preview), které nabízejí možnost snadno hostovat statický frontend ve spojení s Azure Functions pro API (backend).

Moq – základní seznámení [Jiří Kanda, Vzdělávací okénko, 17.6.2020]

Záznam ze Vzdělávacího okénka HAVIT ze 17. června 2020, kde Jiří Kanda mluvil o Moq, mockovacím frameworku pro tvorbu unit-testů.

Nahrávka je publikována na našem HAVIT YouTube Channelu.

C# 9.0 Candidates + .NET 5 – záznam, slides a dema [TechEd Praha 2019]

Záznam z přednášky pro konferenci TechEd DevCon Praha ze 5. května 2020. Konference letos probíhala on-line.

Array, List, Dictionary – jaký je v tom rozdíl? (Level 100)

Dotaz studenta:

Na learnCS.org jsem narazil na tři skoro stejné kapitoly: arrays, lists, dictionaries. Nevidím v nich prakticky žádný rozdíl. Mám se učit všechny tři, nebo stačí pole(arrays)?

Moje odpověď (Level 100):

  • Array (pole) je primitivní datová struktura, která je prazákladem všeho. Je to prostě souvislý kus paměti předem určené velikosti (počet prvků se určuje při zakládání pole), do kterého se dají uložit jednotlivé prvky stejného typu, a to každý zásadně na konkrétní pozici určenou indexem (např pole[3] = hodnota). Pole je základ všeho, většina složitějších množinových datových struktur interně pole používá.
  • List (seznam) je datová struktura vyšší úrovně, která je určená pro ukládání libovolného počtu prvků stejného typu. Na rozdíl od čistého pole:
    • není nutné určovat předem velikost, List se sám přizpůsobuje podle počtu prvků v něm uložených,
    • není nutné pracovat jen s pozicemi (indexy) prvků, ale je možné použít připravené pomocné metody
      • Add(prvek) – přidá prvek na konec seznamu
      • Remove(prvek) – odebere prvek ze seznamu
      • Insert(pozice, prvek) – přidá prvek na konkrétní pozici
      • Contains(prvek) – ověří, zdali určitý prvek v Listu existuje
      • Find(predikát) – vyhledá prvek
      • je tam spousta dalších metod, které ti práci usnadní
    • Interně List používá Array, jenom tě odstíní od nutnosti řešit detaily. Na začátku si sám vytvoří pole určité základní velikosti, které když se zaplní, tak vytvoří nové pole dvojnásobné velikosti, prvky do něj přesune a původní pole uvolní. Naopak Remove() umí přesouvat do menšího pole, Insert/Remove se stará o posouvání prvků v podkladovém poli, Contains/Find umí pole sekvenčně projít, atp.
    • List je prostě pohodlnější pro běžnou práci, pokud se nechceš zaobírat detaily pole a nepotřebuje optimalizovat výkon na krev.
    • Pro snadné použití List podporuje i podobnou syntaxi jako array, tj. přístup přes indexer, např. list[3] = hodnota.
  • Dictionary (slovník) je datová struktura vyšší úrovně, kde hlavním rozdílem je uložení prvků pod klíčem.
      • Klíč se pak používá v podstatě místo indexu jako způsob přístupu na prvky (dict[klíč] = hodnota). Cokoliv do Dictionary dávám, musí mít určený klíč – do slovníku se ve skutečnosti ukládají dvojice klíč-hodnota.
      • Interně je to uspořádáno do hashovací tabulky (podrobnosti někdy později), díky čemuž je přístup prostřednictvím klíče extrémně rychlý.
      • Slovník má podobné metody jako List, jen se tam pracuje s tou dvojící klíč-hodnota:
        • Add(klíč, hodnota) – přidá do slovníku
        • Remove(klíč) – odebere ze slovníku (hodnotu nepotřebuji znát)
        • Contains(klíč)
        • atd.
      • Slovník se používá všude tam, kde si potřebuješ uspořádat data v pojetí klíč-hodnota, např. pokud chceš spočítat četnost něčeho ve velké vstupní sadě, potom si jako klíč použiješ identifikátor a jako hodnotu ten aktuální počet. Když ti budou přicházet slova a ty je máš spočítat v celé knížce, tak třeba pro každé slovo děláš dict[slovo] = dict[slovo] + 1. Hodnota samozřejmě nemusí být jen číslo, ale i něco složitějšího (v podstatě jakýkoliv typ).
      • I slovník podporuje podobnou syntaxi jako pole/seznam, tj. přístup přes indexer, jen se tam používá klíč, např. dict[klíč] =hodnota

     

C# Code Analysers [Ondřej Václavek, HAVIT Vzdělávací okénko, 21.11.2019]

Záznam ze Vzdělávacího okénka HAVIT z 21. listopadu 2019, kdy nám Ondřej Václavek povídal o tvorbě vlastních C# Code Analyserů.

Nahrávka je publikována na našem HAVIT YouTube Channelu.

Nullable Reference Types [Jiří Kanda, HAVIT Vzdělávací okénko, 24.10.2019]

Záznam ze Vzdělávacího okénka HAVIT z 24. října 2019, kde Jiří Kanda povídal o nullable reference types v C# 8.0 a jejich využitelnosti na našich projektech.

Nahrávka je publikována na našem HAVIT YouTube Channelu.

C# – Přehled konstrukcí pro začátečníky 1

Základní struktura (konzolové) aplikace

using System;

namespace ConsoleApp
{
	class Program
	{
		static void Main(string[] args)				// metoda, která se spustí po startu aplikace
		{
			Console.WriteLine("Hello World!");		// výpis textu na obrazovku 
		}
	}
}

Práce s konzolí – vstup, výstup

Console.Write("Blah, blah.");				// výpis textu bez odřádkování
Console.WriteLine("Hello World!");			// výpis textu s odřádkováním
string s1 = Console.ReadLine();				// přečtení řádku do proměnné s1
Console.WriteLine($"Ahoj {s1}, vítám tě!");	// skládání textu s proměnnými pomocí $

Proměnné, datové typy a jejich konverze

string text = "Můj text";       // text
char c = 'a';                   // znak
int i = 10;                     // celé číslo (Int32)
decimal d = 10.20m;             // desetinné číslo
double dbl = 3.14159;           // číslo s plovoucí desetinnou čárkou
bool b = true;                  // logická hodnota - pravda / nepravda
var x = 10;                     // zkrácený zápis, typ proměnné je automaticky odvozen
int i2 = Convert.ToInt32(text); // Convert zařídí konverzi mezi základními typy 

Aritmetické operace, matematika

i = 1 + 10;
i = 10 - 1;
i = 10 / 2;		// dělení
i = 10 * 20;    // násobení
i = 11 % 7;     // zbytek po celočíselném dělení (= 4)
i++;            // přičte jedničku
i--;            // odečte jedničku

// Math = matematické funkce
i = Math.Abs(-10);      // absolutní hodnota (10)
d = Math.Round(1.25);   // zaokrouhlední (1)
d = Math.Pow(2, 4);     // mocnina (16)
i = Math.Min(1, 5);		// minumum (Max je maximum)

Podmínka, přepínač

if (i == 10)
{
	// podmínka splněna
}
else
{
	// podmínka nesplněna
}

switch (i)
{
	case 1:
		// i je 1
		break;
	case 2:
	case 3:
		// i je 2´nebo 3
		break;
	default:
		// v ostatních případech
		break;
}

Porovnávání, logické operace do podmínek

if (a == b)						// rovnají se
if (a != b)						// nerovnají se
if (a < b)						// menší než
if (a <= b)                     // menší nebo rovno

if ((a == 1) && (b == 2))		// a zároveň (AND)
if ((a == 1) || (b == 2))		// nebo (OR)
if (!(a == 1))					// negace (NOT)

Cykly

for (int i = 0; i < 10; i++)
{
	// opakuj 10x
}

while (i < 10)
{
	// opakuj, dokud je podmínka splněna
}

do
{
	// opakuj  (alespoň jednou), dokud je podmínka splněna
}
while (i < 10);

Vytvoření vlastní metody

static void Main(string[] args)
{
	int vysledek = Spocti(10, 15);	// vysledek bude 40
}

static int Spocti(int a, int b)     // void, pokud žádný výsledek nevracíme
{
	int c = a + 2 * b;
	return c;
}

[ASP].NET [Core] Performance Tuning – záznam, slides, dema [WUG Days Brno, 14.9.2019]

Záznam z mé přednášky pro konferenci WUG Days Brno ze 14. září 2019, kde jsem ukazoval pár performance tipů z praxe:

  • String Concatenation
  • StringBuilder Capacity Preinitialization
  • Collection Capacity Preinitialization
  • Substring as Span
  • String Concat Consolidation
  • Search In Collection
  • Dictionary Pickup Redundant Checks
  • Dictionary Remove Redundant Checks
  • Collection Empty Check
  • Redundant Casting
  • Boxing Unboxing
  • Caching
  • Finalization
  • Exception Handling (Try Catch)
  • Reflection
  • Reflection – Layout Trick

Slides a dema:

Nahrávka je publikována na našem HAVIT YouTube Channelu.

C# 8.0 Novinky a C# 9.0 Candidates [WUG Days Brno, 15.9.2019]

Před pár hodinami byl vydán finální release .NET Core 3.0 a C# 8.0. Přináším Vám začerstva záznam z mé přednášky pro konferenci WUG Days Brno z 15. září 2019, kde jsem ukazoval chystané novinky v C# 8.0:

  • Index, Range
  • Switch Expressions
  • Pattern Matching
  • Static Local Function
  • Using Declarations
  • Nullable Reference Types
  • Async Streams, Async Dispose
  • (Target Typed New)
  • Default Interface Methods
  • Null Coallescing Operator
  • Readonly Struct Members
  • Disposable ref Structs
  • Interpolated Verbatim Strings
  • Unmanaged Constructed Types

…a plány na C# 9.0:

  • Primary Constructors, Records
  • pattern-based with expressions
  • Top level statements and member declarations
  • Covariant return types
  • Nullable-Enhanced Common Type
  • Target typed null coalescing (??) expression
  • and, or, and not patterns
  • Switch expression as a statement expression
  • Comparison operators in switch cases
  • Native-Sized Number Types
  • Extension everything

Slides a dema:

Nahrávka je publikována na našem HAVIT YouTube Channelu.