Kameswara Sarma Uppuluri
(MCT, MCPD, MCTS, MCAD, MCDBA, MCSD)

 

Blazor Online Training

Your Instructor for this course is Kameswara Sarma Uppuluri.

He is an accomplished Senior Technical Corporate Trainer here in India and a consultant. He has been a Microsoft Certified Trainer since 2004 and a Microsoft Certified Professional since 1998. He has delivered various trainings at client places, on Microsoft Technologies for top MNC's in India .

He is passionate about teaching developers how to make the most out of their chosen technologies and doing web development in the best way possible.

He has spent years of developing course materials and teaching professional developers online throughout the world.

He has worked in technology for 16 years, specializing in web Development,Content Management Systems,databases and business intelligence.

He is an independent consultant that enjoys development and teaching.

He is a consultant based in Hyderabad, India. He has over 16 years of experience in the IT field, and over a decade of experience as a trainer.

He is an expert in SharePoint Development/Configuration/,Administration and .NET development and Database business intelligence technologies.
Live Online Training Videos

Course Fee : ₹ 5000/-

Course Duration :
35 Days
Session Duration :
90 Minutes (Mon – Sat)

 
 

What is Blazor?
  • Blazor is a feature of ASP.NET for building interactive web UIs using C# instead of JavaScript. It's real .NET running in the browser on WebAssembly.
Audience Profile:

This course is for those people who wants to build web applications with C# instead of JavaScript.


Prerequisites

This course is designed for individuals with an intermediate knowledge of C# and basic web development technologies.


Our Trainer's Profile :
  • Our Trainers speak from Experience
  • Our Trainers Are Subject Matter Experts
  • Our Trainers Are Expert instructors
  • Our Trainers are Microsoft Certified
  • Our Trainers have more than 13+ years of experience on Microsoft Technologies
Career Path :

After completing this course you will be able to take up the roles of
  • Blazor Developer


Lesson 1 - Introduction to WebAssembly and Blazor

In this lesson, we will cover the following topics.
  1. Introducing WebAssembly
  2. Which Browsers Support WebAssembly?
  3. WebAssembly and Mono
  4. Interacting with the Browser with Blazor
  5. Blazor Server
  6. Pros and Cons of the Blazor Server
  7. Your First Blazor Project
  8. Installing Blazor Prerequisites
  9. Using Visual Studio
  10. Using Visual Studio Code
  11. Understanding the Blazor Templates for VS/Code
  12. Generating the Project with Dotnet CLI
  13. Generating Your Project with Visual Studio
  14. Running Blazor with Visual Studio Code
  15. Running the Generated Project
  16. Examining the Project’s Parts
  17. The Server Project
  18. Using a Shared Project
  19. Understanding the Client Blazor Project
  20. Layout Components
  21. Debugging Client-Side Blazor
  22. Debugging with Visual Studio
  23. Debugging with Visual Studio Code
  24. Developing with Hot Reload
  25. Hot Reload with .NET CLI
  26. Hot Reload with Visual Studio
  27. The Blazor WASM Bootstrap Process
  28. The Blazor Server Bootstrap Process
  29. Nullable Reference Types
  30. Using Null in C#
  31. Using References
  32. The Null-Forgiving Operator
  33. Nullable Reference Types and .NET Libraries

Lesson 2 - Data Binding

In this lesson, we will cover the following topics.
  1. A Quick Look at Razor
  2. One-Way Data Binding
  3. One-Way Data Binding Syntax
  4. Attribute Binding
  5. Conditional Attributes
  6. Event Handling and Data Binding
  7. Event Binding Syntax
  8. Event Arguments
  9. Using C# Lambda Functions
  10. Two-Way Data Binding
  11. Two-Way Data Binding Syntax
  12. Binding to Other Events: @bind:{event}
  13. Preventing Default Actions
  14. Stopping Event Propagation
  15. Formatting Dates
  16. Change Detection
  17. The PizzaPlace Single-Page Application
  18. Creating the PizzaPlace Project
  19. Adding Shared Classes to Represent the Data
  20. Building the UI to Show the Menu
  21. Converting Values
  22. Adding Pizzas to the Shopping Basket
  23. Displaying the Shopping Basket
  24. Entering the Customer Information
  25. Debugging Tip
  26. Blazor Validation
  27. Letting Entities Validate Themselves
  28. Using FormField and InputText to Enable Validation
  29. Showing Validation Errors
  30. Customizing the Validation Feedback

Lesson 3 - Components and Structure for Blazor Applications

