In this episode, Robert is joined by Erik Ejlskov Jensen, the author of several Visual Studio Extensions for working with databases. Here, Erik shows the Entity Framework 6 Power Tools (including viewing entity data models and generating views) and the EF Core Power Tools (including reverse engineering and viewing a database schema as a DGML graph).

In this episode, Robert is joined by Ed Charbeneau for a discussion of how a number of language features in C# support functional programming, a programming style that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. Resources: The Essential Cheat Sheet: Functional Programming with C# 7.1 Functional C# self-guided workshop and presentation assetsPodcast on Functional C#

In this episode, Donovan is joined by Charles Taylor, to show the Visual Studio Team Services Work Item Rules. Using these rules, you can customize the behavior of your work items in VSTS.

In this episode, Robert is joined by Ed Charbeneau for a discussion on using Angular with ASP.NET Core. Ed shows how to create an Angular app using the new ASP.NET Core project templates [01:45], how to create an Angular app with a Web API backend [20:45] and how to use Angular to build a native iOS and Android app [27:10]. Resources Read about the Angular template for .NET Professional UI components for Angular Build Native Mobile applications using Angular

In this episode Dmitry Lyalin is joined by Jeremy Likness, a Cloud Developer Advocate at Microsoft and the coder behind Sterling DB, an open source project originally created for Silverlight data storage. Jeremy will cover what recently inspired him to convert this 2010 built data library and port it to run on .NET Core 2.0 thanks to advances in .NET Standard 2.0 that made it (finally) possible. He'll show us exactly how easy it was to port, demo the code actually running against some sample solutions and discuss his views on .NET Core 2.0, and why we believe it's finally ready to go big with open source project developers, enterprises and beyond. Resources: .NET Core 2.0: https://www.microsoft.com/netBlog post: https://jlik.me/78GitHub: https://github.com/JeremyLikness/sterling-net-core

In this episode, Donovan is joined by Sandeep Chadda, to show the Visual Studio Team Services Wiki support to help your team members collaborate. Here is a link to learn more about VSTS Wiki powered by Git.

This is the last of an eight part series where Robert is joined by Phil Japikse to discuss design patterns. A design pattern is a best practice you can use in your code to solve a common problem. In this episode, Phil demonstrates the Decorator pattern. This pattern allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. Episodes in this series: Command/Memento patternsStrategy patternTemplate Method patternObserver/Publish-Subscribe patternsSingleton patternFactory patternsAdapter/Facade patternsDecorator pattern (this episode)Resources Sample codeDesign Patterns: Elements of Reusable Object-Oriented Software bookHead First Design Patterns book

This is the seventh of an eight part series where Robert is joined by Phil Japikse to discuss design patterns. A design pattern is a best practice you can use in your code to solve a common problem. In this episode, Phil demonstrates the Adapter and Façade patterns. The Adapter pattern allows the interface of an existing class to be used as another interface. The Façade pattern enables an object to provide a simplified interface to a larger body of code, such as a class library. Episodes in this series: Command/Memento patternsStrategy patternTemplate Method patternObserver/Publish-Subscribe patternsSingleton patternFactory patternsAdapter/Facade patterns (this episode)Decorator patternResources Sample codeDesign Patterns: Elements of Reusable Object-Oriented Software bookHead First Design Patterns book

This is the sixth of an eight part series where Robert is joined by Phil Japikse to discuss design patterns. A design pattern is a best practice you can use in your code to solve a common problem. In this episode, Phil demonstrates the Simple Factory, Factory Method and Abstract Factory patterns. The Simple Factory pattern encapsulates object creation in one place. The Factory Method pattern uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. The Abstract Factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes. Episodes in this series: Command/Memento patternsStrategy patternTemplate Method patternObserver/Publish-Subscribe patternsSingleton patternFactory patterns (this episode)Adapter/Facade patternsDecorator patternResources Sample codeDesign Patterns: Elements of Reusable Object-Oriented Software bookHead First Design Patterns book

This is the fifth of an eight part series where Robert is joined by Phil Japikse to discuss design patterns. A design pattern is a best practice you can use in your code to solve a common problem. In this episode, Phil demonstrates the Singleton pattern. This pattern restricts the instantiation of a class to one instance and provides global access to that instance. Episodes in this series: Command/Memento patternsStrategy patternTemplate Method pattern Observer/Publish-Subscribe patternsSingleton pattern (this episode)Factory patternsAdapter/Facade patternsDecorator patternResources Sample codeDesign Patterns: Elements of Reusable Object-Oriented Software bookHead First Design Patterns book