Overview
Nothin But .Net is a five day (intense) boot camp style course that will focus on applying .Net development best practices in the context of developing a working N-Tiered application. Registrants will learn about how to practically apply.Net as they apply it to the task of building a complete application from the UI layer all the way down to the mapping layer.
WARNING!!!!
If you are expecting to come to this course to learn about how to have VS.Net automatically generate an “application” for you, then this course is NOT for you.
This course is all about taking control of the .Net framework and having it work the way you want. This course will place a heavy emphasis on getting back to the basics and making .Net do things the way you want it to, in a predictable and testable way.
During the course of the week, there will be absolutely no code that gets compiled from within Visual Studio. Studio itself will be relegated to a glorified code editor. I will teach you development techniques and tools that will dramatically increase your day to day productivity as a software developer.
This course will focus on a code centric view of application development vs. the typical databinding/designer magic covered by many typical .Net courses. You will walk away with a deep understanding of fundamental aspects of .Net and how these pieces can be used to develop and deliver enterprise scale applications.
Core Concepts Overview
Expand the capabilities of developing with VS.Net - Enter ReSharper (a productivity add-in for Visual Studio .Net)
There’s more to development than code generators
Automated Builds
Generics ( they’re not just for collections )
Object Relational Mapping in .Net
Creating layered architectures
Driving out functionality and design through testing
Taking Control Of Databinding
Test Driven Development & Mock Objects
Core Design Patterns Applied
Detailed Topic Coverage Breakdown
· Language Enhancements
o Generics
o Anonymous Delegates
o Iterators
o Linq
· Collections
o Taking advantage of the collection interfaces
o Making use of the IDictionary<T> and IList<T> interfaces.
o Overcoming the limitations of the IList<T> interface
o Sorting, searching, and manipulating collections using generic delegates
o Overcoming limitations of searching with generic delegates
o Creating custom comparers
· Events
o Delegates in depth
o Creating classes that expose events
o Safely publishing events
o Multithreading with delegates
· ADO .Net
o Creating a Custom Object Relational mapping layer
o Effective uses of TransactionScope to test the mapping layer
o Eliminating the need for stored procedures
o Effective techniques for querying data
· ASP.Net
o Master Pages
o Passing Data Between Pages
o Taking Control Of Databinding
o Validation Techniques
o Leveraging Front Controller Architecture styles for cleaner separation of concerns.
o Saying goodbye to WebForms
o MVC vs MVP vs SC
· OO Practices & Principles
o Dependency Inversion
o Single Responsibility
o Open Closed
o Hollywood
o Tell Don’t Ask
o Encapsulation
o Polymorphism
· Patterns
o Layered Architecture
o Data Transfer Object
o Supervising Controller
o Passive View
o Notification
o Static Gateway
o Unit Of Work
o Mapper
o Gateway
o Domain Model
o Null Object
o Proxy
o Adapter
o Abstract Factory
o Event Aggreagor
o Service Layer
o Façade
o Visitor
o Decorator
o Composite
o Front Controller
o Notification
· Testing
o Using Automated Testing Frameworks
o Dependency Based/Interaction Based
o TDD as a design tool
o Applied Test Driven Development
o Avoiding over specification problems with Interaction Based Testing
o Test Partitioning
o Different types of testing (Integration,Acceptance,Unit)
Recommended Prerequisites
This is an intermediate to expert level course. In order to walk away with the most benefit from the course the following list outlines key prerequisites and the level of knowledge that people would be best served entering the course with:
Knowledge of the C# syntax (Strong)
Knowledge of the .Net event/delegate architecture (Moderate/Strong)
OO programming concepts (Moderate/Strong)
Domain Driven Design (Cursory)
Refactoring (Cursory)
Design Patterns (Cursory)
Automated Testing Frameworks (Cursory/Moderate)
Test Driven Development (Cursory)
Utilizing Events and Delegates in .Net (Moderate/Strong)
Manipulation of core ADO.Net objects (Moderate/Strong)
Build Automation (Cursory)
**********Please be aware that the length of course days (based on prior iterations of the course) can fluctuate dramatically based on the level of student interaction. It is best to come ready expecting the course days to be no less than 10 hours.************
Intended Outcomes
Upon completion of this course students should be equipped with a practical, applied understanding of the following concepts:
Interface Based Programming
Design By Contract
Test Driven Development
Layered architecture
Object Oriented Programming
Design Patterns
Unit Testing
Interaction vs. State Based Testing
Dependency Injection
Object Relational Mapping
Domain Driven Design
Build Automation