In this lesson, we will cover the following topics.
  1. What Is a Blazor Component?
  2. Examining the SurveyPrompt Component
  3. Building a Simple Alert Component with Razor
  4. Separating View and View Model
  5. Creating a DismissibleAlert Component
  6. Understanding Parent-Child Communication
  7. Adding a Timer Component
  8. Using Two-Way Data Binding Between Components
  9. Using EventCallback
  10. Referring to a Child Component
  11. Communicating with Cascading Parameters
  12. Using the CascadingValue Component
  13. Resolving Ambiguities
  14. Component Life Cycle Hooks
  15. Life Cycle Overview
  16. SetParametersAsync
  17. OnInitialized and OnInitializedAsync
  18. OnParametersSet and OnParametersSetAsync
  19. ShouldRender
  20. OnAfterRender and OnAfterRenderAsync
  21. IDisposable
  22. A Word on Asynchronous Methods
  23. Refactoring PizzaPlace into Components
  24. Creating a Component to Display a List of Pizzas
  25. Showing the ShoppingBasket Component
  26. Adding the CustomerEntry Component
  27. Using Cascading Properties
  28. Disabling the Submit Button

Lesson 4 - Advanced Components

In this lesson, we will cover the following topics.
  1. Using Templated Components
  2. Creating the Grid Templated Component
  3. Using the Grid Templated Component
  4. Specifying the Type Parameter’s Type Explicitly
  5. Using Generic Type Constraints
  6. Razor Templates
  7. Wig-Pig Syntax
  8. Using Blazor Error Boundaries
  9. Building a Component Library
  10. Creating the Component Library Project
  11. Adding Components to the Library
  12. Referring to the Library from Your Project
  13. Using the Library Components
  14. Static Resources in a Component Library
  15. Virtualization
  16. Displaying a Large Number of Rows
  17. Using the Virtualize Component
  18. Adding Paging
  19. Dynamic Components
  20. Component Reuse and PizzaPlace

Lesson 5 - Services and Dependency Injection

In this lesson, we will cover the following topics.
  1. What Is Dependency Inversion?
  2. Understanding Dependency Inversion
  3. Using the Dependency Inversion Principle
  4. Adding Dependency Injection
  5. Using an Inversion-of-Control Container
  6. Constructor Dependency Injection
  7. Property Dependency Injection
  8. Configuring Dependency Injection
  9. Singleton Dependencies
  10. Transient Dependencies
  11. Scoped Dependencies
  12. Understanding Blazor Dependency Lifetime
  13. Blazor WebAssembly Experiment
  14. Blazor Server Experiment
  15. Using OwningComponentBase
  16. The Result of the Experiment
  17. Building Pizza Services
  18. Adding the MenuService and IMenuService Abstraction
  19. Ordering Pizzas with a Service

Lesson 6 - Data Storage and Microservices

In this lesson, we will cover the following topics.
  1. What Is REST?
  2. Understanding HTTP
  3. Universal Resource Identifiers and Methods
  4. HTTP Status Codes
  5. Invoking Server Functionality Using REST
  6. HTTP Headers
  7. JavaScript Object Notation
  8. Some Examples of REST Calls
  9. Building a Simple Microservice Using ASP.NET Core
  10. Services and Single Responsibility
  11. The Pizza Service
  12. What Is Entity Framework Core?
  13. Using the Code-First Approach
  14. Preparing Your Project for Code-First Migrations
  15. Finding Your Database Server’s Connection String
  16. Creating Your First Code-First Migration
  17. Generating the Database
  18. Enhancing the Pizza Microservice
  19. Testing Your Microservice Using Postman

Lesson 7 - Communication with Microservices

In this lesson, we will cover the following topics.
  1. Using the HttpClient Class
  2. Examining the Server Project
  3. Using a Shared Project. Why?
  4. Looking at the Client Project
  5. Emulating a Slow Network in Chrome
  6. Understanding the HttpClient Class
  7. The HttpClientJsonExtensions Methods
  8. Customizing Serialization with JsonSerializerOptions
  9. Retrieving Data from the Server
  10. Implementing the MenuService
  11. Showing a Loading UI
  12. Storing Changes
  13. Updating the Database with Orders
  14. Building the Order Microservice
  15. Talking to the Order Microservice

Lesson 8 - Unit Testing

In this lesson, we will cover the following topics.
  1. Where Can We Find Bugs?
  2. Requirements
  3. Coding
  4. Integration
  5. Beta Testing
  6. Post-release
  7. Why Should We Use Unit Tests?
  8. What Makes a Good Unit Test?
  9. Unit Testing Blazor Components
  10. Adding a Unit Test Project
  11. Adding bUnit to the Test Project
  12. Write Your First Unit Test
  13. Writing Good Unit Test Methods
  14. Running Your Tests
  15. Making Your Test Pass
  16. Using Facts and Theories
  17. Checking Your Sanity
  18. Write a bUnit Tests with C#
  19. Understanding bUnit?
  20. Testing Component Interaction
  21. Passing Parameters to Our Component
  22. Testing Two-Way Data Binding and Events
  23. Testing Components that Use RenderFragment
  24. Using Cascading Parameters
  25. Using MOQ to Create Fake Implementations
  26. Injecting Dependencies with bUnit
  27. Replacing Dependencies with Fake Objects
  28. Using Stubs
  29. Using Mocks
  30. Implementing Stubs and Mocks with MOQ
  31. Writing bUnit Tests in Razor
  32. The First Razor Test
  33. Handling Asynchronous Re-renders
  34. Configuring Semantic Comparison
  35. Why Do We Need Semantic Comparison?
  36. Customizing Semantic Comparison

Lesson 9 - Single-Page Applications and Routing

In this lesson, we will cover the following topics.
  1. What Is a Single-Page Application?
  2. Single-Page Applications
  3. Layout Components
  4. Using Blazor Layout Components
  5. Configuring the Default Layout Component
  6. Selecting a Layout Component
  7. Nesting Layouts
  8. Blazor Routing
  9. Installing the Router
  10. The NavMenu Component
  11. Setting the Route Template
  12. Redirecting to Other Pages
  13. Understanding the Base Tag
  14. Lazy Loading with Routing
  15. Lazy Loading Component Libraries
  16. Marking an Assembly for Lazy Loading
  17. Dynamically Loading an Assembly
  18. Lazy Loading and Dependencies
  19. Adding Another Page to PizzaPlace

Lesson 10 - JavaScript Interoperability

In this lesson, we will cover the following topics.
  1. Calling JavaScript from C#
  2. Providing a Glue Function
  3. Using IJSRuntime to Call the Glue Function
  4. Storing Data in the Browser with Interop
  5. Passing a Reference to JavaScript
  6. Calling .NET Methods from JavaScript
  7. Adding a Glue Function Taking a .NET Instance
  8. Using Services for Interop
  9. Building the LocalStorage Service
  10. Dynamically Loading JavaScript with Modules
  11. Using JavaScript Modules
  12. Loading the Module into a Blazor Service
  13. Adding a Map to PizzaPlace
  14. Choosing the Map JavaScript Library
  15. Adding the Leaflet Library
  16. Building the Leaflet Map Razor Library
  17. Registering with the Map Provider
  18. Creating the Map Component
  19. Consuming the Map Component
  20. Adding Markers to the Map

Lesson 11 - Blazor State Management

In this lesson, we will cover the following topics.
  1. Examining Component State
  2. What Not to Store
  3. Local Storage
  4. The Server
  5. URL
  6. Using Protected Browser Storage
  7. The Redux Pattern
  8. The Big Picture
  9. The Application Store
  10. Actions
  11. Reducers
  12. Views
  13. Using Fluxor
  14. Creating the Store
  15. Using the Store in Our Blazor Application
  16. Adding an Action
  17. Implementing the Reducer
  18. Redux Effects
  19. Adding the First Action
  20. Adding the Second Action and Effect

Lesson 12 - Building Real-Time Applications with Blazor and SignalR

In this lesson, we will cover the following topics.
  1. What Is SignalR?
  2. How Does SignalR Work?
  3. Building a WhiteBoard Application
  4. Creating the WhiteBoard Solution
  5. Implementing the Mouse Handling Logic
  6. Painting the Segments on the Board
  7. Adding a SignalR Hub on the Server
  8. Implementing the BoardHub Class
  9. Configuring the Server
  10. Implementing the SignalR Client
  11. Making the SignalR Hub Connection
  12. Notifying the Hub from the Client
  13. Cleaning Up the Hub Connection

Lesson 13 - Efficient Communication with gRPC

In this lesson, we will cover the following topics.
  1. What Is gRPC?
  2. Pros and Cons of RPC
  3. Understanding gRPC
  4. Protocol Buffers
  5. Describing Your Network Interchange with Proto Files
  6. Installing the gRPC Tooling
  7. Adding the Service Contract
  8. Implementing gRPC on the Server
  9. Implementing the Service
  10. Adding gRPC
  11. Building a gRPC Client in Blazor
  12. Creating the ForecastGrpcService
  13. Enabling gRPC on the Client
  14. Updating the FetchData Component
  15. Comparing REST with gRPC

Lesson 14 - Supporting Multiple Languages in Your Blazor Application

In this lesson, we will cover the following topics.

  1. Understanding Internationalization, Globalization, and Localization
  2. Representing the User’s Locale
  3. CurrentCulture vs. CurrentUICulture
  4. Enabling Multiple Languages
  5. Using Request Localization
  6. Internationalizing Your App
  7. Localizing Your App
  8. Adding Your First Resource File
  9. Localizing SurveyPrompt
  10. Understanding Resource Lookup
  11. Adding a Language Picker in Blazor Server
  12. Making PizzaPlace International
  13. Enabling Globalization Data
  14. Globalizing Your Components
  15. Adding a Language Picker in Blazor WebAssembly
  16. Using Global Resources

Lesson 15 - Deploying Your Blazor Application

In this lesson, we will cover the following topics.
  1. Deploying Standalone Blazor WebAssembly
  2. Hosting on GitHub
  3. Creating a Simple Website
  4. Deploying a Simple Site in GitHub
  5. Deploying a Blazor WASM Project
  6. Fix the Base Tag
  7. Disabling Jekyll
  8. Fixing GitHub 404s
  9. Alternatives for GitHub
  10. Deploying Your Site As WebAssembly
  11. Deploying Hosted Applications
  12. Understanding the Deployment Models
  13. Deploying to Microsoft Azure
  14. Creating the Publishing Profile
  15. Selecting Publishing Options
  16. Publishing the Application

Lesson 16 - Security with OpenId Connect

In this lesson, we will cover the following topics.
  1. Representing the User
  2. Using Claims-Based Security
  3. Understanding Token Serialization
  4. Representing Claims in .NET
  5. OpenId Connect
  6. Understanding OpenId Connect Hybrid Flow
  7. Identity Providers
  8. Implementing the Identity Provider with IdentityServer4
  9. Adding the Login UI to Our Identity Provider
  10. Understanding User Consent
  11. Protecting a Blazor Server Application with Hybrid Flow
  12. Adding OpenId Connect to Blazor Server
  13. Implementing Authorization in Blazor Server
  14. Using AuthorizeView
  15. Adding and Removing Claims
  16. Enabling Role-Based Security
  17. Accessing a Secured API
  18. Using an Access Token
  19. Registering the API Project with the Identity Provider
  20. Adding JWT Bearer Token Middleware
  21. Enabling the Bearer Token in the Client
  22. Using Policy-Based Access Control

Lesson 17 - Securing Blazor WebAssembly

In this lesson, we will cover the following topics.
  1. Authorization Code Flow with PKCE
  2. Understanding PKCE
  3. Registering the WASM Client Application
  4. Creating and Examining the Application
  5. Registering the Client Application
  6. Implementing Authentication
  7. Customizing the Login Experience
  8. Accessing a Protected API
  9. Fetching Data from the WeatherService API
  10. Using the AuthorizationMessageHandler
  11. Adding Client-Side Authorization
  12. Using Role-Based Security
  13. Creating the Claims Component
  14. Enabling RBAC
  15. Promoting the Role Claim
  16. Using Policy-Based Access Control
  17. Updating Scopes
  18. Adding Policies
Why you should choose UIAcademy.co.in as your Online Training provider?

• We are into training industry for more than 16+ years.
• Scenario Based Training.
• Certification Exam preparation.
• Our trainers are certified and qualified with Real-World experience.
• Our Large List of Satisfied Students & Clients Around the World.
• Demo of live project including Source Code and other resources will be provided to the students.
• Students will have access to soft copies of all the Case Studies and other examples used during the sessions.
• We provide complete guidance towards MCP Certification Exams.
• Step by Step Lab Manuals and Course Materials.
• Resume and Interview Preparation Guidance.
 
 
Client Testimonials
 

I have learned BLAZOR course with UIAcademy.co.in. I am absolutely, an happy Customer. Thanks to Google for putting me at the right place.
Kashish Arora
Australia
 

 

Client Testimonials
 

I found people at UIAcademy.IN are very organized, provide friendly environment and deliver courses at right pace with the best content as their curriculums
Sarita
Pune
 

 
Home Training Courses Support Company  
 
SharePoint 2019, SPFx
Angular , React , Vue
ASP.NET Core MVC , Blazor
SQL SERVER 2019
SSIS 2019 , SSRS 2019
Why UIAcademy ?
Free Videos
Training Schedule
About Us
Contact Us
Careers
Online Training
© Copyright 2010 - 2023 | UIAcademy.co.in | All trademarks and logos are the sole property of their respective owners.