Table of Contents

New to .NET development?

What to learn first if you want to build and extend DynamicWeb 10 solutions

This article is for developers who are new to modern .NET development and want to work with DynamicWeb 10.

It is not a complete .NET tutorial. Instead, it gives you a practical learning path so you can understand how DynamicWeb solutions are built, where custom code fits, and which .NET concepts matter most in day-to-day work.

Who this article is for

This article is a good starting point if you:

  • Are new to C# and ASP.NET Core
  • Have worked with other backend platforms and want to understand the .NET stack behind DynamicWeb 10
  • Have experience with DynamicWeb 9 and want to understand what to learn before doing custom development in DynamicWeb 10

This article assumes that you want to build or customize solutions in DynamicWeb 10.

It does not assume that you already understand:

  • ASP.NET Core request handling
  • Razor templates and .cshtml files
  • Dependency injection
  • DynamicWeb extension points and deployment patterns

Start with the platform shift

Before you start writing code, it helps to understand the platform you are targeting.

DynamicWeb 10 runs on modern .NET and ASP.NET Core. That affects how solutions are hosted, how requests are handled, how custom code is packaged, and how you approach local development and deployment.

If you are coming from DynamicWeb 9, this is the first article you should read:

That article explains the shift from earlier DynamicWeb versions and gives you the technical context for working in DynamicWeb 10.

Learn C# fundamentals first

If you are new to .NET, start with C# before diving into DynamicWeb-specific APIs.

Focus on these topics first:

  • Classes, objects, interfaces, inheritance, and abstraction
  • Collections, generics, and LINQ
  • Exception handling
  • Asynchronous programming with async and await
  • Basic project structure in a .NET application

You do not need to master the full language before becoming productive, but you should be comfortable reading and writing small C# classes and understanding how data flows through an application.

Useful resources:

Understand ASP.NET Core concepts

DynamicWeb 10 builds on ASP.NET Core, so you should understand the basics of how an ASP.NET Core application behaves.

The most important concepts are:

  • Routing, which determines how requests are mapped
  • Dependency injection, which is the standard way to wire services together
  • Middleware, which defines how requests move through the application pipeline
  • Configuration, including environment-specific settings and secrets

You do not need to build a full standalone ASP.NET Core application before working with DynamicWeb, but you should know enough to recognize these concepts when you encounter them in documentation, sample code, and extension points.

Useful resources:

Learn how Razor fits into DynamicWeb

For many DynamicWeb developers, Razor is the first place where .NET development becomes tangible.

Razor templates are commonly used to render output for:

  • CMS pages
  • Product lists and product details
  • PIM-related frontend views
  • Other server-rendered experiences in a DynamicWeb solution

When learning Razor, focus on:

  • Basic Razor syntax
  • Working with models in .cshtml files
  • Layouts and partial views
  • Keeping presentation logic separate from business logic

Here is a simple example of a Razor template:

@using Dynamicweb.Ecommerce.Products
@model Product

<h1>@Model.Name</h1>
<p>Price: @Model.Price</p>

@if (Model.VariantGroups.Any())
{
    <ul>
        @foreach (var variantGroup in Model.VariantGroups)
        {
            <li>@variantGroup.Name</li>
        }
    </ul>
}

The goal is not just to learn Razor syntax. The goal is to understand how DynamicWeb passes data into templates and where template customization is appropriate.

Useful resources:

Know where custom code belongs

DynamicWeb development is not only about templates. You also need to understand where to place custom logic.

In practice, custom development in DynamicWeb often falls into these areas:

  • Razor templates for presentation
  • Custom services and supporting classes for business logic
  • Extensions and integrations for changing or expanding platform behavior

As a rule of thumb:

  • Put rendering logic in Razor when it belongs to the view
  • Put reusable logic in C# classes or services
  • Use DynamicWeb extension points when you need to integrate with or alter platform behavior

This separation becomes increasingly important as a solution grows.

Useful resources:

Understand DynamicWeb extension points

One of the strengths of DynamicWeb is that you can extend standard behavior instead of rewriting the platform.

As you move beyond templates, become familiar with:

  • Notifications and other platform extension points
  • Providers and configurable add-ins
  • Management API usage for automation and orchestration
  • Installation and deployment of custom packages or assemblies

You do not need to learn all extension patterns at once. Start by understanding the extension model relevant to the task in front of you, then deepen your knowledge from there.

Useful resources:

Build a practical learning path

If you are not sure where to begin, use this order:

  1. Read New to DynamicWeb to understand the product areas
  2. Read New to .NET Core development in DynamicWeb to understand the platform shift
  3. Learn enough C# to read and write small classes
  4. Learn the ASP.NET Core concepts that appear in DynamicWeb documentation
  5. Customize a simple Razor template
  6. Explore one DynamicWeb extension point relevant to your project

You are ready to move on when you can:

  • Read a small C# class and understand what it does
  • Follow data from a model into a Razor template
  • Recognize when a change belongs in a template versus in custom backend code
  • Understand the surrounding docs when they reference ASP.NET Core concepts such as middleware or dependency injection

Development and deployment basics

Even if you are just getting started with code, it is worth understanding that DynamicWeb projects are developed and deployed using modern .NET practices.

That typically includes:

  • Working in local development environments
  • Managing configuration per environment
  • Using command-line tooling during development and deployment
  • Automating build and release flows where relevant

You do not need deep DevOps knowledge on day one, but a basic understanding of how code moves from local development to a running solution will make the rest of the documentation easier to follow.

Useful resources:

Continue your learning

Once you are comfortable with the basics, continue with:

If possible, practice in a real or sample DynamicWeb 10 solution. The fastest way to get comfortable is to make a small change, verify the result, and then build from there.

Improve this doc
To top