Programming C#

• A simple Windows Forms project
• Building own user controls
• Anonymous methods with lambda expressions
• What is a delegate?
• Anonymous objects
• Extension methods
• Example of extension methods: LINQ

• Let's create a simple calculator!
• What is needed?
• How should the buttons work?
• Using the designer for creating events
• Understanding partial classes
• Advanced topic: Separation of concerns

• All common Windows controls exist
• Some new ones have been integrated as well
• ComboBox, TextBox, Label, Button
• Or with children: TabControl, Panel, GroupBox
• Specialized input: NumericUpDown, DateTimePicker
• Each control has a big range of (mostly useful) properties

• Most basic starting point: Inherit from Component
• Far better: Derive from Control
• Option with designer: UserControl
• Or pick one like ScrollableControl
• In most cases we have to do the drawing
• Drawing is done over GDI+, more about it later

• An anonymous method is one that has no name
• In C# there is an easy way of creating those, using =>
• This is the so called fat arrow operator
• Example: (x, y) => x * x + y
• Or: x => { return x > 0 ? 1 : (x < 0 ? -1 : 0); }
• Omit round brackets is possible if just 1 argument
• Curly brackets (and return) can be omitted if single statement

• How to use anonymous methods if they have no name?
• A pointer to the function is required
• delegate [RET] [NAME]([ARGUMENTS]) solves this problem
• This is like a managed function pointer
• There are already some generic delegates like Func<TReturn>
• Use: Func<double, double> squ = x => x * x;
• They can be used like functions, e.g. squ(2)

• C# lets us also create anonymous objects
• Here the type is unknown, it will be compiler generated
• new { Name = "Florian", Age = 28 } creates such an object
• Usage: (temporary) data-encapsulation
• Advantage: No need to write a whole class for it
• Disadvantage: Access to members only in local method
• Passing such an object is only possible as object

• Problem: What's the type of the anonymous object?
• We do not know, it is compiler generated...
• Therefore can only use object, unless ...
• ... the compiler can detect the type! Keyword: var
• Simple: var i = 4 will infer Int32
• Or something more complicated: var pi = 3.14f (Single)
• Our case: var a = new { Name = "My name" } (who cares!)

• Scenario: We get a library with cool classes, but ...
• ... we see that a some useful methods are missing!
• Usual solution: Write your own (static) methods
• The first argument would always be an instance of the specific class
• So why not bring together what belongs together?
• Extension methods solve this problem with the this keyword
• Before we had to write something like MyClass.MyMethod(a)
• Now we can just write a.MyMethod() (shorter and more expressive)

namespace MyExtensionMethods
{
	static class ExtMethods {
		public static void Dump(this string s) {
			Console.WriteLine(s);
		}
	}
}
			

• A set of really useful extension methods
• The required namespace is System.Linq
• Every IEnumerable<T> has LINQ methods
• Purpose: Run queries of (large) datasets
• Advantage: Reduction of code
• Highly useful: lambda expressions, anonymous objects
• Sort some array e.g. double[] a? a.OrderBy(m => m)
• Get even elements of int[] a: a.Where(m => m % 2 == 0)

• foreach is more expensive than for
• There is some overhead associated with LINQ statements
• LINQ statements are deferred, i.e. only performed if requested
• If your dataset changes, the LINQ result will change as well
• IEnumerable<T> is in-memory query
• IQueryable<T> is for remote-data
• Important difference that does not matter for us (no remote data)