AVG 24th 2015 ADVANCED c# - part 1

Advanced C# & tips and tricks Delegates Events Extensions Memory management

Tips and tricks Parameter labels: Use parameter labels to additionally explain a function call Useful when we have large number of primitive parameters, especially Booleans Used when we want to define just one parameter but it’s in the middle of the list of default parameters

Tips and tricks Parameters with default value: Gives support for optional parameters Useful when we need to extend existing support without large changes

Tips and tricks Usage of enumerations as an alternative for Boolean parameters: Brings more information (clarity) Easier to extend

Tips and tricks Const variables vs static readonly, pros and cons? Const variables are directly ‘burned’ into the code Used primarily for primitive types Allows value to be defined only during declaration time Static – readonly are defined/assigned during the runtime Used primarily for reference types Allows value to be defined during declaration and inside constructor There is no special need to declare primitive constant as static readonly instead of as const. Yes, it’s possible later to supply just library (dll) with constant definition and entire solution will use A new value without rebuild. But in that case we have to rethink do we actually need a constant or Configuration parameter. So, const variables are something like macros and a bit faster than static readonly, but on other Side they require rebuilt of entire solution to utilize a new value.

Tips and tricks Proper usage of tuple class: Easy way to group / wrap multiple objects

Tips and tricks Avoid nesting of tuple classes or its usage with too many parameters !!

Tips and tricks Exception handling: Do not reset exception stack trace. Use throw; statement

Tips and tricks Exception handling: Do not mask exceptions !

Extensions Static methods which are used with instance syntax Extension class should be defined as a static Extension method requires parameter of class which is extended. This parameter should be marked with ‘this’ keyword. Can be used to extend system framework classes which are not owned

Extensions Useful to separate product or type specific functionality: Ex1: Choice between fast support or memory efficient Ex2: Choice between multiple supports for different productions Make sure that namespaces which contain product specific support are exclusive ! Same support can be implemented with Factory pattern which includes some configuration pulling !

Extensions Can be used to extend interface with implemented methods This way all classes which implement this interface are enriched automatically with those methods (LINQ support) Can be used to decouple dependency between base class and unwanted class or even assembly. Extension methods are used to unlock more advanced functionality of class (That way base API stays clean and simple for user). When interface type is extended in the case of very common methods, it’s recommended to put extensions in the same namespace as original type, that way that functionality is automatically unlocked when user includes base class In the project. We can give as many as we want implementation for the interface not just one. We can switch between them by including specific namespace. Do not exaggerate with usage of extension methods. Think carefully do you need them. In the case if base class is owned by the user maybe better way is to extend directly base class.

Delegates Delegate is a type that presents reference to a method Used to supply method as an argument to another method Used to define callback method Can be compared with C++ function pointers but they are type safe a delegate object encapsulates a method

Delegates We can associate instance of the delegate with any method containing compatible signature as delegate We can associate both, static or instance methods

Delegates We can instantiate / supply delegate on a few ways:

Delegates We can instantiate / supply delegate on a few ways:

Delegates We can instantiate / supply delegate on a few ways:

Delegates We have two generic predefined C# delegates: Action – for methods without return result Function – for methods with return result

Delegates Delegates with out parameters: Require types in anonymous function headers

Delegates Delegates can be combined together to form multicast delegate (operator + is used) Multicast delegate contains a list of delegates When multicast delegate is called, all delegates in the list are invoked in exact order Multicast delegates are base for C# events The – operator can be used to remove a component delegate from multicast delegate

Delegates Delegates are objects like any other (with special purpose), we can: Get list of component delegates Get method info info of a delegate Get class info of a delegate

Delegates But still, why use it ?!? This is trick question, both have its place where they are used. For simplest cases we will use delegates with anonymous functions, For more complicated we will still use delegates but which accept method target, And for the most complicated we will use template pattern in which code is decoupled into separated classes.

Delegates Why use it ?!?

Delegates So, why use it ?!? Callbacks Divide abstraction from concrete implementation Alternative to template function and strategy pattern Dependency injection Inversion of dependency Policy injection Events

Events Events provide a useful way for objects to signal state changes that may be useful to clients of the object Events rely entirely on delegates support Event property utilize a delegate definition Used quite often in modern dynamically extendable architectures (pluggable systems)

Events Before declaring event in class, declare appropriate delegate Event declaration follows:

Events Event invocation: Hooking up to an event:

Events .NET framework guidelines: Delegate type used for an event should take two parameters: source of the event and event info itself Second parameter should be either EventArgs class itself or derived from it Delegate name should indicate that it’s used as event handler / processor

Events There is predefined event handler in System namespace, use it for events that do not require any custom information.

Memory management Managed memory space divided into: LOH (objects > 85 kb) SOH Generation 0 Generation 1 Generation 2

Memory management Possible problems with memory: Memory fragmentation on the LOH -> OOME Memory leaks (unmanaged resources) -> OOME Performance issues

Memory management There are two types of garbage collector: Workstation garbage collector Server garbage collector

Memory management To enable server garbage collector: <configuration> <runtime> <gcServer enabled="true"/> </runtime> </configuration>

Memory management Good practice to prevent memory management issues: Inspect string manipulation parts of the code, make sure that it’s done in most efficient way Check whether some containers could be initialized with capacity flag: List<string> list = new List<string>(1200); All Disposable objects should be disposed at the end of usage. If application creates lots of temporary containers with large object check is it possible to reuse those containers or to change their scope from function scope to higher.

Memory management Good practice to prevent memory management issues: Check for unnecessary boxing and unboxing. If some object are reusable, try to introduce a cache or a pool of the objects. Use struct instead of the class for object definition in the case when object should be really small and composed of just a few primitive types. In the end, try to redesign your code to create less as possible of small and temporary objects. GC will have less job and application will be more responsive.

Thank you Ivan Nemeš