​You just can't make sense of React.js and ASP.NET Core...​​Nothing you "learn" from the tutorials really sinks in...​

​How will you ever make it as a "full stack" developer?

Everyone keeps banging on about javascript these days.


You can't move for people telling you how productive React.js is and how you really should be embracing it for everything above and beyond "simple" web applications.


But from where you're standing, with all the ceremony required just to get a simple ASP.NET Core Web API + React.js application up and running, you're not feeling very productive right about now.


It's maddening because you want to enjoy full-stack development; you want to spend your days seeing features spring into life in your browser, but instead you find yourself spending hours, days, even weeks trying to implement the simplest of functionality. 


Everyone else appears to be off building amazing apps using React and ASP.NET Core, so why do you just feel like you're drowning in new concepts and endless terminology?


Can it really be true? that to get even the simplest feature up and running you need to learn webpack, react, state management, node/npm, Typescript?


And that's just the frontend.


Sprinkle in some API concerns like dependency injection, ORMs, REST and it's hard to see how anyone ever gets anything  built with this stuff.


But what if you could sideline all this complexity and focus on building your features?


Imagine being able to calmly and confidently use React + Web API to quickly (and reliably) build any feature that came your way.


You could be that developer, you know, the one who embraces new feature requests instead of trying to dive out of sight every time the product owner walks towards you!


Figuring out how to build solid React + Web API applications on your own is an uphill struggle but you don't have to tackle this by yourself.


Practical React + ASP.NET Core Web API is coming and will fast-track your React + Web API journey.


  • Learn the fundamental building blocks of ASP.NET Core Web API and React.js
  • Discover the simplest way to deconstruct features and build them, one React.js component at a time
  • Discover a time (and sanity) saving approach for quickly building up an ASP.NET Core Web API so you can glide, effortlessly from one feature to the next

Absolutely loving your React course so far!


The way it’s presented is really refreshing, the focus on pragmatism is unlike any course I’ve done (and I’ve done a lot of Udemy/online courses). 


It has a very nice balance of written tutorials and videos, which helps to cement the learning.


Can’t think of any negatives so far.


​​​Nathan Morris

Developer

All you need is a few hours

By the end of the course you'll be able to...


  • Take any feature all the way from idea to fully working implementation using ASP.NET Core and React.js
  • Reliably break features down into smaller components in order to build them as quickly and simply as possible
  • Create a fully-functional ASP.NET Core Web API backend
  • Build an API that is easily extended and adapted as requirements change
  • Integrate your API with third party systems (e.g. Stripe)
  • Secure your Web API
  • Configure authentication for any React.js application (and talk to an ASP.NET Core backend)

​Here's ​what you'll ​learn

Module #1 - Prototype the frontend using React.js

Starting is the hardest bit so we'll quickly build up the first few components that make up the front-end of our online store.


You'll see how to use hard-coded data in your React components and bring in bootstrap markup to make everything look respectable!


​Finish this module and you'll ​be able to:


  • ​Write JSX markup
  • ​Create components using javascript classes​
  • Understand how ​class components​ and ​function components​ differ in React​​​​​​
  • ​Import and export modules in your javascript applications
  • ​Use React state ​to drive your components UI
  • Refactor your React components

Module #2 - Hook it up to an ASP.NET Core backend

​We'll switch gears and spin up an ASP.NET Core Web API to power our application.


ASP.NET Core is a super-fast and reliable platform for building your API.


​You can quickly get something to work ​using hard-coded data, before eventually pushing that data into a database.​

By the end of this module you'll be able to:


  • Create web API endpoints using controllers and actions
  • Quickly get something up and running without a database (rapid prototyping)
  • Make network calls from your React components to your API and bind them to the data that comes back

Module #3 - Making it real (databases and EF Core)

​We can only ignore reality for so long! 


​It's time to bring in a real database using EF Core.


​EF Core is a good starting point for data access.


You can define the models (entities) you want to represent in your application (things like people, shopping carts, products etc.) and use these models to build out the database.

By the end of this module you'll be able to:


  • Add EF Core to an existing project
  • Introduce Models into your application to represent  your key domain entities
  • Generate migrations and update your database as you add more entities to your project

Module #4 - Implement a shopping cart

Time to take everything you've learned so far and put it to good use; you'll build new components to let your hypothetical customers add items to their cart.


You'll be able to:


  • Use sessionId to store data "in the browser"
  • Refactor your backend code as it starts to creep up in complexity
  • Push business logic down into your domain entities
  • Write tests to check your business logic works as you expect
  • Use React state to improve the experience for your users

Module #5 - View cart and checkout

"Integrating with third parties is always fun" (said no-one, ever!)


We can only go so far without accepting payment; in this module we'll give users a way to view their cart and (crucially) checkout via integration with Stripe.


You'll be able to:


  • Implement forms in React to capture details such as addresses
  • Integrate with Stripe for taking payments
  • Unit test the backend code without having to hit "real" systems e.g. Stripe

Module #6 - ​Auth

​Agghhh Auth!


​We can't ignore it any longer; time to do the simplest thing possible to let users register on our site and then checkout as a registered user.


You'll be able to:


  • Set up integration using Auth0
  • Redirect users to login via your Auth server
  • ​Conditionally show or hide content in your React app for each user

And more (details to be finalised).

​Coming soon...

​I'm busy working on the course; pop your details in the boxes below to be notified when it becomes available.

Who wrote this?

​Hey, I'm Jon Hilton and I've been "doing" software development for more years than I care to remember (about 20 in fact).


My first site was ​a Red Dwarf fan site which I built when I was 16 and, well, I haven't really stopped "hacking" away at web sites and applications since.


I develop software for a company called Remote as well as blogging ​at jonhilton.net and building training materials/courses and books (like this one).


Think of me as primarily here to help you level up your development skills and find your way ​in the (often confusing) world of Microsoft software development.

​Get up and running with ​React.js and ASP.NET Core
or your money back

I don’t want you to miss out on this ​course and I'm confident it will get you up and running with ​React and ASP.NET Core so here’s my offer to you.


Take the ​course for a spin.


If​, after you’ve run through the ​course and tried the steps for yourself, you feel you haven’t gained the ability and understanding to tackle your own ASP.NET/React projects, I will cheerfully refund your money, no questions asked, any time within the next 30 days.


© Jon Hilton All rights Reserved

Privacy Policy