Learning resources
.NET

Load pdf

  • UNDERSTANDING THE OPP AND DESIGN PATTERNS

    1. Basic requirements
      • Understanding the basic principles of OOP: abstraction, inheritance,
        encapsulation, and polymorphism. Ability to use these principles in the C#
        programming language
      • Skills in applying object-oriented analysis in the design of application elements,
        and, consequently, skills in writing the most efficient code
    2. Would be a perk:
      • Theoretical understanding of multi-tier architecture
      • Comprehension of the difference between tier and layer
      • Skills to split the program level into 3 layers (Pl, Bl, and Dl) and
        understanding the reason why it is important
    3. Recommended references and information sources
      • E. Gamma, R. Helm, R. Johnson, J. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software
      • Martin Fowler: Patterns of Enterprise Application Architecture
      • Web architecture

  • UNDERSTANDING THE PRINCIPLES OF CLR AND .NET CORE (OR .NET FRAMEWORK)

    1. Basic requirements
      • .NET architecture (concepts of CIL, Assembly, CLR, CLI, CTS, JIT-compiler, FCL, BCL)
      • Working with assemblies (Global Assembly Cache, GAC)
      • Working with and managing types (primitive, reference and value types,boxing/unboxing, anonymous, type conversion, access modifiers to type
        members, strings, and features of working with them)
      • Understanding the garbage collection process and the operation of the garbage
        collector (GC – Garbage Collector)
      • Assignment of domains (AppDomain class)
      • Skills in working with reflection (System.Reflection namespace, Assembly, MemberInfo classes)
      • PropertyInfo, TypeInfo, MethodInfo, Type, and Activator classes
    2. Recommended references and information sources

  • KNOWING THE CAPABILITIES OF THE C# LANGUAGE AND THEIR APPLICATION

    1. Basic requirements
      • Skills in designing classes, structures, and interfaces, as well as the ability to
        work with objects (access modifiers, constants, and readonly fields, static
        members, operator, and method overloading, generic types, nullable types,
        iterators, anonymous methods, automatic properties, object initializes,
        anonymous types, extensions methods, lambda expressions, expression trees,
        partial methods, namespaces, and aliases)
      • Skills in working with the delegate, event, and lambda expressions. Func, Action,
        and Predicate delegates
      • Null values and nullable types
      • Skills in working with non-generalized and generalized collections (namespace
        such as System.Collections and System.Collections.Generic, basic classes such
        as ArrayList, SortedList, Hashtable, Queue, Stack, List<T>, Queue<T>, Stack<T>, Dictionary<T,V>, interfaces such as IList, ICollection, IEnumerable, IEnumerator, IDictionary, IComparer, indexers, yield statement)
      • Working with tuples (Tuple class)
      • Working with streams and file systems (System.IO namespace, main classes
        such as Directory, DirectoryInfo, File, FileInfo, DriveInfo, Path, FileStream,
        MemoryStream, StreamWriter, StreamReader, BinaryWriter, BinaryReader)
      • Serialization (namespaces such as System.Runtime.Serialization and
        System.Xml.Serialization, classes such as BinaryFormatter, SoapFormatter,
        XmlSerializer, DataContractJsonSerializer, attributes such as Serializable,
        NonSerialized)
      • Working with strings (String and StringBuilder classes, string operations,
        string formatting, Regex class)
      • DLR – Dynamic Language Runtime (dynamic types)
      • Basics of multithreaded programming (Thread, ThreadPool classes, thread synchronization, lock keyword, AutoResetEvent, Monitor, Mutex, Semaphore, Timer classes)
      • Library of parallel tasks (Task Parallel Library, TPL) (Task and Parallel classes)
      • Basics of asynchronous programming (asynchronous delegates, Task-based Asynchronous Pattern, async/await)
      • Working with Reflection (namespace System.Reflection)
      • Working with LINQ (Language Integrated Query) and Parallel LINQ
      • Applying the resource release model (concept of destructor, IDisposable
        interface, Dispose and Finalize methods)
      • Working with dates and time (DateTime, TimeSpan, and TimeZone structures)
      • Working with attributes (Attribute base class)
      • Working with exceptions (try/catch/finally construct, throw keyword, Exception
        base class)
    2. Recommended references and information sources
      • Jeffrey Richter. CLR via C#, 4th Edition
      • Jon Skeet. C# in depth

  • BASICS OF WEB TECHNOLOGIES

    1. Basic requirements
      • Addressing (IPv4, IPv6)
      • DNS — Domain Name Servers
      • HTTP and HTTPS protocols
      • The concept of URL — Uniform Resource Locator
      • The concept of the Same origin
      • Skills in using Chrome Developer Tools, Fiddler
    2. Recommended references and information sources

  • BASICS OF HTML AND CSS

    1. Basic requirements
      • Tags and selectors
      • Layout using div, style files, templates, media, semantics, and forms
      • Skills in using Google Developer Tools to work with HTML and CSS
      • Bootstrap basics (templates, CSS, components, and JavaScript)
    2. Recommended references and information sources

  • BASICS OF JAVASCRIPT

    1. Basic requirements
      • Basics of JavaScript (syntax, types, objects (OOP), events, functions (closure, scope), this keyword, DOM
      • Basic capabilities of the jQuery library (function $(), ajax)
    2. Recommended references and information sources

  • WEB APPLICATION DEVELOPMENT ON ASP.NET CORE

    1. Basic requirements
      • Understanding middleware pipeline and web application lifecycle
      • Dependency implementation and management
      • Hosting ASP.NET application and server
      • Routing
      • Logging
      • Bug fixing
      • Session and application status
      • Razor syntax
      • User data validation
      • Authentication and authorization
      • Understanding the Model-View-Controller (MVC) pattern
      • Understanding the differences between MVC and Web API
    2. Recommended references and information sources

  • BASICS OF SQL AND TRANSACT-SQL

    1. Basic requirements
      • Basics of SQL — Structured query language. Data definition and data
        manipulation operators, querying of databases (CRUD)
      • T-SQL additional features (control statements, local and global variables,
        functions for processing strings, dates, mathematics)
      • Skills in using SQL Server Management Studio
    2. Recommended references and information sources

  • WORKING WITH DATABASES THROUGH ENTITY FRAMEWORK

    1. Basic requirements
      • Working with database connectivity and connecting to the project
      • Mapping development (Database First, Code First, Model First approaches,one-to-one, one-to-many, many-to-many connections)
      • Working with related entities
      • Building the simplest and “custom” database queries using the built-in capabilities of the system (LINQ to Entities)
      • Running CRUD operations
      • Skills in working with stored procedures
      • Inheritance in EF (Table Per Hierarchy, Table Per Type, and Table Per Concrete Type approaches)
      • Understanding and using Repository, UnitOfWork, and Specification patterns
    2. Recommended references and information sources
      • https://docs.microsoft.com/en-us/ef/

    Besides, we would like to mention the following resources that can be highly
    beneficial and provide a lot of educational information on all the necessary topics: