Microsoft Dynamics 365 CRM Advanced Training

Here is your Udemy Title and Description based on your C# Basics for Plugin Preparation topic
(Reference: Day 33MSCRM Day 1_Plugins.docx)

? Title (SEO Optimized)

C# Basics for Dynamics 365 CRM Plugin Development

(57 characters)

? Description

Before building plugins in Microsoft Dynamics 365 CRM, you must understand the fundamentals of C# programming.

In this course, you will learn the core C# concepts required for Dynamics 365 CRM Plugin development using Visual Studio. This beginner-friendly technical foundation prepares you for advanced CRM server-side customization.

We will build a simple console application to understand:

• Methods and parameters

• Variables and data types

• String concatenation

• Arithmetic operations

• Method calls

• Debugging techniques

This practical session ensures you are comfortable writing C# code before moving to real CRM plugin development.

? What You Will Learn

• How to create a C# project in Visual Studio

• Understanding Console Applications (.NET Framework / .NET 6+)

• Writing methods in C#

• Passing parameters to methods

• Performing arithmetic calculations

• String manipulation in C#

• Using Console.WriteLine()

• Build and run projects

• Debugging using breakpoints

• Step Into (F11) and Step Over (F10)

• Understanding method execution flow

? Why This Course Is Important

C# is required for:

• Dynamics 365 CRM Plugins

• Custom Workflow Activities

• Azure Functions Integration

• Server-side business logic

• Enterprise CRM customizations

If you want to become a Dynamics 365 CRM Technical Developer, mastering C# basics is mandatory.

? What You Will Build

✔ A working C# console application
✔ A reusable method for adding numbers
✔ Understanding how method execution works
✔ Debugging practice in Visual Studio

In this course, you will learn how to develop and register a C# Plugin in Microsoft Dynamics 365 CRM to automatically populate the Full Name field based on First Name and Last Name.

Plugins are one of the most important server-side customization techniques in Dynamics 365 CRM. In this hands-on technical implementation, you will build a real-time business scenario using Dataverse and Visual Studio.

We will create a Student table where:

• First Name is entered

• Last Name is entered

• Full Name (Primary Name field) is automatically populated

• Plugin runs during Create and Update

• No extra update call is required

• No recursion issues occur

This is a practical enterprise-level plugin implementation suitable for interviews and real projects.

? What You Will Learn

• What is a Plugin in Dynamics 365 CRM

• Understanding IPlugin interface

• Working with IPluginExecutionContext

• Using Target entity from InputParameters

• Handling Create and Update messages

• Difference between Pre-Operation and Post-Operation

• Why Pre-Operation avoids recursion

• Building Full Name dynamically in C#

• Exception handling in plugins

• Using Tracing Service for debugging

• Building Class Library in Visual Studio

• Installing Microsoft.CrmSdk.CoreAssemblies

• Registering Plugin using Plugin Registration Tool (PRT)

• Configuring Create and Update Steps

• Using Filtering Attributes

• Configuring Pre-Image correctly

• Testing and troubleshooting plugin issues

? Real-Time Scenario Covered

✔ Auto-generate Full Name (John + Doe → John Doe)
✔ Update Full Name when First or Last Name changes
✔ Avoid extra database update calls
✔ Use Pre-Operation stage for efficiency
✔ Handle errors properly

? Step-by-Step Implementation Included

1. Create Student table & fields in Dataverse

2. Create Class Library project

3. Install CRM SDK assemblies

4. Write Plugin code

5. Build DLL in Release mode

6. Register assembly in Plugin Registration Tool

7. Add Create step (Pre-Operation)

8. Add Update step with Filtering Attributes

9. Configure Pre-Image

10. Test & troubleshoot

In this course, you will learn how to use Pre-Image in a Dynamics 365 CRM Plugin to correctly update the Full Name field when either First Name or Last Name is modified.

During Update operations in Dataverse, the Target entity only contains modified fields. This often leads to incomplete data when building calculated values like Full Name.

In this step-by-step technical session, you will solve this problem using:

• Pre-Operation plugin stage

• Pre-Image configuration

• Synchronous execution

• Proper attribute handling

• Efficient server-side logic

You will implement a real-world Contact scenario where:

• Updating only First Name still updates Full Name correctly

• Updating only Last Name still updates Full Name correctly

• Updating both fields works perfectly

• No extra update call is required

• No recursion issues occur

? What You Will Learn

• Why Target contains only modified fields

• What is Pre-Image in plugin registration

• When to use Pre-Operation stage

• How to configure Pre-Image attributes

• How to merge old and new values

• Writing efficient C# plugin code

• Avoiding unnecessary service update calls

• Proper testing scenarios

• Important interview concepts

? Step-by-Step Implementation Includes

1. Understanding the business requirement

2. Identifying the update problem

3. Writing C# plugin using IPlugin

4. Registering Update step

5. Configuring Pre-Image

6. Selecting correct attributes

7. Testing different update scenarios

8. Interview-focused explanation

In this course, you will learn how to properly debug and understand the Plugin Execution Pipeline in Microsoft Dynamics 365 CRM (Dataverse).

Plugin development is incomplete without mastering debugging techniques and pipeline stages. Many developers struggle with tracing errors, understanding execution depth, handling recursion, and choosing the correct pipeline stage.

This step-by-step technical guide teaches you how to debug plugins effectively using:

• ITracingService

• Plugin Trace Log

• Plugin Profiler (PRT)

• Advanced Find for trace analysis

• Proper exception handling

You will also deeply understand the complete plugin pipeline including:

• Pre-Validation (Stage 10)

• Pre-Operation (Stage 20)

• Post-Operation (Stage 40 – Sync & Async)

Using real-time business scenarios like populating a custom Full Name field, blocking invalid operations, auto-numbering records, and triggering dependent records.

? What You Will Learn

• How plugin execution works internally

• Understanding MessageName, Stage, Depth, CorrelationId

• Writing production-ready tracing code

• Enabling and analyzing Plugin Trace Logs

• Debugging using Plugin Profiler replay

• Setting breakpoints in Visual Studio

• Using Filtering Attributes correctly

• Avoiding recursion using context.Depth

• Choosing the correct pipeline stage for business logic

• Differences between synchronous and asynchronous plugins

? Real-Time Implementation Covered

• Populate custom new_fullname field using Pre-Operation

• Prevent invalid record creation using Pre-Validation

• Create dependent records in Post-Operation

• Use async plugins for long-running integrations

• Analyze execution logs using Advanced Find

In this course, you will learn how to develop a Dynamics 365 CRM Plugin on the Retrieve message to dynamically modify record data during retrieval.

Unlike Create or Update plugins, Retrieve message plugins execute when a record is opened or fetched. In this hands-on implementation, you will build a real-world Case (Incident) scenario where:

When Priority = High

And Status = Active

A warning message is automatically prefixed to the Case Title

This is a powerful technique used to control UI behavior and display dynamic alerts without modifying stored database values.

You will implement the solution using:

Post-Operation stage

Retrieve message registration

OutputParameters handling

OptionSetValue validation

Proper entity type checking

? What You Will Learn

What is the Retrieve message in Dynamics 365

Difference between Create/Update vs Retrieve plugins

When to use Post-Operation stage

How OutputParameters works

Accessing BusinessEntity from OutputParameters

Reading OptionSetValue fields (prioritycode, statecode)

Safely modifying entity attributes during retrieval

Preventing duplicate prefix addition

Best practices for UI-level warning messages

? Step-by-Step Implementation Includes

Create .NET Class Library project

Install Microsoft.CrmSdk.CoreAssemblies

Implement IPlugin interface

Write Retrieve message logic

Build DLL in Release mode

Register assembly using Plugin Registration Tool

Configure step (Message = Retrieve, Entity = incident, Stage = PostOperation)

Test High Priority Active Case scenario

? Real-Time Scenario Covered

Detect High Priority Cases

Detect Active Status

Prefix warning message to Title

Avoid modifying database permanently

Display dynamic UI-level alert

In this course, you will learn how to prevent infinite loops in Dynamics 365 CRM Update Plugins using the Depth guard mechanism.

When a plugin performs an Update operation inside its own execution, it can retrigger itself and cause recursive loops. This is a common real-world issue in enterprise CRM development.

In this step-by-step technical implementation, you will build a Contact Update plugin that:

• Automatically stamps the Description field with a timestamp

• Executes synchronously on Update

• Uses context.Depth to prevent re-entrancy

• Follows production-ready coding practices

• Implements proper tracing and exception handling

You will understand how the Plugin Execution Pipeline works internally and why Depth checking is critical for stable server-side customization.

? What You Will Learn

• What is context.Depth in Dynamics 365 CRM

• Why infinite loops happen in Update plugins

• How to use Depth guard correctly

• Difference between Pre-Operation and Post-Operation

• How Target behaves during Update

• Performing partial entity updates efficiently

• Using ITracingService for debugging

• Writing production-ready plugin code

• Avoiding recursion without breaking business logic

• Interview-ready explanations of Depth and pipeline behavior

? Step-by-Step Implementation Includes

1. Create .NET Class Library project

2. Install Microsoft.CrmSdk.CoreAssemblies

3. Write Contact Update Plugin logic

4. Implement Depth guard

5. Build and sign the assembly

6. Register Update step using Plugin Registration Tool

7. Configure execution stage and mode

8. Test stamping behavior

9. Verify loop prevention

? Real-Time Scenario Covered

• Update Contact record

• Stamp Description with timestamp

• Prevent infinite recursion

• Ensure plugin runs only once per update

• Maintain system stability

In this course, you will learn how to prevent deletion of Active Contacts using a Pre-Operation Delete Plugin in Microsoft Dynamics 365 CRM.

In real-world CRM implementations, certain records must not be deleted while they are in an Active state. This course teaches you how to enforce business rules at the server level using C# plugins.

You will implement a production-ready solution where:

• If Contact statecode = Active (0), deletion is blocked

• A user-friendly error message is displayed

• The plugin runs in Pre-Operation stage (Stage 20)

• Execution is Synchronous

• Pre-Image is used for performance optimization

• Retrieve fallback logic is implemented

• Proper tracing and null guards are added

This is a real enterprise-level scenario commonly implemented in financial, healthcare, and enterprise CRM systems.

? What You Will Learn

• How Delete message works in Dynamics 365 CRM

• What Target contains during Delete (EntityReference)

• Why Pre-Operation stage is required to block delete

• How to configure Pre-Entity Image

• Difference between statecode and statuscode

• Writing robust production-ready plugin code

• Using ITracingService for debugging

• Throwing InvalidPluginExecutionException correctly

• Registering Delete step using Plugin Registration Tool

• Common pitfalls and best practices

• Interview-ready explanations

? Step-by-Step Implementation Includes

1. Create Class Library project (.NET Framework)

2. Install Microsoft.CrmSdk.CoreAssemblies

3. Write Delete plugin logic

4. Add strong-name signing

5. Build Release DLL

6. Register assembly in Plugin Registration Tool

7. Configure Delete step (Pre-Operation, Sync)

8. Configure Pre-Image (statecode)

9. Test Active vs Inactive delete scenarios

10. Analyze plugin trace logs

? Real-Time Scenario Covered

• Block deletion of Active Contact

• Allow deletion of Inactive Contact

• Show user-friendly validation message

• Maintain data integrity

• Follow enterprise development standards

Here is a professional Udemy-ready description for your PCF Controls (PowerApps Component Framework) topic:

? Description

In this course, you will learn how to build and implement custom PCF (PowerApps Component Framework) controls in Microsoft Dynamics 365 CRM and Model-Driven Apps.

PCF allows developers to create powerful, reusable UI components using TypeScript and integrate them directly into Dataverse fields and forms. This course provides a complete step-by-step implementation starting from project setup to deployment inside Dynamics 365.

You will learn how to:

• Set up Power Platform CLI and development environment

• Create a PCF field control project

• Understand ControlManifest and bound properties

• Write TypeScript logic for custom UI behavior

• Build and test using local test harness

• Package the control inside a solution

• Deploy and use the PCF control in a Model-Driven App

• Understand PCF lifecycle methods (init, updateView, getOutputs, destroy)

• Follow best practices for performance and maintainability

A real-time example is implemented where a field dynamically changes appearance based on business logic, demonstrating practical enterprise usage.

This course is ideal for developers who want to move beyond traditional JavaScript customization and build modern, scalable UI components in Dynamics 365.

In this course, you will learn the fundamentals of Microsoft Power Pages using Design Studio with a hands-on practical lab.

This beginner-friendly training focuses on building a real Student Portal website while understanding how Forms and Tables work together with Dataverse.

You will learn how to:

• Navigate Power Pages Design Studio

• Create blank pages

• Add and manage Dataverse tables

• Add forms to web pages

• Connect forms to tables

• Publish and test your website

• Understand Power Pages management concepts

Through a structured lab exercise, you will build a StudentPortal page, create a StudentDetails table, connect a form, and test data entry.

This course also includes important interview questions and explanations to strengthen your Power Pages fundamentals.

? What You Will Learn

• What is Power Pages Design Studio

• Difference between Forms and Tables

• Creating blank pages

• Creating Dataverse tables

• Adding columns and schema

• Adding forms to web pages

• Publishing and testing Power Pages site

• Core Power Pages management concepts

• Interview-ready Power Pages fundamentals

? Practical Lab Covered

• Create StudentPortal page

• Create StudentDetails table

• Add Name, Email, Course columns

• Create form linked to StudentDetails

• Add form to page

• Publish and test

In this course, you will learn how to build and manage a complete Microsoft Power Pages website using both Design Studio and Power Pages Management.

Through a real-world Student Portal scenario, you will understand how front-end design connects with Dataverse and how back-end security and permissions are configured.

You will learn how to:

• Create a website from powerapps

• Build pages using Design Studio

• Add Forms and Lists connected to Dataverse

• Create and manage Web Roles

• Configure Table Permissions

• Manage Basic Forms and Lists

• Publish and test your website

This course provides step-by-step practical implementation to help you understand both low-code design and management-level configuration in Power Pages.

? What You Will Learn

• Creating a Power Pages website from scratch

• Using Blank template provisioning

• Creating pages and dashboards

• Adding forms linked to Dataverse tables

• Displaying data using Lists

• Creating Web Roles

• Configuring Table Permissions

• Managing Basic Forms

• Managing Lists in Power Pages Management

• Understanding security flow in Power Pages

? Practical Scenarios Covered

• Student Portal website creation

• Student Dashboard page

• Student Registration form

• Registered Students list

• StudentRole web role

• Contact table permissions

In this course, you will learn how to create and publish a public Microsoft Power Pages website with anonymous access.

This hands-on lab guides you step-by-step through building a Power Pages site from scratch using a blank template. You will configure security settings, enable anonymous access, set page permissions, update content, and publish the website for public viewing without login.

You will implement a real training website scenario and understand how public access works in Power Pages integrated with Dataverse.

This course is beginner-friendly and ideal for anyone starting with Power Pages development.

? What You Will Learn

• How to create a Power Pages website

• Selecting and provisioning a template

• Using Design Studio

• Enabling anonymous (public) access

• Configuring page-level permissions

• Removing login options

• Publishing a Power Pages site

• Testing public access in Incognito mode

• Troubleshooting common Power Pages issues

? Step-by-Step Implementation Includes

1. Create site using Blank template

2. Open and explore Design Studio

3. Enable Allow Anonymous Users

4. Configure page permissions to Everyone

5. Update homepage content

6. Remove login button (optional)

7. Publish site

8. Test public access

In this course, you will learn how to deploy a Microsoft Power Pages portal using Power Platform Pipelines following a structured ALM strategy.

You will implement a real-world scenario where a Customer Self-Service Power Pages portal is built in a Development environment and deployed to TEST (UAT) and Production using managed solutions and approval-based pipelines.

This hands-on lab covers complete end-to-end deployment including solution packaging, pipeline configuration, stage approvals, and production release best practices.

You will understand how to properly manage environments such as:

• DEV (Development)

• TEST (UAT)

• PROD (Production)

And follow enterprise-grade deployment standards.

? What You Will Learn

• Understanding Power Pages ALM

• Creating and configuring unmanaged solutions

• Enabling Power Platform Pipelines

• Creating multi-stage pipelines (DEV → TEST → PROD)

• Deploying solutions using pipelines

• Managing approvals

• Validating deployments in TEST

• Promoting changes to Production

• Difference between Managed and Unmanaged solutions

• Deployment best practices

? Practical Lab Covered

• Create Customer Self-Service portal in DEV

• Package portal components in solution

• Configure pipeline stages

• Deploy DEV to TEST

• Perform UAT validation

• Deploy TEST to PROD

• Follow enterprise governance model