V programu se občas může objevit kód, který je volán pouze prostřednictvím delegáta. Následný kód se umísťuje do pojmenovaných metod jako součást tříd nebo struktur, což se jeví jako zbytečné. Výhodnější je využít tzv. anonymních metod, které představují elegantnější řešení.

Anonymní metody umožňují psát kód delegátů přímo "in-line" . Využít je lze v místech kódu, kde jsou očekáváni delegáti, případně delegáti s argumenty. Vytváří se klíčovým slovem delegate . Připomínají lambda funkce, které známe z jazyků Python a Lisp. Lisp je jazyk pro funkcionální programování s výrazně regulární syntaxí. Syntaxe jazyka Lisp je nazývána prefixová, neboť operátor se nachází na začátku výrazu a až po něm následují operandy. Anonymní metody jsou založeny na implicitní konverzi na typ delegate. Kde překladač vyžaduje kompatibilní seznam parametrů a návratovou hodnotu.

Dvě hlavní vlastnosti anonymních metod:

Seznam parametrů delegáta je kompatibilní s anonymní metodou pokud:

Návratový typ delegáta je kompatibilní s anonymní metodou pokud platí alespoň jedno z těchto tvrzení:

Návratový typ a seznam parametrů delegáta musí být kompatibilní s anonymní metodou ještě předtím, než dojde k implicitní konverzi na delegátský typ delegáta.

Následující příklad využívá anonymních funkcí napsaných jako "in-line". Anonymní metody jsou zde vloženy jako parametry delegátského typu Function.

Nejprve deklarace delegáta vně příslušné třídy:

	delegate double Function(double x);

Dále si vytvoříme, již uvnitř vlastní třídy, statickou metodu Apply() s jedním parametrem pro pole čísel double a druhým parametrem bude náš vytvořený delegát. Tato metoda vrátí pole reálných čísel, jejichž přepočet je dán pozdějším předpisem anonymní funkce při volání metody.

	static double[] Apply(double[] a, Function f) { double[] result = new double[a.Length]; for (int i = 0; i < a.Length; i++) { result[i] = f(a[i]); } return result; }

Volání metody Apply() v metodě Main() by vypadalo následovně:

	double[] a = {0.0, 0.5, 1.0}; //fill the field double[] squares = Apply(a, delegate(double x) { return x * x; });

Jak můžete vidět, druhým parametrem v metodě Apply() je ukázka "in-line" psané anonymní metody, která je kompatibilní s delegátským typem Function. Tato anonymní metoda vrací mocninu jejího argumentu. Proto výsledek volání metody Apply() je typu double[] a obsahuje mocniny hodnot v poli a.

Vytvořením další metody MultiplyAllBy() můžeme rozšířit funkčnost stávajícího programu:

	static double[] MultiplyAllBy(double[] a, double factor) { return Apply(a, delegate(double x) { return x * factor; }); }

Metoda MultiplyAllBy() vrací také pole čísel typu double[], kde je každá z hodnot v poli daná argumentem factor. Tato metoda k výpočtu využívá volání předchozí anonymní metody Apply(). V metodě Apply() anonymní metoda násobí argumenty x hodnotou argumentu factor. Volání funkce MultipleAllBy(), která přenásobí prvky hodnotou 2 typu double by vypadalo takto:

	double[] a = {0.0, 0.5, 1.0}; //naplnění pole double[] doubles = MultiplyAllBy(a, 2.0);

V předchozí sekci jsme si říkali, že anonymní metoda může být implicitně přetypována na kompatibilní delegátský typ. C# 2.0 dovoluje stejný způsob konverze i pro skupinu metod. Dovoluje totiž explicitním konkretizacím delegátů, aby byly ve všech případech vynechány. Využitím předešlé metody Apply()

	static double[] Apply(double[] a, Function f) { double[] result = new double[a.Length]; for (int i = 0; i < a.Length; i++) { result[i] = f(a[i]); } return result; }

mohou být tyto výrazy

	addButton.Click += new EventHandler(AddClick); Apply(a, new Function(Math.Sin));

zapsány následovně s vynecháním zápisu instance události a delegáta

	addButton.Click += AddClick; Apply(a, Math.Sin);

Při využití druhé kratší formy příkazu překladač sám odvodí konkretní delegátský typ. Efekt je samozřejmě u obou forem zápisu stejný. Jedná se o novou vlastnost, která je využívána i dalšího rysu jazyka C# 2.0, a to u dedukce delegátů .